Class

work.martins.simon.expect.fluent

ExpectBlock

Related Doc: package fluent

Permalink

class ExpectBlock[R] extends Runnable[R] with Expectable[R] with Whenable[R]

Linear Supertypes
Whenable[R], Expectable[R], Runnable[R], AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. ExpectBlock
  2. Whenable
  3. Expectable
  4. Runnable
  5. AnyRef
  6. Any
  1. Hide All
  2. Show all
Visibility
  1. Public
  2. All

Instance Constructors

  1. new ExpectBlock(parent: Expect[R])

    Permalink

Value Members

  1. final def !=(arg0: Any): Boolean

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

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

    Permalink
    Definition Classes
    AnyRef → Any
  4. def addExpectBlock(f: (Expect[R]) ⇒ Unit): Expect[R]

    Permalink

    Add arbitrary ExpectBlocks to this Expect.

    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
  5. def addWhen[W <: When[R]](f: (ExpectBlock[R]) ⇒ W): W

    Permalink

    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.

    Definition Classes
    ExpectBlockWhenable
  6. def addWhens(f: (ExpectBlock[R]) ⇒ Unit): ExpectBlock[R]

    Permalink

    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.

    Definition Classes
    ExpectBlockWhenable
  7. final def asInstanceOf[T0]: T0

    Permalink
    Definition Classes
    Any
  8. def clone(): AnyRef

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

    Permalink
    Definition Classes
    AnyRef
  10. def equals(other: Any): Boolean

    Permalink
    Definition Classes
    ExpectBlock → AnyRef → Any
  11. def expect(pattern: EndOfFile.type): EndOfFileWhen[R]

    Permalink

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

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

    pattern

    the pattern to be used in the EndOfFileWhen.

    returns

    the new RegexWhen.

    Definition Classes
    Expectable
  12. def expect(pattern: Timeout.type): TimeoutWhen[R]

    Permalink

    Adds, in a new ExpectBlock, a TimeoutWhen that matches whenever the read from the process output (stdOut) times out.

    Adds, in a new ExpectBlock, a TimeoutWhen that matches whenever the read from the process output (stdOut) 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
  13. def expect(pattern: Regex): RegexWhen[R]

    Permalink

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

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

    pattern

    the pattern to be used in the RegexWhen.

    returns

    the new RegexWhen.

    Definition Classes
    Expectable
  14. def expect(pattern: String): StringWhen[R]

    Permalink

    Adds, in a new ExpectBlock, a StringWhen that matches whenever pattern is contained in the text read from the process output (stdOut).

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

    pattern

    the pattern to be used in the StringWhen.

    returns

    the new StringWhen.

    Definition Classes
    Expectable
  15. def expect: ExpectBlock[R]

    Permalink

    Adds an empty new ExpectBlock.

    Adds an empty new ExpectBlock.

    returns

    the new ExpectBlock.

    Definition Classes
    Expectable
  16. val expectableParent: Expectable[R]

    Permalink
    Attributes
    protected
    Definition Classes
    ExpectBlockExpectable
  17. def finalize(): Unit

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

    Permalink
    Definition Classes
    AnyRef → Any
  19. def hashCode(): Int

    Permalink
    Definition Classes
    ExpectBlock → AnyRef → Any
  20. final def isInstanceOf[T0]: Boolean

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

    Permalink
    Definition Classes
    AnyRef
  22. def newWhen[W <: When[R]](when: W): W

    Permalink
    Attributes
    protected
  23. final def notify(): Unit

    Permalink
    Definition Classes
    AnyRef
  24. final def notifyAll(): Unit

    Permalink
    Definition Classes
    AnyRef
  25. val parent: Expect[R]

    Permalink
  26. def run(timeout: FiniteDuration = settings.timeout, charset: Charset = settings.charset, bufferSize: Int = settings.bufferSize, redirectStdErrToStdOut: Boolean = settings.redirectStdErrToStdOut)(implicit ex: ExecutionContext): Future[R]

    Permalink

    Runs this Expect.

    Runs this Expect.

    timeout

    the maximum time to wait for each read.

    charset

    the charset to use when decoding/encoding the read/write text.

    bufferSize

    the size of the buffer to use when performing reads.

    redirectStdErrToStdOut

    whether to redirect the stdErr of the spawned process to the stdOut.

    ex

    the ExecutionContext upon which this Expect will be run.

    returns

    a Future with the value returned by a ReturningAction, if no ReturningAction exists defaultValue will be returned. If an exception occurred during the execution of the future then that exception will be returned in the Failure of the Future.

    Definition Classes
    Runnable
  27. val runnableParent: Runnable[R]

    Permalink
    Attributes
    protected
    Definition Classes
    ExpectBlockRunnable
  28. val settings: Settings

    Permalink
    Definition Classes
    ExpectBlockRunnable
  29. final def synchronized[T0](arg0: ⇒ T0): T0

    Permalink
    Definition Classes
    AnyRef
  30. def toCore: core.ExpectBlock[R]

    Permalink

    *

    *

    returns

    the core.ExpectBlock equivalent of this fluent.ExpectBlock.

  31. def toString(): String

    Permalink
    Definition Classes
    ExpectBlock → AnyRef → Any
  32. final def wait(): Unit

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

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

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

    Permalink

    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.

    Definition Classes
    ExpectBlockWhenable
  36. def when(pattern: EndOfFile.type): EndOfFileWhen[R]

    Permalink

    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.

    Definition Classes
    ExpectBlockWhenable
  37. def when(pattern: Regex): RegexWhen[R]

    Permalink

    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.

    Definition Classes
    ExpectBlockWhenable
  38. def when(pattern: String): StringWhen[R]

    Permalink

    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.

    Definition Classes
    ExpectBlockWhenable
  39. val whenableParent: Whenable[R]

    Permalink
    Attributes
    protected
    Definition Classes
    ExpectBlockWhenable

Inherited from Whenable[R]

Inherited from Expectable[R]

Inherited from Runnable[R]

Inherited from AnyRef

Inherited from Any

Ungrouped