user/test/com/google/gwt/junit/client/TestManualAsync.java

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