/*
* 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.
*/
package com.google.gwt.junit.client;
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.dom.client.ButtonElement;
import com.google.gwt.dom.client.Document;
import com.google.gwt.user.client.DOM;
import com.google.gwt.user.client.Event;
import com.google.gwt.user.client.EventListener;
import com.google.gwt.user.client.Timer;
/**
* This test must be run manually to inspect for correct results. Many of these
* tests are designed to fail in specific ways, the rest should succeed. The
* name of each test method indicates how it should behave.
*/
public class TestManualAsync extends GWTTestCaseTest {
// The following tests (all prefixed with test_) are intended to test the
// interaction of synchronous failures (within event handlers) with various
// other types of failures and successes. All of them are expected to fail
// with the message "Expected failure".
//
// Nomenclature for these tests:
// DTF => delayTestFinish()
// SF => synchronous failure (from event handler)
// FT => finishTest()
// F => fail()
// R => return;
public void test_dtf_sf() {
delayTestFinish();
synchronousFailure("test_dtf_sf");
}
public void test_dtf_sf_f() {
delayTestFinish();
synchronousFailure("test_dtf_sf_f");
failNow("test_dtf_sf_f");
}
public void test_dtf_sf_ft() {
delayTestFinish();
synchronousFailure("test_dtf_sf_ft");
finishTest();
}
public void test_dtf_sf_r_f() {
delayTestFinish();
synchronousFailure("test_dtf_sf_r_f");
failLater("test_dtf_sf_r_f");
}
public void test_dtf_sf_r_ft() {
delayTestFinish();
synchronousFailure("test_dtf_sf_r_ft");
finishTestLater();
}
public void test_sf() {
synchronousFailure("test_sf");
}
public void test_sf_dtf_f() {
synchronousFailure("test_sf_dtf_f");
delayTestFinish();
failNow("test_sf_dtf_f");
}
public void test_sf_dtf_ft() {
synchronousFailure("test_sf_dtf_ft");
delayTestFinish();
finishTest();
}
public void test_sf_dtf_r_f() {
synchronousFailure("test_sf_dtf_r_f");
delayTestFinish();
failLater("test_sf_dtf_r_f");
}
public void test_sf_dtf_r_ft() {
synchronousFailure("test_sf_dtf_r_ft");
delayTestFinish(5 * 60 * 1000);
finishTestLater();
}
public void test_sf_f() {
synchronousFailure("test_sf_f");
failNow("test_sf_f");
}
/**
* Fails normally.
*/
public void testDelayFail() {
delayTestFinish(100);
fail("Expected failure");
finishTest();
}
/**
* Completes normally.
*/
public void testDelayNormal() {
delayTestFinish(100);
finishTest();
}
/**
* Fails normally.
*/
public void testFail() {
fail("Expected failure");
}
/**
* Async fails.
*/
public void testFailAsync() {
delayTestFinish(1000);
new Timer() {
public void run() {
fail("Expected failure");
}
}.schedule(100);
}
/**
* Tests the case where a JUnit exception is thrown from an event handler, but
* after this test method has completed successfully.
*
* This test should *not* fail, but the next one should.
*/
public void testLateFailPart1() {
// Leave the test in synchronous mode, but crank up a timer to fail in 2.5s.
new Timer() {
@Override
public void run() {
// This fail should be called during the next test.
fail();
}
}.schedule(2500);
// We don't actually assert anything here. This test exists solely to make
// the next one fail.
}
/**
* Second half of the previous test.
*/
public void testLateFailPart2() {
// Go into async mode from 5s, finishing in 4. The timer from the previous
// test will go off and call fail() before finishTest() is called.
delayTestFinish(5000);
new Timer() {
@Override
public void run() {
finishTest();
}
}.schedule(4000);
}
/**
* Completes normally.
*/
public void testNormal() {
}
/**
* Completes async.
*/
public void testNormalAsync() {
delayTestFinish(200);
new Timer() {
public void run() {
finishTest();
}
}.schedule(100);
}
/**
* Completes async.
*/
public void testRepeatingNormal() {
delayTestFinish(200);
new Timer() {
private int i = 0;
public void run() {
if (++i < 4) {
delayTestFinish(200);
} else {
cancel();
finishTest();
}
}
}.scheduleRepeating(100);
}
/**
* Fails async.
*/
public void testSetUpTearDownFailAsync() {
assertEquals(IS_SETUP, setupTeardownFlag);
delayTestFinish(1000);
new Timer() {
@Override
public void run() {
fail("Expected failure");
}
}.schedule(1);
new Timer() {
@Override
public void run() {
/*
* The failing test should have triggered tearDown.
*/
if (setupTeardownFlag != IS_TORNDOWN) {
recordOutofBandError("Bad async failure tearDown behavior not catchable by JUnit");
}
}
}.schedule(100);
}
/**
* Completes async.
*/
public void testSetUpTearDownFailAsyncHadNoOutOfBandErrors() {
assertNoOutOfBandErrorsAsync();
}
/**
* Times out async.
*/
public void testSetUpTearDownTimeoutAsync() {
assertSame(IS_SETUP, setupTeardownFlag);
delayTestFinish(1);
new Timer() {
@Override
public void run() {
/*
* The failing test should have triggered tearDown.
*/
if (setupTeardownFlag != IS_TORNDOWN) {
recordOutofBandError("Bad async timeout tearDown behavior not catchable by JUnit");
}
}
}.schedule(100);
}
/**
* Completes async.
*/
public void testSetUpTearDownTimeoutAsyncHadNoOutOfBandErrors() {
assertNoOutOfBandErrorsAsync();
}
/**
* Completes normally.
*/
public void testSpuriousFinishTest() {
try {
finishTest();
fail("Unexpected failure");
} catch (IllegalStateException e) {
}
}
/**
* Times out.
*/
public void testTimeoutAsync() {
delayTestFinish(100);
new Timer() {
public void run() {
finishTest();
}
}.schedule(200);
}
// Call delayTestFinish() with enough time so that failLater() will
// definitely fail.
private void delayTestFinish() {
delayTestFinish(2500);
}
// Fail asynchronously after a small amount of time.
private void failLater(final String failMsg) {
new Timer() {
@Override
public void run() {
failNow(failMsg);
}
}.schedule(100);
}
// Fail synchronously with an "expected failure" message.
private void failNow(String failMsg) {
fail("Expected failure (" + failMsg + ")");
}
// Finish the test asynchronously after a small amount of time.
private void finishTestLater() {
new Timer() {
@Override
public void run() {
finishTest();
}
}.schedule(1);
}
// Trigger a test failure synchronously, but from within an event handler.
// (The exception thrown from fail() will get caught by the GWT
// UncaughtExceptionHandler).
private void synchronousFailure(final String failMsg) {
ButtonElement btn = Document.get().createButtonElement();
Document.get().getBody().appendChild(btn);
Event.sinkEvents(btn, Event.ONCLICK);
EventListener listener = new EventListener() {
public void onBrowserEvent(Event event) {
failNow(failMsg);
}
};
DOM.setEventListener(btn.<com.google.gwt.user.client.Element>cast(), listener);
btn.click();
}
}