RubyGems - closure - Versions diffs - 1.2.701 → 1.3.0 - Mend

closure 1.2.701 → 1.3.0

Files changed (1566) hide show

data/closure-library/closure/goog/testing/continuationtestcase_test.html DELETED Viewed

@@ -1,349 +0,0 @@
-<!DOCTYPE html>
-<html>
-<!--
-Copyright 2009 The Closure Library Authors. All Rights Reserved.
-Use of this source code is governed by the Apache License, Version 2.0.
-See the COPYING file for details.
--->
-<!--
--->
-<head>
-<meta http-equiv="X-UA-Compatible" content="IE=edge">
-<title>Closure Unit Tests - goog.testing.ContinuationTestCase</title>
-<script src="../base.js"></script>
-<script>
-goog.require('goog.events');
-goog.require('goog.events.EventTarget');
-goog.require('goog.testing.ContinuationTestCase');
-goog.require('goog.testing.MockClock');
-goog.require('goog.testing.PropertyReplacer');
-goog.require('goog.testing.TestCase.Test');
-goog.require('goog.testing.jsunit');
-</script>
-</head>
-<body>
-<script>
-/**
- * @fileoverview This test file uses the ContinuationTestCase to test itself,
- * which is a little confusing. It's also difficult to write a truly effective
- * test, since testing a failure causes an actual failure in the test runner.
- * All tests have been manually verified using a sophisticated combination of
- * alerts and false assertions.
- */
-var testCase = new goog.testing.ContinuationTestCase('Continuation Test Case');
-testCase.autoDiscoverTests();
-// Standalone Closure Test Runner.
-if (typeof G_testRunner != 'undefined') {
-  G_testRunner.initialize(testCase);
-}
-var clock = new goog.testing.MockClock();
-var count = 0;
-var stubs = new goog.testing.PropertyReplacer();
-function setUpPage() {
-  count = testCase.getCount();
-}
-/**
- * Resets the mock clock. Includes a wait step to verify that setUp routines
- * can contain continuations.
- */
-function setUp() {
-  waitForTimeout(function() {
-    // Pointless assertion to verify that setUp methods can contain waits.
-    assertEquals(count, testCase.getCount());
-  }, 0);
-  clock.reset();
-}
-/**
- * Uninstalls the mock clock if it was installed, and restores the Step timeout
- * functions to the default window implementations.
- */
-function tearDown() {
-  clock.uninstall();
-  stubs.reset();
-  waitForTimeout(function() {
-    // Pointless assertion to verify that tearDown methods can contain waits.
-    assertTrue(testCase.now_() >= testCase.startTime_);
-  }, 0);
-}
-/**
- * Installs the Mock Clock and replaces the Step timeouts with the mock
- * implementations.
- */
-function installMockClock() {
-  clock.install();
-  // Overwrite the "protected" setTimeout and clearTimeout with the versions
-  // replaced by MockClock. Normal tests should never do this, but we need to
-  // test the ContinuationTest itself.
-  stubs.set(goog.testing.ContinuationTestCase.Step, 'protectedClearTimeout_',
-            window.clearTimeout);
-  stubs.set(goog.testing.ContinuationTestCase.Step, 'protectedSetTimeout_',
-            window.setTimeout);
-}
-/**
- * @return {goog.testing.ContinuationTestCase.Step} A generic step in a
- *     continuation test.
- */
-function getSampleStep() {
-  return new goog.testing.ContinuationTestCase.Step('test', function() {});
-}
-/**
- * @return {goog.testing.ContinuationTestCase.Test} A simple continuation test
- *     with generic setUp, test, and tearDown functions.
- */
-function getSampleTest() {
-  var setupStep = new goog.testing.TestCase.Test('setup', function() {})
-  var testStep = new goog.testing.TestCase.Test('test', function() {})
-  var teardownStep = new goog.testing.TestCase.Test('teardown', function() {})
-  return new goog.testing.ContinuationTestCase.Test(setupStep,
-                                                    testStep,
-                                                    teardownStep);
-}
-function testStepWaiting() {
-  var step = getSampleStep();
-  assertTrue(step.waiting);
-}
-function testStepSetTimeout() {
-  installMockClock();
-  var step = getSampleStep();
-  var timeoutReached = false;
-  step.setTimeout(function() {timeoutReached = true}, 100);
-  clock.tick(50);
-  assertFalse(timeoutReached);
-  clock.tick(50);
-  assertTrue(timeoutReached);
-}
-function testStepClearTimeout() {
-  var step = new goog.testing.ContinuationTestCase.Step('test', function() {});
-  var timeoutReached = false;
-  step.setTimeout(function() {timeoutReached = true}, 100);
-  clock.tick(50);
-  assertFalse(timeoutReached);
-  step.clearTimeout();
-  clock.tick(50);
-  assertFalse(timeoutReached);
-}
-function testTestPhases() {
-  var test = getSampleTest();
-  assertEquals('setup', test.getCurrentPhase()[0].name);
-  test.cancelCurrentPhase();
-  assertEquals('test', test.getCurrentPhase()[0].name);
-  test.cancelCurrentPhase();
-  assertEquals('teardown', test.getCurrentPhase()[0].name);
-  test.cancelCurrentPhase();
-  assertNull(test.getCurrentPhase());
-}
-function testTestSetError() {
-  var test = getSampleTest();
-  var error1 = new Error('Oh noes!');
-  var error2 = new Error('B0rken.');
-  assertNull(test.getError());
-  test.setError(error1);
-  assertEquals(error1, test.getError());
-  test.setError(error2);
-  assertEquals('Once an error has been set, it should not be overwritten.',
-               error1, test.getError());
-}
-function testAddStep() {
-  var test = getSampleTest();
-  var step = getSampleStep();
-  // Try adding a step to each phase and then cancelling the phase.
-  for (var i = 0; i < 3; i++) {
-    assertEquals(1, test.getCurrentPhase().length);
-    test.addStep(step);
-    assertEquals(2, test.getCurrentPhase().length);
-    assertEquals(step, test.getCurrentPhase()[1]);
-    test.cancelCurrentPhase();
-  }
-  assertNull(test.getCurrentPhase());
-}
-function testCancelTestPhase() {
-  var test = getSampleTest();
-  test.cancelTestPhase();
-  assertEquals('teardown', test.getCurrentPhase()[0].name);
-  test = getSampleTest();
-  test.cancelCurrentPhase();
-  test.cancelTestPhase();
-  assertEquals('teardown', test.getCurrentPhase()[0].name);
-  test = getSampleTest();
-  test.cancelTestPhase();
-  test.cancelTestPhase();
-  assertEquals('teardown', test.getCurrentPhase()[0].name);
-}
-function testWaitForTimeout() {
-  var reachedA = false;
-  var reachedB = false;
-  var reachedC = false;
-  waitForTimeout(function a() {
-    reachedA = true;
-    assertTrue('A must be true at callback a.', reachedA);
-    assertFalse('B must be false at callback a.', reachedB);
-    assertFalse('C must be false at callback a.', reachedC);
-  }, 10);
-  waitForTimeout(function b() {
-    reachedB = true;
-    assertTrue('A must be true at callback b.', reachedA);
-    assertTrue('B must be true at callback b.', reachedB);
-    assertFalse('C must be false at callback b.', reachedC);
-  }, 20);
-  waitForTimeout(function c() {
-    reachedC = true;
-    assertTrue('A must be true at callback c.', reachedA);
-    assertTrue('B must be true at callback c.', reachedB);
-    assertTrue('C must be true at callback c.', reachedC);
-  }, 20);
-  assertFalse('a', reachedA);
-  assertFalse('b', reachedB);
-  assertFalse('c', reachedC);
-}
-function testWaitForEvent() {
-  var et = new goog.events.EventTarget();
-  var eventFired = false;
-  goog.events.listen(et, 'testPrefire', function() {
-    eventFired = true;
-    et.dispatchEvent('test');
-  });
-  waitForEvent(et, 'test', function() {
-    assertTrue(eventFired);
-  });
-  et.dispatchEvent('testPrefire');
-}
-function testWaitForCondition() {
-  var counter = 0;
-  waitForCondition(function() {
-    return ++counter >= 3;
-  }, function() {
-    assertEquals(3, counter);
-  }, 10, 100);
-}
-function testOutOfOrderWaits() {
-  var counter = 0;
-  waitForTimeout(function() {assertEquals(5, ++counter);}, 50);
-  waitForTimeout(function() {assertEquals(1, ++counter);}, 10);
-  waitForTimeout(function() {assertEquals(3, ++counter);}, 30);
-  waitForTimeout(function() {assertEquals(2, ++counter);}, 20);
-  waitForTimeout(function() {assertEquals(4, ++counter);}, 40);
-}
-/*
- * Any of the test functions below (except the condition check passed into
- * waitForCondition) can raise an assertion successfully. Any level of nested
- * test steps should be possible, in any configuration.
- */
-var testObj;
-function testCrazyNestedWaitFunction() {
-  testObj = {
-    lock: true,
-    et: new goog.events.EventTarget(),
-    steps: 0
-  }
-  waitForTimeout(handleTimeout, 10);
-  waitForEvent(testObj.et, 'test', handleEvent);
-  waitForCondition(condition, handleCondition, 1);
-}
-function handleTimeout() {
-  testObj.steps++;
-  assertEquals('handleTimeout should be called first.', 1, testObj.steps);
-  waitForTimeout(fireEvent, 10);
-}
-function fireEvent() {
-  testObj.steps++;
-  assertEquals('fireEvent should be called second.', 2, testObj.steps);
-  testObj.et.dispatchEvent('test');
-}
-function handleEvent() {
-  testObj.steps++;
-  assertEquals('handleEvent should be called third.', 3, testObj.steps);
-  testObj.lock = false;
-}
-function condition() {
-  return !testObj.lock;
-}
-function handleCondition() {
-  assertFalse(testObj.lock);
-  testObj.steps++;
-  assertEquals('handleCondition should be called last.', 4, testObj.steps);
-}
-</script>
-</body>
-</html>

data/closure-library/closure/goog/testing/deferredtestcase.js DELETED Viewed

@@ -1,157 +0,0 @@
-// Copyright 2010 The Closure Library Authors. All Rights Reserved.
-//
-// 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.
-/**
- * @fileoverview Defines DeferredTestCase class. By calling waitForDeferred(),
- * tests in DeferredTestCase can wait for a Deferred object to complete its
- * callbacks before continuing to the next test.
- *
- * Example Usage:
- *
- *   var deferredTestCase = goog.testing.DeferredTestCase.createAndInstall();
- *   // Optionally, set a longer-than-usual step timeout.
- *   deferredTestCase.stepTimeout = 15 * 1000; // 15 seconds
- *
- *   function testDeferredCallbacks() {
- *     var callbackTime = goog.now();
- *     var callbacks = new goog.async.Deferred();
- *     deferredTestCase.addWaitForAsync('Waiting for 1st callback', callbacks);
- *     callbacks.addCallback(
- *         function() {
- *           assertTrue(
- *               'We\'re going back in time!', goog.now() >= callbackTime);
- *           callbackTime = goog.now();
- *         });
- *     deferredTestCase.addWaitForAsync('Waiting for 2nd callback', callbacks);
- *     callbacks.addCallback(
- *         function() {
- *           assertTrue(
- *               'We\'re going back in time!', goog.now() >= callbackTime);
- *           callbackTime = goog.now();
- *         });
- *     deferredTestCase.addWaitForAsync('Waiting for last callback', callbacks);
- *     callbacks.addCallback(
- *         function() {
- *           assertTrue(
- *               'We\'re going back in time!', goog.now() >= callbackTime);
- *           callbackTime = goog.now();
- *         });
- *
- *     deferredTestCase.waitForDeferred(callbacks);
- *   }
- *
- * Note that DeferredTestCase still preserves the functionality of
- * AsyncTestCase.
- *
- * @see.goog.async.Deferred
- * @see goog.testing.AsyncTestCase
- */
-goog.provide('goog.testing.DeferredTestCase');
-goog.require('goog.async.Deferred');
-goog.require('goog.testing.AsyncTestCase');
-goog.require('goog.testing.TestCase');
-/**
- * A test case that can asynchronously wait on a Deferred object.
- * @param {string=} opt_name A descriptive name for the test case.
- * @constructor
- * @extends {goog.testing.AsyncTestCase}
- */
-goog.testing.DeferredTestCase = function(opt_name) {
-  goog.testing.AsyncTestCase.call(this, opt_name);
-};
-goog.inherits(goog.testing.DeferredTestCase, goog.testing.AsyncTestCase);
-/**
- * Preferred way of creating a DeferredTestCase. Creates one and initializes it
- * with the G_testRunner.
- * @param {string=} opt_name A descriptive name for the test case.
- * @return {goog.testing.DeferredTestCase} The created DeferredTestCase.
- */
-goog.testing.DeferredTestCase.createAndInstall = function(opt_name) {
-  var deferredTestCase = new goog.testing.DeferredTestCase(opt_name);
-  goog.testing.AsyncTestCase.initializeTestRunner(deferredTestCase, opt_name);
-  return deferredTestCase;
-};
-/**
- * Handler for when the test produces an error.
- * @param {Error|string} err The error object.
- * @protected
- * @throws Always throws a ControlBreakingException.
- */
-goog.testing.DeferredTestCase.prototype.onError = function(err) {
-  this.doAsyncError(err);
-};
-/**
- * Handler for when the test succeeds.
- * @protected
- */
-goog.testing.DeferredTestCase.prototype.onSuccess = function() {
-  this.continueTesting();
-};
-/**
- * Adds a callback to update the wait message of this async test case. Using
- * this method generously also helps to document the test flow.
- * @param {string} msg The update wait status message.
- * @param {goog.async.Deferred} d The deferred object to add the waitForAsync
- *     callback to.
- * @see goog.testing.AsyncTestCase#waitForAsync
- */
-goog.testing.DeferredTestCase.prototype.addWaitForAsync = function(msg, d) {
-  d.addCallback(goog.bind(this.waitForAsync, this, msg));
-};
-/**
- * Wires up given Deferred object to the test case, then starts the
- * goog.async.Deferred object's callback.
- * @param {!string|goog.async.Deferred} a The wait status message or the
- *     deferred object to wait for.
- * @param {goog.async.Deferred=} opt_b The deferred object to wait for.
- */
-goog.testing.DeferredTestCase.prototype.waitForDeferred = function(a, opt_b) {
-  var waitMsg;
-  var deferred;
-  switch (arguments.length) {
-    case 1:
-      deferred = a;
-      waitMsg = null;
-      break;
-    case 2:
-      deferred = opt_b;
-      waitMsg = a;
-      break;
-    default: // Shouldn't be here in compiled mode
-      throw Error('Invalid number of arguments');
-  }
-  deferred.addCallbacks(this.onSuccess, this.onError, this);
-  if (!waitMsg) {
-    waitMsg =
-        'Waiting for deferred in ' + this.activeTest.name;
-  }
-  this.waitForAsync( /** @type {!string} */ (waitMsg));
-  deferred.callback(true);
-};

data/closure-library/closure/goog/testing/deferredtestcase_test.html DELETED Viewed

@@ -1,152 +0,0 @@
-<!DOCTYPE html>
-<html>
-<!--
-Copyright 2010 The Closure Library Authors. All Rights Reserved.
-Use of this source code is governed by the Apache License, Version 2.0.
-See the COPYING file for details.
--->
-<!--
--->
-<head>
-<title>Closure Unit Tests - goog.testing.DeferredTestCase Asyncronous Tests</title>
-  <script src="../base.js"></script>
-  <script src="../../../third_party/closure/goog/deps.js"></script>
-  <script>
-    goog.require('goog.async.Deferred');
-    goog.require('goog.testing.DeferredTestCase');
-    goog.require('goog.testing.TestRunner');
-    goog.require('goog.testing.jsunit');
-  </script>
-</head>
-<body>
-  <script type="text/javascript">
-    var deferredTestCase =
-        goog.testing.DeferredTestCase.createAndInstall(document.title);
-    var testTestCase;
-    var runner;
-    // Optionally, set a longer-than-usual step timeout.
-    deferredTestCase.stepTimeout = 15 * 1000; // 15 seconds
-    // This is the sample code in deferredtestcase.js
-    function testDeferredCallbacks() {
-      var callbackTime = goog.now();
-      var callbacks = new goog.async.Deferred();
-      deferredTestCase.addWaitForAsync('Waiting for 1st callback', callbacks);
-      callbacks.addCallback(
-          function() {
-            assertTrue(
-                'We\'re going back in time!', goog.now() >= callbackTime);
-            callbackTime = goog.now();
-          });
-      deferredTestCase.addWaitForAsync('Waiting for 2nd callback', callbacks);
-      callbacks.addCallback(
-          function() {
-            assertTrue(
-                'We\'re going back in time!', goog.now() >= callbackTime);
-            callbackTime = goog.now();
-          });
-      deferredTestCase.addWaitForAsync('Waiting for last callback', callbacks);
-      callbacks.addCallback(
-          function() {
-            assertTrue(
-                'We\'re going back in time!', goog.now() >= callbackTime);
-            callbackTime = goog.now();
-          });
-      deferredTestCase.waitForDeferred(callbacks);
-    }
-    function createDeferredTestCase(d) {
-      testTestCase = new goog.testing.DeferredTestCase('Foobar TestCase');
-      testTestCase.add(new goog.testing.TestCase.Test(
-        'Foobar Test',
-        function() {
-          this.waitForDeferred(d);
-        },
-        testTestCase));
-      var testCompleteCallback = new goog.async.Deferred();
-      testTestCase.setCompletedCallback(
-          function() {
-            testCompleteCallback.callback(true);
-          });
-      // We're not going to use the runner to run the test, but we attach one
-      // here anyway because without a runner TestCase throws an exception in
-      // finalize().
-      var runner = new goog.testing.TestRunner();
-      runner.initialize(testTestCase);
-      return testCompleteCallback;
-    }
-    function testDeferredWait() {
-      var d = new goog.async.Deferred();
-      deferredTestCase.addWaitForAsync('Foobar', d);
-      d.addCallback(function() {
-        return goog.async.Deferred.succeed(true);
-      });
-      deferredTestCase.waitForDeferred(d);
-    }
-    function testNonAsync() {
-      assertTrue(true);
-    }
-    function testPassWithTestRunner() {
-      var d = new goog.async.Deferred();
-      d.addCallback(function() {
-        return goog.async.Deferred.succeed(true);
-        //return goog.async.Deferred.fail(true);
-        //return new goog.async.Deferred();
-      });
-      var testCompleteDeferred = createDeferredTestCase(d);
-      testTestCase.execute();
-      var deferredCallbackOnPass = new goog.async.Deferred();
-      deferredCallbackOnPass.addCallback(function() {
-        return testCompleteDeferred;
-      });
-      deferredCallbackOnPass.addCallback(function() {
-        assertTrue('Test case should have succeded.', testTestCase.isSuccess());
-      });
-      deferredTestCase.waitForDeferred(deferredCallbackOnPass);
-    }
-    function testFailWithTestRunner() {
-      var d = new goog.async.Deferred();
-      d.addCallback(function() {
-        return goog.async.Deferred.fail(true);
-      });
-      var testCompleteDeferred = createDeferredTestCase(d);
-      // Override and consume test exception
-      var origFn = testTestCase.doAsyncError;
-      testTestCase.doAsyncError = function() {
-        try {
-          origFn();
-        } catch (e) {
-          testCompleteDeferred.callback(true);
-        }
-      }
-      testTestCase.execute();
-      var deferredCallbackOnFail = new goog.async.Deferred();
-      deferredCallbackOnFail.addCallback(function() {
-        return testCompleteDeferred;
-      });
-      deferredCallbackOnFail.addCallback(function() {
-        assertTrue('Test case should have failed.', !testTestCase.isSuccess());
-      });
-      deferredTestCase.waitForDeferred(deferredCallbackOnFail);
-    }
-  </script>
-</body>
-</html>