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,359 @@
+<!DOCTYPE html>
+<html>
+<!--
+Copyright 2008 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.graphics.Path</title>
+<script src="../base.js"></script>
+<script>
+  goog.require('goog.array');
+  goog.require('goog.math');
+  goog.require('goog.graphics.Path');
+  goog.require('goog.graphics.AffineTransform');
+  goog.require('goog.testing.graphics');
+  goog.require('goog.testing.jsunit');
+</script>
+</head>
+<body>
+
+<script>
+  function testConstructor() {
+    var path = new goog.graphics.Path();
+    assertTrue(path.isSimple());
+    assertNull(path.getCurrentPoint());
+    goog.testing.graphics.assertPathEquals([], path);
+  }
+
+
+  function testGetSegmentCount() {
+    assertArrayEquals([2, 2, 6, 6, 0], goog.array.map([
+      goog.graphics.Path.Segment.MOVETO,
+      goog.graphics.Path.Segment.LINETO,
+      goog.graphics.Path.Segment.CURVETO,
+      goog.graphics.Path.Segment.ARCTO,
+      goog.graphics.Path.Segment.CLOSE
+    ], goog.graphics.Path.getSegmentCount));
+  }
+
+
+  function testSimpleMoveTo() {
+    var path = new goog.graphics.Path();
+    path.moveTo(30, 50);
+    assertTrue(path.isSimple());
+    assertObjectEquals([30, 50], path.getCurrentPoint());
+    goog.testing.graphics.assertPathEquals(['M', 30, 50], path);
+  }
+
+
+  function testRepeatedMoveTo() {
+    var path = new goog.graphics.Path();
+    path.moveTo(30, 50);
+    path.moveTo(40, 60);
+    assertTrue(path.isSimple());
+    assertObjectEquals([40, 60], path.getCurrentPoint());
+    goog.testing.graphics.assertPathEquals(['M', 40, 60], path);
+  }
+
+
+  function testSimpleLineTo() {
+    var path = new goog.graphics.Path();
+    var e = assertThrows(function() {
+      path.lineTo(30, 50);
+    });
+    assertEquals('Path cannot start with lineTo', e.message);
+    path.moveTo(0, 0);
+    path.lineTo(30, 50);
+    assertTrue(path.isSimple());
+    assertObjectEquals([30, 50], path.getCurrentPoint());
+    goog.testing.graphics.assertPathEquals(['M', 0, 0, 'L', 30, 50], path);
+  }
+
+
+  function testMultiArgLineTo() {
+    var path = new goog.graphics.Path();
+    path.moveTo(0, 0);
+    path.lineTo(30, 50, 40 , 60);
+    assertTrue(path.isSimple());
+    assertObjectEquals([40, 60], path.getCurrentPoint());
+    goog.testing.graphics.assertPathEquals(['M', 0, 0, 'L', 30, 50, 40, 60],
+        path);
+  }
+
+
+  function testRepeatedLineTo() {
+    var path = new goog.graphics.Path();
+    path.moveTo(0, 0);
+    path.lineTo(30, 50);
+    path.lineTo(40, 60);
+    assertTrue(path.isSimple());
+    assertObjectEquals([40, 60], path.getCurrentPoint());
+    goog.testing.graphics.assertPathEquals(['M', 0, 0, 'L', 30, 50, 40, 60],
+        path);
+  }
+
+
+  function testSimpleCurveTo() {
+    var path = new goog.graphics.Path();
+    var e = assertThrows(function() {
+      path.curveTo(10, 20, 30, 40, 50, 60);
+    });
+    assertEquals('Path cannot start with curve', e.message);
+    path.moveTo(0, 0);
+    path.curveTo(10, 20, 30, 40, 50, 60);
+    assertTrue(path.isSimple());
+    assertObjectEquals([50, 60], path.getCurrentPoint());
+    goog.testing.graphics.assertPathEquals(
+        ['M', 0, 0, 'C', 10, 20, 30, 40, 50, 60], path);
+  }
+
+
+  function testMultiCurveTo() {
+    var path = new goog.graphics.Path();
+    path.moveTo(0, 0);
+    path.curveTo(10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120);
+    assertTrue(path.isSimple());
+    assertObjectEquals([110, 120], path.getCurrentPoint());
+    goog.testing.graphics.assertPathEquals(
+        ['M', 0, 0, 'C', 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120],
+        path);
+  }
+
+
+  function testRepeatedCurveTo() {
+    var path = new goog.graphics.Path();
+    path.moveTo(0, 0);
+    path.curveTo(10, 20, 30, 40, 50, 60);
+    path.curveTo(70, 80, 90, 100, 110, 120);
+    assertTrue(path.isSimple());
+    assertObjectEquals([110, 120], path.getCurrentPoint());
+    goog.testing.graphics.assertPathEquals(
+        ['M', 0, 0, 'C', 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120],
+        path);
+  }
+
+
+  function testSimpleArc() {
+    var path = new goog.graphics.Path();
+    path.arc(50, 60, 10, 20, 30, 30, false);
+    assertFalse(path.isSimple());
+    var p = path.getCurrentPoint();
+    assertEquals(55, p[0]);
+    assertRoughlyEquals(77.32, p[1], 0.01);
+    goog.testing.graphics.assertPathEquals(
+        ['M', 58.66, 70, 'A', 10, 20, 30, 30, 55, 77.32], path);
+  }
+
+
+  function testArcNonConnectClose() {
+    var path = new goog.graphics.Path();
+    path.moveTo(0, 0);
+    path.arc(10, 10, 10, 10, -90, 180);
+    assertObjectEquals([10, 20], path.getCurrentPoint());
+    path.close();
+    assertObjectEquals([10, 0], path.getCurrentPoint());
+  }
+
+
+  function testRepeatedArc() {
+    var path = new goog.graphics.Path();
+    path.arc(50, 60, 10, 20, 30, 30, false);
+    path.arc(50, 60, 10, 20, 60, 30, false);
+    assertFalse(path.isSimple());
+    assertObjectEquals([50, 80], path.getCurrentPoint());
+    goog.testing.graphics.assertPathEquals(['M', 58.66, 70,
+        'A', 10, 20, 30, 30, 55, 77.32,
+        'M', 55, 77.32,
+        'A', 10, 20, 60, 30, 50, 80], path);
+  }
+
+
+  function testRepeatedArc2() {
+    var path = new goog.graphics.Path();
+    path.arc(50, 60, 10, 20, 30, 30, false);
+    path.arc(50, 60, 10, 20, 60, 30, true);
+    goog.testing.graphics.assertPathEquals(['M', 58.66, 70,
+        'A', 10, 20, 30, 30, 55, 77.32,
+        'A', 10, 20, 60, 30, 50, 80], path);
+  }
+
+
+  function testCompleteCircle() {
+    var path = new goog.graphics.Path();
+    path.arc(0, 0, 10, 10, 0, 360, false);
+    assertFalse(path.isSimple());
+    var p = path.getCurrentPoint();
+    assertRoughlyEquals(10, p[0], 0.01);
+    assertRoughlyEquals(0, p[1], 0.01);
+    goog.testing.graphics.assertPathEquals(
+        ['M', 10, 0, 'A', 10, 10, 0, 360, 10, 0], path);
+  }
+
+
+  function testClose() {
+    var path = new goog.graphics.Path();
+    try {
+      path.close();
+      fail();
+    } catch (e) {
+      // Expected
+      assertEquals('Path cannot start with close', e.message);
+    }
+    path.moveTo(0, 0);
+    path.lineTo(10, 20, 30, 40, 50, 60);
+    path.close()
+    assertTrue(path.isSimple());
+    assertObjectEquals([0, 0], path.getCurrentPoint());
+    goog.testing.graphics.assertPathEquals(
+        ['M', 0, 0, 'L', 10, 20, 30, 40, 50, 60, 'X'], path);
+  }
+
+
+  function testClear() {
+    var path = new goog.graphics.Path();
+    path.moveTo(0, 0);
+    path.arc(50, 60, 10, 20, 30, 30, false);
+    path.clear();
+    assertTrue(path.isSimple());
+    assertNull(path.getCurrentPoint());
+    goog.testing.graphics.assertPathEquals([], path);
+  }
+
+
+  function testCreateSimplifiedPath() {
+    var path = new goog.graphics.Path();
+    path.moveTo(0, 0);
+    path.arc(50, 60, 10, 20, 30, 30, false);
+    assertFalse(path.isSimple());
+    path = goog.graphics.Path.createSimplifiedPath(path);
+    assertTrue(path.isSimple());
+    var p = path.getCurrentPoint();
+    assertEquals(55, p[0]);
+    assertRoughlyEquals(77.32, p[1], 0.01);
+    goog.testing.graphics.assertPathEquals(['M', 58.66, 70,
+        'C', 57.78, 73.04, 56.52, 75.57, 55, 77.32], path);
+  }
+
+
+  function testCreateSimplifiedPath2() {
+    var path = new goog.graphics.Path();
+    path.arc(50, 60, 10, 20, 30, 30, false);
+    path.arc(50, 60, 10, 20, 60, 30, false);
+    assertFalse(path.isSimple());
+    path = goog.graphics.Path.createSimplifiedPath(path);
+    assertTrue(path.isSimple());
+    goog.testing.graphics.assertPathEquals(['M', 58.66, 70,
+        'C', 57.78, 73.04, 56.52, 75.57, 55, 77.32,
+        'M', 55, 77.32,
+        'C', 53.48, 79.08, 51.76, 80, 50, 80], path);
+  }
+
+
+  function testCreateSimplifiedPath3() {
+    var path = new goog.graphics.Path();
+    path.arc(50, 60, 10, 20, 30, 30, false);
+    path.arc(50, 60, 10, 20, 60, 30, true);
+    path.close();
+    path = goog.graphics.Path.createSimplifiedPath(path);
+    goog.testing.graphics.assertPathEquals(['M', 58.66, 70,
+        'C', 57.78, 73.04, 56.52, 75.57, 55, 77.32,
+        53.48, 79.08, 51.76, 80, 50, 80, 'X'], path);
+    var p = path.getCurrentPoint();
+    assertRoughlyEquals(58.66, p[0], 0.01);
+    assertRoughlyEquals(70, p[1], 0.01);
+  }
+
+
+  function testArcToAsCurves() {
+    var path = new goog.graphics.Path();
+    path.moveTo(58.66, 70);
+    path.arcToAsCurves(10, 20, 30, 30, false);
+    goog.testing.graphics.assertPathEquals(['M', 58.66, 70,
+        'C', 57.78, 73.04, 56.52, 75.57, 55, 77.32], path);
+  }
+
+
+  function testCreateTransformedPath() {
+    var path = new goog.graphics.Path();
+    path.moveTo(0, 0);
+    path.lineTo(0, 10, 10, 10, 10, 0);
+    path.close();
+    var tx = new goog.graphics.AffineTransform(2, 0, 0, 3, 10, 20);
+    var path2 = path.createTransformedPath(tx);
+    goog.testing.graphics.assertPathEquals(
+        ['M', 0, 0, 'L', 0, 10, 10, 10, 10, 0, 'X'], path);
+    goog.testing.graphics.assertPathEquals(
+        ['M', 10, 20, 'L', 10, 50, 30, 50, 30, 20, 'X'], path2);
+  }
+
+
+  function testTransform() {
+    var path = new goog.graphics.Path();
+    path.moveTo(0, 0);
+    path.lineTo(0, 10, 10, 10, 10, 0);
+    path.close();
+    var tx = new goog.graphics.AffineTransform(2, 0, 0, 3, 10, 20);
+    var path2 = path.transform(tx);
+    assertTrue(path === path2);
+    goog.testing.graphics.assertPathEquals(
+        ['M', 10, 20, 'L', 10, 50, 30, 50, 30, 20, 'X'], path2);
+  }
+
+
+  function testTransformCurrentAndClosePoints() {
+    var path = new goog.graphics.Path();
+    path.moveTo(0, 0);
+    assertObjectEquals([0, 0], path.getCurrentPoint());
+    path.transform(new goog.graphics.AffineTransform(1, 0, 0, 1, 10, 20));
+    assertObjectEquals([10, 20], path.getCurrentPoint());
+    path.lineTo(50, 50);
+    path.close();
+    assertObjectEquals([10, 20], path.getCurrentPoint());
+  }
+
+
+  function testTransformNonSimple() {
+    var path = new goog.graphics.Path();
+    path.arc(50, 60, 10, 20, 30, 30, false);
+    assertThrows(function() {
+      path.transform(new goog.graphics.AffineTransform(1, 0, 0, 1, 10, 20));
+    });
+  }
+
+
+  function testAppendPath() {
+    var path1 = new goog.graphics.Path();
+    path1.moveTo(0, 0);
+    path1.lineTo(0, 10, 10, 10, 10, 0);
+    path1.close();
+
+    var path2 = new goog.graphics.Path();
+    path2.arc(50, 60, 10, 20, 30, 30, false);
+
+    assertTrue(path1.isSimple());
+    path1.appendPath(path2);
+    assertFalse(path1.isSimple());
+    goog.testing.graphics.assertPathEquals([
+        'M', 0, 0, 'L', 0, 10, 10, 10, 10, 0, 'X',
+        'M', 58.66, 70, 'A', 10, 20, 30, 30, 55, 77.32
+    ], path1);
+  }
+
+
+  function testIsEmpty() {
+    var path = new goog.graphics.Path();
+    assertTrue('Initially path is empty', path.isEmpty());
+
+    path.moveTo(0, 0);
+    assertFalse('After command addition, path is not empty', path.isEmpty());
+
+    path.clear();
+    assertTrue('After clear, path is empty again', path.isEmpty());
+  }
+</script>
+</body>
+</html>