/*
* 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 com.google.gwt.core.client.GWT;
import com.google.gwt.core.client.JavaScriptException;
import com.google.gwt.core.shared.SerializableThrowable;
import com.google.gwt.junit.DoNotRunWith;
import com.google.gwt.junit.Platform;
import junit.framework.AssertionFailedError;
import java.util.Collections;
/**
* This class tests our implementation of the GWTTestCase class which provides the behavior of
* TestCase that is necessary in GWT.
*/
public class GWTTestCaseTest extends GWTTestCaseTestBase {
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 + ")");
}
}
private Object obj1 = Collections.nCopies(1, "data");
private Object obj2 = Collections.nCopies(2, "data");
private Object obj1Equal = Collections.nCopies(1, "data");
@ExpectedFailure(withMessage = "testFail")
public void testFail() {
fail("testFail");
}
@ExpectedFailure(withType = Exception.class)
public void testThrowsException() throws Exception {
throw new Exception();
}
@ExpectedFailure(withType = JavaScriptException.class)
public void testThrowsJavaScriptException() {
throw new JavaScriptException("name", "desc");
}
@ExpectedFailure(withType = NullPointerException.class)
public void testThrowsNullPointerException() {
throw new NullPointerException();
}
static class SomeNonSerializableException extends RuntimeException {
public SomeNonSerializableException(String msg) {
super(msg);
}
// no default constructor
// public SomeNonSerializableException() {}
}
// We lose some type information if class meta data is not available, setting expected failure
// to RuntimeException will ensure this test case passes for no metadata. Also see the next test.
@ExpectedFailure(withType = RuntimeException.class,
withMessage = "testThrowsNonSerializableException")
public void testThrowsNonSerializableException() {
throw new SomeNonSerializableException("testThrowsNonSerializableException");
}
@ExpectedFailure(withType = SomeNonSerializableException.class)
public void testThrowsNonSerializableException_hasMetaData() throws Throwable {
if (!Object.class.getName().equals("java.lang.Object")) {
// If there is no metadata lets make the test case happy
SerializableThrowable throwable = SerializableThrowable.fromThrowable(new Exception());
throwable.setDesignatedType(
"com.google.gwt.junit.client.GWTTestCaseTest$SomeNonSerializableException", true);
throw throwable;
}
testThrowsNonSerializableException();
}
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);
assertEquals("msg", 5, 5);
}
@ExpectedFailure
public void testAssertEqualsIntIntFail() {
assertEquals(5, 4);
}
@ExpectedFailure(withMessage = "msg")
public void testAssertEqualsIntIntFailWithMessage() {
assertEquals("msg", 5, 4);
}
public void testAssertEqualsObjectObject() {
assertEquals(obj1, obj1Equal);
assertEquals("msg", obj1, obj1);
}
@ExpectedFailure
public void testAssertEqualsObjectObjectFail() {
assertEquals(obj1, obj2);
}
@ExpectedFailure(withMessage = "msg")
public void testAssertEqualsObjectObjectFailWithMessage() {
assertEquals("msg", obj1, obj2);
}
public void testAssertFalse() {
assertFalse(false);
assertFalse("msg", false);
}
@ExpectedFailure
public void testAssertFalseFail() {
assertFalse(true);
}
@ExpectedFailure(withMessage = "msg")
public void testAssertFalseFailWithMessage() {
assertFalse("msg", true);
}
public void testAssertNotNull() {
assertNotNull("Hello");
assertNotNull("msg", "Hello");
}
@ExpectedFailure
public void testAssertNotNullFail() {
assertNotNull(null);
}
@ExpectedFailure(withMessage = "msg")
public void testAssertNotNullStringFailWithMessage() {
assertNotNull("msg", null);
}
public void testAssertNotSame() {
assertNotSame(obj1, obj2);
assertNotSame("msg", obj1, obj2);
assertNotSame(obj1, obj1Equal);
assertNotSame("msg", obj1, obj1Equal);
}
@ExpectedFailure
public void testAssertNotSameFail() {
assertNotSame(obj1, obj1);
}
@ExpectedFailure(withMessage = "msg")
public void testAssertNotSameFailWithMessage() {
assertNotSame("msg", obj1, obj1);
}
public void testAssertNull() {
assertNull(null);
assertNull("msg", null);
}
@ExpectedFailure
public void testAssertNullFail() {
assertNull("Hello");
}
@ExpectedFailure(withMessage = "msg")
public void testAssertNullFailWithMessage() {
assertNull("msg", "Hello");
}
public void testAssertSame() {
assertSame(obj1, obj1);
assertSame("msg", obj1, obj1);
}
@ExpectedFailure
public void testAssertSameFail() {
assertSame(obj1, obj1Equal);
}
@ExpectedFailure(withMessage = "msg")
public void testAssertSameFailWithMessage() {
assertSame("msg", obj1, obj1Equal);
}
public void testAssertTrue() {
assertTrue(true);
assertTrue("msg", true);
}
@ExpectedFailure
public void testAssertTrueFail() {
assertTrue(false);
}
@ExpectedFailure(withMessage = "msg")
public void testAssertTrueFailWithMessage() {
assertTrue("msg", false);
}
/**
* 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());
}
}