final def !=(arg0: Any): Boolean

Definition Classes: AnyRef → Any

final def ##(): Int

Definition Classes: AnyRef → Any

def +(other: String): String

Implicit: This member is added by an implicit conversion from ExpectBlock[R] to any2stringadd[ExpectBlock[R]] performed by method any2stringadd in scala.Predef.
Definition Classes: any2stringadd

def ->[B](y: B): (ExpectBlock[R], B)

Implicit: This member is added by an implicit conversion from ExpectBlock[R] to ArrowAssoc[ExpectBlock[R]] performed by method ArrowAssoc in scala.Predef.
Definition Classes: ArrowAssoc
Annotations: @inline()

final def ==(arg0: Any): Boolean

Definition Classes: AnyRef → Any

def addExpectBlock(f: (Expect[R]) ⇒ Unit): Expect[R]

Add arbitrary ExpectBlocks to this Expect.

This is helpful to refactor code. For example: imagine you have an error case you want to add to multiple expects. You could leverage this method to do so in the following way:

def errorCaseExpectBlock(expect: Expect[String]): Unit {
  expect.expect
    .when("Some error")
      .returning("Got some error")
}

//Then in your expects
def parseOutputA: Expect[String] = {
  val e = new Expect("some command", "")
  e.expect(...)
  e.expect
    .when(...)
      .action1
    .when(...)
      .action2
  e.addExpectBlock(errorCaseExpectBlock)
}

def parseOutputB: Expect[String] = {
  val e = new Expect("some command", "")
  e.expect
    .when(...)
      .action1
      .action2
    .when(...)
      .action1
  e.expect(...)
    .action2
  e.addExpectBlock(errorCaseExpectBlock)
}

f: function that adds ExpectBlocks.
returns: this Expect.

Definition Classes: Expectable

def addWhen[W <: When[R]](f: (ExpectBlock[R]) ⇒ W): W

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.

Definition Classes: ExpectBlock → Whenable

def addWhens(f: (ExpectBlock[R]) ⇒ Unit): ExpectBlock[R]

Add arbitrary Whens to this ExpectBlock.

This method is very similar to the addWhen with the following differences:

f has a more relaxed type.
It returns this ExpectBlock. Which effectively prohibits you from invoking When methods.
Has a more semantic name when it comes to adding multiple When's.

f: function that adds Whens.
returns: this ExpectBlock.

Definition Classes: ExpectBlock → Whenable

final def asInstanceOf[T0]: T0

Definition Classes: Any

def clone(): AnyRef

Attributes: protected[java.lang]
Definition Classes: AnyRef
Annotations: @throws( ... )

def containsWhens(): Boolean

Attributes: protected[work.martins.simon.expect]

def ensuring(cond: (ExpectBlock[R]) ⇒ Boolean, msg: ⇒ Any): ExpectBlock[R]

Implicit: This member is added by an implicit conversion from ExpectBlock[R] to Ensuring[ExpectBlock[R]] performed by method Ensuring in scala.Predef.
Definition Classes: Ensuring

def ensuring(cond: (ExpectBlock[R]) ⇒ Boolean): ExpectBlock[R]

Implicit: This member is added by an implicit conversion from ExpectBlock[R] to Ensuring[ExpectBlock[R]] performed by method Ensuring in scala.Predef.
Definition Classes: Ensuring

def ensuring(cond: Boolean, msg: ⇒ Any): ExpectBlock[R]

Implicit: This member is added by an implicit conversion from ExpectBlock[R] to Ensuring[ExpectBlock[R]] performed by method Ensuring in scala.Predef.
Definition Classes: Ensuring

def ensuring(cond: Boolean): ExpectBlock[R]

Implicit: This member is added by an implicit conversion from ExpectBlock[R] to Ensuring[ExpectBlock[R]] performed by method Ensuring in scala.Predef.
Definition Classes: Ensuring

final def eq(arg0: AnyRef): Boolean

Definition Classes: AnyRef

def equals(other: Any): Boolean

Definition Classes: ExpectBlock → AnyRef → Any

def expect(pattern: Timeout.type): TimeoutWhen[R]

Adds, in a new ExpectBlock, a TimeoutWhen that matches whenever the read from any of the FromStreamInputs times out.

Adds, in a new ExpectBlock, a TimeoutWhen that matches whenever the read from any of the FromStreamInputs times out. This is a shortcut to expect.when(pattern).

pattern: the pattern to be used in the TimeoutWhen.
returns: the new RegexWhen.

Definition Classes: Expectable

def expect(pattern: EndOfFile.type, readFrom: FromInputStream): EndOfFileWhen[R]

Adds, in a new ExpectBlock, a EndOfFileWhen that matches whenever the end of file is reached while trying to read from the specified FromInputStream.

Adds, in a new ExpectBlock, a EndOfFileWhen that matches whenever the end of file is reached while trying to read from the specified FromInputStream. This is a shortcut to expect.when(pattern, readFrom).

pattern: the pattern to be used in the EndOfFileWhen.
readFrom: from which FromInputStream to read the output.
returns: the new RegexWhen.

Definition Classes: Expectable

def expect(pattern: EndOfFile.type): EndOfFileWhen[R]

Adds, in a new ExpectBlock, a EndOfFileWhen that matches whenever the end of file is reached while trying to read from the StdOut output.

Adds, in a new ExpectBlock, a EndOfFileWhen that matches whenever the end of file is reached while trying to read from the StdOut output. This is a shortcut to expect.when(pattern).

pattern: the pattern to be used in the EndOfFileWhen.
returns: the new RegexWhen.

Definition Classes: Expectable

def expect(pattern: Regex, readFrom: FromInputStream): RegexWhen[R]

Adds, in a new ExpectBlock, a RegexWhen that matches whenever the regex pattern successfully matches against the text read from the specified FromInputStream.

Adds, in a new ExpectBlock, a RegexWhen that matches whenever the regex pattern successfully matches against the text read from the specified FromInputStream. This is a shortcut to expect.when(pattern, readFrom).

pattern: the pattern to be used in the RegexWhen.
readFrom: from which FromInputStream to read the output.
returns: the new RegexWhen.

Definition Classes: Expectable

def expect(pattern: Regex): RegexWhen[R]

Adds, in a new ExpectBlock, a RegexWhen that matches whenever the regex pattern successfully matches against the text read from the StdOut output.

Adds, in a new ExpectBlock, a RegexWhen that matches whenever the regex pattern successfully matches against the text read from the StdOut output. This is a shortcut to expect.when(pattern).

pattern: the pattern to be used in the RegexWhen.
returns: the new RegexWhen.

Definition Classes: Expectable

def expect(pattern: String, readFrom: FromInputStream): StringWhen[R]

Adds, in a new ExpectBlock, a StringWhen that matches whenever pattern is contained in the text read from the specified FromInputStream.

Adds, in a new ExpectBlock, a StringWhen that matches whenever pattern is contained in the text read from the specified FromInputStream. This is a shortcut to expect.when(pattern, readFrom).

pattern: the pattern to be used in the StringWhen.
readFrom: from which FromInputStream to read the output.
returns: the new StringWhen.

Definition Classes: Expectable

def expect(pattern: String): StringWhen[R]

Adds, in a new ExpectBlock, a StringWhen that matches whenever pattern is contained in the text read from the StdOut output.

Adds, in a new ExpectBlock, a StringWhen that matches whenever pattern is contained in the text read from the StdOut output. This is a shortcut to expect.when(pattern).

pattern: the pattern to be used in the StringWhen.
returns: the new StringWhen.

Definition Classes: Expectable

def expect(readFrom: FromInputStream): ExpectBlock[R]

Adds an empty new ExpectBlock reading from the specified FromInputStream.

readFrom: from which FromInputStream to read the output.
returns: the new ExpectBlock.

Definition Classes: Expectable

def expect: ExpectBlock[R]

Adds an empty new ExpectBlock.

returns: the new ExpectBlock.

Definition Classes: Expectable

lazy val expectableParent: Expect[R]

Attributes: protected
Definition Classes: Whenable → Expectable

def finalize(): Unit

Attributes: protected[java.lang]
Definition Classes: AnyRef
Annotations: @throws( classOf[java.lang.Throwable] )

def formatted(fmtstr: String): String

Implicit: This member is added by an implicit conversion from ExpectBlock[R] to StringFormat[ExpectBlock[R]] performed by method StringFormat in scala.Predef.
Definition Classes: StringFormat
Annotations: @inline()

final def getClass(): Class[_]

Definition Classes: AnyRef → Any

def hashCode(): Int

Definition Classes: ExpectBlock → AnyRef → Any

final def isInstanceOf[T0]: Boolean

Definition Classes: Any

final def ne(arg0: AnyRef): Boolean

Definition Classes: AnyRef

def newWhen[W <: When[R]](when: W): W

Attributes: protected

final def notify(): Unit

Definition Classes: AnyRef

final def notifyAll(): Unit

Definition Classes: AnyRef

val parent: Expect[R]

val readFrom: FromInputStream

final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes: AnyRef

def toCore: core.ExpectBlock[R]

*

returns: the core.ExpectBlock equivalent of this fluent.ExpectBlock.

def toString(): String

Definition Classes: ExpectBlock → 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 the read from any of the FromStreamInputs times out.

pattern: the pattern to match against.
returns: the new TimeoutWhen.

Definition Classes: ExpectBlock → Whenable

def when(pattern: EndOfFile.type, readFrom: FromInputStream): EndOfFileWhen[R]

Adds a new EndOfFileWhen that matches whenever the EndOfFile in read from the specified FromInputStream.

pattern: the pattern to match against.
readFrom: from which FromInputStream to read the output.
returns: the new EndOfFileWhen.

Definition Classes: ExpectBlock → Whenable

def when(pattern: Regex, readFrom: FromInputStream): RegexWhen[R]

Adds a new RegexWhen that matches whenever the regex pattern successfully matches against the text read from the specified FromInputStream.

pattern: the pattern to match against.
readFrom: from which FromInputStream to read the output.
returns: the new RegexWhen.

Definition Classes: ExpectBlock → Whenable

def when(pattern: String, readFrom: FromInputStream): StringWhen[R]

Adds a new StringWhen that matches whenever pattern is contained in the text read from the specified FromInputStream.

pattern: the pattern to match against.
readFrom: from which FromInputStream to read the output.
returns: the new StringWhen.

Definition Classes: ExpectBlock → Whenable

def when(pattern: EndOfFile.type): EndOfFileWhen[R]

Adds a new EndOfFileWhen that matches whenever the EndOfFile in read from FromInputStream specified in the parent ExpectBlock.

pattern: the pattern to match against.
returns: the new EndOfFileWhen.

Definition Classes: Whenable

def when(pattern: Regex): RegexWhen[R]

Adds a new RegexWhen that matches whenever the regex pattern successfully matches against the text read from FromInputStream specified in the parent ExpectBlock.

pattern: the pattern to match against.
returns: the new RegexWhen.

Definition Classes: Whenable

def when(pattern: String): StringWhen[R]

Adds a new StringWhen that matches whenever pattern is contained in the text read from the FromInputStream specified in the parent ExpectBlock.

pattern: the pattern to match against.
returns: the new StringWhen.

Definition Classes: Whenable

val whenableParent: ExpectBlock[R]

Attributes: protected
Definition Classes: ExpectBlock → Whenable

var whens: Seq[When[R]]

Attributes: protected

def →[B](y: B): (ExpectBlock[R], B)

Implicit: This member is added by an implicit conversion from ExpectBlock[R] to ArrowAssoc[ExpectBlock[R]] performed by method ArrowAssoc in scala.Predef.
Definition Classes: ArrowAssoc

Packages

ExpectBlock

final class ExpectBlock[R] extends Whenable[R]

Instance Constructors

Value Members

Inherited from Whenable[R]

Inherited from Expectable[R]

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion any2stringadd from ExpectBlock[R] to any2stringadd[ExpectBlock[R]]

Inherited by implicit conversion StringFormat from ExpectBlock[R] to StringFormat[ExpectBlock[R]]

Inherited by implicit conversion Ensuring from ExpectBlock[R] to Ensuring[ExpectBlock[R]]

Inherited by implicit conversion ArrowAssoc from ExpectBlock[R] to ArrowAssoc[ExpectBlock[R]]

Ungrouped