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,198 @@
+// Copyright 2008 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.testing.PerformanceTimerTest');
+goog.setTestOnly('goog.testing.PerformanceTimerTest');
+
+goog.require('goog.async.Deferred');
+goog.require('goog.dom');
+goog.require('goog.math');
+goog.require('goog.testing.MockClock');
+goog.require('goog.testing.PerformanceTimer');
+goog.require('goog.testing.jsunit');
+
+var mockClock;
+var sandbox;
+var timer;
+function setUpPage() {
+  sandbox = document.getElementById('sandbox');
+}
+
+function setUp() {
+  mockClock = new goog.testing.MockClock(true);
+  timer = new goog.testing.PerformanceTimer();
+}
+
+function tearDown() {
+  mockClock.dispose();
+  timer = null;
+  goog.dom.removeChildren(sandbox);
+}
+
+function testConstructor() {
+  assertTrue('Timer must be an instance of goog.testing.PerformanceTimer',
+      timer instanceof goog.testing.PerformanceTimer);
+  assertEquals('Timer must collect the default number of samples', 10,
+      timer.getNumSamples());
+  assertEquals('Timer must have the default timeout interval', 5000,
+      timer.getTimeoutInterval());
+}
+
+function testRun_noSetUpOrTearDown() {
+  runAndAssert(false, false, false);
+}
+
+function testRun_withSetup() {
+  runAndAssert(true, false, false);
+}
+
+function testRun_withTearDown() {
+  runAndAssert(false, true, false);
+}
+
+function testRun_withSetUpAndTearDown() {
+  runAndAssert(true, true, false);
+}
+
+function testRunAsync_noSetUpOrTearDown() {
+  runAndAssert(false, false, true);
+}
+
+function testRunAsync_withSetup() {
+  runAndAssert(true, false, true);
+}
+
+function testRunAsync_withTearDown() {
+  runAndAssert(false, true, true);
+}
+
+function testRunAsync_withSetUpAndTearDown() {
+  runAndAssert(true, true, true);
+}
+
+function runAndAssert(useSetUp, useTearDown, runAsync) {
+  var fakeExecutionTime = [100, 95, 98, 104, 130, 101, 96, 98, 90, 103];
+  var count = 0;
+  var testFunction = function() {
+    mockClock.tick(fakeExecutionTime[count++]);
+    if (runAsync) {
+      var deferred = new goog.async.Deferred();
+      deferred.callback();
+      return deferred;
+    }
+  };
+
+  var setUpCount = 0;
+  var setUpFunction = function() {
+    // Should have no effect on total time.
+    mockClock.tick(7);
+    setUpCount++;
+    if (runAsync) {
+      var deferred = new goog.async.Deferred();
+      deferred.callback();
+      return deferred;
+    }
+  };
+
+  var tearDownCount = 0;
+  var tearDownFunction = function() {
+    // Should have no effect on total time.
+    mockClock.tick(11);
+    tearDownCount++;
+    if (runAsync) {
+      var deferred = new goog.async.Deferred();
+      deferred.callback();
+      return deferred;
+    }
+  };
+
+  // Fast test function should complete successfully in under 5 seconds...
+  var task = new goog.testing.PerformanceTimer.Task(testFunction);
+  if (useSetUp) {
+    task.withSetUp(setUpFunction);
+  }
+  if (useTearDown) {
+    task.withTearDown(tearDownFunction);
+  }
+  if (runAsync) {
+    var assertsRan = false;
+    var deferred = timer.runAsyncTask(task);
+    deferred.addCallback(
+        function(results) {
+          assertsRan = assertResults(results, useSetUp, useTearDown,
+              setUpCount, tearDownCount, fakeExecutionTime);
+        });
+    assertTrue(assertsRan);
+  } else {
+    var results = timer.runTask(task);
+    assertResults(results, useSetUp, useTearDown, setUpCount, tearDownCount,
+        fakeExecutionTime);
+  }
+}
+
+function assertResults(results, useSetUp, useTearDown, setUpCount,
+    tearDownCount, fakeExecutionTime) {
+  assertNotNull('Results must be available.', results);
+
+  assertEquals('Average is wrong.',
+      goog.math.average.apply(null, fakeExecutionTime), results['average']);
+  assertEquals('Standard deviation is wrong.',
+      goog.math.standardDeviation.apply(null, fakeExecutionTime),
+      results['standardDeviation']);
+
+  assertEquals('Count must be as expected.', 10, results['count']);
+  assertEquals('Maximum is wrong.', 130, results['maximum']);
+  assertEquals('Mimimum is wrong.', 90, results['minimum']);
+  assertEquals('Total must be a nonnegative number.',
+      goog.math.sum.apply(null, fakeExecutionTime), results['total']);
+
+  assertEquals('Set up count must be as expected.',
+      useSetUp ? 10 : 0, setUpCount);
+  assertEquals('Tear down count must be as expected.',
+      useTearDown ? 10 : 0, tearDownCount);
+
+  return true;
+}
+
+function testTimeout() {
+  var count = 0;
+  var testFunction = function() {
+    mockClock.tick(100);
+    ++count;
+  };
+
+  timer.setNumSamples(200);
+  timer.setTimeoutInterval(2500);
+  var results = timer.run(testFunction);
+
+  assertNotNull('Results must be available', results);
+  assertEquals('Count is wrong', count, results['count']);
+  assertTrue('Count must less than expected',
+      results['count'] < timer.getNumSamples());
+}
+
+function testCreateResults() {
+  var samples = [53, 0, 103];
+  var expectedResults = {
+    'average': 52,
+    'count': 3,
+    'maximum': 103,
+    'minimum': 0,
+    'standardDeviation': goog.math.standardDeviation.apply(null, samples),
+    'total': 156
+  };
+  assertObjectEquals(
+      expectedResults,
+      goog.testing.PerformanceTimer.createResults(samples));
+}