Trait

work.martins.simon.expect.fluent

Whenable

Related Doc: package fluent

Permalink

trait Whenable[R] extends AnyRef

Linear Supertypes

Known Subclasses

EndOfFileWhen, ExpectBlock, RegexWhen, StringWhen, TimeoutWhen, When

Ordering

Alphabetic
By inheritance

Inherited

Whenable
AnyRef
Any

Hide All
Show all

Visibility

Public
All

Abstract Value Members

abstract val whenableParent: Whenable[R]

Attributes
protected

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def addWhen[W <: When[R]](f: (ExpectBlock[R]) ⇒ W): W

Add an arbitrary When to this ExpectBlock.
Add an arbitrary When to this ExpectBlock.
This is helpful to refactor code. For example: imagine you have an error case you want to add to multiple ExpectBlocks. You could leverage this method to do so in the following way:
```
def errorCaseWhen(expectBlock: ExpectBlock[String]): When[String] = {
  expectBlock
    .when("Some error")
      .returning("Got some error")
}

def parseOutputA: Expect[String] = {
  val e = new Expect("some command", "")
  e.expect
    .when(...)
      .sendln(...)
  e.expect
    .addWhen(errorCaseWhen)
      .exit()
}

def parseOutputB: Expect[String] = {
  val e = new Expect("some command", "")
  e.expect
    .when(...)
      .sendln(..)
      .returning(...)
    .addWhen(errorCaseWhen)
}
```
This function returns the added When which allows you to add further actions, see the exit action of the parseOutputA method in the above code.
It is possible to add more than one When using this method, however this is discouraged since it will make the code somewhat more illegible because "hidden" Whens will also be added.
If you need to add more than one When you have two options:
```
e.expect
  .when(...)
     .sendln(..)
     .returning(...)
  .addWhen(errorCaseWhen)
  .addWhen(anotherWhen)
```
```
e.expect
  .when(...)
     .sendln(..)
     .returning(...)
  .addWhens(multipleWhens)
```
f
function that adds the When.
returns
the added When.
def addWhens(f: (ExpectBlock[R]) ⇒ Unit): ExpectBlock[R]

Add arbitrary Whens to this ExpectBlock.
Add arbitrary Whens to this ExpectBlock.
This method is very similar to the addWhen with the following differences:
1. f has a more relaxed type.
2. It returns this ExpectBlock. Which effectively prohibits you from invoking When methods.
3. Has a more semantic name when it comes to adding multiple When's.
f
function that adds Whens.
returns
this ExpectBlock.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def when(pattern: Timeout.type): TimeoutWhen[R]

Adds a new TimeoutWhen that matches whenever a Timeout in thrown while trying to read text from the process output (stdOut).
Adds a new TimeoutWhen that matches whenever a Timeout in thrown while trying to read text from the process output (stdOut).
pattern
the pattern to match against.
returns
the new TimeoutWhen.
def when(pattern: EndOfFile.type): EndOfFileWhen[R]

Adds a new EndOfFileWhen that matches whenever the EndOfFile in the process output (stdOut) is reached.
Adds a new EndOfFileWhen that matches whenever the EndOfFile in the process output (stdOut) is reached.
pattern
the pattern to match against.
returns
the new EndOfFileWhen.
def when(pattern: Regex): RegexWhen[R]

Adds a new RegexWhen that matches whenever the regex pattern successfully matches against the text read from the process output (stdOut).
Adds a new RegexWhen that matches whenever the regex pattern successfully matches against the text read from the process output (stdOut).
pattern
the pattern to match against.
returns
the new RegexWhen.
def when(pattern: String): StringWhen[R]

Adds a new StringWhen that matches whenever pattern is contained in the text read from the process output (stdOut).
Adds a new StringWhen that matches whenever pattern is contained in the text read from the process output (stdOut).
pattern
the pattern to match against.
returns
the new StringWhen.

Inherited from AnyRef

Inherited from Any

Ungrouped