Adding mapbox-gl branch

mapbox-gl/closure-library/closure/goog/labs/events/nondisposableeventtarget.js

@@ -0,0 +1,305 @@
+// Copyright 2005 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 An implementation of {@link goog.events.Listenable} that does
+ * not need to be disposed.
+ */
+
+goog.provide('goog.labs.events.NonDisposableEventTarget');
+
+
+goog.require('goog.array');
+goog.require('goog.asserts');
+goog.require('goog.events.Event');
+goog.require('goog.events.Listenable');
+goog.require('goog.events.ListenerMap');
+goog.require('goog.object');
+
+
+
+/**
+ * An implementation of {@code goog.events.Listenable} with full W3C
+ * EventTarget-like support (capture/bubble mechanism, stopping event
+ * propagation, preventing default actions).
+ *
+ * You may subclass this class to turn your class into a Listenable.
+ *
+ * Unlike {@link goog.events.EventTarget}, this class does not implement
+ * {@link goog.disposable.IDisposable}. Instances of this class that have had
+ * It is not necessary to call {@link goog.dispose}
+ * or {@link #removeAllListeners} in order for an instance of this class
+ * to be garbage collected.
+ *
+ * Unless propagation is stopped, an event dispatched by an
+ * EventTarget will bubble to the parent returned by
+ * {@code getParentEventTarget}. To set the parent, call
+ * {@code setParentEventTarget}. Subclasses that don't support
+ * changing the parent can override the setter to throw an error.
+ *
+ * Example usage:
+ * <pre>
+ *   var source = new goog.labs.events.NonDisposableEventTarget();
+ *   function handleEvent(e) {
+ *     alert('Type: ' + e.type + '; Target: ' + e.target);
+ *   }
+ *   source.listen('foo', handleEvent);
+ *   source.dispatchEvent('foo'); // will call handleEvent
+ * </pre>
+ *
+ * TODO(chrishenry|johnlenz): Consider a more modern, less viral
+ * (not based on inheritance) replacement of goog.Disposable, which will allow
+ * goog.events.EventTarget to not be disposable.
+ *
+ * @constructor
+ * @implements {goog.events.Listenable}
+ * @final
+ */
+goog.labs.events.NonDisposableEventTarget = function() {
+  /**
+   * Maps of event type to an array of listeners.
+   * @private {!goog.events.ListenerMap}
+   */
+  this.eventTargetListeners_ = new goog.events.ListenerMap(this);
+};
+goog.events.Listenable.addImplementation(
+    goog.labs.events.NonDisposableEventTarget);
+
+
+/**
+ * An artificial cap on the number of ancestors you can have. This is mainly
+ * for loop detection.
+ * @const {number}
+ * @private
+ */
+goog.labs.events.NonDisposableEventTarget.MAX_ANCESTORS_ = 1000;
+
+
+/**
+ * Parent event target, used during event bubbling.
+ * @private {goog.events.Listenable}
+ */
+goog.labs.events.NonDisposableEventTarget.prototype.parentEventTarget_ = null;
+
+
+/** @override */
+goog.labs.events.NonDisposableEventTarget.prototype.getParentEventTarget =
+    function() {
+  return this.parentEventTarget_;
+};
+
+
+/**
+ * Sets the parent of this event target to use for capture/bubble
+ * mechanism.
+ * @param {goog.events.Listenable} parent Parent listenable (null if none).
+ */
+goog.labs.events.NonDisposableEventTarget.prototype.setParentEventTarget =
+    function(parent) {
+  this.parentEventTarget_ = parent;
+};
+
+
+/** @override */
+goog.labs.events.NonDisposableEventTarget.prototype.dispatchEvent = function(
+    e) {
+  this.assertInitialized_();
+  var ancestorsTree, ancestor = this.getParentEventTarget();
+  if (ancestor) {
+    ancestorsTree = [];
+    var ancestorCount = 1;
+    for (; ancestor; ancestor = ancestor.getParentEventTarget()) {
+      ancestorsTree.push(ancestor);
+      goog.asserts.assert(
+          (++ancestorCount <
+                  goog.labs.events.NonDisposableEventTarget.MAX_ANCESTORS_),
+          'infinite loop');
+    }
+  }
+
+  return goog.labs.events.NonDisposableEventTarget.dispatchEventInternal_(
+      this, e, ancestorsTree);
+};
+
+
+/** @override */
+goog.labs.events.NonDisposableEventTarget.prototype.listen = function(
+    type, listener, opt_useCapture, opt_listenerScope) {
+  this.assertInitialized_();
+  return this.eventTargetListeners_.add(
+      String(type), listener, false /* callOnce */, opt_useCapture,
+      opt_listenerScope);
+};
+
+
+/** @override */
+goog.labs.events.NonDisposableEventTarget.prototype.listenOnce = function(
+    type, listener, opt_useCapture, opt_listenerScope) {
+  return this.eventTargetListeners_.add(
+      String(type), listener, true /* callOnce */, opt_useCapture,
+      opt_listenerScope);
+};
+
+
+/** @override */
+goog.labs.events.NonDisposableEventTarget.prototype.unlisten = function(
+    type, listener, opt_useCapture, opt_listenerScope) {
+  return this.eventTargetListeners_.remove(
+      String(type), listener, opt_useCapture, opt_listenerScope);
+};
+
+
+/** @override */
+goog.labs.events.NonDisposableEventTarget.prototype.unlistenByKey = function(
+    key) {
+  return this.eventTargetListeners_.removeByKey(key);
+};
+
+
+/** @override */
+goog.labs.events.NonDisposableEventTarget.prototype.removeAllListeners =
+    function(opt_type) {
+  return this.eventTargetListeners_.removeAll(opt_type);
+};
+
+
+/** @override */
+goog.labs.events.NonDisposableEventTarget.prototype.fireListeners = function(
+    type, capture, eventObject) {
+  // TODO(chrishenry): Original code avoids array creation when there
+  // is no listener, so we do the same. If this optimization turns
+  // out to be not required, we can replace this with
+  // getListeners(type, capture) instead, which is simpler.
+  var listenerArray = this.eventTargetListeners_.listeners[String(type)];
+  if (!listenerArray) {
+    return true;
+  }
+  listenerArray = goog.array.clone(listenerArray);
+
+  var rv = true;
+  for (var i = 0; i < listenerArray.length; ++i) {
+    var listener = listenerArray[i];
+    // We might not have a listener if the listener was removed.
+    if (listener && !listener.removed && listener.capture == capture) {
+      var listenerFn = listener.listener;
+      var listenerHandler = listener.handler || listener.src;
+
+      if (listener.callOnce) {
+        this.unlistenByKey(listener);
+      }
+      rv = listenerFn.call(listenerHandler, eventObject) !== false && rv;
+    }
+  }
+
+  return rv && eventObject.returnValue_ != false;
+};
+
+
+/** @override */
+goog.labs.events.NonDisposableEventTarget.prototype.getListeners = function(
+    type, capture) {
+  return this.eventTargetListeners_.getListeners(String(type), capture);
+};
+
+
+/** @override */
+goog.labs.events.NonDisposableEventTarget.prototype.getListener = function(
+    type, listener, capture, opt_listenerScope) {
+  return this.eventTargetListeners_.getListener(
+      String(type), listener, capture, opt_listenerScope);
+};
+
+
+/** @override */
+goog.labs.events.NonDisposableEventTarget.prototype.hasListener = function(
+    opt_type, opt_capture) {
+  var id = goog.isDef(opt_type) ? String(opt_type) : undefined;
+  return this.eventTargetListeners_.hasListener(id, opt_capture);
+};
+
+
+/**
+ * Asserts that the event target instance is initialized properly.
+ * @private
+ */
+goog.labs.events.NonDisposableEventTarget.prototype.assertInitialized_ =
+    function() {
+  goog.asserts.assert(
+      this.eventTargetListeners_,
+      'Event target is not initialized. Did you call the superclass ' +
+      '(goog.labs.events.NonDisposableEventTarget) constructor?');
+};
+
+
+/**
+ * Dispatches the given event on the ancestorsTree.
+ *
+ * TODO(chrishenry): Look for a way to reuse this logic in
+ * goog.events, if possible.
+ *
+ * @param {!Object} target The target to dispatch on.
+ * @param {goog.events.Event|Object|string} e The event object.
+ * @param {Array<goog.events.Listenable>=} opt_ancestorsTree The ancestors
+ *     tree of the target, in reverse order from the closest ancestor
+ *     to the root event target. May be null if the target has no ancestor.
+ * @return {boolean} If anyone called preventDefault on the event object (or
+ *     if any of the listeners returns false) this will also return false.
+ * @private
+ */
+goog.labs.events.NonDisposableEventTarget.dispatchEventInternal_ = function(
+    target, e, opt_ancestorsTree) {
+  var type = e.type || /** @type {string} */ (e);
+
+  // If accepting a string or object, create a custom event object so that
+  // preventDefault and stopPropagation work with the event.
+  if (goog.isString(e)) {
+    e = new goog.events.Event(e, target);
+  } else if (!(e instanceof goog.events.Event)) {
+    var oldEvent = e;
+    e = new goog.events.Event(type, target);
+    goog.object.extend(e, oldEvent);
+  } else {
+    e.target = e.target || target;
+  }
+
+  var rv = true, currentTarget;
+
+  // Executes all capture listeners on the ancestors, if any.
+  if (opt_ancestorsTree) {
+    for (var i = opt_ancestorsTree.length - 1; !e.propagationStopped_ && i >= 0;
+         i--) {
+      currentTarget = e.currentTarget = opt_ancestorsTree[i];
+      rv = currentTarget.fireListeners(type, true, e) && rv;
+    }
+  }
+
+  // Executes capture and bubble listeners on the target.
+  if (!e.propagationStopped_) {
+    currentTarget = e.currentTarget = target;
+    rv = currentTarget.fireListeners(type, true, e) && rv;
+    if (!e.propagationStopped_) {
+      rv = currentTarget.fireListeners(type, false, e) && rv;
+    }
+  }
+
+  // Executes all bubble listeners on the ancestors, if any.
+  if (opt_ancestorsTree) {
+    for (i = 0; !e.propagationStopped_ && i < opt_ancestorsTree.length; i++) {
+      currentTarget = e.currentTarget = opt_ancestorsTree[i];
+      rv = currentTarget.fireListeners(type, false, e) && rv;
+    }
+  }
+
+  return rv;
+};

mapbox-gl/closure-library/closure/goog/labs/events/nondisposableeventtarget_test.html

@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html>
+<!--
+Copyright 2006 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.labs.events.EventTarget
+  </title>
+  <script src="../../base.js">
+  </script>
+  <script>
+    goog.require('goog.labs.events.NonDisposableEventTargetTest');
+  </script>
+ </head>
+ <body>
+ </body>
+</html>

mapbox-gl/closure-library/closure/goog/labs/events/nondisposableeventtarget_test.js

@@ -0,0 +1,72 @@
+// 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.labs.events.NonDisposableEventTargetTest');
+goog.setTestOnly('goog.labs.events.NonDisposableEventTargetTest');
+
+goog.require('goog.events.Listenable');
+goog.require('goog.events.eventTargetTester');
+goog.require('goog.events.eventTargetTester.KeyType');
+goog.require('goog.events.eventTargetTester.UnlistenReturnType');
+goog.require('goog.labs.events.NonDisposableEventTarget');
+goog.require('goog.testing.jsunit');
+
+function setUp() {
+  var newListenableFn = function() {
+    return new goog.labs.events.NonDisposableEventTarget();
+  };
+  var listenFn = function(src, type, listener, opt_capt, opt_handler) {
+    return src.listen(type, listener, opt_capt, opt_handler);
+  };
+  var unlistenFn = function(src, type, listener, opt_capt, opt_handler) {
+    return src.unlisten(type, listener, opt_capt, opt_handler);
+  };
+  var unlistenByKeyFn = function(src, key) {
+    return src.unlistenByKey(key);
+  };
+  var listenOnceFn = function(src, type, listener, opt_capt, opt_handler) {
+    return src.listenOnce(type, listener, opt_capt, opt_handler);
+  };
+  var dispatchEventFn = function(src, e) {
+    return src.dispatchEvent(e);
+  };
+  var removeAllFn = function(src, opt_type, opt_capture) {
+    return src.removeAllListeners(opt_type, opt_capture);
+  };
+  var getListenersFn = function(src, type, capture) {
+    return src.getListeners(type, capture);
+  };
+  var getListenerFn = function(src, type, listener, capture, opt_handler) {
+    return src.getListener(type, listener, capture, opt_handler);
+  };
+  var hasListenerFn = function(src, opt_type, opt_capture) {
+    return src.hasListener(opt_type, opt_capture);
+  };
+
+  goog.events.eventTargetTester.setUp(
+      newListenableFn, listenFn, unlistenFn, unlistenByKeyFn,
+      listenOnceFn, dispatchEventFn,
+      removeAllFn, getListenersFn, getListenerFn, hasListenerFn,
+      goog.events.eventTargetTester.KeyType.NUMBER,
+      goog.events.eventTargetTester.UnlistenReturnType.BOOLEAN, false);
+}
+
+function tearDown() {
+  goog.events.eventTargetTester.tearDown();
+}
+
+function testRuntimeTypeIsCorrect() {
+  var target = new goog.labs.events.NonDisposableEventTarget();
+  assertTrue(goog.events.Listenable.isImplementedBy(target));
+}

mapbox-gl/closure-library/closure/goog/labs/events/nondisposableeventtarget_via_googevents_test.html

@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html>
+<!--
+Copyright 2006 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.labs.events.EventTarget
+  </title>
+  <script src="../../base.js">
+  </script>
+  <script>
+  goog.require('goog.labs.events.NonDisposableEventTargetGoogEventsTest');
+  </script>
+ </head>
+ <body>
+ </body>
+</html>

mapbox-gl/closure-library/closure/goog/labs/events/nondisposableeventtarget_via_googevents_test.js

@@ -0,0 +1,78 @@
+// 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.labs.events.NonDisposableEventTargetGoogEventsTest');
+goog.setTestOnly('goog.labs.events.NonDisposableEventTargetGoogEventsTest');
+
+goog.require('goog.events');
+goog.require('goog.events.eventTargetTester');
+goog.require('goog.events.eventTargetTester.KeyType');
+goog.require('goog.events.eventTargetTester.UnlistenReturnType');
+goog.require('goog.labs.events.NonDisposableEventTarget');
+goog.require('goog.testing');
+goog.require('goog.testing.jsunit');
+
+function setUp() {
+  var newListenableFn = function() {
+    return new goog.labs.events.NonDisposableEventTarget();
+  };
+  var unlistenByKeyFn = function(src, key) {
+    return goog.events.unlistenByKey(key);
+  };
+  goog.events.eventTargetTester.setUp(
+      newListenableFn, goog.events.listen, goog.events.unlisten,
+      unlistenByKeyFn,
+      goog.events.listenOnce, goog.events.dispatchEvent,
+      goog.events.removeAll, goog.events.getListeners,
+      goog.events.getListener, goog.events.hasListener,
+      goog.events.eventTargetTester.KeyType.NUMBER,
+      goog.events.eventTargetTester.UnlistenReturnType.BOOLEAN, true);
+}
+
+function tearDown() {
+  goog.events.eventTargetTester.tearDown();
+}
+
+function testUnlistenProperCleanup() {
+  goog.events.listen(eventTargets[0], EventType.A, listeners[0]);
+  goog.events.unlisten(eventTargets[0], EventType.A, listeners[0]);
+
+  goog.events.listen(eventTargets[0], EventType.A, listeners[0]);
+  eventTargets[0].unlisten(EventType.A, listeners[0]);
+}
+
+function testUnlistenByKeyProperCleanup() {
+  var keyNum = goog.events.listen(eventTargets[0], EventType.A, listeners[0]);
+  goog.events.unlistenByKey(keyNum);
+}
+
+function testListenOnceProperCleanup() {
+  goog.events.listenOnce(eventTargets[0], EventType.A, listeners[0]);
+  eventTargets[0].dispatchEvent(EventType.A);
+}
+
+function testListenWithObject() {
+  var obj = {};
+  obj.handleEvent = goog.testing.recordFunction();
+  goog.events.listen(eventTargets[0], EventType.A, obj);
+  eventTargets[0].dispatchEvent(EventType.A);
+  assertEquals(1, obj.handleEvent.getCallCount());
+}
+
+function testListenWithObjectHandleEventReturningFalse() {
+  var obj = {};
+  obj.handleEvent = function() { return false; };
+  goog.events.listen(eventTargets[0], EventType.A, obj);
+  assertFalse(eventTargets[0].dispatchEvent(EventType.A));
+}

mapbox-gl/closure-library/closure/goog/labs/events/touch.js

@@ -0,0 +1,82 @@
+// Copyright 2013 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 Utilities to abstract mouse and touch events.
+ */
+
+
+goog.provide('goog.labs.events.touch');
+goog.provide('goog.labs.events.touch.TouchData');
+
+goog.require('goog.array');
+goog.require('goog.asserts');
+goog.require('goog.events.EventType');
+goog.require('goog.string');
+
+
+/**
+ * Description the geometry and target of an event.
+ *
+ * @typedef {{
+ *   clientX: number,
+ *   clientY: number,
+ *   screenX: number,
+ *   screenY: number,
+ *   target: EventTarget
+ * }}
+ */
+goog.labs.events.touch.TouchData;
+
+
+/**
+ * Takes a mouse or touch event and returns the relevent geometry and target
+ * data.
+ * @param {!Event} e A mouse or touch event.
+ * @return {!goog.labs.events.touch.TouchData}
+ */
+goog.labs.events.touch.getTouchData = function(e) {
+
+  var source = e;
+  goog.asserts.assert(
+      goog.string.startsWith(e.type, 'touch') ||
+      goog.string.startsWith(e.type, 'mouse'),
+      'Event must be mouse or touch event.');
+
+  if (goog.string.startsWith(e.type, 'touch')) {
+    goog.asserts.assert(
+        goog.array.contains([
+          goog.events.EventType.TOUCHCANCEL,
+          goog.events.EventType.TOUCHEND,
+          goog.events.EventType.TOUCHMOVE,
+          goog.events.EventType.TOUCHSTART
+        ], e.type),
+        'Touch event not of valid type.');
+
+    // If the event is end or cancel, take the first changed touch,
+    // otherwise the first target touch.
+    source = (e.type == goog.events.EventType.TOUCHEND ||
+              e.type == goog.events.EventType.TOUCHCANCEL) ?
+             e.changedTouches[0] : e.targetTouches[0];
+  }
+
+  return {
+    clientX: source['clientX'],
+    clientY: source['clientY'],
+    screenX: source['screenX'],
+    screenY: source['screenY'],
+    target: source['target']
+  };
+};
+

mapbox-gl/closure-library/closure/goog/labs/events/touch_test.html

@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html>
+<!--
+Copyright 2013 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.labs.events.touch</title>
+<script src="../../base.js"></script>
+<script>
+goog.require('goog.labs.events.touchTest');
+</script>
+</head>
+<body>
+</body>
+</html>

mapbox-gl/closure-library/closure/goog/labs/events/touch_test.js

@@ -0,0 +1,96 @@
+// Copyright 2013 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 Unit tests for goog.labs.events.touch.
+ */
+
+
+goog.provide('goog.labs.events.touchTest');
+
+goog.require('goog.labs.events.touch');
+goog.require('goog.testing.jsunit');
+
+goog.setTestOnly('goog.labs.events.touchTest');
+
+function testMouseEvent() {
+  var fakeTarget = {};
+
+  var fakeMouseMove = {
+    'clientX': 1,
+    'clientY': 2,
+    'screenX': 3,
+    'screenY': 4,
+    'target': fakeTarget,
+    'type': 'mousemove'
+  };
+
+  var data = goog.labs.events.touch.getTouchData(fakeMouseMove);
+  assertEquals(1, data.clientX);
+  assertEquals(2, data.clientY);
+  assertEquals(3, data.screenX);
+  assertEquals(4, data.screenY);
+  assertEquals(fakeTarget, data.target);
+}
+
+function testTouchEvent() {
+  var fakeTarget = {};
+
+  var fakeTouch = {
+    'clientX': 1,
+    'clientY': 2,
+    'screenX': 3,
+    'screenY': 4,
+    'target': fakeTarget
+  };
+
+  var fakeTouchStart = {
+    'targetTouches': [fakeTouch],
+    'target': fakeTarget,
+    'type': 'touchstart'
+  };
+
+  var data = goog.labs.events.touch.getTouchData(fakeTouchStart);
+  assertEquals(1, data.clientX);
+  assertEquals(2, data.clientY);
+  assertEquals(3, data.screenX);
+  assertEquals(4, data.screenY);
+  assertEquals(fakeTarget, data.target);
+}
+
+function testTouchChangeEvent() {
+  var fakeTarget = {};
+
+  var fakeTouch = {
+    'clientX': 1,
+    'clientY': 2,
+    'screenX': 3,
+    'screenY': 4,
+    'target': fakeTarget
+  };
+
+  var fakeTouchStart = {
+    'changedTouches': [fakeTouch],
+    'target': fakeTarget,
+    'type': 'touchend'
+  };
+
+  var data = goog.labs.events.touch.getTouchData(fakeTouchStart);
+  assertEquals(1, data.clientX);
+  assertEquals(2, data.clientY);
+  assertEquals(3, data.screenX);
+  assertEquals(4, data.screenY);
+  assertEquals(fakeTarget, data.target);
+}
+