libv8 3.11.8.17 → 3.16.14.0

data/vendor/v8/test/mjsunit/object-define-property.js

@@ -27,7 +27,7 @@
 
 // Tests the object.defineProperty method - ES 15.2.3.6
 
-// Flags: --allow-natives-syntax
+// Flags: --allow-natives-syntax --es5-readonly
 
 // Check that an exception is thrown when null is passed as object.
 var exception = false;
@@ -1057,6 +1057,8 @@ assertEquals(999, o[999]);
 
 
 // Regression test: Bizzare behavior on non-strict arguments object.
+// TODO(yangguo): Tests disabled, needs investigation!
+/*
 (function test(arg0) {
   // Here arguments[0] is a fast alias on arg0.
   Object.defineProperty(arguments, "0", {
@@ -1075,7 +1077,7 @@ assertEquals(999, o[999]);
   assertEquals(2, arg0);
   assertEquals(3, arguments[0]);
 })(0);
-
+*/
 
 // Regression test: We should never observe the hole value.
 var objectWithGetter = {};
@@ -1085,3 +1087,106 @@ assertEquals(undefined, objectWithGetter.__lookupSetter__('foo'));
 var objectWithSetter = {};
 objectWithSetter.__defineSetter__('foo', function(x) {});
 assertEquals(undefined, objectWithSetter.__lookupGetter__('foo'));
+
+// An object with a getter on the prototype chain.
+function getter() { return 111; }
+function anotherGetter() { return 222; }
+
+function testGetterOnProto(expected, o) {
+  assertEquals(expected, o.quebec);
+}
+
+obj1 = {};
+Object.defineProperty(obj1, "quebec", { get: getter, configurable: true });
+obj2 = Object.create(obj1);
+obj3 = Object.create(obj2);
+
+testGetterOnProto(111, obj3);
+testGetterOnProto(111, obj3);
+%OptimizeFunctionOnNextCall(testGetterOnProto);
+testGetterOnProto(111, obj3);
+testGetterOnProto(111, obj3);
+
+Object.defineProperty(obj1, "quebec", { get: anotherGetter });
+
+testGetterOnProto(222, obj3);
+testGetterOnProto(222, obj3);
+%OptimizeFunctionOnNextCall(testGetterOnProto);
+testGetterOnProto(222, obj3);
+testGetterOnProto(222, obj3);
+
+// An object with a setter on the prototype chain.
+var modifyMe;
+function setter(x) { modifyMe = x+1; }
+function anotherSetter(x) { modifyMe = x+2; }
+
+function testSetterOnProto(expected, o) {
+  modifyMe = 333;
+  o.romeo = 444;
+  assertEquals(expected, modifyMe);
+}
+
+obj1 = {};
+Object.defineProperty(obj1, "romeo", { set: setter, configurable: true });
+obj2 = Object.create(obj1);
+obj3 = Object.create(obj2);
+
+testSetterOnProto(445, obj3);
+testSetterOnProto(445, obj3);
+%OptimizeFunctionOnNextCall(testSetterOnProto);
+testSetterOnProto(445, obj3);
+testSetterOnProto(445, obj3);
+
+Object.defineProperty(obj1, "romeo", { set: anotherSetter });
+
+testSetterOnProto(446, obj3);
+testSetterOnProto(446, obj3);
+%OptimizeFunctionOnNextCall(testSetterOnProto);
+testSetterOnProto(446, obj3);
+testSetterOnProto(446, obj3);
+
+// Removing a setter on the prototype chain.
+function testSetterOnProtoStrict(o) {
+  "use strict";
+  o.sierra = 12345;
+}
+
+obj1 = {};
+Object.defineProperty(obj1, "sierra",
+                      { get: getter, set: setter, configurable: true });
+obj2 = Object.create(obj1);
+obj3 = Object.create(obj2);
+
+testSetterOnProtoStrict(obj3);
+testSetterOnProtoStrict(obj3);
+%OptimizeFunctionOnNextCall(testSetterOnProtoStrict);
+testSetterOnProtoStrict(obj3);
+testSetterOnProtoStrict(obj3);
+
+Object.defineProperty(obj1, "sierra",
+                      { get: getter, set: undefined, configurable: true });
+
+exception = false;
+try {
+  testSetterOnProtoStrict(obj3);
+} catch (e) {
+  exception = true;
+  assertTrue(/which has only a getter/.test(e));
+}
+assertTrue(exception);
+
+// Test assignment to a getter-only property on the prototype chain. This makes
+// sure that crankshaft re-checks its assumptions and doesn't rely only on type
+// feedback (which would be monomorphic here).
+
+function Assign(o) {
+  o.blubb = 123;
+}
+
+function C() {}
+
+Assign(new C);
+Assign(new C);
+%OptimizeFunctionOnNextCall(Assign);
+Object.defineProperty(C.prototype, "blubb", {get: function() { return -42; }});
+Assign(new C);

data/vendor/v8/test/mjsunit/override-read-only-property.js

@@ -25,6 +25,8 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+// Flags: --es5_readonly
+
 // According to ECMA-262, sections 8.6.2.2 and 8.6.2.3 you're not
 // allowed to override read-only properties, not even if the read-only
 // property is in the prototype chain.
@@ -38,19 +40,19 @@ F.prototype = Number;
 var original_number_max = Number.MAX_VALUE;
 
 // Assignment to a property which does not exist on the object itself,
-// but is read-only in a prototype takes effect.
+// but is read-only in a prototype does not take effect.
 var f = new F();
 assertEquals(original_number_max, f.MAX_VALUE);
 f.MAX_VALUE = 42;
-assertEquals(42, f.MAX_VALUE);
+assertEquals(original_number_max, f.MAX_VALUE);
 
 // Assignment to a property which does not exist on the object itself,
-// but is read-only in a prototype takes effect.
+// but is read-only in a prototype does not take effect.
 f = new F();
 with (f) {
   MAX_VALUE = 42;
 }
-assertEquals(42, f.MAX_VALUE);
+assertEquals(original_number_max, f.MAX_VALUE);
 
 // Assignment to read-only property on the object itself is ignored.
 Number.MAX_VALUE = 42;

data/vendor/v8/test/mjsunit/packed-elements.js

@@ -96,9 +96,9 @@ function test6() {
 function test_with_optimization(f) {
   // Run tests in a loop to make sure that inlined Array() constructor runs out
   // of new space memory and must fall back on runtime impl.
-  for (i = 0; i < 250000; ++i) f();
+  for (i = 0; i < 25000; ++i) f();
   %OptimizeFunctionOnNextCall(f);
-  for (i = 0; i < 250000; ++i) f(); // Make sure GC happens
+  for (i = 0; i < 25000; ++i) f(); // Make sure GC happens
 }
 
 if (has_packed_elements) {

data/vendor/v8/test/mjsunit/parse-int-float.js

@@ -29,10 +29,10 @@ assertEquals(0, parseInt('0'));
 assertEquals(0, parseInt(' 0'));
 assertEquals(0, parseInt(' 0 '));
 
-assertEquals(63, parseInt('077'));
-assertEquals(63, parseInt('  077'));
-assertEquals(63, parseInt('  077   '));
-assertEquals(-63, parseInt('  -077'));
+assertEquals(77, parseInt('077'));
+assertEquals(77, parseInt('  077'));
+assertEquals(77, parseInt('  077   '));
+assertEquals(-77, parseInt('  -077'));
 
 assertEquals(3, parseInt('11', 2));
 assertEquals(4, parseInt('11', 3));

data/vendor/v8/test/mjsunit/pixel-array-rounding.js

@@ -27,7 +27,7 @@
 
 // Flags: --allow-natives-syntax
 
-var pixels = new PixelArray(8);
+var pixels = new Uint8ClampedArray(8);
 
 function f() {
   for (var i = 0; i < 8; i++) {

data/vendor/v8/test/mjsunit/readonly.js

@@ -0,0 +1,228 @@
+// Copyright 2011 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Flags: --allow-natives-syntax --harmony-proxies --es5_readonly
+
+// Different ways to create an object.
+
+function CreateFromLiteral() {
+  return {};
+}
+
+function CreateFromObject() {
+  return new Object;
+}
+
+function CreateDefault() {
+  return Object.create(Object.prototype);
+}
+
+function CreateFromConstructor(proto) {
+  function C() {}
+  (new C).b = 9;  // Make sure that we can have an in-object property.
+  C.prototype = proto;
+  return function() { return new C; }
+}
+
+function CreateFromApi(proto) {
+  return function() { return Object.create(proto); }
+}
+
+function CreateWithProperty(proto) {
+  function C() { this.a = -100; }
+  C.prototype = proto;
+  return function() { return new C; }
+}
+
+var bases = [CreateFromLiteral, CreateFromObject, CreateDefault];
+var inherits = [CreateFromConstructor, CreateFromApi, CreateWithProperty];
+var constructs = [CreateFromConstructor, CreateFromApi];
+
+function TestAllCreates(f) {
+  // The depth of the prototype chain up the.
+  for (var depth = 0; depth < 3; ++depth) {
+    // Introduce readonly-ness this far up the chain.
+    for (var up = 0; up <= depth; ++up) {
+      // Try different construction methods.
+      for (var k = 0; k < constructs.length; ++k) {
+        // Construct a fresh prototype chain from above functions.
+        for (var i = 0; i < bases.length; ++i) {
+          var p = bases[i]();
+          // There may be a preexisting property under the insertion point...
+          for (var j = 0; j < depth - up; ++j) {
+            p = inherits[Math.floor(inherits.length * Math.random())](p)();
+          }
+          // ...but not above it.
+          for (var j = 0; j < up; ++j) {
+            p = constructs[Math.floor(constructs.length * Math.random())](p)();
+          }
+          // Create a fresh constructor.
+          var c = constructs[k](p);
+          f(function() {
+            var o = c();
+            o.up = o;
+            for (var j = 0; j < up; ++j) o.up = Object.getPrototypeOf(o.up);
+            return o;
+          })
+        }
+      }
+    }
+  }
+}
+
+
+// Different ways to make a property read-only.
+
+function ReadonlyByNonwritableDataProperty(o, name) {
+  Object.defineProperty(o, name, {value: -41, writable: false});
+}
+
+function ReadonlyByAccessorPropertyWithoutSetter(o, name) {
+  Object.defineProperty(o, name, {get: function() { return -42; }});
+}
+
+function ReadonlyByGetter(o, name) {
+  o.__defineGetter__("a", function() { return -43; });
+}
+
+function ReadonlyByFreeze(o, name) {
+  o[name] = -44;
+  Object.freeze(o);
+}
+
+function ReadonlyByProto(o, name) {
+  var p = Object.create(o.__proto__);
+  Object.defineProperty(p, name, {value: -45, writable: false});
+  o.__proto__ = p;
+}
+
+function ReadonlyByProxy(o, name) {
+  var p = Proxy.create({
+    getPropertyDescriptor: function() {
+      return {value: -46, writable: false, configurable: true};
+    }
+  });
+  o.__proto__ = p;
+}
+
+var readonlys = [
+  ReadonlyByNonwritableDataProperty, ReadonlyByAccessorPropertyWithoutSetter,
+  ReadonlyByGetter, ReadonlyByFreeze, ReadonlyByProto, ReadonlyByProxy
+]
+
+function TestAllReadonlys(f) {
+  // Provide various methods to making a property read-only.
+  for (var i = 0; i < readonlys.length; ++i) {
+    print("  readonly =", i)
+    f(readonlys[i]);
+  }
+}
+
+
+// Different use scenarios.
+
+function Assign(o, x) {
+  o.a = x;
+}
+
+function AssignStrict(o, x) {
+  "use strict";
+  o.a = x;
+}
+
+function TestAllModes(f) {
+  for (var strict = 0; strict < 2; ++strict) {
+    print(" strict =", strict);
+    f(strict);
+  }
+}
+
+function TestAllScenarios(f) {
+  for (var t = 0; t < 100; t = 2*t + 1) {
+    print("t =", t)
+    f(function(strict, create, readonly) {
+      // Make sure that the assignments are monomorphic.
+      %DeoptimizeFunction(Assign);
+      %DeoptimizeFunction(AssignStrict);
+      %ClearFunctionTypeFeedback(Assign);
+      %ClearFunctionTypeFeedback(AssignStrict);
+      for (var i = 0; i < t; ++i) {
+        var o = create();
+        assertFalse("a" in o && !("a" in o.__proto__));
+        if (strict === 0)
+          Assign(o, i);
+        else
+          AssignStrict(o, i);
+        assertEquals(i, o.a);
+      }
+      %OptimizeFunctionOnNextCall(Assign);
+      %OptimizeFunctionOnNextCall(AssignStrict);
+      var o = create();
+      assertFalse("a" in o && !("a" in o.__proto__));
+      readonly(o.up, "a");
+      assertTrue("a" in o);
+      if (strict === 0)
+        Assign(o, t + 1);
+      else
+        assertThrows(function() { AssignStrict(o, t + 1) }, TypeError);
+      assertTrue(o.a < 0);
+    });
+  }
+}
+
+
+// Runner.
+
+TestAllScenarios(function(scenario) {
+  TestAllModes(function(strict) {
+    TestAllReadonlys(function(readonly) {
+      TestAllCreates(function(create) {
+        scenario(strict, create, readonly);
+      });
+    });
+  });
+});
+
+
+// Extra test forcing bailout.
+
+function Assign2(o, x) { o.a = x }
+
+(function() {
+  var p = CreateFromConstructor(Object.prototype)();
+  var c = CreateFromConstructor(p);
+  for (var i = 0; i < 3; ++i) {
+    var o = c();
+    Assign2(o, i);
+    assertEquals(i, o.a);
+  }
+  %OptimizeFunctionOnNextCall(Assign2);
+  ReadonlyByNonwritableDataProperty(p, "a");
+  var o = c();
+  Assign2(o, 0);
+  assertTrue(o.a < 0);
+})();

data/vendor/v8/test/mjsunit/regexp-capture-3.js

@@ -162,27 +162,25 @@ assertEquals("*foo * baz", a);
 // string we can test that the relevant node is removed by verifying that
 // there is no hang.
 function NoHang(re) {
-  print(re);
   "This is an ASCII string that could take forever".match(re);
 }
 
-
-NoHang(/(((.*)*)*x)å/);  // Continuation after loop is filtered, so is loop.
-NoHang(/(((.*)*)*å)foo/);  // Body of loop filtered.
-NoHang(/å(((.*)*)*x)/);   // Everything after a filtered character is filtered.
-NoHang(/(((.*)*)*x)å/);   // Everything before a filtered character is filtered.
-NoHang(/[æøå](((.*)*)*x)/);   // Everything after a filtered class is filtered.
-NoHang(/(((.*)*)*x)[æøå]/);   // Everything before a filtered class is filtered.
-NoHang(/[^\x00-\x7f](((.*)*)*x)/);   // After negated class.
-NoHang(/(((.*)*)*x)[^\x00-\x7f]/);   // Before negated class.
-NoHang(/(?!(((.*)*)*x)å)foo/);  // Negative lookahead is filtered.
-NoHang(/(?!(((.*)*)*x))å/);  // Continuation branch of negative lookahead.
-NoHang(/(?=(((.*)*)*x)å)foo/);  // Positive lookahead is filtered.
-NoHang(/(?=(((.*)*)*x))å/);  // Continuation branch of positive lookahead.
-NoHang(/(?=å)(((.*)*)*x)/);  // Positive lookahead also prunes continuation.
-NoHang(/(æ|ø|å)(((.*)*)*x)/);  // All branches of alternation are filtered.
-NoHang(/(a|b|(((.*)*)*x))å/);  // 1 out of 3 branches pruned.
-NoHang(/(a|(((.*)*)*x)ø|(((.*)*)*x)å)/);  // 2 out of 3 branches pruned.
+NoHang(/(((.*)*)*x)Ā/);  // Continuation after loop is filtered, so is loop.
+NoHang(/(((.*)*)*Ā)foo/);  // Body of loop filtered.
+NoHang(/Ā(((.*)*)*x)/);   // Everything after a filtered character is filtered.
+NoHang(/(((.*)*)*x)Ā/);   // Everything before a filtered character is filtered.
+NoHang(/[ćăĀ](((.*)*)*x)/);   // Everything after a filtered class is filtered.
+NoHang(/(((.*)*)*x)[ćăĀ]/);   // Everything before a filtered class is filtered.
+NoHang(/[^\x00-\xff](((.*)*)*x)/);   // After negated class.
+NoHang(/(((.*)*)*x)[^\x00-\xff]/);   // Before negated class.
+NoHang(/(?!(((.*)*)*x)Ā)foo/);  // Negative lookahead is filtered.
+NoHang(/(?!(((.*)*)*x))Ā/);  // Continuation branch of negative lookahead.
+NoHang(/(?=(((.*)*)*x)Ā)foo/);  // Positive lookahead is filtered.
+NoHang(/(?=(((.*)*)*x))Ā/);  // Continuation branch of positive lookahead.
+NoHang(/(?=Ā)(((.*)*)*x)/);  // Positive lookahead also prunes continuation.
+NoHang(/(æ|ø|Ā)(((.*)*)*x)/);  // All branches of alternation are filtered.
+NoHang(/(a|b|(((.*)*)*x))Ā/);  // 1 out of 3 branches pruned.
+NoHang(/(a|(((.*)*)*x)ă|(((.*)*)*x)Ā)/);  // 2 out of 3 branches pruned.
 
 var s = "Don't prune based on a repetition of length 0";
 assertEquals(null, s.match(/å{1,1}prune/));