io.vertx.ext.unit

## Interface TestContext

-     public interface TestContext

  The test context is used for performing test assertions and manage the completion of the test. This context is provided by vertx-unit as argument of the test case.
  Author:
    Julien Viet

- - ### Method Summary

    All Methods Instance Methods Abstract Methods
    Modifier and Type | Method and Description
    --- | ---
    `TestContext` | `assertEquals(Object expected, Object actual)` Assert the `expected` argument is equals to the `actual` argument.
    `TestContext` | `assertEquals(Object expected, Object actual, String message)` Assert the `expected` argument is equals to the `actual` argument.
    `TestContext` | `assertFalse(boolean condition)` Assert the specified `condition` is `false`.
    `TestContext` | `assertFalse(boolean condition, String message)` Assert the specified `condition` is `false`.
    `TestContext` | `assertInRange(double expected, double actual, double delta)` Asserts that the `expected` double argument is equals to the `actual` double argument within a positive delta.
    `TestContext` | `assertInRange(double expected, double actual, double delta, String message)` Asserts that the `expected` double argument is equals to the `actual` double argument within a positive delta.
    `TestContext` | `assertNotEquals(Object first, Object second)` Assert the `first` argument is not equals to the `second` argument.
    `TestContext` | `assertNotEquals(Object first, Object second, String message)` Assert the `first` argument is not equals to the `second` argument.
    `TestContext` | `assertNotNull(Object expected)` Assert the `expected` argument is not `null`.
    `TestContext` | `assertNotNull(Object expected, String message)` Assert the `expected` argument is not `null`.
    `TestContext` | `assertNull(Object expected)` Assert the `expected` argument is `null`.
    `TestContext` | `assertNull(Object expected, String message)` Assert the `expected` argument is `null`.
    `TestContext` | `assertTrue(boolean condition)` Assert the specified `condition` is `true`.
    `TestContext` | `assertTrue(boolean condition, String message)` Assert the specified `condition` is `true`.
    `Async` | `async()` Create and returns a new async object, the returned async controls the completion of the test.
    `Async` | `async(int count)` Create and returns a new async object, the returned async controls the completion of the test.
    `<T> Handler<AsyncResult<T>>` | `asyncAssertFailure()` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a failed result it completes the async operation. When the returned handler is called back with a succeeded result it fails the test.
    `<T> Handler<AsyncResult<T>>` | `asyncAssertFailure(Handler<Throwable> causeHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a failed result it completes the async operation. When the returned handler is called back with a succeeded result it fails the test.
    `<T> Handler<AsyncResult<T>>` | `asyncAssertSuccess()` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a succeeded result it completes the async operation. When the returned handler is called back with a failed result it fails the test with the cause of the failure.
    `<T> Handler<AsyncResult<T>>` | `asyncAssertSuccess(Handler<T> resultHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a succeeded result it invokes the `resultHandler` argument with the async result.
    `Handler<Throwable>` | `exceptionHandler()`
    `void` | `fail()` Throw a failure.
    `void` | `fail(String message)` Throw a failure with the specified failure `message`.
    `void` | `fail(Throwable cause)` Throw a failure with the specified failure `cause`.
    `<T> T` | `get(String key)` Get some data from the context.
    `<T> T` | `put(String key, Object value)` Put some data in the context.
    `<T> T` | `remove(String key)` Remove some data from the context.
    `Async` | `strictAsync(int count)` Create and returns a new async object, the returned async controls the completion of the test.
    `TestContext` | `verify(Handler<Void> block)` Execute the provided handler, which may contain assertions, possibly from any third-party assertion framework.

- - ### Method Detail

    - #### get

          <T> T get(String key)

      Get some data from the context.
      Type Parameters:
        `T` - the type of the data
      Parameters:
        `key` - the key of the data
      Returns:
        the data

    - #### put

          <T> T put(String key,
                    Object value)

      Put some data in the context.

      This can be used to share data between different tests and before/after phases.

      Parameters:
        `key` - the key of the data
        `value` - the data
      Returns:
        the previous object when it exists

    - #### remove

          <T> T remove(String key)

      Remove some data from the context.
      Parameters:
        `key` - the key to remove
      Returns:
        the removed object when it exists

    - #### assertNull

          TestContext assertNull(Object expected)

      Assert the `expected` argument is `null`. If the argument is not, an assertion error is thrown otherwise the execution continue.
      Parameters:
        `expected` - the argument being asserted to be null
      Returns:
        a reference to this, so the API can be used fluently

    - #### assertNull

          TestContext assertNull(Object expected,
                                 String message)

      Assert the `expected` argument is `null`. If the argument is not, an assertion error is thrown otherwise the execution continue.
      Parameters:
        `expected` - the argument being asserted to be null
        `message` - the failure message
      Returns:
        a reference to this, so the API can be used fluently

    - #### assertNotNull

          TestContext assertNotNull(Object expected)

      Assert the `expected` argument is not `null`. If the argument is `null`, an assertion error is thrown otherwise the execution continue.
      Parameters:
        `expected` - the argument being asserted to be not null
      Returns:
        a reference to this, so the API can be used fluently

    - #### assertNotNull

          TestContext assertNotNull(Object expected,
                                    String message)

      Assert the `expected` argument is not `null`. If the argument is `null`, an assertion error is thrown otherwise the execution continue.
      Parameters:
        `expected` - the argument being asserted to be not null
        `message` - the failure message
      Returns:
        a reference to this, so the API can be used fluently

    - #### assertTrue

          TestContext assertTrue(boolean condition)

      Assert the specified `condition` is `true`. If the condition is `false`, an assertion error is thrown otherwise the execution continue.
      Parameters:
        `condition` - the condition to assert
      Returns:
        a reference to this, so the API can be used fluently

    - #### assertTrue

          TestContext assertTrue(boolean condition,
                                 String message)

      Assert the specified `condition` is `true`. If the condition is `false`, an assertion error is thrown otherwise the execution continue.
      Parameters:
        `condition` - the condition to assert
        `message` - the failure message
      Returns:
        a reference to this, so the API can be used fluently

    - #### assertFalse

          TestContext assertFalse(boolean condition)

      Assert the specified `condition` is `false`. If the condition is `true`, an assertion error is thrown otherwise the execution continue.
      Parameters:
        `condition` - the condition to assert
      Returns:
        a reference to this, so the API can be used fluently

    - #### assertFalse

          TestContext assertFalse(boolean condition,
                                  String message)

      Assert the specified `condition` is `false`. If the condition is `true`, an assertion error is thrown otherwise the execution continue.
      Parameters:
        `condition` - the condition to assert
        `message` - the failure message
      Returns:
        a reference to this, so the API can be used fluently

    - #### assertEquals

          TestContext assertEquals(Object expected,
                                   Object actual)

      Assert the `expected` argument is equals to the `actual` argument. If the arguments are not equals an assertion error is thrown otherwise the execution continue.
      Parameters:
        `expected` - the object the actual object is supposedly equals to
        `actual` - the actual object to test
      Returns:
        a reference to this, so the API can be used fluently

    - #### assertEquals

          TestContext assertEquals(Object expected,
                                   Object actual,
                                   String message)

      Assert the `expected` argument is equals to the `actual` argument. If the arguments are not equals an assertion error is thrown otherwise the execution continue.
      Parameters:
        `expected` - the object the actual object is supposedly equals to
        `actual` - the actual object to test
        `message` - the failure message
      Returns:
        a reference to this, so the API can be used fluently

    - #### assertInRange

          TestContext assertInRange(double expected,
                                    double actual,
                                    double delta)

      Asserts that the `expected` double argument is equals to the `actual` double argument within a positive delta. If the arguments do not satisfy this, an assertion error is thrown otherwise the execution continue.
      Parameters:
        `expected` - the object the actual object is supposedly equals to
        `actual` - the actual object to test
        `delta` - the maximum delta
      Returns:
        a reference to this, so the API can be used fluently

    - #### assertInRange

          TestContext assertInRange(double expected,
                                    double actual,
                                    double delta,
                                    String message)

      Asserts that the `expected` double argument is equals to the `actual` double argument within a positive delta. If the arguments do not satisfy this, an assertion error is thrown otherwise the execution continue.
      Parameters:
        `expected` - the object the actual object is supposedly equals to
        `actual` - the actual object to test
        `delta` - the maximum delta
        `message` - the failure message
      Returns:
        a reference to this, so the API can be used fluently

    - #### assertNotEquals

          TestContext assertNotEquals(Object first,
                                      Object second)

      Assert the `first` argument is not equals to the `second` argument. If the arguments are equals an assertion error is thrown otherwise the execution continue.
      Parameters:
        `first` - the first object to test
        `second` - the second object to test
      Returns:
        a reference to this, so the API can be used fluently

    - #### assertNotEquals

          TestContext assertNotEquals(Object first,
                                      Object second,
                                      String message)

      Assert the `first` argument is not equals to the `second` argument. If the arguments are equals an assertion error is thrown otherwise the execution continue.
      Parameters:
        `first` - the first object to test
        `second` - the second object to test
        `message` - the failure message
      Returns:
        a reference to this, so the API can be used fluently

    - #### verify

          TestContext verify(Handler<Void> block)

      Execute the provided handler, which may contain assertions, possibly from any third-party assertion framework. Any `AssertionError` thrown will be caught (and propagated) in order to fulfill potential expected async completeness.
      Parameters:
        `block` - block of code to be executed
      Returns:
        a reference to this, so the API can be used fluently

    - #### fail

          void fail()

      Throw a failure.

    - #### fail

          void fail(String message)

      Throw a failure with the specified failure `message`.
      Parameters:
        `message` - the failure message

    - #### fail

          void fail(Throwable cause)

      Throw a failure with the specified failure `cause`.
      Parameters:
        `cause` - the failure cause

    - #### async

          Async async()

      Create and returns a new async object, the returned async controls the completion of the test. Calling the `Async.complete()` completes the async operation.

      The test case will complete when all the async objects have their `Async.complete()` method called at least once.

      This method shall be used for creating asynchronous exit points for the executed test.
      Returns:
        the async instance

    - #### async

          Async async(int count)

      Create and returns a new async object, the returned async controls the completion of the test. This async operation completes when the `Async.countDown()` is called `count` times.

      The test case will complete when all the async objects have their `Async.complete()` method called at least once.

      This method shall be used for creating asynchronous exit points for the executed test.

      Returns:
        the async instance

    - #### strictAsync

          Async strictAsync(int count)

      Create and returns a new async object, the returned async controls the completion of the test. This async operation completes when the `Async.countDown()` is called `count` times.

      If `Async.countDown()` is called more than `count` times, an `IllegalStateException` is thrown.

      The test case will complete when all the async objects have their `Async.complete()` method called at least once.

      This method shall be used for creating asynchronous exit points for the executed test.

      Returns:
        the async instance

    - #### asyncAssertSuccess

          <T> Handler<AsyncResult<T>> asyncAssertSuccess()

      Creates and returns a new async handler, the returned handler controls the completion of the test.

      When the returned handler is called back with a succeeded result it completes the async operation.

      When the returned handler is called back with a failed result it fails the test with the cause of the failure.

      Returns:
        the async result handler

    - #### asyncAssertSuccess

          <T> Handler<AsyncResult<T>> asyncAssertSuccess(Handler<T> resultHandler)

      Creates and returns a new async handler, the returned handler controls the completion of the test.

      When the returned handler is called back with a succeeded result it invokes the `resultHandler` argument with the async result. The test completes after the result handler is invoked and does not fails.

      When the returned handler is called back with a failed result it fails the test with the cause of the failure.

      Note that the result handler can create other async objects during its invocation that would postpone the completion of the test case until those objects are resolved.
      Parameters:
        `resultHandler` - the result handler
      Returns:
        the async result handler

    - #### asyncAssertFailure

          <T> Handler<AsyncResult<T>> asyncAssertFailure()

      Creates and returns a new async handler, the returned handler controls the completion of the test.

      When the returned handler is called back with a failed result it completes the async operation.

      When the returned handler is called back with a succeeded result it fails the test.

      Returns:
        the async result handler

    - #### asyncAssertFailure

          <T> Handler<AsyncResult<T>> asyncAssertFailure(Handler<Throwable> causeHandler)

      Creates and returns a new async handler, the returned handler controls the completion of the test.

      When the returned handler is called back with a failed result it completes the async operation.

      When the returned handler is called back with a succeeded result it fails the test.

      Parameters:
        `causeHandler` - the cause handler
      Returns:
        the async result handler

    - #### exceptionHandler

          Handler<Throwable> exceptionHandler()

      Returns:
        an exception handler that will fail this context

Copyright © 2021 Eclipse. All rights reserved.