@Test public void should_pass_if_actual_is_empty_whatever_given_comparator_is() { arrays.assertIsSortedAccordingToComparator( someInfo(), emptyArray(), byteDescendingOrderComparator); arrays.assertIsSortedAccordingToComparator( someInfo(), emptyArray(), byteAscendingOrderComparator); }
@Test public void should_fail_if_actual_contains_given_values() { AssertionInfo info = someInfo(); byte[] expected = {6, 8, 20}; try { arrays.assertDoesNotContain(info, actual, expected); } catch (AssertionError e) { verify(failures).failure(info, shouldNotContain(actual, expected, set((byte) 6, (byte) 8))); return; } throw expectedAssertionErrorNotThrown(); }
@Test public void should_fail_if_actual_starts_with_first_elements_of_sequence_only() { AssertionInfo info = someInfo(); byte[] sequence = {6, 20}; try { arrays.assertStartsWith(info, actual, sequence); } catch (AssertionError e) { verifyFailureThrownWhenSequenceNotFound(info, sequence); return; } throw expectedAssertionErrorNotThrown(); }
@Test public void should_fail_if_actual_is_not_sorted_according_to_given_comparator() { AssertionInfo info = someInfo(); actual = new byte[] {3, 2, 1, 9}; try { arrays.assertIsSortedAccordingToComparator(info, actual, byteDescendingOrderComparator); } catch (AssertionError e) { verify(failures).failure(info, shouldBeSortedAccordingToGivenComparator(2, actual)); return; } failBecauseExpectedAssertionErrorWasNotThrown(); }
@Test public void should_fail_if_sequence_is_bigger_than_actual() { AssertionInfo info = someInfo(); byte[] sequence = {6, 8, 10, 12, 20, 22}; try { arrays.assertStartsWith(info, actual, sequence); } catch (AssertionError e) { verifyFailureThrownWhenSequenceNotFound(info, sequence); return; } throw expectedAssertionErrorNotThrown(); }
@Test public void should_fail_if_actual_does_not_start_with_sequence() { AssertionInfo info = someInfo(); byte[] sequence = {8, 10}; try { arrays.assertStartsWith(info, actual, sequence); } catch (AssertionError e) { verifyFailureThrownWhenSequenceNotFound(info, sequence); return; } throw expectedAssertionErrorNotThrown(); }
@Before public void setUp() { failures = spy(new Failures()); actual = new byte[] {4, 3, 2, 2, 1}; arrays = new ByteArrays(); arrays.failures = failures; byteDescendingOrderComparator = new Comparator<Byte>() { public int compare(Byte byte1, Byte byte2) { return -byte1.compareTo(byte2); } }; byteAscendingOrderComparator = new Comparator<Byte>() { public int compare(Byte byte1, Byte byte2) { return byte1.compareTo(byte2); } }; }
@Test public void should_fail_if_actual_is_null() { thrown.expectAssertionError(actualIsNull()); arrays.assertStartsWith(someInfo(), null, array(8)); }
@Test public void should_throw_error_if_sequence_is_empty() { thrown.expectIllegalArgumentException(valuesToLookForIsEmpty()); arrays.assertStartsWith(someInfo(), actual, emptyArray()); }
@Test public void should_throw_error_if_sequence_is_null() { thrown.expectNullPointerException(valuesToLookForIsNull()); arrays.assertStartsWith(someInfo(), actual, null); }
@Before public void setUp() { failures = spy(new Failures()); arrays = new ByteArrays(); arrays.failures = failures; }
@Test public void should_pass_if_actual_and_sequence_are_equal() { arrays.assertStartsWith(someInfo(), actual, array(6, 8, 10, 12)); }
@Test public void should_fail_if_comparator_is_null() { thrown.expect(NullPointerException.class); arrays.assertIsSortedAccordingToComparator(someInfo(), emptyArray(), null); }
@Test public void should_pass_if_actual_is_sorted_according_to_given_comparator() { arrays.assertIsSortedAccordingToComparator(someInfo(), actual, byteDescendingOrderComparator); }
@Test public void should_fail_if_actual_is_null() { thrown.expectAssertionError(actualIsNull()); arrays.assertDoesNotContain(someInfo(), null, array(8)); }
@Test public void should_throw_error_if_array_of_values_to_look_for_is_null() { thrown.expectNullPointerException(valuesToLookForIsNull()); arrays.assertDoesNotContain(someInfo(), actual, null); }
@Test public void should_throw_error_if_array_of_values_to_look_for_is_empty() { thrown.expectIllegalArgumentException(valuesToLookForIsEmpty()); arrays.assertDoesNotContain(someInfo(), actual, emptyArray()); }
@Test public void should_pass_if_actual_does_not_contain_given_values_even_if_duplicated() { arrays.assertDoesNotContain(someInfo(), actual, array(12, 12, 20)); }
@Test public void should_pass_if_actual_starts_with_sequence() { arrays.assertStartsWith(someInfo(), actual, array(6, 8, 10)); }
@Test public void should_fail_if_actual_is_null() { thrown.expectAssertionError(actualIsNull()); arrays.assertIsSortedAccordingToComparator(someInfo(), null, byteDescendingOrderComparator); }