Add arbitrary Actions to this When.

This is helpful to refactor code. For example: imagine you want to perform the same actions whenever an error occurs. You could leverage this method to do so in the following way:

def preemtiveExit(when: When[String]): Unit {
  when
    .returning("Got some error")
    .exit()
}

def parseOutputA: Expect[String] = {
  val e = new Expect("some command", "")
  e.expect
    .when(...)
      .action1
    .when(...)
      .addActions(preemtiveExit)
}

def parseOutputB: Expect[String] = {
  val e = new Expect("some command", "")
  e.expect(...)
    .addActions(preemtiveExit)
}

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)
}

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)

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.

Terminates the current run of Expect causing it to return the last returned value. Any action or expect block added after this Exit will not be executed.

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).

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).

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).

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).

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).

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).

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).

Adds an empty new ExpectBlock reading from the specified FromInputStream.

Adds an empty new ExpectBlock.

Returns result when this Expect is run. If this method is invoked more than once only the last result will be returned. Note however that the previous returning actions will also be executed.

Send text to the stdIn of the underlying process. Send will only occur when Expect is run.

Sends text terminated with System.lineSeparator() to the stdIn of the underlying process. Send will only occur when Expect is run.

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

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

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

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

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

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

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