/*
* 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);
}
}