| /* | |
| * Copyright 2007 Google Inc. | |
| * | |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may not | |
| * use this file except in compliance with the License. You may obtain a copy of | |
| * the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT | |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the | |
| * License for the specific language governing permissions and limitations under | |
| * the License. | |
| */ | |
| /* | |
| * Portions copyright 2006 Mat Gessel <mat.gessel@gmail.com>; licensed under | |
| * Apache 2.0 | |
| */ | |
| package com.google.gwt.junit.client; | |
| import static com.google.gwt.junit.client.GWTTestCaseTest.SetUpTearDownState.INITIAL; | |
| import static com.google.gwt.junit.client.GWTTestCaseTest.SetUpTearDownState.IS_SETUP; | |
| import static com.google.gwt.junit.client.GWTTestCaseTest.SetUpTearDownState.IS_TORNDOWN; | |
| import com.google.gwt.core.client.GWT; | |
| import com.google.gwt.junit.DoNotRunWith; | |
| import com.google.gwt.junit.Platform; | |
| import com.google.gwt.user.client.Timer; | |
| import junit.framework.AssertionFailedError; | |
| /** | |
| * This class tests our implementation of the GWTTestCase class which provides | |
| * the behavior of TestCase that is necessary in GWT. | |
| */ | |
| public class GWTTestCaseTest extends GWTTestCase { | |
| /** | |
| * Tracks whether or not setup and teardown have run. | |
| */ | |
| protected enum SetUpTearDownState { | |
| INITIAL, IS_SETUP, IS_TORNDOWN | |
| } | |
| /** | |
| * If non-null, records an error related to setup/teardown that could not have | |
| * been caught during normal test execution. | |
| */ | |
| private static String outOfBandError = null; | |
| /** | |
| * These two variables test the retry functionality, currently used with | |
| * HtmlUnit. | |
| */ | |
| private static boolean attemptedOnce = false; | |
| private static boolean htmlunitMode = true; | |
| private static void assertNotEquals(double a, double b, double delta) { | |
| boolean failed = false; | |
| try { | |
| assertEquals(a, b, delta); | |
| } catch (AssertionFailedError e) { | |
| // EXPECTED | |
| failed = true; | |
| } | |
| if (!failed) { | |
| fail("Expected failure for assertEquals(" + a + ", " + b + ", " + delta | |
| + ")"); | |
| } | |
| } | |
| private static void assertNotEquals(float a, float b, float delta) { | |
| boolean failed = false; | |
| try { | |
| assertEquals(a, b, delta); | |
| } catch (AssertionFailedError e) { | |
| // EXPECTED | |
| failed = true; | |
| } | |
| if (!failed) { | |
| fail("Expected failure for assertEquals(" + a + ", " + b + ", " + delta | |
| + ")"); | |
| } | |
| } | |
| /** | |
| * Tracks whether this test has been setup and torn down. | |
| */ | |
| protected SetUpTearDownState setupTeardownFlag = INITIAL; | |
| public String getModuleName() { | |
| return "com.google.gwt.junit.JUnit"; | |
| } | |
| public void testAssertEqualsDouble() { | |
| assertEquals(0.0, 0.0, 0.0); | |
| assertEquals(1.1, 1.1, 0.0); | |
| assertEquals(-1.1, -1.1, 0.0); | |
| assertEquals(Float.MIN_VALUE, Float.MIN_VALUE, 0.0); | |
| assertEquals(Float.MAX_VALUE, Float.MAX_VALUE, 0.0); | |
| assertNotEquals(0.0, 0.00000000000000000000000000000000000000001, 0.0); | |
| assertNotEquals(0.0, 0.0000000000000000001, 0.0); | |
| assertNotEquals(0.0, 0.000000001, 0.0); | |
| assertNotEquals(0.0, 0.0001, 0.0); | |
| assertNotEquals(0.0, 0.1, 0.0); | |
| assertNotEquals(1.0, 2.0, 0.1); | |
| assertNotEquals(2.0, 1.0, 0.1); | |
| assertNotEquals(-1.0, -2.0, 0.1); | |
| assertNotEquals(-2.0, -1.0, 0.1); | |
| } | |
| public void testAssertEqualsFloat() { | |
| assertEquals(0.0f, 0.0f, 0.0f); | |
| assertEquals(1.1f, 1.1f, 0.0f); | |
| assertEquals(-1.1f, -1.1f, 0.0f); | |
| assertEquals(Float.MIN_VALUE, Float.MIN_VALUE, 0.0f); | |
| assertEquals(Float.MAX_VALUE, Float.MAX_VALUE, 0.0f); | |
| assertNotEquals(0.0f, 0.00000000000000000000000000000000000000001f, 0.0f); | |
| assertNotEquals(0.0f, 0.0000000000000000001f, 0.0f); | |
| assertNotEquals(0.0f, 0.000000001f, 0.0f); | |
| assertNotEquals(0.0f, 0.0001f, 0.0f); | |
| assertNotEquals(0.0f, 0.1f, 0.0f); | |
| assertNotEquals(1.0f, 2.0f, 0.1f); | |
| assertNotEquals(2.0f, 1.0f, 0.1f); | |
| assertNotEquals(-1.0f, -2.0f, 0.1f); | |
| assertNotEquals(-2.0f, -1.0f, 0.1f); | |
| } | |
| /** | |
| * | |
| */ | |
| public void testAssertEqualsIntInt() { | |
| assertEquals(5, 5); | |
| boolean exWasThrown = false; | |
| try { | |
| assertEquals(5, 4); | |
| } catch (Throwable ex) { | |
| exWasThrown = true; | |
| if (!(ex instanceof AssertionFailedError)) { | |
| fail("Unexpected type of exception during assertEquals(int,int) testing"); | |
| } | |
| } | |
| if (!exWasThrown) { | |
| fail("No exception was thrown during assertEquals(int,int) testing"); | |
| } | |
| } | |
| /** | |
| * | |
| */ | |
| public void testAssertEqualsObjectObject() { | |
| Object obj1 = "String"; | |
| assertEquals(obj1, obj1); | |
| boolean exWasThrown = false; | |
| try { | |
| Object obj2 = "not String"; | |
| assertEquals(obj1, obj2); | |
| } catch (Throwable ex) { | |
| exWasThrown = true; | |
| if (!(ex instanceof AssertionFailedError)) { | |
| fail("Unexpected type of exception during assertEquals(String,String) testing"); | |
| } | |
| } | |
| if (!exWasThrown) { | |
| fail("No exception was thrown during assertEquals(String,String) testing"); | |
| } | |
| } | |
| /** | |
| * | |
| */ | |
| public void testAssertEqualsStringIntInt() { | |
| assertEquals("", 5, 5); | |
| boolean exWasThrown = false; | |
| try { | |
| assertEquals("hello", 5, 4); | |
| } catch (Throwable ex) { | |
| exWasThrown = true; | |
| if (!(ex instanceof AssertionFailedError)) { | |
| fail("Unexpected type of exception during assertEquals(String,int,int) testing"); | |
| } | |
| } | |
| if (!exWasThrown) { | |
| fail("No exception was thrown during assertEquals(String,int,int) testing"); | |
| } | |
| } | |
| /** | |
| * | |
| */ | |
| public void testAssertEqualsStringObjectObject() { | |
| Object obj1 = "String"; | |
| assertEquals("msg", obj1, obj1); | |
| boolean exWasThrown = false; | |
| try { | |
| Object obj2 = "not String"; | |
| assertEquals("msg", obj1, obj2); | |
| } catch (Throwable ex) { | |
| exWasThrown = true; | |
| if (!(ex instanceof AssertionFailedError)) { | |
| fail("Unexpected type of exception during assertEquals(String,Object,Object) testing"); | |
| } | |
| } | |
| if (!exWasThrown) { | |
| fail("No exception was thrown during assertEquals(String,Object,Object) testing"); | |
| } | |
| } | |
| /** | |
| * | |
| */ | |
| public void testAssertFalse() { | |
| // Should not fail | |
| assertFalse(false); | |
| // Should not fail | |
| assertFalse("We should be okay", false); | |
| boolean exWasThrown = false; | |
| try { | |
| // Should fail | |
| assertFalse(true); | |
| } catch (Throwable ex) { | |
| exWasThrown = true; | |
| if (!(ex instanceof AssertionFailedError)) { | |
| fail("Unexpected type of exception during assertFalse(boolean) testing"); | |
| } | |
| } | |
| if (!exWasThrown) { | |
| fail("No exception was thrown"); | |
| } | |
| exWasThrown = false; | |
| try { | |
| // Should fail | |
| assertFalse("This should be okay", true); | |
| } catch (Throwable ex) { | |
| exWasThrown = true; | |
| if (ex instanceof AssertionFailedError) { | |
| return; | |
| } | |
| } | |
| if (!exWasThrown) { | |
| fail("No exception was thrown"); | |
| } else { | |
| fail("Unexpected exception during assertFalse(String, boolean) testing"); | |
| } | |
| } | |
| /** | |
| * | |
| */ | |
| public void testAssertNotNull() { | |
| assertNotNull("Hello"); | |
| assertNotNull("We should be okay", "Hello"); | |
| try { | |
| assertNotNull("Hello"); | |
| } catch (Throwable ex) { | |
| if (!(ex instanceof AssertionFailedError)) { | |
| fail("Unexpected type of exception during assertNotNull(Object) testing"); | |
| } | |
| } | |
| try { | |
| assertNotNull("This should be okay", null); | |
| } catch (Throwable ex) { | |
| if (ex instanceof AssertionFailedError) { | |
| return; | |
| } | |
| } | |
| fail("Unexpected exception during assertNotNull(String, Object) testing"); | |
| } | |
| /** | |
| * | |
| */ | |
| public void testAssertNotSame() { | |
| Object obj1 = "Foo"; | |
| Object obj2 = "Bar"; | |
| assertNotSame(obj1, obj2); | |
| assertNotSame("Hello", obj1, obj2); | |
| try { | |
| assertNotSame(obj1, "Baz"); | |
| } catch (Throwable ex) { | |
| if (!(ex instanceof AssertionFailedError)) { | |
| fail("Unexpected type of exception"); | |
| } | |
| } | |
| } | |
| /** | |
| * | |
| */ | |
| public void testAssertNull() { | |
| assertNull(null); | |
| assertNull("We should be okay", null); | |
| try { | |
| assertNull("Hello"); | |
| } catch (Throwable ex) { | |
| if (!(ex instanceof AssertionFailedError)) { | |
| fail("Unexpected type of exception during assertNull(Object) testing"); | |
| } | |
| } | |
| try { | |
| assertNull("This should be okay", "Hello"); | |
| } catch (Throwable ex) { | |
| if (ex instanceof AssertionFailedError) { | |
| return; | |
| } | |
| } | |
| fail("Unexpected exception during assertNull(String, Object) testing"); | |
| } | |
| /** | |
| * | |
| */ | |
| public void testAssertSame() { | |
| // TODO(mmendez): finish this test | |
| } | |
| /** | |
| * | |
| */ | |
| public void testAssertTrue() { | |
| assertTrue(true); | |
| assertTrue("We should be okay", true); | |
| try { | |
| assertTrue(false); | |
| } catch (Throwable ex) { | |
| if (!(ex instanceof AssertionFailedError)) { | |
| fail("Unexpected type of exception during assertFalse(boolean) testing"); | |
| } | |
| } | |
| try { | |
| assertTrue("This should be okay", false); | |
| } catch (Throwable ex) { | |
| if (ex instanceof AssertionFailedError) { | |
| return; | |
| } | |
| } | |
| fail("Unexpected exception during assertTrue(String, boolean) testing"); | |
| } | |
| /** | |
| * Test skipping a test for dev mode. | |
| */ | |
| @DoNotRunWith(Platform.Devel) | |
| public void testPlatformDevel() { | |
| assertTrue("Should not run in devel mode", GWT.isScript()); | |
| } | |
| /** | |
| * Test skipping a test for prod mode. | |
| */ | |
| @DoNotRunWith(Platform.Prod) | |
| public void testPlatformProd() { | |
| assertTrue("Should not run in prod mode", !GWT.isScript()); | |
| } | |
| public void testSetUpTearDown() throws Exception { | |
| assertSame(IS_SETUP, setupTeardownFlag); | |
| tearDown(); | |
| assertSame(IS_TORNDOWN, setupTeardownFlag); | |
| setUp(); | |
| assertSame(IS_SETUP, setupTeardownFlag); | |
| gwtTearDown(); | |
| assertSame(IS_TORNDOWN, setupTeardownFlag); | |
| gwtSetUp(); | |
| assertSame(IS_SETUP, setupTeardownFlag); | |
| } | |
| public void testSetUpTearDownAsync() { | |
| assertSame(IS_SETUP, setupTeardownFlag); | |
| delayTestFinish(1000); | |
| new Timer() { | |
| @Override | |
| public void run() { | |
| assertSame(IS_SETUP, setupTeardownFlag); | |
| finishTest(); | |
| if (setupTeardownFlag != IS_TORNDOWN) { | |
| recordOutofBandError("Bad async success tearDown behavior not catchable by JUnit"); | |
| } | |
| } | |
| }.schedule(1); | |
| } | |
| public void testSetUpTearDownAsyncHadNoOutOfBandErrors() { | |
| assertNoOutOfBandErrorsAsync(); | |
| } | |
| @Override | |
| protected void gwtSetUp() throws Exception { | |
| setupTeardownFlag = IS_SETUP; | |
| } | |
| @Override | |
| protected void gwtTearDown() throws Exception { | |
| if (setupTeardownFlag != IS_SETUP) { | |
| // Must use window alert to grind the test to a halt in this failure. | |
| recordOutofBandError("Bad tearDown behavior not catchable by JUnit"); | |
| } | |
| setupTeardownFlag = IS_TORNDOWN; | |
| } | |
| protected static void recordOutofBandError(String outOfBandError) { | |
| GWTTestCaseTest.outOfBandError = outOfBandError; | |
| } | |
| /** | |
| * Call this method to asynchronously check for out of band errors in the | |
| * previous test. | |
| */ | |
| protected void assertNoOutOfBandErrorsAsync() { | |
| // Give things a chance to settle down. | |
| delayTestFinish(10000); | |
| new Timer() { | |
| @Override | |
| public void run() { | |
| if (outOfBandError != null) { | |
| String msg = outOfBandError; | |
| outOfBandError = null; | |
| fail(msg); | |
| } | |
| finishTest(); | |
| } | |
| }.schedule(1000); | |
| } | |
| } |