/** * Returns "..." in place of common prefix and "..." in * place of common suffix between expected and actual. * * @see Throwable#getMessage() */ @Override public String getMessage() { return new ComparisonCompactor(MAX_CONTEXT_LENGTH, fExpected, fActual).compact(super.getMessage()); }
/** * Returns "..." in place of common prefix and "..." in * place of common suffix between expected and actual. * * @see Throwable#getMessage() */ @Override public String getMessage() { return new ComparisonCompactor(MAX_CONTEXT_LENGTH, fExpected, fActual).compact(super.getMessage()); }
private void assertBadUseOfReferentialEquality(Class<?> cls) throws Exception { try { tester.testEquals(cls); } catch (AssertionFailedError expected) { assertThat(expected.getMessage()).contains(cls.getSimpleName() + "("); return; } fail("should have failed for " + cls); }
public void testMessageOtherException() throws Exception { Method method = OneArg.class.getMethod("staticOneArgThrowsOtherThanNpe", String.class); boolean foundProblem = false; try { new NullPointerTester().testMethodParameter(new OneArg(), method, 0); } catch (AssertionFailedError expected) { assertThat(expected.getMessage()).contains("index 0"); assertThat(expected.getMessage()).contains("[null]"); foundProblem = true; } assertTrue("Should report error when different exception is thrown", foundProblem); }
public void testInstantiate_factoryMethodReturnsNullButNotAnnotated() throws Exception { try { tester.instantiate(FactoryMethodReturnsNullButNotAnnotated.class); } catch (AssertionFailedError expected) { assertThat(expected.getMessage()).contains("@Nullable"); return; } fail("should have failed"); }
public void testMessageNoException() throws Exception { Method method = OneArg.class.getMethod("staticOneArgShouldThrowNpeButDoesnt", String.class); boolean foundProblem = false; try { new NullPointerTester().testMethodParameter(new OneArg(), method, 0); } catch (AssertionFailedError expected) { assertThat(expected.getMessage()).contains("index 0"); assertThat(expected.getMessage()).contains("[null]"); foundProblem = true; } assertTrue("Should report error when no exception is thrown", foundProblem); }
public void testBadEquals() throws Exception { try { tester.testEquals(BadEquals.class); } catch (AssertionFailedError expected) { assertThat(expected.getMessage()).contains("create(null)"); return; } fail("should have failed"); }
public void testBadEquals_withParameterizedType() throws Exception { try { tester.testEquals(BadEqualsWithParameterizedType.class); } catch (AssertionFailedError expected) { assertThat(expected.getMessage()).contains("create([[1]])"); return; } fail("should have failed"); }
private <T> void assertFailure( Class<T> interfaceType, Function<T, ? extends T> wrapperFunction, String... expectedMessages) { try { tester.testForwarding(interfaceType, wrapperFunction); } catch (AssertionFailedError expected) { for (String message : expectedMessages) { assertThat(expected.getMessage()).contains(message); } return; } fail("expected failure not reported"); }
public void testClassWhichDoesNotImplementEquals() { ClassWhichDoesNotImplementEquals orig = new ClassWhichDoesNotImplementEquals(); boolean errorNotThrown = false; try { SerializableTester.reserializeAndAssert(orig); errorNotThrown = true; } catch (AssertionFailedError error) { // expected assertContains("must be Object#equals to", error.getMessage()); } assertFalse(errorNotThrown); }
public void testObjectWhichIsEqualButChangesClass() { ObjectWhichIsEqualButChangesClass orig = new ObjectWhichIsEqualButChangesClass(); boolean errorNotThrown = false; try { SerializableTester.reserializeAndAssert(orig); errorNotThrown = true; } catch (AssertionFailedError error) { // expected assertContains("expected:<class ", error.getMessage()); } assertFalse(errorNotThrown); }
public void testClassWhichIsAlwaysEqualButHasDifferentHashcodes() { ClassWhichIsAlwaysEqualButHasDifferentHashcodes orig = new ClassWhichIsAlwaysEqualButHasDifferentHashcodes(); boolean errorNotThrown = false; try { SerializableTester.reserializeAndAssert(orig); errorNotThrown = true; } catch (AssertionFailedError error) { // expected assertContains("must be equal to the Object#hashCode", error.getMessage()); } assertFalse(errorNotThrown); }
public TerminalTestCase assertLinesAre(String... lines) { assertEquals(lines.length, mTerminal.getScreen().mScreenRows); for (int i = 0; i < lines.length; i++) try { assertLineIs(i, lines[i]); } catch (AssertionFailedError e) { throw new AssertionFailedError("Line: " + i + " - " + e.getMessage()); } return this; }
public void testTest_hash() { Object group1Item1 = new TestObject(1, 1); Object group1Item2 = new TestObject(1, 2); equivalenceMock.expectEquivalent(group1Item1, group1Item2); equivalenceMock.expectEquivalent(group1Item2, group1Item1); equivalenceMock.expectHash(group1Item1, 1); equivalenceMock.expectHash(group1Item2, 2); equivalenceMock.replay(); try { tester.addEquivalenceGroup(group1Item1, group1Item2).test(); } catch (AssertionFailedError expected) { String expectedMessage = "the hash (1) of TestObject{group=1, item=1} [group 1, item 1] must be " + "equal to the hash (2) of TestObject{group=1, item=2} [group 1, item 2]"; if (!expected.getMessage().contains(expectedMessage)) { fail("<" + expected.getMessage() + "> expected to contain <" + expectedMessage + ">"); } return; } fail(); }
public void testTest_symmetric() { Object group1Item1 = new TestObject(1, 1); Object group1Item2 = new TestObject(1, 2); equivalenceMock.expectEquivalent(group1Item1, group1Item2); equivalenceMock.expectDistinct(group1Item2, group1Item1); equivalenceMock.expectHash(group1Item1, 1); equivalenceMock.expectHash(group1Item2, 1); equivalenceMock.replay(); try { tester.addEquivalenceGroup(group1Item1, group1Item2).test(); } catch (AssertionFailedError expected) { assertThat(expected.getMessage()) .contains( "TestObject{group=1, item=2} [group 1, item 2] must be equivalent to " + "TestObject{group=1, item=1} [group 1, item 1]"); return; } fail(); }
public void testTest_inequivalence() { Object group1Item1 = new TestObject(1, 1); Object group2Item1 = new TestObject(2, 1); equivalenceMock.expectEquivalent(group1Item1, group2Item1); equivalenceMock.expectDistinct(group2Item1, group1Item1); equivalenceMock.expectHash(group1Item1, 1); equivalenceMock.expectHash(group2Item1, 2); equivalenceMock.replay(); try { tester.addEquivalenceGroup(group1Item1).addEquivalenceGroup(group2Item1).test(); } catch (AssertionFailedError expected) { assertThat(expected.getMessage()) .contains( "TestObject{group=1, item=1} [group 1, item 1] must not be equivalent to " + "TestObject{group=2, item=1} [group 2, item 1]"); return; } fail(); }
public void testTest_trasitive() { Object group1Item1 = new TestObject(1, 1); Object group1Item2 = new TestObject(1, 2); Object group1Item3 = new TestObject(1, 3); equivalenceMock.expectEquivalent(group1Item1, group1Item2); equivalenceMock.expectEquivalent(group1Item1, group1Item3); equivalenceMock.expectEquivalent(group1Item2, group1Item1); equivalenceMock.expectDistinct(group1Item2, group1Item3); equivalenceMock.expectEquivalent(group1Item3, group1Item1); equivalenceMock.expectEquivalent(group1Item3, group1Item2); equivalenceMock.expectHash(group1Item1, 1); equivalenceMock.expectHash(group1Item2, 1); equivalenceMock.expectHash(group1Item3, 1); equivalenceMock.replay(); try { tester.addEquivalenceGroup(group1Item1, group1Item2, group1Item3).test(); } catch (AssertionFailedError expected) { assertThat(expected.getMessage()) .contains( "TestObject{group=1, item=2} [group 1, item 2] must be equivalent to " + "TestObject{group=1, item=3} [group 1, item 3]"); return; } fail(); }
/** * Returns "..." in place of common prefix and "..." in * place of common suffix between expected and actual. * * @see Throwable#getMessage() */ @Override public String getMessage() { return new ComparisonCompactor(MAX_CONTEXT_LENGTH, fExpected, fActual).compact(super.getMessage()); }
/** * Returns "..." in place of common prefix and "..." in * place of common suffix between expected and actual. * * @see Throwable#getMessage() */ @Override public String getMessage() { return new ComparisonCompactor(MAX_CONTEXT_LENGTH, fExpected, fActual).compact(super.getMessage()); }
public void testObjectWhichIsEqualButChangesClass() { ObjectWhichIsEqualButChangesClass orig = new ObjectWhichIsEqualButChangesClass(); boolean errorNotThrown = false; try { SerializableTester.reserializeAndAssert(orig); errorNotThrown = true; } catch (AssertionFailedError error) { // expected assertContains("expected:<class ", error.getMessage()); } assertFalse(errorNotThrown); }