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,313 @@
+// 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.DisposableTest');
+goog.setTestOnly('goog.DisposableTest');
+
+goog.require('goog.Disposable');
+goog.require('goog.testing.jsunit');
+goog.require('goog.testing.recordFunction');
+var d1, d2;
+
+// Sample subclass of goog.Disposable.
+
+function DisposableTest() {
+  goog.Disposable.call(this);
+  this.element = document.getElementById('someElement');
+}
+goog.inherits(DisposableTest, goog.Disposable);
+
+DisposableTest.prototype.disposeInternal = function() {
+  DisposableTest.superClass_.disposeInternal.call(this);
+  delete this.element;
+};
+
+// Class that doesn't inherit from goog.Disposable, but implements the
+// disposable interface via duck typing.
+
+function DisposableDuck() {
+  this.element = document.getElementById('someElement');
+}
+
+DisposableDuck.prototype.dispose = function() {
+  delete this.element;
+};
+
+// Class which calls dispose recursively.
+
+function RecursiveDisposable() {
+  this.disposedCount = 0;
+}
+goog.inherits(RecursiveDisposable, goog.Disposable);
+
+RecursiveDisposable.prototype.disposeInternal = function() {
+  ++this.disposedCount;
+  assertEquals('Disposed too many times', 1, this.disposedCount);
+  this.dispose();
+};
+
+// Test methods.
+
+function setUp() {
+  d1 = new goog.Disposable();
+  d2 = new DisposableTest();
+}
+
+function tearDown() {
+  goog.Disposable.MONITORING_MODE = goog.Disposable.MonitoringMode.OFF;
+  goog.Disposable.INCLUDE_STACK_ON_CREATION = true;
+  goog.Disposable.instances_ = {};
+  d1.dispose();
+  d2.dispose();
+}
+
+function testConstructor() {
+  assertFalse(d1.isDisposed());
+  assertFalse(d2.isDisposed());
+  assertEquals(document.getElementById('someElement'), d2.element);
+}
+
+function testDispose() {
+  assertFalse(d1.isDisposed());
+  d1.dispose();
+  assertTrue('goog.Disposable instance should have been disposed of',
+      d1.isDisposed());
+
+  assertFalse(d2.isDisposed());
+  d2.dispose();
+  assertTrue('goog.DisposableTest instance should have been disposed of',
+      d2.isDisposed());
+}
+
+function testDisposeInternal() {
+  assertNotUndefined(d2.element);
+  d2.dispose();
+  assertUndefined('goog.DisposableTest.prototype.disposeInternal should ' +
+      'have deleted the element reference', d2.element);
+}
+
+function testDisposeAgain() {
+  d2.dispose();
+  assertUndefined('goog.DisposableTest.prototype.disposeInternal should ' +
+      'have deleted the element reference', d2.element);
+  // Manually reset the element to a non-null value, and call dispose().
+  // Because the object is already marked disposed, disposeInternal won't
+  // be called again.
+  d2.element = document.getElementById('someElement');
+  d2.dispose();
+  assertNotUndefined('disposeInternal should not be called again if the ' +
+      'object has already been marked disposed', d2.element);
+}
+
+function testDisposeWorksRecursively() {
+  new RecursiveDisposable().dispose();
+}
+
+function testStaticDispose() {
+  assertFalse(d1.isDisposed());
+  goog.dispose(d1);
+  assertTrue('goog.Disposable instance should have been disposed of',
+      d1.isDisposed());
+
+  assertFalse(d2.isDisposed());
+  goog.dispose(d2);
+  assertTrue('goog.DisposableTest instance should have been disposed of',
+      d2.isDisposed());
+
+  var duck = new DisposableDuck();
+  assertNotUndefined(duck.element);
+  goog.dispose(duck);
+  assertUndefined('goog.dispose should have disposed of object that ' +
+      'implements the disposable interface', duck.element);
+}
+
+function testStaticDisposeOnNonDisposableType() {
+  // Call goog.dispose() with various types and make sure no errors are
+  // thrown.
+  goog.dispose(true);
+  goog.dispose(false);
+  goog.dispose(null);
+  goog.dispose(undefined);
+  goog.dispose('');
+  goog.dispose([]);
+  goog.dispose({});
+
+  function A() {}
+  goog.dispose(new A());
+}
+
+function testMonitoringFailure() {
+  function BadDisposable() {};
+  goog.inherits(BadDisposable, goog.Disposable);
+
+  goog.Disposable.MONITORING_MODE =
+      goog.Disposable.MonitoringMode.PERMANENT;
+
+  var badDisposable = new BadDisposable;
+  assertArrayEquals('no disposable objects registered', [],
+      goog.Disposable.getUndisposedObjects());
+  assertThrows('the base ctor should have been called',
+      goog.bind(badDisposable.dispose, badDisposable));
+}
+
+function testGetUndisposedObjects() {
+  goog.Disposable.MONITORING_MODE =
+      goog.Disposable.MonitoringMode.PERMANENT;
+
+  var d1 = new DisposableTest();
+  var d2 = new DisposableTest();
+  assertSameElements('the undisposed instances', [d1, d2],
+      goog.Disposable.getUndisposedObjects());
+
+  d1.dispose();
+  assertSameElements('1 undisposed instance left', [d2],
+      goog.Disposable.getUndisposedObjects());
+
+  d1.dispose();
+  assertSameElements('second disposal of the same object is no-op', [d2],
+      goog.Disposable.getUndisposedObjects());
+
+  d2.dispose();
+  assertSameElements('all objects have been disposed of', [],
+      goog.Disposable.getUndisposedObjects());
+}
+
+function testClearUndisposedObjects() {
+  goog.Disposable.MONITORING_MODE =
+      goog.Disposable.MonitoringMode.PERMANENT;
+
+  var d1 = new DisposableTest();
+  var d2 = new DisposableTest();
+  d2.dispose();
+  goog.Disposable.clearUndisposedObjects();
+  assertSameElements('no undisposed object in the registry', [],
+      goog.Disposable.getUndisposedObjects());
+
+  assertThrows('disposal after clearUndisposedObjects()', function() {
+    d1.dispose();
+  });
+
+  // d2 is already disposed of, the redisposal shouldn't throw error.
+  d2.dispose();
+}
+
+function testRegisterDisposable() {
+  var d1 = new DisposableTest();
+  var d2 = new DisposableTest();
+
+  d1.registerDisposable(d2);
+  d1.dispose();
+
+  assertTrue('d2 should be disposed when d1 is disposed', d2.isDisposed());
+}
+
+function testDisposeAll() {
+  var d1 = new DisposableTest();
+  var d2 = new DisposableTest();
+
+  goog.disposeAll(d1, d2);
+
+  assertTrue('d1 should be disposed', d1.isDisposed());
+  assertTrue('d2 should be disposed', d2.isDisposed());
+}
+
+function testDisposeAllRecursive() {
+  var d1 = new DisposableTest();
+  var d2 = new DisposableTest();
+  var d3 = new DisposableTest();
+  var d4 = new DisposableTest();
+
+  goog.disposeAll(d1, [[d2], d3, d4]);
+
+  assertTrue('d1 should be disposed', d1.isDisposed());
+  assertTrue('d2 should be disposed', d2.isDisposed());
+  assertTrue('d3 should be disposed', d3.isDisposed());
+  assertTrue('d4 should be disposed', d4.isDisposed());
+}
+
+function testCreationStack() {
+  if (!new Error().stack)
+    return;
+  goog.Disposable.MONITORING_MODE =
+      goog.Disposable.MonitoringMode.PERMANENT;
+  var disposableStack = new DisposableTest().creationStack;
+  // Check that the name of this test function occurs in the stack trace.
+  assertNotEquals(-1, disposableStack.indexOf('testCreationStack'));
+}
+
+function testMonitoredWithoutCreationStack() {
+  if (!new Error().stack)
+    return;
+  goog.Disposable.MONITORING_MODE =
+      goog.Disposable.MonitoringMode.PERMANENT;
+  goog.Disposable.INCLUDE_STACK_ON_CREATION = false;
+  var d1 = new DisposableTest();
+
+  // Check that it is tracked, but not with a creation stack.
+  assertUndefined(d1.creationStack);
+  assertSameElements('the undisposed instance', [d1],
+      goog.Disposable.getUndisposedObjects());
+}
+
+function testOnDisposeCallback() {
+  var callback = goog.testing.recordFunction();
+  d1.addOnDisposeCallback(callback);
+  assertEquals('callback called too early', 0, callback.getCallCount());
+  d1.dispose();
+  assertEquals('callback should be called once on dispose',
+      1, callback.getCallCount());
+}
+
+function testOnDisposeCallbackOrder() {
+  var invocations = [];
+  var callback = function(str) {
+    invocations.push(str);
+  };
+  d1.addOnDisposeCallback(goog.partial(callback, 'a'));
+  d1.addOnDisposeCallback(goog.partial(callback, 'b'));
+  goog.dispose(d1);
+  assertArrayEquals('callbacks should be called in chronological order',
+      ['a', 'b'], invocations);
+}
+
+function testAddOnDisposeCallbackAfterDispose() {
+  var callback = goog.testing.recordFunction();
+  var scope = {};
+  goog.dispose(d1);
+  d1.addOnDisposeCallback(callback, scope);
+  assertEquals('Callback should be immediately called if already disposed', 1,
+      callback.getCallCount());
+  assertEquals('Callback scope should be respected', scope,
+      callback.getLastCall().getThis());
+}
+
+function testInteractiveMonitoring() {
+  var d1 = new DisposableTest();
+  goog.Disposable.MONITORING_MODE =
+      goog.Disposable.MonitoringMode.INTERACTIVE;
+  var d2 = new DisposableTest();
+
+  assertSameElements('only 1 undisposed instance tracked', [d2],
+      goog.Disposable.getUndisposedObjects());
+
+  // No errors should be thrown.
+  d1.dispose();
+
+  assertSameElements('1 undisposed instance left', [d2],
+      goog.Disposable.getUndisposedObjects());
+
+  d2.dispose();
+  assertSameElements('all disposed', [],
+      goog.Disposable.getUndisposedObjects());
+}