org.junit

## Class Assert

- java.lang.Object
- - org.junit.Assert

-     public class Assert
      extends Object

  A set of assertion methods useful for writing tests. Only failed assertions are recorded. These methods can be used directly: `Assert.assertEquals(...)`, however, they read better if they are referenced through static import:

       import static org.junit.Assert.*;
          ...
          assertEquals(...);

  Since:
    4.0
  See Also:
    `AssertionError`

- - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `Assert()` Protect constructor since it is a static only class

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `static void` | `assertArrayEquals(byte[] expecteds, byte[] actuals)` Asserts that two byte arrays are equal.
    `static void` | `assertArrayEquals(char[] expecteds, char[] actuals)` Asserts that two char arrays are equal.
    `static void` | `assertArrayEquals(double[] expecteds, double[] actuals, double delta)` Asserts that two double arrays are equal.
    `static void` | `assertArrayEquals(float[] expecteds, float[] actuals, float delta)` Asserts that two float arrays are equal.
    `static void` | `assertArrayEquals(int[] expecteds, int[] actuals)` Asserts that two int arrays are equal.
    `static void` | `assertArrayEquals(long[] expecteds, long[] actuals)` Asserts that two long arrays are equal.
    `static void` | `assertArrayEquals(Object[] expecteds, Object[] actuals)` Asserts that two object arrays are equal.
    `static void` | `assertArrayEquals(short[] expecteds, short[] actuals)` Asserts that two short arrays are equal.
    `static void` | `assertArrayEquals(String message, byte[] expecteds, byte[] actuals)` Asserts that two byte arrays are equal.
    `static void` | `assertArrayEquals(String message, char[] expecteds, char[] actuals)` Asserts that two char arrays are equal.
    `static void` | `assertArrayEquals(String message, double[] expecteds, double[] actuals, double delta)` Asserts that two double arrays are equal.
    `static void` | `assertArrayEquals(String message, float[] expecteds, float[] actuals, float delta)` Asserts that two float arrays are equal.
    `static void` | `assertArrayEquals(String message, int[] expecteds, int[] actuals)` Asserts that two int arrays are equal.
    `static void` | `assertArrayEquals(String message, long[] expecteds, long[] actuals)` Asserts that two long arrays are equal.
    `static void` | `assertArrayEquals(String message, Object[] expecteds, Object[] actuals)` Asserts that two object arrays are equal.
    `static void` | `assertArrayEquals(String message, short[] expecteds, short[] actuals)` Asserts that two short arrays are equal.
    `static void` | `assertEquals(double expected, double actual)` Deprecated. Use `assertEquals(double expected, double actual, double delta)` instead
    `static void` | `assertEquals(double expected, double actual, double delta)` Asserts that two doubles are equal to within a positive delta.
    `static void` | `assertEquals(float expected, float actual, float delta)` Asserts that two floats are equal to within a positive delta.
    `static void` | `assertEquals(long expected, long actual)` Asserts that two longs are equal.
    `static void` | `assertEquals(Object[] expecteds, Object[] actuals)` Deprecated. use assertArrayEquals
    `static void` | `assertEquals(Object expected, Object actual)` Asserts that two objects are equal.
    `static void` | `assertEquals(String message, double expected, double actual)` Deprecated. Use `assertEquals(String message, double expected, double actual, double delta)` instead
    `static void` | `assertEquals(String message, double expected, double actual, double delta)` Asserts that two doubles are equal to within a positive delta.
    `static void` | `assertEquals(String message, float expected, float actual, float delta)` Asserts that two floats are equal to within a positive delta.
    `static void` | `assertEquals(String message, long expected, long actual)` Asserts that two longs are equal.
    `static void` | `assertEquals(String message, Object[] expecteds, Object[] actuals)` Deprecated. use assertArrayEquals
    `static void` | `assertEquals(String message, Object expected, Object actual)` Asserts that two objects are equal.
    `static void` | `assertFalse(boolean condition)` Asserts that a condition is false.
    `static void` | `assertFalse(String message, boolean condition)` Asserts that a condition is false.
    `static void` | `assertNotEquals(double first, double second, double delta)` Asserts that two doubles or floats are not equal to within a positive delta.
    `static void` | `assertNotEquals(long first, long second)` Asserts that two longs are not equals.
    `static void` | `assertNotEquals(Object first, Object second)` Asserts that two objects are not equals.
    `static void` | `assertNotEquals(String message, double first, double second, double delta)` Asserts that two doubles or floats are not equal to within a positive delta.
    `static void` | `assertNotEquals(String message, long first, long second)` Asserts that two longs are not equals.
    `static void` | `assertNotEquals(String message, Object first, Object second)` Asserts that two objects are not equals.
    `static void` | `assertNotNull(Object object)` Asserts that an object isn't null.
    `static void` | `assertNotNull(String message, Object object)` Asserts that an object isn't null.
    `static void` | `assertNotSame(Object unexpected, Object actual)` Asserts that two objects do not refer to the same object.
    `static void` | `assertNotSame(String message, Object unexpected, Object actual)` Asserts that two objects do not refer to the same object.
    `static void` | `assertNull(Object object)` Asserts that an object is null.
    `static void` | `assertNull(String message, Object object)` Asserts that an object is null.
    `static void` | `assertSame(Object expected, Object actual)` Asserts that two objects refer to the same object.
    `static void` | `assertSame(String message, Object expected, Object actual)` Asserts that two objects refer to the same object.
    `static <T> void` | `assertThat(String reason, T actual, Matcher<? super T> matcher)` Asserts that `actual` satisfies the condition specified by `matcher`.
    `static <T> void` | `assertThat(T actual, Matcher<? super T> matcher)` Asserts that `actual` satisfies the condition specified by `matcher`.
    `static void` | `assertTrue(boolean condition)` Asserts that a condition is true.
    `static void` | `assertTrue(String message, boolean condition)` Asserts that a condition is true.
    `static void` | `fail()` Fails a test with no message.
    `static void` | `fail(String message)` Fails a test with the given message.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### Assert

          protected Assert()

      Protect constructor since it is a static only class

  - ### Method Detail

    - #### assertTrue

          public static void assertTrue(String message,
                        boolean condition)

      Asserts that a condition is true. If it isn't it throws an `AssertionError` with the given message.
      Parameters:
        `message` - the identifying message for the `AssertionError` (`null` okay)
        `condition` - condition to be checked

    - #### assertTrue

          public static void assertTrue(boolean condition)

      Asserts that a condition is true. If it isn't it throws an `AssertionError` without a message.
      Parameters:
        `condition` - condition to be checked

    - #### assertFalse

          public static void assertFalse(String message,
                         boolean condition)

      Asserts that a condition is false. If it isn't it throws an `AssertionError` with the given message.
      Parameters:
        `message` - the identifying message for the `AssertionError` (`null` okay)
        `condition` - condition to be checked

    - #### assertFalse

          public static void assertFalse(boolean condition)

      Asserts that a condition is false. If it isn't it throws an `AssertionError` without a message.
      Parameters:
        `condition` - condition to be checked

    - #### fail

          public static void fail(String message)

      Fails a test with the given message.
      Parameters:
        `message` - the identifying message for the `AssertionError` (`null` okay)
      See Also:
        `AssertionError`

    - #### fail

          public static void fail()

      Fails a test with no message.

    - #### assertEquals

          public static void assertEquals(String message,
                          Object expected,
                          Object actual)

      Asserts that two objects are equal. If they are not, an `AssertionError` is thrown with the given message. If `expected` and `actual` are `null`, they are considered equal.
      Parameters:
        `message` - the identifying message for the `AssertionError` (`null` okay)
        `expected` - expected value
        `actual` - actual value

    - #### assertEquals

          public static void assertEquals(Object expected,
                          Object actual)

      Asserts that two objects are equal. If they are not, an `AssertionError` without a message is thrown. If `expected` and `actual` are `null`, they are considered equal.
      Parameters:
        `expected` - expected value
        `actual` - the value to check against `expected`

    - #### assertNotEquals

          public static void assertNotEquals(String message,
                             Object first,
                             Object second)

      Asserts that two objects are not equals. If they are, an `AssertionError` is thrown with the given message. If `first` and `second` are `null`, they are considered equal.
      Parameters:
        `message` - the identifying message for the `AssertionError` (`null` okay)
        `first` - first value to check
        `second` - the value to check against `first`

    - #### assertNotEquals

          public static void assertNotEquals(Object first,
                             Object second)

      Asserts that two objects are not equals. If they are, an `AssertionError` without a message is thrown. If `first` and `second` are `null`, they are considered equal.
      Parameters:
        `first` - first value to check
        `second` - the value to check against `first`

    - #### assertNotEquals

          public static void assertNotEquals(String message,
                             long first,
                             long second)

      Asserts that two longs are not equals. If they are, an `AssertionError` is thrown with the given message.
      Parameters:
        `message` - the identifying message for the `AssertionError` (`null` okay)
        `first` - first value to check
        `second` - the value to check against `first`

    - #### assertNotEquals

          public static void assertNotEquals(long first,
                             long second)

      Asserts that two longs are not equals. If they are, an `AssertionError` without a message is thrown.
      Parameters:
        `first` - first value to check
        `second` - the value to check against `first`

    - #### assertNotEquals

          public static void assertNotEquals(String message,
                             double first,
                             double second,
                             double delta)

      Asserts that two doubles or floats are not equal to within a positive delta. If they are, an `AssertionError` is thrown with the given message. If the expected value is infinity then the delta value is ignored. NaNs are considered equal: `assertNotEquals(Double.NaN, Double.NaN, *)` fails
      Parameters:
        `message` - the identifying message for the `AssertionError` (`null` okay)
        `first` - first value to check
        `second` - the value to check against `first`
        `delta` - the maximum delta between `expected` and `actual` for which both numbers are still considered equal.

    - #### assertNotEquals

          public static void assertNotEquals(double first,
                             double second,
                             double delta)

      Asserts that two doubles or floats are not equal to within a positive delta. If they are, an `AssertionError` is thrown. If the expected value is infinity then the delta value is ignored.NaNs are considered equal: `assertNotEquals(Double.NaN, Double.NaN, *)` fails
      Parameters:
        `first` - first value to check
        `second` - the value to check against `first`
        `delta` - the maximum delta between `expected` and `actual` for which both numbers are still considered equal.

    - #### assertArrayEquals

          public static void assertArrayEquals(String message,
                               Object[] expecteds,
                               Object[] actuals)
                                        throws org.junit.internal.ArrayComparisonFailure

      Asserts that two object arrays are equal. If they are not, an `AssertionError` is thrown with the given message. If `expecteds` and `actuals` are `null`, they are considered equal.
      Parameters:
        `message` - the identifying message for the `AssertionError` (`null` okay)
        `expecteds` - Object array or array of arrays (multi-dimensional array) with expected values.
        `actuals` - Object array or array of arrays (multi-dimensional array) with actual values
      Throws:
        `org.junit.internal.ArrayComparisonFailure`

    - #### assertArrayEquals

          public static void assertArrayEquals(Object[] expecteds,
                               Object[] actuals)

      Asserts that two object arrays are equal. If they are not, an `AssertionError` is thrown. If `expected` and `actual` are `null`, they are considered equal.
      Parameters:
        `expecteds` - Object array or array of arrays (multi-dimensional array) with expected values
        `actuals` - Object array or array of arrays (multi-dimensional array) with actual values

    - #### assertArrayEquals

          public static void assertArrayEquals(String message,
                               byte[] expecteds,
                               byte[] actuals)
                                        throws org.junit.internal.ArrayComparisonFailure

      Asserts that two byte arrays are equal. If they are not, an `AssertionError` is thrown with the given message.
      Parameters:
        `message` - the identifying message for the `AssertionError` (`null` okay)
        `expecteds` - byte array with expected values.
        `actuals` - byte array with actual values
      Throws:
        `org.junit.internal.ArrayComparisonFailure`

    - #### assertArrayEquals

          public static void assertArrayEquals(byte[] expecteds,
                               byte[] actuals)

      Asserts that two byte arrays are equal. If they are not, an `AssertionError` is thrown.
      Parameters:
        `expecteds` - byte array with expected values.
        `actuals` - byte array with actual values

    - #### assertArrayEquals

          public static void assertArrayEquals(String message,
                               char[] expecteds,
                               char[] actuals)
                                        throws org.junit.internal.ArrayComparisonFailure

      Asserts that two char arrays are equal. If they are not, an `AssertionError` is thrown with the given message.
      Parameters:
        `message` - the identifying message for the `AssertionError` (`null` okay)
        `expecteds` - char array with expected values.
        `actuals` - char array with actual values
      Throws:
        `org.junit.internal.ArrayComparisonFailure`

    - #### assertArrayEquals

          public static void assertArrayEquals(char[] expecteds,
                               char[] actuals)

      Asserts that two char arrays are equal. If they are not, an `AssertionError` is thrown.
      Parameters:
        `expecteds` - char array with expected values.
        `actuals` - char array with actual values

    - #### assertArrayEquals

          public static void assertArrayEquals(String message,
                               short[] expecteds,
                               short[] actuals)
                                        throws org.junit.internal.ArrayComparisonFailure

      Asserts that two short arrays are equal. If they are not, an `AssertionError` is thrown with the given message.
      Parameters:
        `message` - the identifying message for the `AssertionError` (`null` okay)
        `expecteds` - short array with expected values.
        `actuals` - short array with actual values
      Throws:
        `org.junit.internal.ArrayComparisonFailure`

    - #### assertArrayEquals

          public static void assertArrayEquals(short[] expecteds,
                               short[] actuals)

      Asserts that two short arrays are equal. If they are not, an `AssertionError` is thrown.
      Parameters:
        `expecteds` - short array with expected values.
        `actuals` - short array with actual values

    - #### assertArrayEquals

          public static void assertArrayEquals(String message,
                               int[] expecteds,
                               int[] actuals)
                                        throws org.junit.internal.ArrayComparisonFailure

      Asserts that two int arrays are equal. If they are not, an `AssertionError` is thrown with the given message.
      Parameters:
        `message` - the identifying message for the `AssertionError` (`null` okay)
        `expecteds` - int array with expected values.
        `actuals` - int array with actual values
      Throws:
        `org.junit.internal.ArrayComparisonFailure`

    - #### assertArrayEquals

          public static void assertArrayEquals(int[] expecteds,
                               int[] actuals)

      Asserts that two int arrays are equal. If they are not, an `AssertionError` is thrown.
      Parameters:
        `expecteds` - int array with expected values.
        `actuals` - int array with actual values

    - #### assertArrayEquals

          public static void assertArrayEquals(String message,
                               long[] expecteds,
                               long[] actuals)
                                        throws org.junit.internal.ArrayComparisonFailure

      Asserts that two long arrays are equal. If they are not, an `AssertionError` is thrown with the given message.
      Parameters:
        `message` - the identifying message for the `AssertionError` (`null` okay)
        `expecteds` - long array with expected values.
        `actuals` - long array with actual values
      Throws:
        `org.junit.internal.ArrayComparisonFailure`

    - #### assertArrayEquals

          public static void assertArrayEquals(long[] expecteds,
                               long[] actuals)

      Asserts that two long arrays are equal. If they are not, an `AssertionError` is thrown.
      Parameters:
        `expecteds` - long array with expected values.
        `actuals` - long array with actual values

    - #### assertArrayEquals

          public static void assertArrayEquals(String message,
                               double[] expecteds,
                               double[] actuals,
                               double delta)
                                        throws org.junit.internal.ArrayComparisonFailure

      Asserts that two double arrays are equal. If they are not, an `AssertionError` is thrown with the given message.
      Parameters:
        `message` - the identifying message for the `AssertionError` (`null` okay)
        `expecteds` - double array with expected values.
        `actuals` - double array with actual values
      Throws:
        `org.junit.internal.ArrayComparisonFailure`

    - #### assertArrayEquals

          public static void assertArrayEquals(double[] expecteds,
                               double[] actuals,
                               double delta)

      Asserts that two double arrays are equal. If they are not, an `AssertionError` is thrown.
      Parameters:
        `expecteds` - double array with expected values.
        `actuals` - double array with actual values

    - #### assertArrayEquals

          public static void assertArrayEquals(String message,
                               float[] expecteds,
                               float[] actuals,
                               float delta)
                                        throws org.junit.internal.ArrayComparisonFailure

      Asserts that two float arrays are equal. If they are not, an `AssertionError` is thrown with the given message.
      Parameters:
        `message` - the identifying message for the `AssertionError` (`null` okay)
        `expecteds` - float array with expected values.
        `actuals` - float array with actual values
      Throws:
        `org.junit.internal.ArrayComparisonFailure`

    - #### assertArrayEquals

          public static void assertArrayEquals(float[] expecteds,
                               float[] actuals,
                               float delta)

      Asserts that two float arrays are equal. If they are not, an `AssertionError` is thrown.
      Parameters:
        `expecteds` - float array with expected values.
        `actuals` - float array with actual values

    - #### assertEquals

          public static void assertEquals(String message,
                          double expected,
                          double actual,
                          double delta)

      Asserts that two doubles are equal to within a positive delta. If they are not, an `AssertionError` is thrown with the given message. If the expected value is infinity then the delta value is ignored. NaNs are considered equal: `assertEquals(Double.NaN, Double.NaN, *)` passes
      Parameters:
        `message` - the identifying message for the `AssertionError` (`null` okay)
        `expected` - expected value
        `actual` - the value to check against `expected`
        `delta` - the maximum delta between `expected` and `actual` for which both numbers are still considered equal.

    - #### assertEquals

          public static void assertEquals(String message,
                          float expected,
                          float actual,
                          float delta)

      Asserts that two floats are equal to within a positive delta. If they are not, an `AssertionError` is thrown with the given message. If the expected value is infinity then the delta value is ignored. NaNs are considered equal: `assertEquals(Float.NaN, Float.NaN, *)` passes
      Parameters:
        `message` - the identifying message for the `AssertionError` (`null` okay)
        `expected` - expected value
        `actual` - the value to check against `expected`
        `delta` - the maximum delta between `expected` and `actual` for which both numbers are still considered equal.

    - #### assertEquals

          public static void assertEquals(long expected,
                          long actual)

      Asserts that two longs are equal. If they are not, an `AssertionError` is thrown.
      Parameters:
        `expected` - expected long value.
        `actual` - actual long value

    - #### assertEquals

          public static void assertEquals(String message,
                          long expected,
                          long actual)

      Asserts that two longs are equal. If they are not, an `AssertionError` is thrown with the given message.
      Parameters:
        `message` - the identifying message for the `AssertionError` (`null` okay)
        `expected` - long expected value.
        `actual` - long actual value

    - #### assertEquals

          @Deprecated
          public static void assertEquals(double expected,
                                     double actual)

      Deprecated. Use `assertEquals(double expected, double actual, double delta)` instead

    - #### assertEquals

          @Deprecated
          public static void assertEquals(String message,
                                     double expected,
                                     double actual)

      Deprecated. Use `assertEquals(String message, double expected, double actual, double delta)` instead

    - #### assertEquals

          public static void assertEquals(double expected,
                          double actual,
                          double delta)

      Asserts that two doubles are equal to within a positive delta. If they are not, an `AssertionError` is thrown. If the expected value is infinity then the delta value is ignored.NaNs are considered equal: `assertEquals(Double.NaN, Double.NaN, *)` passes
      Parameters:
        `expected` - expected value
        `actual` - the value to check against `expected`
        `delta` - the maximum delta between `expected` and `actual` for which both numbers are still considered equal.

    - #### assertEquals

          public static void assertEquals(float expected,
                          float actual,
                          float delta)

      Asserts that two floats are equal to within a positive delta. If they are not, an `AssertionError` is thrown. If the expected value is infinity then the delta value is ignored. NaNs are considered equal: `assertEquals(Float.NaN, Float.NaN, *)` passes
      Parameters:
        `expected` - expected value
        `actual` - the value to check against `expected`
        `delta` - the maximum delta between `expected` and `actual` for which both numbers are still considered equal.

    - #### assertNotNull

          public static void assertNotNull(String message,
                           Object object)

      Asserts that an object isn't null. If it is an `AssertionError` is thrown with the given message.
      Parameters:
        `message` - the identifying message for the `AssertionError` (`null` okay)
        `object` - Object to check or `null`

    - #### assertNotNull

          public static void assertNotNull(Object object)

      Asserts that an object isn't null. If it is an `AssertionError` is thrown.
      Parameters:
        `object` - Object to check or `null`

    - #### assertNull

          public static void assertNull(String message,
                        Object object)

      Asserts that an object is null. If it is not, an `AssertionError` is thrown with the given message.
      Parameters:
        `message` - the identifying message for the `AssertionError` (`null` okay)
        `object` - Object to check or `null`

    - #### assertNull

          public static void assertNull(Object object)

      Asserts that an object is null. If it isn't an `AssertionError` is thrown.
      Parameters:
        `object` - Object to check or `null`

    - #### assertSame

          public static void assertSame(String message,
                        Object expected,
                        Object actual)

      Asserts that two objects refer to the same object. If they are not, an `AssertionError` is thrown with the given message.
      Parameters:
        `message` - the identifying message for the `AssertionError` (`null` okay)
        `expected` - the expected object
        `actual` - the object to compare to `expected`

    - #### assertSame

          public static void assertSame(Object expected,
                        Object actual)

      Asserts that two objects refer to the same object. If they are not the same, an `AssertionError` without a message is thrown.
      Parameters:
        `expected` - the expected object
        `actual` - the object to compare to `expected`

    - #### assertNotSame

          public static void assertNotSame(String message,
                           Object unexpected,
                           Object actual)

      Asserts that two objects do not refer to the same object. If they do refer to the same object, an `AssertionError` is thrown with the given message.
      Parameters:
        `message` - the identifying message for the `AssertionError` (`null` okay)
        `unexpected` - the object you don't expect
        `actual` - the object to compare to `unexpected`

    - #### assertNotSame

          public static void assertNotSame(Object unexpected,
                           Object actual)

      Asserts that two objects do not refer to the same object. If they do refer to the same object, an `AssertionError` without a message is thrown.
      Parameters:
        `unexpected` - the object you don't expect
        `actual` - the object to compare to `unexpected`

    - #### assertEquals

          @Deprecated
          public static void assertEquals(String message,
                                     Object[] expecteds,
                                     Object[] actuals)

      Deprecated. use assertArrayEquals
      Asserts that two object arrays are equal. If they are not, an `AssertionError` is thrown with the given message. If `expecteds` and `actuals` are `null`, they are considered equal.
      Parameters:
        `message` - the identifying message for the `AssertionError` (`null` okay)
        `expecteds` - Object array or array of arrays (multi-dimensional array) with expected values.
        `actuals` - Object array or array of arrays (multi-dimensional array) with actual values

    - #### assertEquals

          @Deprecated
          public static void assertEquals(Object[] expecteds,
                                     Object[] actuals)

      Deprecated. use assertArrayEquals
      Asserts that two object arrays are equal. If they are not, an `AssertionError` is thrown. If `expected` and `actual` are `null`, they are considered equal.
      Parameters:
        `expecteds` - Object array or array of arrays (multi-dimensional array) with expected values
        `actuals` - Object array or array of arrays (multi-dimensional array) with actual values

    - #### assertThat

          public static <T> void assertThat(T actual,
                            Matcher<? super T> matcher)

      Asserts that `actual` satisfies the condition specified by `matcher`. If not, an `AssertionError` is thrown with information about the matcher and failing value. Example:

             assertThat(0, is(1)); // fails:
               // failure message:
               // expected: is <1>
               // got value: <0>
             assertThat(0, is(not(1))) // passes

      `org.hamcrest.Matcher` does not currently document the meaning of its type parameter `T`. This method assumes that a matcher typed as `Matcher<T>` can be meaningfully applied only to values that could be assigned to a variable of type `T`.
      Type Parameters:
        `T` - the static type accepted by the matcher (this can flag obvious compile-time problems such as `assertThat(1, is("a"))`
      Parameters:
        `actual` - the computed value being compared
        `matcher` - an expression, built of `Matcher`s, specifying allowed values
      See Also:
        `CoreMatchers`, `MatcherAssert`

    - #### assertThat

          public static <T> void assertThat(String reason,
                            T actual,
                            Matcher<? super T> matcher)

      Asserts that `actual` satisfies the condition specified by `matcher`. If not, an `AssertionError` is thrown with the reason and information about the matcher and failing value. Example:

             assertThat("Help! Integers don't work", 0, is(1)); // fails:
               // failure message:
               // Help! Integers don't work
               // expected: is <1>
               // got value: <0>
             assertThat("Zero is one", 0, is(not(1))) // passes

      `org.hamcrest.Matcher` does not currently document the meaning of its type parameter `T`. This method assumes that a matcher typed as `Matcher<T>` can be meaningfully applied only to values that could be assigned to a variable of type `T`.
      Type Parameters:
        `T` - the static type accepted by the matcher (this can flag obvious compile-time problems such as `assertThat(1, is("a"))`
      Parameters:
        `reason` - additional information about the error
        `actual` - the computed value being compared
        `matcher` - an expression, built of `Matcher`s, specifying allowed values
      See Also:
        `CoreMatchers`, `MatcherAssert`