/* Run a single test and decide whether the test was * successful, meaningless, or a failure. This is the * Template Method pattern abstraction of the inner loop in a * JML/JUnit test. */ public void runTest() throws java.lang.Throwable { try { // The call being tested! doCall(); } catch (org.jmlspecs.jmlrac.runtime.JMLEntryPreconditionError e) { // meaningless test input addMeaningless(); } catch (org.jmlspecs.jmlrac.runtime.JMLAssertionError e) { // test failure int l = org.jmlspecs.jmlrac.runtime.JMLChecker.getLevel(); org.jmlspecs.jmlrac.runtime.JMLChecker.setLevel(org.jmlspecs.jmlrac.runtime.JMLOption.NONE); try { java.lang.String failmsg = this.failMessage(e); junit.framework.AssertionFailedError err = new junit.framework.AssertionFailedError(failmsg); err.setStackTrace(new java.lang.StackTraceElement[] {}); err.initCause(e); result.addFailure(this, err); } finally { org.jmlspecs.jmlrac.runtime.JMLChecker.setLevel(l); } } catch (java.lang.Throwable e) { // test success } }
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(); }
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 testFailure() { selenium.setContext( "A real negative test, using the real Selenium on the browser side served by Jetty, driven from Java", SeleniumLogLevels.DEBUG); selenium.open("/selenium-server/tests/html/test_click_page1.html"); String badElementName = "This element doesn't exist, so Selenium should throw an exception"; try { selenium.getText(badElementName); fail("No exception was thrown!"); } catch (SeleniumException se) { assertTrue( "Exception message isn't as expected: " + se.getMessage(), se.getMessage().indexOf(badElementName + " not found") != -1); } try { assertTrue( "Negative test", selenium.isTextPresent("Negative test: verify non-existent text")); fail("No exception was thrown!"); } catch (AssertionFailedError se) { assertTrue( "Exception message isn't as expected: " + se.getMessage(), se.getMessage().indexOf("Negative test") != -1); } }
public void testExceptionContainsFileNameUnmarshalResourceWithBadResource() throws MarshalException, ValidationException, FileNotFoundException, IOException { /* * We are going to attempt to unmarshal groups.xml with the wrong * class so we get a MarshalException and we can then test to see if the * file name is embedded in the exception. */ boolean gotException = false; File file = ConfigurationTestUtils.getFileForConfigFile("groups.xml"); try { CastorUtils.unmarshal(Userinfo.class, new FileSystemResource(file)); } catch (MarshalException e) { String matchString = file.getAbsolutePath().replace('\\', '/'); if (e.toString().contains(matchString)) { gotException = true; } else { AssertionFailedError ae = new AssertionFailedError( "Got an exception, but not one containing the message we were expecting ('" + matchString + "'): " + e); ae.initCause(e); throw ae; } } if (!gotException) { fail("Did not get a MarshalException, but we were expecting one."); } }
public void testLoadFile() { try { String datadir = System.getProperty("planworks.test.data.dir") .concat(System.getProperty("file.separator")) .concat("loadTest") .concat(System.getProperty("file.separator")); checkConstraintLoad(datadir); checkConstraintVarMapLoad(datadir); checkObjectLoad(datadir); checkPartialPlanLoad(datadir); checkProjectLoad(datadir); checkSequenceLoad(datadir); checkTokenLoad(datadir); checkVariableLoad(datadir); // checkTransactionLoad(datadir); checkPartialPlanStatsLoad(datadir); checkResourceInstantsLoad(datadir); checkRulesLoad(datadir); checkRuleInstanceLoad(datadir); checkDecisionLoad(datadir); // catch assert errors and Exceptions here, since JUnit seems to not do it } catch (AssertionFailedError err) { err.printStackTrace(); System.exit(-1); } catch (Exception excp) { excp.printStackTrace(); System.exit(-1); } }
static Throwable wrapWithAddendum(Throwable ex, String addendum, boolean after) { if (ex instanceof AssertionFailedError) { AssertionFailedError ne = new AssertionFailedError(combineMessages(ex, addendum, after)); if (ex.getCause() != null) { ne.initCause(ex.getCause()); } ne.setStackTrace(ex.getStackTrace()); return ne; } if (ex instanceof AssertionError) { // preferred in JUnit 4 AssertionError ne = new AssertionError(combineMessages(ex, addendum, after)); if (ex.getCause() != null) { ne.initCause(ex.getCause()); } ne.setStackTrace(ex.getStackTrace()); return ne; } if (ex instanceof IOException) { // #66208 IOException ne = new IOException(combineMessages(ex, addendum, after)); if (ex.getCause() != null) { ne.initCause(ex.getCause()); } ne.setStackTrace(ex.getStackTrace()); return ne; } if (ex instanceof Exception) { return new InvocationTargetException(ex, combineMessages(ex, addendum, after)); } return ex; }
public void testThrowsAssertionFailedErrorIfTriesToThrowIncompatibleCheckedException() throws Throwable { Class[] expectedExceptionTypes = {ExpectedExceptionType1.class, ExpectedExceptionType2.class}; Invocation incompatibleInvocation = new Invocation( "INVOKED-OBJECT", methodFactory.newMethod( "methodName", MethodFactory.NO_ARGUMENTS, void.class, expectedExceptionTypes), null); try { throwStub.invoke(incompatibleInvocation); } catch (AssertionFailedError ex) { String message = ex.getMessage(); for (int i = 0; i < expectedExceptionTypes.length; i++) { AssertMo.assertIncludes( "should include name of expected exception types", expectedExceptionTypes[i].getName(), message); } AssertMo.assertIncludes( "should include name of thrown exception type", THROWABLE.getClass().getName(), message); return; } fail("should have failed"); }
protected final <A extends Annotation> void assertAnnotation( PropertyInfo<?, ?> property, Class<A> annotationClass, Map<String, Object> expectedAnnotation) { A ann1 = property.getAnnotation(annotationClass); assertNotNull(ann1); Map<String, Object> values = new HashMap<String, Object>(); for (Method m : ann1.getClass().getDeclaredMethods()) { if (m.getName().equals("equals") && m.getParameterTypes().length == 1 && m.getParameterTypes()[0] == Object.class) { continue; } if (m.getName().equals("hashCode") && m.getParameterTypes().length == 0) { continue; } if (m.getName().equals("toString") && m.getParameterTypes().length == 0) { continue; } if (m.getName().equals("annotationType") && m.getParameterTypes().length == 0) { continue; } try { Object value = m.invoke(ann1); values.put(m.getName(), value); } catch (Exception e) { AssertionFailedError afe = new AssertionFailedError("Could not invoke annotation value " + m); afe.initCause(e); throw afe; } } assertEquals(expectedAnnotation, values); }
private void _transition_exprAction__grid_transitions0_actions1(final GridImpl<String> it) { try { this.gridImpl.setElement(0, 1, "0, 1"); } catch (junit.framework.AssertionFailedError error) { fail("gridImpl.setElement(0, 1, \"0, 1\") failed: " + error.getMessage()); } }
public void testPathsCanRevealNamingAmbiguitiesWhenUsingSubstrings() throws Exception { try { tree.select("child/child1_1"); throw new AssertionFailureNotDetectedError(); } catch (AssertionFailedError e) { assertEquals("Naming ambiguity: there are several 'child' under 'root'", e.getMessage()); } }
public void testSelectChildrenWithNoMatch() throws Exception { try { tree.select("", "UNKNOWN"); throw new AssertionFailureNotDetectedError(); } catch (AssertionFailedError e) { assertEquals("No children found", e.getMessage()); } }
public void testSelectMultiplePathsWithInvalidPath() throws Exception { try { tree.select(new String[] {"child1", "unknown"}); throw new AssertionFailureNotDetectedError(); } catch (AssertionFailedError e) { assertEquals(Tree.badTreePath("unknown"), e.getMessage()); } }
private void _transition_exprAction__gridIteratorColumnMajor_transitions0_actions5( final GridImpl<String> it, final GridIterator<String> gridIterator) { try { this.gridImpl.setElement(1, 2, "1, 2"); } catch (junit.framework.AssertionFailedError error) { fail("gridImpl.setElement(1, 2, \"1, 2\") failed: " + error.getMessage()); } }
public void testPathsCanRevealNamingAmbiguitiesWhenUsingExactNames() throws Exception { rootNode.add(new DefaultMutableTreeNode(child1)); try { tree.select("child1/child1_1"); throw new AssertionFailureNotDetectedError(); } catch (AssertionFailedError e) { assertEquals("Naming ambiguity: there are several 'child1' under 'root'", e.getMessage()); } }
public void testInsertTextAtABadPosition() throws Exception { textBox.setText("text"); try { textBox.insertText("a", 10); throw new AssertionFailureNotDetectedError(); } catch (AssertionFailedError e) { assertEquals("Position should be between 0 and 4", e.getMessage()); } }
public void verify() { forgetFailure(); try { invocationDispatcher.verify(); } catch (AssertionFailedError ex) { throw new AssertionFailedError("mock object " + name + ": " + ex.getMessage()); } }
/** Sleeps until the given time has elapsed. Throws AssertionFailedError if interrupted. */ void sleep(long millis) { try { delay(millis); } catch (InterruptedException ie) { AssertionFailedError afe = new AssertionFailedError("Unexpected InterruptedException"); afe.initCause(ie); throw afe; } }
public void testCheckSelectionWithBadPath() throws Exception { tree.select("child1/child1_1"); String pathToCheck = "child1/toto"; try { assertTrue(tree.selectionEquals(pathToCheck)); throw new AssertionFailureNotDetectedError(); } catch (AssertionFailedError e) { assertEquals(Tree.badTreePath("child1/toto"), e.getMessage()); } }
protected void enableAutoCommit() { try { netConn.setAutoCommit(false); } catch (SQLException se) { junit.framework.AssertionFailedError ase = new junit.framework.AssertionFailedError(se.getMessage()); ase.initCause(se); throw ase; } }
public void testAssertEmptyWithPlainText() throws Exception { jTextComponent.setText(""); assertTrue(textBox.textIsEmpty()); jTextComponent.setText("a"); try { assertTrue(textBox.textIsEmpty()); throw new AssertionFailureNotDetectedError(); } catch (AssertionFailedError e) { assertEquals("Text should be empty but contains: a", e.getMessage()); } }
public void testSelectNonexistingPath() throws Exception { assertNull(jTree.getSelectionRows()); String path = "child1/unexistingElement"; try { tree.select(path); throw new AssertionFailureNotDetectedError(); } catch (AssertionFailedError e) { assertEquals(Tree.badTreePath("child1/unexistingElement"), e.getMessage()); } assertNull(jTree.getSelectionRows()); }
public void testInsertTextChecksThatTheComponentIsEditable() throws Exception { textBox.setText("text"); jTextComponent.setEditable(false); try { textBox.insertText("new text", 0); throw new AssertionFailureNotDetectedError(); } catch (AssertionFailedError e) { assertEquals("The text box is not editable", e.getMessage()); } assertEquals("text", jTextComponent.getText()); }
public void testAppendsInfoToFailureMessage() throws Exception { try { conditionRunner.waitFor("this condition should always fail", new AlwaysFalseCondition()); fail("the condition should have failed"); } catch (AssertionFailedError expected) { assertEquals( "Condition \"Sky should be blue\" failed to become true within 100 msec; " + "this condition should always fail; [sky is in fact pink]", expected.getMessage()); } }
/** * Records the given exception using {@link #threadRecordFailure}, then rethrows the exception, * wrapping it in an AssertionFailedError if necessary. */ public void threadUnexpectedException(Throwable t) { threadRecordFailure(t); t.printStackTrace(); if (t instanceof RuntimeException) throw (RuntimeException) t; else if (t instanceof Error) throw (Error) t; else { AssertionFailedError afe = new AssertionFailedError("unexpected exception: " + t); afe.initCause(t); throw afe; } }
public int await() { try { return super.await(2 * LONG_DELAY_MS, MILLISECONDS); } catch (TimeoutException e) { throw new AssertionFailedError("timed out"); } catch (Exception e) { AssertionFailedError afe = new AssertionFailedError("Unexpected exception: " + e); afe.initCause(e); throw afe; } }
public void test_assertReceivedMessage_withMultipleSender() throws Exception { sendMail("darth.Vader", new String[] {"luke", "chewbacca"}, "n/a", "n/a"); mailFixture.getReceivedMessage(0).assertThat().to("luke", "chewbacca"); try { mailFixture.getReceivedMessage(0).assertThat().to("mika"); fail("should fail"); } catch (AssertionFailedError error) { assertEquals("Assert To - The value 'mika' is not in [luke, chewbacca]", error.getMessage()); } }
public void test_assertReceivedMessagesCount() throws Exception { sendMail("darth.Vader", "luke.Skywalker", "scoop", "Je suis ton pere"); mailFixture.assertReceivedMessagesCount(1); try { mailFixture.assertReceivedMessagesCount(2); fail("should fail"); } catch (AssertionFailedError error) { assertEquals("Received message count expected:<2> but was:<1>", error.getMessage()); } }
public void testReportsUsefulErrorMessageWhenTryingToMockNonStaticInnerClass() { try { mock(NonStaticInnerClass.class); } catch (AssertionFailedError e) { assertTrue("should report error", e.getMessage().indexOf("non-static inner class") >= 0); assertTrue( "should report name of inner class", e.getMessage().indexOf(NonStaticInnerClass.class.getName()) >= 0); return; } fail("should have failed"); }
/** * Test method for {@link * org.jboss.jsfunit.analysis.ApplicationFactoryTestCase#testClassLoadable()}. */ public void testTestClassLoadable() { ApplicationFactoryTestCase testcase = new ApplicationFactoryTestCase("testTestClassLoadable", "com.nonexist.Foo"); try { testcase.testClassLoadable(); fail("should have failed"); } catch (AssertionFailedError afe) { assertEquals( "Could not load class 'com.nonexist.Foo' for element 'Application Factory'", afe.getMessage()); } }