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,563 @@
+// 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.
+
+goog.provide('goog.jsonTest');
+goog.setTestOnly('goog.jsonTest');
+
+goog.require('goog.functions');
+goog.require('goog.json');
+goog.require('goog.testing.jsunit');
+goog.require('goog.userAgent');
+
+function allChars(start, end, opt_allowControlCharacters) {
+  var sb = [];
+  for (var i = start; i < end; i++) {
+    // unicode without the control characters 0x00 - 0x1f
+    if (opt_allowControlCharacters || i > 0x1f) {
+      sb.push(String.fromCharCode(i));
+    }
+  }
+  return sb.join('');
+}
+
+// serialization
+
+function testStringSerialize() {
+  assertSerialize('""', '');
+
+  // unicode
+  var str = allChars(0, 10000);
+  eval(goog.json.serialize(str));
+
+  assertSerialize('"true"', 'true');
+  assertSerialize('"false"', 'false');
+  assertSerialize('"null"', 'null');
+  assertSerialize('"0"', '0');
+}
+
+function testNullSerialize() {
+  assertSerialize('null', null);
+  assertSerialize('null', undefined);
+  assertSerialize('null', NaN);
+
+  assertSerialize('0', 0);
+  assertSerialize('""', '');
+  assertSerialize('false', false);
+}
+
+function testNullPropertySerialize() {
+  assertSerialize('{"a":null}', {'a': null});
+  assertSerialize('{"a":null}', {'a': undefined});
+}
+
+function testNumberSerialize() {
+  assertSerialize('0', 0);
+  assertSerialize('12345', 12345);
+  assertSerialize('-12345', -12345);
+
+  assertSerialize('0.1', 0.1);
+  // the leading zero may not be omitted
+  assertSerialize('0.1', .1);
+
+  // no leading +
+  assertSerialize('1', +1);
+
+  // either format is OK
+  var s = goog.json.serialize(1e50);
+  assertTrue('1e50',
+      s == '1e50' || s == '1E50' ||
+      s == '1e+50' || s == '1E+50');
+
+  // either format is OK
+  s = goog.json.serialize(1e-50);
+  assertTrue('1e50', s == '1e-50' || s == '1E-50');
+
+  // These numbers cannot be represented in JSON
+  assertSerialize('null', NaN);
+  assertSerialize('null', Infinity);
+  assertSerialize('null', -Infinity);
+}
+
+function testBooleanSerialize() {
+  assertSerialize('true', true);
+  assertSerialize('"true"', 'true');
+
+  assertSerialize('false', false);
+  assertSerialize('"false"', 'false');
+}
+
+function testArraySerialize() {
+  assertSerialize('[]', []);
+  assertSerialize('[1]', [1]);
+  assertSerialize('[1,2]', [1, 2]);
+  assertSerialize('[1,2,3]', [1, 2, 3]);
+  assertSerialize('[[]]', [[]]);
+
+  assertNotEquals('{length:0}', goog.json.serialize({length: 0}), '[]');
+}
+
+function testObjectSerialize_emptyObject() {
+  assertSerialize('{}', {});
+}
+
+function testObjectSerialize_oneItem() {
+  assertSerialize('{"a":"b"}', {a: 'b'});
+}
+
+function testObjectSerialize_twoItems() {
+  assertEquals('{"a":"b","c":"d"}',
+               goog.json.serialize({a: 'b', c: 'd'}),
+               '{"a":"b","c":"d"}');
+}
+
+function testObjectSerialize_whitespace() {
+  assertSerialize('{" ":" "}', {' ': ' '});
+}
+
+function testSerializeSkipFunction() {
+  var object = {
+    s: 'string value',
+    b: true,
+    i: 100,
+    f: function() { var x = 'x'; }
+  };
+  assertSerialize('', object.f);
+  assertSerialize('{"s":"string value","b":true,"i":100}', object);
+}
+
+function testObjectSerialize_array() {
+  assertNotEquals('[0,1]', goog.json.serialize([0, 1]), '{"0":"0","1":"1"}');
+}
+
+function testObjectSerialize_recursion() {
+  if (goog.userAgent.WEBKIT) {
+    return; // this makes safari 4 crash.
+  }
+
+  var anObject = {};
+  anObject.thisObject = anObject;
+  assertThrows('expected recursion exception', function() {
+    goog.json.serialize(anObject);
+  });
+}
+
+function testObjectSerializeWithHasOwnProperty() {
+  var object = {'hasOwnProperty': null};
+  if (goog.userAgent.IE && !goog.userAgent.isVersionOrHigher('9')) {
+    assertEquals('{}', goog.json.serialize(object));
+  } else {
+    assertEquals('{"hasOwnProperty":null}', goog.json.serialize(object));
+  }
+}
+
+// parsing
+
+function testStringParse() {
+
+  assertEquals('Empty string', goog.json.parse('""'), '');
+  assertEquals('whitespace string', goog.json.parse('" "'), ' ');
+
+  // unicode without the control characters 0x00 - 0x1f, 0x7f - 0x9f
+  var str = allChars(0, 1000);
+  var jsonString = goog.json.serialize(str);
+  var a = eval(jsonString);
+  assertEquals('unicode string', goog.json.parse(jsonString), a);
+
+  assertEquals('true as a string', goog.json.parse('"true"'), 'true');
+  assertEquals('false as a string', goog.json.parse('"false"'), 'false');
+  assertEquals('null as a string', goog.json.parse('"null"'), 'null');
+  assertEquals('number as a string', goog.json.parse('"0"'), '0');
+}
+
+function testStringUnsafeParse() {
+
+  assertEquals('Empty string', goog.json.unsafeParse('""'), '');
+  assertEquals('whitespace string', goog.json.unsafeParse('" "'), ' ');
+
+  // unicode
+  var str = allChars(0, 1000);
+  var jsonString = goog.json.serialize(str);
+  var a = eval(jsonString);
+  assertEquals('unicode string', goog.json.unsafeParse(jsonString), a);
+
+  assertEquals('true as a string', goog.json.unsafeParse('"true"'), 'true');
+  assertEquals('false as a string', goog.json.unsafeParse('"false"'), 'false');
+  assertEquals('null as a string', goog.json.unsafeParse('"null"'), 'null');
+  assertEquals('number as a string', goog.json.unsafeParse('"0"'), '0');
+}
+
+function testNullParse() {
+  assertEquals('null', goog.json.parse(null), null);
+  assertEquals('null', goog.json.parse('null'), null);
+
+  assertNotEquals('0', goog.json.parse('0'), null);
+  assertNotEquals('""', goog.json.parse('""'), null);
+  assertNotEquals('false', goog.json.parse('false'), null);
+}
+
+function testNullUnsafeParse() {
+  assertEquals('null', goog.json.unsafeParse(null), null);
+  assertEquals('null', goog.json.unsafeParse('null'), null);
+
+  assertNotEquals('0', goog.json.unsafeParse('0'), null);
+  assertNotEquals('""', goog.json.unsafeParse('""'), null);
+  assertNotEquals('false', goog.json.unsafeParse('false'), null);
+}
+
+function testNumberParse() {
+  assertEquals('0', goog.json.parse('0'), 0);
+  assertEquals('12345', goog.json.parse('12345'), 12345);
+  assertEquals('-12345', goog.json.parse('-12345'), -12345);
+
+  assertEquals('0.1', goog.json.parse('0.1'), 0.1);
+
+  // either format is OK
+  assertEquals(1e50, goog.json.parse('1e50'));
+  assertEquals(1e50, goog.json.parse('1E50'));
+  assertEquals(1e50, goog.json.parse('1e+50'));
+  assertEquals(1e50, goog.json.parse('1E+50'));
+
+  // either format is OK
+  assertEquals(1e-50, goog.json.parse('1e-50'));
+  assertEquals(1e-50, goog.json.parse('1E-50'));
+}
+
+function testNumberUnsafeParse() {
+  assertEquals('0', goog.json.unsafeParse('0'), 0);
+  assertEquals('12345', goog.json.unsafeParse('12345'), 12345);
+  assertEquals('-12345', goog.json.unsafeParse('-12345'), -12345);
+
+  assertEquals('0.1', goog.json.unsafeParse('0.1'), 0.1);
+
+  // either format is OK
+  assertEquals(1e50, goog.json.unsafeParse('1e50'));
+  assertEquals(1e50, goog.json.unsafeParse('1E50'));
+  assertEquals(1e50, goog.json.unsafeParse('1e+50'));
+  assertEquals(1e50, goog.json.unsafeParse('1E+50'));
+
+  // either format is OK
+  assertEquals(1e-50, goog.json.unsafeParse('1e-50'));
+  assertEquals(1e-50, goog.json.unsafeParse('1E-50'));
+}
+
+function testBooleanParse() {
+  assertEquals('true', goog.json.parse('true'), true);
+  assertEquals('false', goog.json.parse('false'), false);
+
+  assertNotEquals('0', goog.json.parse('0'), false);
+  assertNotEquals('"false"', goog.json.parse('"false"'), false);
+  assertNotEquals('null', goog.json.parse('null'), false);
+
+  assertNotEquals('1', goog.json.parse('1'), true);
+  assertNotEquals('"true"', goog.json.parse('"true"'), true);
+  assertNotEquals('{}', goog.json.parse('{}'), true);
+  assertNotEquals('[]', goog.json.parse('[]'), true);
+}
+
+function testBooleanUnsafeParse() {
+  assertEquals('true', goog.json.unsafeParse('true'), true);
+  assertEquals('false', goog.json.unsafeParse('false'), false);
+
+  assertNotEquals('0', goog.json.unsafeParse('0'), false);
+  assertNotEquals('"false"', goog.json.unsafeParse('"false"'), false);
+  assertNotEquals('null', goog.json.unsafeParse('null'), false);
+
+  assertNotEquals('1', goog.json.unsafeParse('1'), true);
+  assertNotEquals('"true"', goog.json.unsafeParse('"true"'), true);
+  assertNotEquals('{}', goog.json.unsafeParse('{}'), true);
+  assertNotEquals('[]', goog.json.unsafeParse('[]'), true);
+}
+
+function testArrayParse() {
+  assertArrayEquals([], goog.json.parse('[]'));
+  assertArrayEquals([1], goog.json.parse('[1]'));
+  assertArrayEquals([1, 2], goog.json.parse('[1,2]'));
+  assertArrayEquals([1, 2, 3], goog.json.parse('[1,2,3]'));
+  assertArrayEquals([[]], goog.json.parse('[[]]'));
+
+  // Note that array-holes are not valid json. However, goog.json.parse
+  // supports them so that clients can reap the security benefits of
+  // goog.json.parse even if they are using this non-standard format.
+  assertArrayEquals([1, /* hole */, 3], goog.json.parse('[1,,3]'));
+
+  // make sure we do not get an array for something that looks like an array
+  assertFalse('{length:0}', 'push' in goog.json.parse('{"length":0}'));
+}
+
+function testArrayUnsafeParse() {
+  function arrayEquals(a1, a2) {
+    if (a1.length != a2.length) {
+      return false;
+    }
+    for (var i = 0; i < a1.length; i++) {
+      if (a1[i] != a2[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  assertTrue('[]', arrayEquals(goog.json.unsafeParse('[]'), []));
+  assertTrue('[1]', arrayEquals(goog.json.unsafeParse('[1]'), [1]));
+  assertTrue('[1,2]', arrayEquals(goog.json.unsafeParse('[1,2]'), [1, 2]));
+  assertTrue('[1,2,3]',
+      arrayEquals(goog.json.unsafeParse('[1,2,3]'), [1, 2, 3]));
+  assertTrue('[[]]', arrayEquals(goog.json.unsafeParse('[[]]')[0], []));
+
+  // make sure we do not get an array for something that looks like an array
+  assertFalse('{length:0}', 'push' in goog.json.unsafeParse('{"length":0}'));
+}
+
+function testObjectParse() {
+  function objectEquals(a1, a2) {
+    for (var key in a1) {
+      if (a1[key] != a2[key]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  assertTrue('{}', objectEquals(goog.json.parse('{}'), {}));
+  assertTrue('{"a":"b"}',
+      objectEquals(goog.json.parse('{"a":"b"}'), {a: 'b'}));
+  assertTrue('{"a":"b","c":"d"}',
+             objectEquals(goog.json.parse('{"a":"b","c":"d"}'),
+             {a: 'b', c: 'd'}));
+  assertTrue('{" ":" "}',
+      objectEquals(goog.json.parse('{" ":" "}'), {' ': ' '}));
+
+  // make sure we do not get an Object when it is really an array
+  assertTrue('[0,1]', 'length' in goog.json.parse('[0,1]'));
+}
+
+function testObjectUnsafeParse() {
+  function objectEquals(a1, a2) {
+    for (var key in a1) {
+      if (a1[key] != a2[key]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  assertTrue('{}', objectEquals(goog.json.unsafeParse('{}'), {}));
+  assertTrue('{"a":"b"}',
+      objectEquals(goog.json.unsafeParse('{"a":"b"}'), {a: 'b'}));
+  assertTrue('{"a":"b","c":"d"}',
+             objectEquals(goog.json.unsafeParse('{"a":"b","c":"d"}'),
+             {a: 'b', c: 'd'}));
+  assertTrue('{" ":" "}',
+      objectEquals(goog.json.unsafeParse('{" ":" "}'), {' ': ' '}));
+
+  // make sure we do not get an Object when it is really an array
+  assertTrue('[0,1]', 'length' in goog.json.unsafeParse('[0,1]'));
+}
+
+
+function testForValidJson() {
+  function error_(msg, s) {
+    assertThrows(msg + ', Should have raised an exception: ' + s,
+        goog.partial(goog.json.parse, s));
+  }
+
+  error_('Non closed string', '"dasdas');
+  error_('undefined is not valid json', 'undefined');
+
+  // These numbers cannot be represented in JSON
+  error_('NaN cannot be presented in JSON', 'NaN');
+  error_('Infinity cannot be presented in JSON', 'Infinity');
+  error_('-Infinity cannot be presented in JSON', '-Infinity');
+}
+
+function testIsNotValid() {
+  assertFalse(goog.json.isValid('t'));
+  assertFalse(goog.json.isValid('r'));
+  assertFalse(goog.json.isValid('u'));
+  assertFalse(goog.json.isValid('e'));
+  assertFalse(goog.json.isValid('f'));
+  assertFalse(goog.json.isValid('a'));
+  assertFalse(goog.json.isValid('l'));
+  assertFalse(goog.json.isValid('s'));
+  assertFalse(goog.json.isValid('n'));
+  assertFalse(goog.json.isValid('E'));
+
+  assertFalse(goog.json.isValid('+'));
+  assertFalse(goog.json.isValid('-'));
+
+  assertFalse(goog.json.isValid('t++'));
+  assertFalse(goog.json.isValid('++t'));
+  assertFalse(goog.json.isValid('t--'));
+  assertFalse(goog.json.isValid('--t'));
+  assertFalse(goog.json.isValid('-t'));
+  assertFalse(goog.json.isValid('+t'));
+
+  assertFalse(goog.json.isValid('"\\"')); // "\"
+  assertFalse(goog.json.isValid('"\\'));  // "\
+
+  // multiline string using \ at the end is not valid
+  assertFalse(goog.json.isValid('"a\\\nb"'));
+
+
+  assertFalse(goog.json.isValid('"\n"'));
+  assertFalse(goog.json.isValid('"\r"'));
+  assertFalse(goog.json.isValid('"\r\n"'));
+  // Disallow the unicode newlines
+  assertFalse(goog.json.isValid('"\u2028"'));
+  assertFalse(goog.json.isValid('"\u2029"'));
+
+  assertFalse(goog.json.isValid(' '));
+  assertFalse(goog.json.isValid('\n'));
+  assertFalse(goog.json.isValid('\r'));
+  assertFalse(goog.json.isValid('\r\n'));
+
+  assertFalse(goog.json.isValid('t.r'));
+
+  assertFalse(goog.json.isValid('1e'));
+  assertFalse(goog.json.isValid('1e-'));
+  assertFalse(goog.json.isValid('1e+'));
+
+  assertFalse(goog.json.isValid('1e-'));
+
+  assertFalse(goog.json.isValid('"\\\u200D\\"'));
+  assertFalse(goog.json.isValid('"\\\0\\"'));
+  assertFalse(goog.json.isValid('"\\\0"'));
+  assertFalse(goog.json.isValid('"\\0"'));
+  assertFalse(goog.json.isValid('"\x0c"'));
+
+  assertFalse(goog.json.isValid('"\\\u200D\\", alert(\'foo\') //"\n'));
+}
+
+function testIsValid() {
+  assertTrue(goog.json.isValid('\n""\n'));
+  assertTrue(goog.json.isValid('[1\n,2\r,3\u2028\n,4\u2029]'));
+  assertTrue(goog.json.isValid('"\x7f"'));
+  assertTrue(goog.json.isValid('"\x09"'));
+  // Test tab characters in json.
+  assertTrue(goog.json.isValid('{"\t":"\t"}'));
+}
+
+function testDoNotSerializeProto() {
+  function F() {};
+  F.prototype = {
+    c: 3
+  };
+
+  var obj = new F;
+  obj.a = 1;
+  obj.b = 2;
+
+  assertEquals('Should not follow the prototype chain',
+               '{"a":1,"b":2}',
+               goog.json.serialize(obj));
+}
+
+function testEscape() {
+  var unescaped = '1a*/]';
+  assertEquals('Should not escape',
+               '"' + unescaped + '"',
+               goog.json.serialize(unescaped));
+
+  var escaped = '\n\x7f\u1049';
+  assertEquals('Should escape',
+               '',
+               findCommonChar(escaped, goog.json.serialize(escaped)));
+  assertEquals('Should eval to the same string after escaping',
+               escaped,
+               goog.json.parse(goog.json.serialize(escaped)));
+}
+
+function testReplacer() {
+  assertSerialize('[null,null,0]', [, , 0]);
+
+  assertSerialize('[0,0,{"x":0}]', [, , {x: 0}], function(k, v) {
+    if (v === undefined && goog.isArray(this)) {
+      return 0;
+    }
+    return v;
+  });
+
+  assertSerialize('[0,1,2,3]', [0, 0, 0, 0], function(k, v) {
+    var kNum = Number(k);
+    if (k && !isNaN(kNum)) {
+      return kNum;
+    }
+    return v;
+  });
+
+  var f = function(k, v) {
+    return typeof v == 'number' ? v + 1 : v;
+  };
+  assertSerialize('{"a":1,"b":{"c":2}}', {'a': 0, 'b': {'c': 1}}, f);
+}
+
+function testDateSerialize() {
+  assertSerialize('{}', new Date(0));
+}
+
+function testToJSONSerialize() {
+  assertSerialize('{}', {toJSON: goog.functions.constant('serialized')});
+  assertSerialize('{"toJSON":"normal"}', {toJSON: 'normal'});
+}
+
+
+/**
+ * Asserts that the given object serializes to the given value.
+ * If the current browser has an implementation of JSON.serialize,
+ * we make sure our version matches that one.
+ */
+function assertSerialize(expected, obj, opt_replacer) {
+  assertEquals(expected, goog.json.serialize(obj, opt_replacer));
+
+  // I'm pretty sure that the goog.json.serialize behavior is correct by the ES5
+  // spec, but JSON.stringify(undefined) is undefined on all browsers.
+  if (obj === undefined) return;
+
+  // Browsers don't serialize undefined properties, but goog.json.serialize does
+  if (goog.isObject(obj) && ('a' in obj) && obj['a'] === undefined) return;
+
+  // Replacers are broken on IE and older versions of firefox.
+  if (opt_replacer && !goog.userAgent.WEBKIT) return;
+
+  // goog.json.serialize does not stringify dates the same way.
+  if (obj instanceof Date) return;
+
+  // goog.json.serialize does not stringify functions the same way.
+  if (obj instanceof Function) return;
+
+  // goog.json.serialize doesn't use the toJSON method.
+  if (goog.isObject(obj) && goog.isFunction(obj.toJSON)) return;
+
+  if (typeof JSON != 'undefined') {
+    assertEquals(
+        'goog.json.serialize does not match JSON.stringify',
+        expected,
+        JSON.stringify(obj, opt_replacer));
+  }
+}
+
+
+/**
+ * @param {string} a
+ * @param {string} b
+ * @return {string} any common character between two strings a and b.
+ */
+function findCommonChar(a, b) {
+  for (var i = 0; i < b.length; i++) {
+    if (a.indexOf(b.charAt(i)) >= 0) {
+      return b.charAt(i);
+    }
+  }
+  return '';
+}