Adding mapbox-gl branch

2015-03-16 18:50:27 +01:00
parent 7985f030fa
commit 57ee7f52fd
3109 changed files with 943365 additions and 0 deletions
@@ -0,0 +1,149 @@
+// Copyright 2006 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.
+
+goog.provide('goog.TimerTest');
+goog.setTestOnly('goog.TimerTest');
+
+goog.require('goog.Promise');
+goog.require('goog.Timer');
+goog.require('goog.events');
+goog.require('goog.testing.MockClock');
+goog.require('goog.testing.jsunit');
+
+var intervalIds = {};
+var intervalIdCounter = 0;
+var mockClock;
+var maxDuration = 60 * 1000; // 60s
+
+function setUp() {
+  mockClock = new goog.testing.MockClock(true /* install */);
+}
+
+function tearDown() {
+  mockClock.dispose();
+}
+
+// Run a test for 60s and see how many counts we get
+function runTest(string, ticks, number) {
+  var t = new goog.Timer(ticks);
+  var count = 0;
+  goog.events.listen(t, 'tick', function(evt) {
+    count++;
+  });
+  t.start();
+  mockClock.tick(maxDuration);
+  assertEquals(string, number, count);
+  t.stop();
+  goog.events.removeAll(t);
+}
+
+
+function test100msTicks() {
+  // Desc, interval in ms, expected ticks in 60s
+  runTest('10 ticks per second for 60 seconds', 100, 600);
+}
+
+function test500msTicks() {
+  runTest('2 ticks per second for 60 seconds', 500, 120);
+}
+
+function test1sTicks() {
+  runTest('1 tick per second for 60 seconds', 1000, 60);
+}
+
+function test2sTicks() {
+  runTest('1 tick every 2 seconds for 60 seconds', 2000, 30);
+}
+
+function test5sTicks() {
+  runTest('1 tick every 5 seconds for 60 seconds', 5000, 12);
+}
+
+function test10sTicks() {
+  runTest('1 tick every 10 seconds for 60 seconds', 10000, 6);
+}
+
+function test30sTicks() {
+  runTest('1 tick every 30 seconds for 60 seconds', 30000, 2);
+}
+
+function test60sTicks() {
+  runTest('1 tick every 60 seconds', 60000, 1);
+}
+
+function testCallOnce() {
+  var c = 0;
+  var actualTimeoutId = goog.Timer.callOnce(
+      function() {
+        if (c > 0) {
+          assertTrue('callOnce should only be called once', false);
+        }
+        c++;
+      });
+  assertEquals('callOnce should return the timeout ID',
+      mockClock.getTimeoutsMade(), actualTimeoutId);
+
+  var obj = {c: 0};
+  goog.Timer.callOnce(function() {
+    if (this.c > 0) {
+      assertTrue('callOnce should only be called once', false);
+    }
+    assertEquals(obj, this);
+    this.c++;
+  }, 1, obj);
+  mockClock.tick(maxDuration);
+}
+
+function testCallOnceIgnoresTimeoutsTooLarge() {
+  var failCallback = goog.partial(fail, 'Timeout should never be called');
+  assertEquals('Timeouts slightly too large should yield a timer ID of -1',
+      -1, goog.Timer.callOnce(failCallback, 2147483648));
+  assertEquals('Infinite timeouts should yield a timer ID of -1',
+      -1, goog.Timer.callOnce(failCallback, Infinity));
+}
+
+function testPromise() {
+  var c = 0;
+  goog.Timer.promise(1, 'A').then(function(result) {
+    c++;
+    assertEquals('promise should return resolved value', 'A', result);
+  });
+  mockClock.tick(10);
+  assertEquals('promise must be yielded once and only once', 1, c);
+}
+
+function testPromise_cancel() {
+  var c = 0;
+  goog.Timer.promise(1, 'A').then(function(result) {
+    fail('promise must not be resolved');
+  }, function(reason) {
+    c++;
+    assertTrue('promise must fail due to cancel signal',
+        reason instanceof goog.Promise.CancellationError);
+  }).cancel();
+  mockClock.tick(10);
+  assertEquals('promise must be canceled once and only once', 1, c);
+}
+
+function testPromise_timeoutTooLarge() {
+  var c = 0;
+  goog.Timer.promise(2147483648, 'A').then(function(result) {
+    fail('promise must not be resolved');
+  }, function(reason) {
+    c++;
+    assertTrue('promise must be rejected', reason instanceof Error);
+  });
+  mockClock.tick(10);
+  assertEquals('promise must be rejected once and only once', 1, c);
+}