diff options
Diffstat (limited to 'deps/v8/test/mjsunit')
120 files changed, 7926 insertions, 200 deletions
diff --git a/deps/v8/test/mjsunit/allocation-site-info.js b/deps/v8/test/mjsunit/allocation-site-info.js new file mode 100644 index 000000000..d57fd321e --- /dev/null +++ b/deps/v8/test/mjsunit/allocation-site-info.js @@ -0,0 +1,272 @@ +// Copyright 2012 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 --smi-only-arrays --expose-gc +// Flags: --track-allocation-sites --nooptimize-constructed-arrays + +// TODO(mvstanton): remove --nooptimize-constructed-arrays and enable +// the constructed array code below when the feature is turned on +// by default. + +// Test element kind of objects. +// Since --smi-only-arrays affects builtins, its default setting at compile +// time sticks if built with snapshot. If --smi-only-arrays is deactivated +// by default, only a no-snapshot build actually has smi-only arrays enabled +// in this test case. Depending on whether smi-only arrays are actually +// enabled, this test takes the appropriate code path to check smi-only arrays. + +support_smi_only_arrays = %HasFastSmiElements(new Array(1,2,3,4,5,6,7,8)); +optimize_constructed_arrays = false; + +if (support_smi_only_arrays) { + print("Tests include smi-only arrays."); +} else { + print("Tests do NOT include smi-only arrays."); +} + +if (optimize_constructed_arrays) { + print("Tests include constructed array optimizations."); +} else { + print("Tests do NOT include constructed array optimizations."); +} + +var elements_kind = { + fast_smi_only : 'fast smi only elements', + fast : 'fast elements', + fast_double : 'fast double elements', + dictionary : 'dictionary elements', + external_byte : 'external byte elements', + external_unsigned_byte : 'external unsigned byte elements', + external_short : 'external short elements', + external_unsigned_short : 'external unsigned short elements', + external_int : 'external int elements', + external_unsigned_int : 'external unsigned int elements', + external_float : 'external float elements', + external_double : 'external double elements', + external_pixel : 'external pixel elements' +} + +function getKind(obj) { + if (%HasFastSmiElements(obj)) return elements_kind.fast_smi_only; + if (%HasFastObjectElements(obj)) return elements_kind.fast; + if (%HasFastDoubleElements(obj)) return elements_kind.fast_double; + if (%HasDictionaryElements(obj)) return elements_kind.dictionary; +} + +function isHoley(obj) { + if (%HasFastHoleyElements(obj)) return true; + return false; +} + +function assertKind(expected, obj, name_opt) { + if (!support_smi_only_arrays && + expected == elements_kind.fast_smi_only) { + expected = elements_kind.fast; + } + assertEquals(expected, getKind(obj), name_opt); +} + +function assertHoley(obj, name_opt) { + assertEquals(true, isHoley(obj), name_opt); +} + +function assertNotHoley(obj, name_opt) { + assertEquals(false, isHoley(obj), name_opt); +} + +if (support_smi_only_arrays) { + + obj = []; + assertNotHoley(obj); + assertKind(elements_kind.fast_smi_only, obj); + + obj = [1, 2, 3]; + assertNotHoley(obj); + assertKind(elements_kind.fast_smi_only, obj); + + obj = new Array(); + assertNotHoley(obj); + assertKind(elements_kind.fast_smi_only, obj); + + obj = new Array(0); + assertNotHoley(obj); + assertKind(elements_kind.fast_smi_only, obj); + + obj = new Array(2); + assertHoley(obj); + assertKind(elements_kind.fast_smi_only, obj); + + obj = new Array(1,2,3); + assertNotHoley(obj); + assertKind(elements_kind.fast_smi_only, obj); + + obj = new Array(1, "hi", 2, undefined); + assertNotHoley(obj); + assertKind(elements_kind.fast, obj); + + function fastliteralcase(literal, value) { + literal[0] = value; + return literal; + } + + function get_standard_literal() { + var literal = [1, 2, 3]; + return literal; + } + + // Case: [1,2,3] as allocation site + obj = fastliteralcase(get_standard_literal(), 1); + assertKind(elements_kind.fast_smi_only, obj); + obj = fastliteralcase(get_standard_literal(), 1.5); + assertKind(elements_kind.fast_double, obj); + obj = fastliteralcase(get_standard_literal(), 2); + assertKind(elements_kind.fast_double, obj); + + obj = fastliteralcase([5, 3, 2], 1.5); + assertKind(elements_kind.fast_double, obj); + obj = fastliteralcase([3, 6, 2], 1.5); + assertKind(elements_kind.fast_double, obj); + obj = fastliteralcase([2, 6, 3], 2); + assertKind(elements_kind.fast_smi_only, obj); + + // Verify that we will not pretransition the double->fast path. + obj = fastliteralcase(get_standard_literal(), "elliot"); + assertKind(elements_kind.fast, obj); + // This fails until we turn off optimistic transitions to the + // most general elements kind seen on keyed stores. It's a goal + // to turn it off, but for now we need it. + // obj = fastliteralcase(3); + // assertKind(elements_kind.fast_double, obj); + + function fastliteralcase_smifast(value) { + var literal = [1, 2, 3, 4]; + literal[0] = value; + return literal; + } + + obj = fastliteralcase_smifast(1); + assertKind(elements_kind.fast_smi_only, obj); + obj = fastliteralcase_smifast("carter"); + assertKind(elements_kind.fast, obj); + obj = fastliteralcase_smifast(2); + assertKind(elements_kind.fast, obj); + + if (optimize_constructed_arrays) { + function newarraycase_smidouble(value) { + var a = new Array(); + a[0] = value; + return a; + } + + // Case: new Array() as allocation site, smi->double + obj = newarraycase_smidouble(1); + assertKind(elements_kind.fast_smi_only, obj); + obj = newarraycase_smidouble(1.5); + assertKind(elements_kind.fast_double, obj); + obj = newarraycase_smidouble(2); + assertKind(elements_kind.fast_double, obj); + + function newarraycase_smiobj(value) { + var a = new Array(); + a[0] = value; + return a; + } + + // Case: new Array() as allocation site, smi->fast + obj = newarraycase_smiobj(1); + assertKind(elements_kind.fast_smi_only, obj); + obj = newarraycase_smiobj("gloria"); + assertKind(elements_kind.fast, obj); + obj = newarraycase_smiobj(2); + assertKind(elements_kind.fast, obj); + + function newarraycase_length_smidouble(value) { + var a = new Array(3); + a[0] = value; + return a; + } + + // Case: new Array(length) as allocation site + obj = newarraycase_length_smidouble(1); + assertKind(elements_kind.fast_smi_only, obj); + obj = newarraycase_length_smidouble(1.5); + assertKind(elements_kind.fast_double, obj); + obj = newarraycase_length_smidouble(2); + assertKind(elements_kind.fast_double, obj); + + // Try to continue the transition to fast object, but + // we will not pretransition from double->fast, because + // it may hurt performance ("poisoning"). + obj = newarraycase_length_smidouble("coates"); + assertKind(elements_kind.fast, obj); + obj = newarraycase_length_smidouble(2.5); + // However, because of optimistic transitions, we will + // transition to the most general kind of elements kind found, + // therefore I can't count on this assert yet. + // assertKind(elements_kind.fast_double, obj); + + function newarraycase_length_smiobj(value) { + var a = new Array(3); + a[0] = value; + return a; + } + + // Case: new Array(<length>) as allocation site, smi->fast + obj = newarraycase_length_smiobj(1); + assertKind(elements_kind.fast_smi_only, obj); + obj = newarraycase_length_smiobj("gloria"); + assertKind(elements_kind.fast, obj); + obj = newarraycase_length_smiobj(2); + assertKind(elements_kind.fast, obj); + + function newarraycase_list_smidouble(value) { + var a = new Array(1, 2, 3); + a[0] = value; + return a; + } + + obj = newarraycase_list_smidouble(1); + assertKind(elements_kind.fast_smi_only, obj); + obj = newarraycase_list_smidouble(1.5); + assertKind(elements_kind.fast_double, obj); + obj = newarraycase_list_smidouble(2); + assertKind(elements_kind.fast_double, obj); + + function newarraycase_list_smiobj(value) { + var a = new Array(4, 5, 6); + a[0] = value; + return a; + } + + obj = newarraycase_list_smiobj(1); + assertKind(elements_kind.fast_smi_only, obj); + obj = newarraycase_list_smiobj("coates"); + assertKind(elements_kind.fast, obj); + obj = newarraycase_list_smiobj(2); + assertKind(elements_kind.fast, obj); + } +} diff --git a/deps/v8/test/mjsunit/array-bounds-check-removal.js b/deps/v8/test/mjsunit/array-bounds-check-removal.js index df7988bda..8ed7901d4 100644 --- a/deps/v8/test/mjsunit/array-bounds-check-removal.js +++ b/deps/v8/test/mjsunit/array-bounds-check-removal.js @@ -52,13 +52,13 @@ test_do_not_assert_on_non_int32(v,"a"); %OptimizeFunctionOnNextCall(test_do_not_assert_on_non_int32); test_do_not_assert_on_non_int32(v,0); -function test_base(base,cond) { +function test_base(a, base, condition) { a[base + 1] = 1; a[base + 4] = 2; a[base + 3] = 3; a[base + 2] = 4; a[base + 4] = base + 4; - if (cond) { + if (condition) { a[base + 1] = 1; a[base + 2] = 2; a[base + 2] = 3; @@ -73,8 +73,8 @@ function test_base(base,cond) { } } -function check_test_base(base,cond) { - if (cond) { +function check_test_base(a, base, condition) { + if (condition) { assertEquals(1, a[base + 1]); assertEquals(4, a[base + 2]); assertEquals(base + 4, a[base + 4]); @@ -87,6 +87,37 @@ function check_test_base(base,cond) { } +test_base(a, 1, true); +test_base(a, 2, true); +test_base(a, 1, false); +test_base(a, 2, false); +%OptimizeFunctionOnNextCall(test_base); +test_base(a, 3, true); +check_test_base(a, 3, true); +test_base(a, 3, false); +check_test_base(a, 3, false); + +// Test that we deopt on failed bounds checks. +var dictionary_map_array = new Int32Array(128); +test_base(dictionary_map_array, 5, true); +test_base(dictionary_map_array, 6, true); +test_base(dictionary_map_array, 5, false); +test_base(dictionary_map_array, 6, false); +%OptimizeFunctionOnNextCall(test_base); +test_base(dictionary_map_array, -2, true); +assertTrue(%GetOptimizationStatus(test_base) != 1); + +// Forget about the dictionary_map_array's map. +%ClearFunctionTypeFeedback(test_base); + +test_base(a, 5, true); +test_base(a, 6, true); +test_base(a, 5, false); +test_base(a, 6, false); +%OptimizeFunctionOnNextCall(test_base); +test_base(a, 2048, true); +assertTrue(%GetOptimizationStatus(test_base) != 1); + function test_minus(base,cond) { a[base - 1] = 1; a[base - 2] = 2; @@ -122,16 +153,6 @@ function check_test_minus(base,cond) { } } -test_base(1,true); -test_base(2,true); -test_base(1,false); -test_base(2,false); -%OptimizeFunctionOnNextCall(test_base); -test_base(3,true); -check_test_base(3,true); -test_base(3,false); -check_test_base(3,false); - test_minus(5,true); test_minus(6,true); %OptimizeFunctionOnNextCall(test_minus); @@ -140,30 +161,7 @@ check_test_minus(7,true); test_minus(7,false); check_test_minus(7,false); -// Optimization status: -// YES: 1 -// NO: 2 -// ALWAYS: 3 -// NEVER: 4 - -// Test that we still deopt on failed bound checks -test_base(5,true); -test_base(6,true); -test_base(5,false); -test_base(6,false); -%OptimizeFunctionOnNextCall(test_base); -test_base(-2,true); -assertTrue(%GetOptimizationStatus(test_base) != 1); - -test_base(5,true); -test_base(6,true); -test_base(5,false); -test_base(6,false); -%OptimizeFunctionOnNextCall(test_base); -test_base(2048,true); -assertTrue(%GetOptimizationStatus(test_base) != 1); - -// Specific test on negative offsets +// Specific test on negative offsets. var short_a = new Array(100); for (var i = 0; i < short_a.length; i++) short_a[i] = 0; function short_test(a, i) { @@ -174,9 +172,60 @@ short_test(short_a, 50); short_test(short_a, 50); %OptimizeFunctionOnNextCall(short_test); short_a.length = 10; -short_test(a, 0); +short_test(short_a, 0); assertTrue(%GetOptimizationStatus(short_test) != 1); -gc(); +// A test for when we would modify a phi index. +var data_phi = [0, 1, 2, 3, 4, 5, 6, 7, 8]; +function test_phi(a, base, check) { + var index; + if (check) { + index = base + 1; + } else { + index = base + 2; + } + var result = a[index]; + result += a[index + 1]; + result += a[index - 1]; + return result; +} +var result_phi = 0; +result_phi = test_phi(data_phi, 3, true); +assertEquals(12, result_phi); +result_phi = test_phi(data_phi, 3, true); +assertEquals(12, result_phi); +%OptimizeFunctionOnNextCall(test_phi); +result_phi = test_phi(data_phi, 3, true); +assertEquals(12, result_phi); + + +// A test for recursive decomposition +var data_composition_long = [0, 1, 2, 3, 4, 5, 6, 7, 8]; +var data_composition_short = [0, 1, 2, 3, 4]; +function test_composition(a, base0, check) { + var base1 = ((base0 + 2)); + var base2 = ((base1 + 8) >> 2); + var base3 = ((base2 + 6) >> 1); + var base4 = ((base3 + 8) >> 1); + + var result = 0; + result += a[base0]; + result += a[base1]; + result += a[base2]; + result += a[base3]; + result += a[base4]; + + return result; +} +var result_composition = 0; +result_composition = test_composition(data_composition_long, 2); +assertEquals(19, result_composition); +result_composition = test_composition(data_composition_long, 2); +assertEquals(19, result_composition); +%OptimizeFunctionOnNextCall(test_composition); +result_composition = test_composition(data_composition_short, 2); +assertEquals(NaN, result_composition); + +gc(); diff --git a/deps/v8/test/mjsunit/array-natives-elements.js b/deps/v8/test/mjsunit/array-natives-elements.js new file mode 100644 index 000000000..b3a714109 --- /dev/null +++ b/deps/v8/test/mjsunit/array-natives-elements.js @@ -0,0 +1,318 @@ +// Copyright 2012 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 --smi-only-arrays +// Flags: --noparallel-recompilation +// Flags: --notrack-allocation-sites + +// Test element kind of objects. +// Since --smi-only-arrays affects builtins, its default setting at compile time +// sticks if built with snapshot. If --smi-only-arrays is deactivated by +// default, only a no-snapshot build actually has smi-only arrays enabled in +// this test case. Depending on whether smi-only arrays are actually enabled, +// this test takes the appropriate code path to check smi-only arrays. + +support_smi_only_arrays = %HasFastSmiElements([1,2,3,4,5,6,7,8,9,10]); + +if (support_smi_only_arrays) { + print("Tests include smi-only arrays."); +} else { + print("Tests do NOT include smi-only arrays."); +} + +// IC and Crankshaft support for smi-only elements in dynamic array literals. +function get(foo) { return foo; } // Used to generate dynamic values. + +function array_natives_test() { + + // Ensure small array literals start in specific element kind mode. + assertTrue(%HasFastSmiElements([])); + assertTrue(%HasFastSmiElements([1])); + assertTrue(%HasFastSmiElements([1,2])); + assertTrue(%HasFastDoubleElements([1.1])); + assertTrue(%HasFastDoubleElements([1.1,2])); + + // Push + var a0 = [1, 2, 3]; + if (%HasFastSmiElements(a0)) { + assertTrue(%HasFastSmiElements(a0)); + a0.push(4); + assertTrue(%HasFastSmiElements(a0)); + a0.push(1.3); + assertTrue(%HasFastDoubleElements(a0)); + a0.push(1.5); + assertTrue(%HasFastDoubleElements(a0)); + a0.push({}); + assertTrue(%HasFastObjectElements(a0)); + a0.push({}); + assertTrue(%HasFastObjectElements(a0)); + } else { + assertTrue(%HasFastObjectElements(a0)); + a0.push(4); + a0.push(1.3); + a0.push(1.5); + a0.push({}); + a0.push({}); + assertTrue(%HasFastObjectElements(a0)); + } + assertEquals([1,2,3,4,1.3,1.5,{},{}], a0); + + // Concat + var a1; + a1 = [1,2,3].concat([]); + assertTrue(%HasFastSmiElements(a1)); + assertEquals([1,2,3], a1); + a1 = [1,2,3].concat([4,5,6]); + assertTrue(%HasFastSmiElements(a1)); + assertEquals([1,2,3,4,5,6], a1); + a1 = [1,2,3].concat([4,5,6], [7,8,9]); + assertTrue(%HasFastSmiElements(a1)); + assertEquals([1,2,3,4,5,6,7,8,9], a1); + a1 = [1.1,2,3].concat([]); + assertTrue(%HasFastDoubleElements(a1)); + assertEquals([1.1,2,3], a1); + a1 = [1,2,3].concat([1.1, 2]); + assertTrue(%HasFastDoubleElements(a1)); + assertEquals([1,2,3,1.1,2], a1); + a1 = [1.1,2,3].concat([1, 2]); + assertTrue(%HasFastDoubleElements(a1)); + assertEquals([1.1,2,3,1,2], a1); + a1 = [1.1,2,3].concat([1.2, 2]); + assertTrue(%HasFastDoubleElements(a1)); + assertEquals([1.1,2,3,1.2,2], a1); + + a1 = [1,2,3].concat([{}]); + assertTrue(%HasFastObjectElements(a1)); + assertEquals([1,2,3,{}], a1); + a1 = [1.1,2,3].concat([{}]); + assertTrue(%HasFastObjectElements(a1)); + assertEquals([1.1,2,3,{}], a1); + a1 = [{}].concat([1,2,3]); + assertTrue(%HasFastObjectElements(a1)); + assertEquals([{},1,2,3], a1); + a1 = [{}].concat([1.1,2,3]); + assertTrue(%HasFastObjectElements(a1)); + assertEquals([{},1.1,2,3], a1); + + // Slice + var a2 = [1,2,3]; + assertTrue(%HasFastSmiElements(a2.slice())); + assertTrue(%HasFastSmiElements(a2.slice(1))); + assertTrue(%HasFastSmiElements(a2.slice(1, 2))); + assertEquals([1,2,3], a2.slice()); + assertEquals([2,3], a2.slice(1)); + assertEquals([2], a2.slice(1,2)); + a2 = [1.1,2,3]; + assertTrue(%HasFastDoubleElements(a2.slice())); + assertTrue(%HasFastDoubleElements(a2.slice(1))); + assertTrue(%HasFastDoubleElements(a2.slice(1, 2))); + assertEquals([1.1,2,3], a2.slice()); + assertEquals([2,3], a2.slice(1)); + assertEquals([2], a2.slice(1,2)); + a2 = [{},2,3]; + assertTrue(%HasFastObjectElements(a2.slice())); + assertTrue(%HasFastObjectElements(a2.slice(1))); + assertTrue(%HasFastObjectElements(a2.slice(1, 2))); + assertEquals([{},2,3], a2.slice()); + assertEquals([2,3], a2.slice(1)); + assertEquals([2], a2.slice(1,2)); + + // Splice + var a3 = [1,2,3]; + var a3r; + a3r = a3.splice(0, 0); + assertTrue(%HasFastSmiElements(a3r)); + assertTrue(%HasFastSmiElements(a3)); + assertEquals([], a3r); + assertEquals([1, 2, 3], a3); + a3 = [1,2,3]; + a3r = a3.splice(0, 1); + assertTrue(%HasFastSmiElements(a3r)); + assertTrue(%HasFastSmiElements(a3)); + assertEquals([1], a3r); + assertEquals([2, 3], a3); + a3 = [1,2,3]; + a3r = a3.splice(0, 0, 2); + assertTrue(%HasFastSmiElements(a3r)); + assertTrue(%HasFastSmiElements(a3)); + assertEquals([], a3r); + assertEquals([2, 1, 2, 3], a3); + a3 = [1,2,3]; + a3r = a3.splice(0, 1, 2); + assertTrue(%HasFastSmiElements(a3r)); + assertTrue(%HasFastSmiElements(a3)); + assertEquals([1], a3r); + assertEquals([2, 2, 3], a3); + + a3 = [1.1,2,3]; + a3r = a3.splice(0, 0); + assertTrue(%HasFastDoubleElements(a3r)); + assertTrue(%HasFastDoubleElements(a3)); + assertEquals([], a3r); + assertEquals([1.1, 2, 3], a3); + a3 = [1.1,2,3]; + a3r = a3.splice(0, 1); + assertTrue(%HasFastDoubleElements(a3r)); + assertTrue(%HasFastDoubleElements(a3)); + assertEquals([1.1], a3r); + assertEquals([2, 3], a3); + a3 = [1.1,2,3]; + a3r = a3.splice(0, 0, 2); + // Commented out since handled in js, which takes the best fit. + // assertTrue(%HasFastDoubleElements(a3r)); + assertTrue(%HasFastSmiElements(a3r)); + assertTrue(%HasFastDoubleElements(a3)); + assertEquals([], a3r); + assertEquals([2, 1.1, 2, 3], a3); + a3 = [1.1,2,3]; + a3r = a3.splice(0, 1, 2); + assertTrue(%HasFastDoubleElements(a3r)); + assertTrue(%HasFastDoubleElements(a3)); + assertEquals([1.1], a3r); + assertEquals([2, 2, 3], a3); + a3 = [1.1,2,3]; + a3r = a3.splice(0, 0, 2.1); + // Commented out since handled in js, which takes the best fit. + // assertTrue(%HasFastDoubleElements(a3r)); + assertTrue(%HasFastSmiElements(a3r)); + assertTrue(%HasFastDoubleElements(a3)); + assertEquals([], a3r); + assertEquals([2.1, 1.1, 2, 3], a3); + a3 = [1.1,2,3]; + a3r = a3.splice(0, 1, 2.2); + assertTrue(%HasFastDoubleElements(a3r)); + assertTrue(%HasFastDoubleElements(a3)); + assertEquals([1.1], a3r); + assertEquals([2.2, 2, 3], a3); + a3 = [1,2,3]; + a3r = a3.splice(0, 0, 2.1); + // Commented out since handled in js, which takes the best fit. + // assertTrue(%HasFastDoubleElements(a3r)); + assertTrue(%HasFastSmiElements(a3r)); + assertTrue(%HasFastDoubleElements(a3)); + assertEquals([], a3r); + assertEquals([2.1, 1, 2, 3], a3); + a3 = [1,2,3]; + a3r = a3.splice(0, 1, 2.2); + assertTrue(%HasFastDoubleElements(a3r)); + assertTrue(%HasFastDoubleElements(a3)); + assertEquals([1], a3r); + assertEquals([2.2, 2, 3], a3); + + a3 = [{},2,3]; + a3r = a3.splice(0, 0); + assertTrue(%HasFastObjectElements(a3r)); + assertTrue(%HasFastObjectElements(a3)); + assertEquals([], a3r); + assertEquals([{}, 2, 3], a3); + a3 = [1,2,{}]; + a3r = a3.splice(0, 1); + assertTrue(%HasFastObjectElements(a3r)); + assertTrue(%HasFastObjectElements(a3)); + assertEquals([1], a3r); + assertEquals([2, {}], a3); + a3 = [1,2,3]; + a3r = a3.splice(0, 0, {}); + assertTrue(%HasFastObjectElements(a3r)); + assertTrue(%HasFastObjectElements(a3)); + assertEquals([], a3r); + assertEquals([{}, 1, 2, 3], a3); + a3 = [1,2,3]; + a3r = a3.splice(0, 1, {}); + assertTrue(%HasFastObjectElements(a3r)); + assertTrue(%HasFastObjectElements(a3)); + assertEquals([1], a3r); + assertEquals([{}, 2, 3], a3); + + a3 = [1.1,2,3]; + a3r = a3.splice(0, 0, {}); + assertTrue(%HasFastObjectElements(a3r)); + assertTrue(%HasFastObjectElements(a3)); + assertEquals([], a3r); + assertEquals([{}, 1.1, 2, 3], a3); + a3 = [1.1,2,3]; + a3r = a3.splice(0, 1, {}); + assertTrue(%HasFastObjectElements(a3r)); + assertTrue(%HasFastObjectElements(a3)); + assertEquals([1.1], a3r); + assertEquals([{}, 2, 3], a3); + + // Pop + var a4 = [1,2,3]; + assertEquals(3, a4.pop()); + assertTrue(%HasFastSmiElements(a4)); + a4 = [1.1,2,3]; + assertEquals(3, a4.pop()); + assertTrue(%HasFastDoubleElements(a4)); + a4 = [{},2,3]; + assertEquals(3, a4.pop()); + assertTrue(%HasFastObjectElements(a4)); + + // Shift + var a4 = [1,2,3]; + assertEquals(1, a4.shift()); + assertTrue(%HasFastSmiElements(a4)); + a4 = [1.1,2,3]; + assertEquals(1.1, a4.shift()); + assertTrue(%HasFastDoubleElements(a4)); + a4 = [{},2,3]; + assertEquals({}, a4.shift()); + assertTrue(%HasFastObjectElements(a4)); + + // Unshift + var a4 = [1,2,3]; + a4.unshift(1); + assertTrue(%HasFastSmiElements(a4)); + assertEquals([1,1,2,3], a4); + a4 = [1,2,3]; + a4.unshift(1.1); + // TODO(verwaest): We'll want to support double unshifting as well. + // assertTrue(%HasFastDoubleElements(a4)); + assertTrue(%HasFastObjectElements(a4)); + assertEquals([1.1,1,2,3], a4); + a4 = [1.1,2,3]; + a4.unshift(1); + // assertTrue(%HasFastDoubleElements(a4)); + assertTrue(%HasFastObjectElements(a4)); + assertEquals([1,1.1,2,3], a4); + a4 = [{},2,3]; + a4.unshift(1); + assertTrue(%HasFastObjectElements(a4)); + assertEquals([1,{},2,3], a4); + a4 = [{},2,3]; + a4.unshift(1.1); + assertTrue(%HasFastObjectElements(a4)); + assertEquals([1.1,{},2,3], a4); +} + +if (support_smi_only_arrays) { + for (var i = 0; i < 3; i++) { + array_natives_test(); + } + %OptimizeFunctionOnNextCall(array_natives_test); + array_natives_test(); +} diff --git a/deps/v8/test/mjsunit/array-reduce.js b/deps/v8/test/mjsunit/array-reduce.js index 1e9618826..429f34808 100755 --- a/deps/v8/test/mjsunit/array-reduce.js +++ b/deps/v8/test/mjsunit/array-reduce.js @@ -418,8 +418,8 @@ try { exception = true; assertTrue(e instanceof TypeError, "reduce callback not a function not throwing TypeError"); - assertEquals("called_non_callable", e.type, - "reduce non function TypeError type"); + assertTrue(e.message.indexOf(" is not a function") >= 0, + "reduce non function TypeError type"); } assertTrue(exception); @@ -430,8 +430,8 @@ try { exception = true; assertTrue(e instanceof TypeError, "reduceRight callback not a function not throwing TypeError"); - assertEquals("called_non_callable", e.type, - "reduceRight non function TypeError type"); + assertTrue(e.message.indexOf(" is not a function") >= 0, + "reduceRight non function TypeError type"); } assertTrue(exception); @@ -442,7 +442,7 @@ try { exception = true; assertTrue(e instanceof TypeError, "reduce no initial value not throwing TypeError"); - assertEquals("reduce_no_initial", e.type, + assertEquals("Reduce of empty array with no initial value", e.message, "reduce no initial TypeError type"); } assertTrue(exception); @@ -454,7 +454,7 @@ try { exception = true; assertTrue(e instanceof TypeError, "reduceRight no initial value not throwing TypeError"); - assertEquals("reduce_no_initial", e.type, + assertEquals("Reduce of empty array with no initial value", e.message, "reduceRight no initial TypeError type"); } assertTrue(exception); @@ -466,7 +466,7 @@ try { exception = true; assertTrue(e instanceof TypeError, "reduce sparse no initial value not throwing TypeError"); - assertEquals("reduce_no_initial", e.type, + assertEquals("Reduce of empty array with no initial value", e.message, "reduce no initial TypeError type"); } assertTrue(exception); @@ -478,7 +478,7 @@ try { exception = true; assertTrue(e instanceof TypeError, "reduceRight sparse no initial value not throwing TypeError"); - assertEquals("reduce_no_initial", e.type, + assertEquals("Reduce of empty array with no initial value", e.message, "reduceRight no initial TypeError type"); } assertTrue(exception); diff --git a/deps/v8/test/mjsunit/array-slice.js b/deps/v8/test/mjsunit/array-slice.js index 5ae31dc52..ae0e3bc1e 100644 --- a/deps/v8/test/mjsunit/array-slice.js +++ b/deps/v8/test/mjsunit/array-slice.js @@ -290,3 +290,15 @@ func('a', 'b', 'c'); })(); + +// Check slicing of holey objects with elements in the prototype +(function() { + function f() { + delete arguments[1]; + arguments.__proto__[1] = 5; + var result = Array.prototype.slice.call(arguments); + delete arguments.__proto__[1]; + assertEquals([1,5,3], result); + } + f(1,2,3); +})(); diff --git a/deps/v8/test/mjsunit/array-store-and-grow.js b/deps/v8/test/mjsunit/array-store-and-grow.js index 131d4ebc5..88f3db8f6 100644 --- a/deps/v8/test/mjsunit/array-store-and-grow.js +++ b/deps/v8/test/mjsunit/array-store-and-grow.js @@ -99,7 +99,10 @@ array_store_5(a, 1, 0.5); a = makeCOW(); array_store_5(a, 1, 0.5); assertEquals(0.5, a[1]); -assertEquals(0.5, array_store_5([], 1, 0.5)); +a = []; +assertEquals(0.5, array_store_5(a, 1, 0.5)); +assertEquals(undefined, a[0]); +assertEquals(0.5, a[1]); function array_store_6(a,b,c) { return (a[b] = c); diff --git a/deps/v8/test/mjsunit/assert-opt-and-deopt.js b/deps/v8/test/mjsunit/assert-opt-and-deopt.js index c79d92349..fa38ae3e5 100644 --- a/deps/v8/test/mjsunit/assert-opt-and-deopt.js +++ b/deps/v8/test/mjsunit/assert-opt-and-deopt.js @@ -25,7 +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: --allow-natives-syntax --noparallel-recompilation +// Flags: --allow-natives-syntax +%SetFlags("--noparallel-recompilation"); /** * This class shows how to use %GetOptimizationCount() and diff --git a/deps/v8/test/mjsunit/big-array-literal.js b/deps/v8/test/mjsunit/big-array-literal.js index 8e0ff8727..9f0617989 100644 --- a/deps/v8/test/mjsunit/big-array-literal.js +++ b/deps/v8/test/mjsunit/big-array-literal.js @@ -25,8 +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. -// On MacOS, this test needs a stack size of at least 538 kBytes. -// Flags: --stack-size=600 +// On MacOS X 10.7.5, this test needs a stack size of at least 788 kBytes. +// Flags: --stack-size=800 // Test that we can make large object literals that work. // Also test that we can attempt to make even larger object literals without diff --git a/deps/v8/test/mjsunit/builtins.js b/deps/v8/test/mjsunit/builtins.js index e43b5891a..062cfd568 100644 --- a/deps/v8/test/mjsunit/builtins.js +++ b/deps/v8/test/mjsunit/builtins.js @@ -54,7 +54,7 @@ function checkConstructor(func, name) { assertFalse(proto_desc.writable, name); assertFalse(proto_desc.configurable, name); var prototype = proto_desc.value; - assertEquals(null, prototype.__proto__, name); + assertEquals(null, Object.getPrototypeOf(prototype), name); for (var i = 0; i < propNames.length; i++) { var propName = propNames[i]; if (propName == "constructor") continue; diff --git a/deps/v8/test/mjsunit/compiler/inline-closures.js b/deps/v8/test/mjsunit/compiler/inline-closures.js new file mode 100644 index 000000000..69161e505 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/inline-closures.js @@ -0,0 +1,49 @@ +// Copyright 2013 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 + +// Test inlining of multiple closures derived from one shared function. + +function mkClosure(continuation) { + return function(value) { + if (continuation == 'g') return this.g(value); + if (continuation == 'h') return this.h(value); + return value.value; + } +} + +var object = {}; +object.f = mkClosure('g'); +object.g = mkClosure('h'); +object.h = mkClosure('x'); + +assertSame(1, object.f({value:1})); +assertSame(2, object.f({value:2})); +%OptimizeFunctionOnNextCall(object.f); +assertSame(3, object.f({value:3})); +assertSame(undefined, object.f({})); diff --git a/deps/v8/test/mjsunit/compiler/inline-function-apply.js b/deps/v8/test/mjsunit/compiler/inline-function-apply.js new file mode 100644 index 000000000..6b761f4df --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/inline-function-apply.js @@ -0,0 +1,89 @@ +// Copyright 2013 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 + +// Test inlining and deoptimization of function.apply(this, arguments) +// calls for which the exact number of arguments is known. +(function () { + "use strict"; + function test(argumentsCount) { + var dispatcher = {}; + var deoptimize = { deopt:false }; + dispatcher["const" + argumentsCount] = 0; + dispatcher.func = C; + + function A(x,y) { + var r = "A"; + if (argumentsCount == 1) r += B(10); + if (argumentsCount == 2) r += B(10, 11); + if (argumentsCount == 3) r += B(10, 11, 12); + assertSame(1, x); + assertSame(2, y); + return r; + } + + function B(x,y) { + x = 0; y = 0; + var r = "B" + dispatcher.func.apply(this, arguments); + assertSame(argumentsCount, arguments.length); + for (var i = 0; i < arguments.length; i++) { + assertSame(10 + i, arguments[i]); + } + return r; + } + + function C(x,y) { + x = 0; y = 0; + var r = "C" + deoptimize.deopt; + assertSame(argumentsCount, arguments.length); + for (var i = 0; i < arguments.length; i++) { + assertSame(10 + i, arguments[i]); + } + return r; + } + + assertEquals("ABC", A(1,2)); + assertEquals("ABC", A(1,2)); + %OptimizeFunctionOnNextCall(A); + assertEquals("ABC", A(1,2)); + delete deoptimize.deopt; + assertEquals("ABC", A(1,2)); + + %DeoptimizeFunction(A); + %ClearFunctionTypeFeedback(A); + %DeoptimizeFunction(B); + %ClearFunctionTypeFeedback(B); + %DeoptimizeFunction(C); + %ClearFunctionTypeFeedback(C); + } + + for (var a = 1; a <= 3; a++) { + test(a); + } +})(); diff --git a/deps/v8/test/mjsunit/compiler/inline-literals.js b/deps/v8/test/mjsunit/compiler/inline-literals.js index 142258691..448799669 100644 --- a/deps/v8/test/mjsunit/compiler/inline-literals.js +++ b/deps/v8/test/mjsunit/compiler/inline-literals.js @@ -87,3 +87,24 @@ TestRegExpLiteral("-b", "reg", "exp", "-expreg"); %OptimizeFunctionOnNextCall(TestRegExpLiteral); TestRegExpLiteral("ab", "reg", "exp", "regexpexpreg"); TestRegExpLiteral("ab", 12345, 54321, "6666666666"); + +function f2(b, c) { + var closure = function(b, c) { return b + c; } + var value = b + c; + return closure; +} + +function f1(a, b, c) { + return a + f2(b, c)(b, c); +} + +function TestFunctionLiteral(a, b, c, expected) { + var result = f1(a, b, c); + assertEquals(expected, result, "TestFunctionLiteral"); +} + +TestFunctionLiteral(1, 2, 3, 6); +TestFunctionLiteral(4, 5, 6, 15); +%OptimizeFunctionOnNextCall(TestFunctionLiteral); +TestFunctionLiteral(7, 8, 9, 24); +TestFunctionLiteral("a", "b", "c", "abc"); diff --git a/deps/v8/test/mjsunit/compiler/multiply-add.js b/deps/v8/test/mjsunit/compiler/multiply-add.js new file mode 100644 index 000000000..2b4304e84 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/multiply-add.js @@ -0,0 +1,69 @@ +// Copyright 2012 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 +// Test expressions that can be computed with a multiply-add instruction. + +function f(a, b, c) { + return a * b + c; +} + +function g(a, b, c) { + return a + b * c; +} + +function h(a, b, c, d) { + return a * b + c * d; +} + +assertEquals(5, f(1, 2, 3)); +assertEquals(5, f(1, 2, 3)); +%OptimizeFunctionOnNextCall(f); +assertEquals(5, f(1, 2, 3)); +assertEquals("2foo", f(1, 2, "foo")); +assertEquals(5.41, f(1.1, 2.1, 3.1)); +assertEquals(5.41, f(1.1, 2.1, 3.1)); +%OptimizeFunctionOnNextCall(f); +assertEquals(5.41, f(1.1, 2.1, 3.1)); + +assertEquals(7, g(1, 2, 3)); +assertEquals(7, g(1, 2, 3)); +%OptimizeFunctionOnNextCall(g); +assertEquals(7, g(1, 2, 3)); +assertEquals(8.36, g(1.1, 2.2, 3.3)); +assertEquals(8.36, g(1.1, 2.2, 3.3)); +%OptimizeFunctionOnNextCall(g); +assertEquals(8.36, g(1.1, 2.2, 3.3)); + +assertEquals(14, h(1, 2, 3, 4)); +assertEquals(14, h(1, 2, 3, 4)); +%OptimizeFunctionOnNextCall(h); +assertEquals(14, h(1, 2, 3, 4)); +assertEquals(15.02, h(1.1, 2.1, 3.1, 4.1)); +assertEquals(15.02, h(1.1, 2.1, 3.1, 4.1)); +%OptimizeFunctionOnNextCall(h); +assertEquals(15.02, h(1.1, 2.1, 3.1, 4.1)); diff --git a/deps/v8/test/mjsunit/compiler/multiply-sub.js b/deps/v8/test/mjsunit/compiler/multiply-sub.js new file mode 100644 index 000000000..4793181d4 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/multiply-sub.js @@ -0,0 +1,56 @@ +// Copyright 2013 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 +// Test expressions that can be computed with a multiply-add instruction. + +function f(a, b, c) { + return a - b * c; +} + +function g(a, b, c) { + return a * b - c; +} + +function h(a, b, c, d) { + return a * b - c * d; +} + +assertEquals(-5.41, f(1.1, 2.1, 3.1)); +assertEquals(-5.41, f(1.1, 2.1, 3.1)); +%OptimizeFunctionOnNextCall(f); +assertEquals(-5.41, f(1.1, 2.1, 3.1)); + +assertEquals(8.36, g(2.2, 3.3, -1.1)); +assertEquals(8.36, g(2.2, 3.3, -1.1)); +%OptimizeFunctionOnNextCall(g); +assertEquals(8.36, g(2.2, 3.3, -1.1)); + +assertEquals(-1.5, h(1.5, 3.0, 12, 0.5)); +assertEquals(-1.5, h(1.5, 3.0, 12, 0.5)); +%OptimizeFunctionOnNextCall(h); +assertEquals(-1.5, h(1.5, 3.0, 12, 0.5)); diff --git a/deps/v8/test/mjsunit/compiler/parallel-proto-change.js b/deps/v8/test/mjsunit/compiler/parallel-proto-change.js new file mode 100644 index 000000000..74e6d86a1 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/parallel-proto-change.js @@ -0,0 +1,45 @@ +// Copyright 2013 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 --parallel-recompilation + +function f(foo) { return foo.bar(); } + +var o = {}; +o.__proto__ = { __proto__: { bar: function() { return 1; } } }; + +assertEquals(1, f(o)); +assertEquals(1, f(o)); + +%OptimizeFunctionOnNextCall(f, "parallel"); +assertEquals(1, f(o)); +// Change the prototype chain during optimization. +o.__proto__.__proto__ = { bar: function() { return 2; } }; + +%WaitUntilOptimized(f); + +assertEquals(2, f(o)); diff --git a/deps/v8/test/mjsunit/compiler/property-static.js b/deps/v8/test/mjsunit/compiler/property-static.js new file mode 100644 index 000000000..07021340c --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/property-static.js @@ -0,0 +1,69 @@ +// Copyright 2013 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 + +// Test usage of static type information for loads that would otherwise +// turn into polymorphic or generic loads. + +// Prepare a highly polymorphic load to be used by all tests. +Object.prototype.load = function() { return this.property; }; +Object.prototype.load.call({ A:0, property:10 }); +Object.prototype.load.call({ A:0, B:0, property:11 }); +Object.prototype.load.call({ A:0, B:0, C:0, property:12 }); +Object.prototype.load.call({ A:0, B:0, C:0, D:0, property:13 }); +Object.prototype.load.call({ A:0, B:0, C:0, D:0, E:0, property:14 }); +Object.prototype.load.call({ A:0, B:0, C:0, D:0, E:0, F:0, property:15 }); + +// Test for object literals. +(function() { + function f(x) { + var object = { property:x }; + return object.load(); + } + + assertSame(1, f(1)); + assertSame(2, f(2)); + %OptimizeFunctionOnNextCall(f); + assertSame(3, f(3)); +})(); + +// Test for inlined constructors. +(function() { + function c(x) { + this.property = x; + } + function f(x) { + var object = new c(x); + return object.load(); + } + + assertSame(1, f(1)); + assertSame(2, f(2)); + %OptimizeFunctionOnNextCall(f); + assertSame(3, f(3)); +})(); diff --git a/deps/v8/test/mjsunit/compiler/proto-chain-constant.js b/deps/v8/test/mjsunit/compiler/proto-chain-constant.js new file mode 100644 index 000000000..0d9e3b0e1 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/proto-chain-constant.js @@ -0,0 +1,55 @@ +// Copyright 2013 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 + +// Test loading a constant function on the prototype chain. + +var c = Object.create; +var obj4 = c(null, { f4: { value: function() { return 4; }, writable: true }}); +var obj3 = c(obj4, { f3: { value: function() { return 3; }, writable: true }}); +var obj2 = c(obj3, { f2: { value: function() { return 2; }, writable: true }}); +var obj1 = c(obj2, { f1: { value: function() { return 1; }, writable: true }}); +var obj0 = c(obj1, { f0: { value: function() { return 0; }, writable: true }}); + +function get4(obj) { return obj.f4; } + +assertEquals(4, get4(obj0)()); +assertEquals(4, get4(obj0)()); +%OptimizeFunctionOnNextCall(get4); +assertEquals(4, get4(obj0)()); +obj4.f4 = function() { return 5; }; +assertEquals(5, get4(obj0)()); + +function get3(obj) { return obj.f3; } + +assertEquals(3, get3(obj0)()); +assertEquals(3, get3(obj0)()); +%OptimizeFunctionOnNextCall(get3); +assertEquals(3, get3(obj0)()); +obj2.f3 = function() { return 6; }; +assertEquals(6, get3(obj0)()); diff --git a/deps/v8/test/mjsunit/compiler/proto-chain-load.js b/deps/v8/test/mjsunit/compiler/proto-chain-load.js new file mode 100644 index 000000000..60c6431d2 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/proto-chain-load.js @@ -0,0 +1,44 @@ +// Copyright 2012 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 + +// Test HLoadNamedField on the proto chain. + +var obj4 = Object.create(null, { f4: {value: 4} }); +var obj3 = Object.create(obj4, { f3: {value: 3} }); +var obj2 = Object.create(obj3, { f2: {value: 2} }); +var obj1 = Object.create(obj2, { f1: {value: 1} }); +var obj0 = Object.create(obj1, { f0: {value: 0} }); + +function get4(obj) { return obj.f4; } + +assertEquals(4, get4(obj0)); +assertEquals(4, get4(obj0)); +%OptimizeFunctionOnNextCall(get4); +assertEquals(4, get4(obj0)); +assertEquals(4, get4(obj0)); diff --git a/deps/v8/test/mjsunit/compiler/regress-177883.js b/deps/v8/test/mjsunit/compiler/regress-177883.js new file mode 100644 index 000000000..d5af58495 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/regress-177883.js @@ -0,0 +1,179 @@ +// Copyright 2013 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 + +// A regression test for a register allocation bug triggered by +// http://n3emscripten.appspot.com/dragons_asmjs.html. Note that the test is +// very fragile, but without a proper testing infrastructure for the register +// allocator we can't really do much better. +// +// The code below is a slighty modified version of Emscripten-translated C++ +// code for the standard textbook algorithm for frustum culling of an object +// with a given bounding box. +// +// The key problem for the underlying bug was a value with a long live range +// which is used often (a context) and a lot of live ranges starting at the same +// point. The bug was that none of the ranges were allowed to be spilled, so the +// allocator was splitting a live range at its start and re-added the very same +// range into the list of unallocated ranges, making no progress. + +(function () { + function __ZNK4Math5plane3dotERKNS_6float4E(i1, i2) { + i1 = i1 | 0; + i2 = i2 | 0; + return +(+HEAPF32[i1 >> 2] * +HEAPF32[i2 >> 2] + +HEAPF32[i1 + 4 >> 2] * +HEAPF32[i2 + 4 >> 2] + +HEAPF32[i1 + 8 >> 2] * +HEAPF32[i2 + 8 >> 2] + +HEAPF32[i1 + 12 >> 2] * +HEAPF32[i2 + 12 >> 2]); + } + + function __ZNK4Math7frustum8clipmaskERKNS_5pointE(i1, i2) { + i1 = i1 | 0; + i2 = i2 | 0; + var i3 = 0, i4 = 0; + i3 = i2 | 0; + i2 = +__ZNK4Math5plane3dotERKNS_6float4E(i1 | 0, i3) > 0.0 & 1; + i4 = +__ZNK4Math5plane3dotERKNS_6float4E(i1 + 16 | 0, i3) > 0.0 ? i2 | 2 : i2; + i2 = +__ZNK4Math5plane3dotERKNS_6float4E(i1 + 32 | 0, i3) > 0.0 ? i4 | 4 : i4; + i4 = +__ZNK4Math5plane3dotERKNS_6float4E(i1 + 48 | 0, i3) > 0.0 ? i2 | 8 : i2; + i2 = +__ZNK4Math5plane3dotERKNS_6float4E(i1 + 64 | 0, i3) > 0.0 ? i4 | 16 : i4; + return (+__ZNK4Math5plane3dotERKNS_6float4E(i1 + 80 | 0, i3) > 0.0 ? i2 | 32 : i2) | 0; + } + + function __ZNK4Math7frustum10clipstatusERKNS_4bboxE(i1, i2) { + i1 = i1 | 0; + i2 = i2 | 0; + var i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, d17 = 0.0, d18 = 0.0, i19 = 0, i20 = 0, i21 = 0, i22 = 0; + i3 = STACKTOP; + STACKTOP = STACKTOP + 16 | 0; + i4 = i3 | 0; + i5 = i4 | 0; + HEAPF32[i5 >> 2] = 0.0; + i6 = i4 + 4 | 0; + HEAPF32[i6 >> 2] = 0.0; + i7 = i4 + 8 | 0; + HEAPF32[i7 >> 2] = 0.0; + i8 = i4 + 12 | 0; + HEAPF32[i8 >> 2] = 1.0; + i9 = i2 | 0; + i10 = i2 + 4 | 0; + i11 = i2 + 8 | 0; + i12 = i2 + 20 | 0; + i13 = i2 + 16 | 0; + i14 = i2 + 24 | 0; + i2 = 65535; + i15 = 0; + i16 = 0; + while (1) { + if ((i16 | 0) == 1) { + d17 = +HEAPF32[i12 >> 2]; + d18 = +HEAPF32[i11 >> 2]; + HEAPF32[i5 >> 2] = +HEAPF32[i9 >> 2]; + HEAPF32[i6 >> 2] = d17; + HEAPF32[i7 >> 2] = d18; + HEAPF32[i8 >> 2] = 1.0; + } else if ((i16 | 0) == 4) { + HEAPF32[i5 >> 2] = +HEAPF32[i13 >> 2]; + HEAPF32[i6 >> 2] = +HEAPF32[i12 >> 2]; + HEAPF32[i7 >> 2] = +HEAPF32[i14 >> 2]; + HEAPF32[i8 >> 2] = 1.0; + } else if ((i16 | 0) == 6) { + d18 = +HEAPF32[i10 >> 2]; + d17 = +HEAPF32[i14 >> 2]; + HEAPF32[i5 >> 2] = +HEAPF32[i9 >> 2]; + HEAPF32[i6 >> 2] = d18; + HEAPF32[i7 >> 2] = d17; + HEAPF32[i8 >> 2] = 1.0; + } else if ((i16 | 0) == 5) { + d17 = +HEAPF32[i12 >> 2]; + d18 = +HEAPF32[i14 >> 2]; + HEAPF32[i5 >> 2] = +HEAPF32[i9 >> 2]; + HEAPF32[i6 >> 2] = d17; + HEAPF32[i7 >> 2] = d18; + HEAPF32[i8 >> 2] = 1.0; + } else if ((i16 | 0) == 3) { + d18 = +HEAPF32[i10 >> 2]; + d17 = +HEAPF32[i11 >> 2]; + HEAPF32[i5 >> 2] = +HEAPF32[i13 >> 2]; + HEAPF32[i6 >> 2] = d18; + HEAPF32[i7 >> 2] = d17; + HEAPF32[i8 >> 2] = 1.0; + } else if ((i16 | 0) == 0) { + HEAPF32[i5 >> 2] = +HEAPF32[i9 >> 2]; + HEAPF32[i6 >> 2] = +HEAPF32[i10 >> 2]; + HEAPF32[i7 >> 2] = +HEAPF32[i11 >> 2]; + HEAPF32[i8 >> 2] = 1.0; + } else if ((i16 | 0) == 2) { + d17 = +HEAPF32[i12 >> 2]; + d18 = +HEAPF32[i11 >> 2]; + HEAPF32[i5 >> 2] = +HEAPF32[i13 >> 2]; + HEAPF32[i6 >> 2] = d17; + HEAPF32[i7 >> 2] = d18; + HEAPF32[i8 >> 2] = 1.0; + } else if ((i16 | 0) == 7) { + d18 = +HEAPF32[i10 >> 2]; + d17 = +HEAPF32[i14 >> 2]; + HEAPF32[i5 >> 2] = +HEAPF32[i13 >> 2]; + HEAPF32[i6 >> 2] = d18; + HEAPF32[i7 >> 2] = d17; + HEAPF32[i8 >> 2] = 1.0; + } + i19 = __ZNK4Math7frustum8clipmaskERKNS_5pointE(i1, i4) | 0; + i20 = i19 & i2; + i21 = i19 | i15; + i19 = i16 + 1 | 0; + if ((i19 | 0) == 8) { + break; + } else { + i2 = i20; + i15 = i21; + i16 = i19; + } + } + if ((i21 | 0) == 0) { + i22 = 0; + STACKTOP = i3; + return i22 | 0; + } + i22 = (i20 | 0) == 0 ? 2 : 1; + STACKTOP = i3; + return i22 | 0; + } + + // ----------------------------------------------------------------- + + var STACKTOP = 0; + var HEAPF32 = new Float32Array(1000); + + for (var i = 0; i < HEAPF32.length; i++) { + HEAPF32[i] = 1.0; + } + + __ZNK4Math7frustum10clipstatusERKNS_4bboxE(0, 0); + __ZNK4Math7frustum10clipstatusERKNS_4bboxE(0, 0); + __ZNK4Math7frustum10clipstatusERKNS_4bboxE(0, 0); + %OptimizeFunctionOnNextCall(__ZNK4Math7frustum10clipstatusERKNS_4bboxE); + __ZNK4Math7frustum10clipstatusERKNS_4bboxE(0, 0); +})(); diff --git a/deps/v8/test/mjsunit/compiler/rotate.js b/deps/v8/test/mjsunit/compiler/rotate.js new file mode 100644 index 000000000..1db1fb329 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/rotate.js @@ -0,0 +1,223 @@ +// Copyright 2012 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 --expose-gc + +// Test shift operations that can be replaced by rotate operation. + +function SideEffect() { + with ({}) { } // not inlinable +} + +function Twenty() { + SideEffect(); + return 20; +} + +function Twelve() { + SideEffect(); + return 12; +} + + +function ROR(x, sa) { + return (x >>> sa) | (x << (32 - sa)); +} + +function ROR1(x, sa) { + return (x >>> sa) | (x << (32 - sa)); +} + +function ROR2(x, sa) { + return (x >>> (32 - sa)) | (x << (sa)); +} + +function ROR3(x, sa) { + return (x << (32 - sa)) | (x >>> sa); +} + +function ROR4(x, sa) { + return (x << (sa)) | (x >>> (32 - sa)); +} + +assertEquals(1 << ((2 % 32)), ROR(1, 30)); +assertEquals(1 << ((2 % 32)), ROR(1, 30)); +%OptimizeFunctionOnNextCall(ROR); +assertEquals(1 << ((2 % 32)), ROR(1, 30)); + +assertEquals(0xF0000FFF | 0, ROR1(0x0000FFFF, 4)); +assertEquals(0xF0000FFF | 0, ROR1(0x0000FFFF, 4)); +%OptimizeFunctionOnNextCall(ROR1); +assertEquals(0xF0000FFF | 0, ROR1(0x0000FFFF, 4)); + +assertEquals(0x0FFFF000 | 0, ROR1(0x0000FFFF, 20)); +assertEquals(0x0FFFF000 | 0, ROR1(0x0000FFFF, 20)); +%OptimizeFunctionOnNextCall(ROR1); +assertEquals(0x0FFFF000 | 0, ROR1(0x0000FFFF, 20)); + +assertEquals(0x0FFFF000 | 0, ROR1(0x0000FFFF, Twenty())); +assertEquals(0x0FFFF000 | 0, ROR1(0x0000FFFF, Twenty())); +%OptimizeFunctionOnNextCall(ROR1); +assertEquals(0x0FFFF000 | 0, ROR1(0x0000FFFF, Twenty())); + +for (var i = 0; i <= 100; i++) { + assertEquals(0xFFFFFFFF | 0, ROR1(0xFFFFFFFF, i)); + assertEquals(0xFFFFFFFF | 0, ROR1(0xFFFFFFFF, i)); + %OptimizeFunctionOnNextCall(ROR1); + assertEquals(0xFFFFFFFF | 0, ROR1(0xFFFFFFFF, i)); +} + +for (var i = 0; i <= 100; i++) { + assertEquals(-1, ROR1(-1, i)); + assertEquals(-1, ROR1(-1, i)); + %OptimizeFunctionOnNextCall(ROR1); + assertEquals(-1, ROR1(-1, i)); +} + +for (var i = 0; i <= 100; i++) { + assertEquals(1 << (32 - (i % 32)), ROR1(1, i)); + assertEquals(1 << (32 - (i % 32)), ROR1(1, i)); + %OptimizeFunctionOnNextCall(ROR1); + assertEquals(1 << (32 - (i % 32)), ROR1(1, i)); +} + +for (var i = 0; i <= 100; i++) { + assertEquals(1 << (32 - (i % 32)), ROR1(1.4, i)); + assertEquals(1 << (32 - (i % 32)), ROR1(1.4, i)); + %OptimizeFunctionOnNextCall(ROR1); + assertEquals(1 << (32 - (i % 32)), ROR1(1.4, i)); +} + + + +assertEquals(0xF0000FFF | 0, ROR2(0x0000FFFF, 28)); +assertEquals(0xF0000FFF | 0, ROR2(0x0000FFFF, 28)); +%OptimizeFunctionOnNextCall(ROR2); +assertEquals(0xF0000FFF | 0, ROR2(0x0000FFFF, 28)); + +assertEquals(0x0FFFF000 | 0, ROR2(0x0000FFFF, 12)); +assertEquals(0x0FFFF000 | 0, ROR2(0x0000FFFF, 12)); +%OptimizeFunctionOnNextCall(ROR2); +assertEquals(0x0FFFF000 | 0, ROR2(0x0000FFFF, 12)); + +assertEquals(0x0FFFF000 | 0, ROR2(0x0000FFFF, Twelve())); +assertEquals(0x0FFFF000 | 0, ROR2(0x0000FFFF, Twelve())); +%OptimizeFunctionOnNextCall(ROR2); +assertEquals(0x0FFFF000 | 0, ROR2(0x0000FFFF, Twelve())); + +for (var i = 0; i <= 100; i++) { + assertEquals(0xFFFFFFFF | 0, ROR2(0xFFFFFFFF, i)); + assertEquals(0xFFFFFFFF | 0, ROR2(0xFFFFFFFF, i)); + %OptimizeFunctionOnNextCall(ROR2); + assertEquals(0xFFFFFFFF | 0, ROR2(0xFFFFFFFF, i)); +} + +for (var i = 0; i <= 100; i++) { + assertEquals(-1, ROR2(-1, i)); + assertEquals(-1, ROR2(-1, i)); + %OptimizeFunctionOnNextCall(ROR2); + assertEquals(-1, ROR2(-1, i)); +} + +for (var i = 0; i <= 100; i++) { + assertEquals(1 << ((i % 32)), ROR2(1, i)); + assertEquals(1 << ((i % 32)), ROR2(1, i)); + %OptimizeFunctionOnNextCall(ROR2); + assertEquals(1 << ((i % 32)), ROR2(1, i)); +} + +assertEquals(0xF0000FFF | 0, ROR3(0x0000FFFF, 4)); +assertEquals(0xF0000FFF | 0, ROR3(0x0000FFFF, 4)); +%OptimizeFunctionOnNextCall(ROR3); +assertEquals(0xF0000FFF | 0, ROR3(0x0000FFFF, 4)); + +assertEquals(0x0FFFF000 | 0, ROR3(0x0000FFFF, 20)); +assertEquals(0x0FFFF000 | 0, ROR3(0x0000FFFF, 20)); +%OptimizeFunctionOnNextCall(ROR3); +assertEquals(0x0FFFF000 | 0, ROR3(0x0000FFFF, 20)); + +assertEquals(0x0FFFF000 | 0, ROR3(0x0000FFFF, Twenty())); +assertEquals(0x0FFFF000 | 0, ROR3(0x0000FFFF, Twenty())); +%OptimizeFunctionOnNextCall(ROR3); +assertEquals(0x0FFFF000 | 0, ROR3(0x0000FFFF, Twenty())); + +for (var i = 0; i <= 100; i++) { + assertEquals(0xFFFFFFFF | 0, ROR3(0xFFFFFFFF, i)); + assertEquals(0xFFFFFFFF | 0, ROR3(0xFFFFFFFF, i)); + %OptimizeFunctionOnNextCall(ROR3); + assertEquals(0xFFFFFFFF | 0, ROR3(0xFFFFFFFF, i)); +} + +for (var i = 0; i <= 100; i++) { + assertEquals(-1, ROR3(-1, i)); + assertEquals(-1, ROR3(-1, i)); + %OptimizeFunctionOnNextCall(ROR3); + assertEquals(-1, ROR3(-1, i)); +} + +for (var i = 0; i <= 100; i++) { + assertEquals(1 << (32 - (i % 32)), ROR3(1, i)); + assertEquals(1 << (32 - (i % 32)), ROR3(1, i)); + %OptimizeFunctionOnNextCall(ROR3); + assertEquals(1 << (32 - (i % 32)), ROR3(1, i)); +} + +assertEquals(0xF0000FFF | 0, ROR4(0x0000FFFF, 28)); +assertEquals(0xF0000FFF | 0, ROR4(0x0000FFFF, 28)); +%OptimizeFunctionOnNextCall(ROR4); +assertEquals(0xF0000FFF | 0, ROR4(0x0000FFFF, 28)); + +assertEquals(0x0FFFF000 | 0, ROR4(0x0000FFFF, 12)); +assertEquals(0x0FFFF000 | 0, ROR4(0x0000FFFF, 12)); +%OptimizeFunctionOnNextCall(ROR4); +assertEquals(0x0FFFF000 | 0, ROR4(0x0000FFFF, 12)); + +assertEquals(0x0FFFF000 | 0, ROR4(0x0000FFFF, Twelve())); +assertEquals(0x0FFFF000 | 0, ROR4(0x0000FFFF, Twelve())); +%OptimizeFunctionOnNextCall(ROR4); +assertEquals(0x0FFFF000 | 0, ROR4(0x0000FFFF, Twelve())); + +for (var i = 0; i <= 100; i++) { + assertEquals(0xFFFFFFFF | 0, ROR4(0xFFFFFFFF, i)); + assertEquals(0xFFFFFFFF | 0, ROR4(0xFFFFFFFF, i)); + %OptimizeFunctionOnNextCall(ROR4); + assertEquals(0xFFFFFFFF | 0, ROR4(0xFFFFFFFF, i)); +} + +for (var i = 0; i <= 100; i++) { + assertEquals(-1, ROR4(-1, i)); + assertEquals(-1, ROR4(-1, i)); + %OptimizeFunctionOnNextCall(ROR4); + assertEquals(-1, ROR4(-1, i)); +} + +for (var i = 0; i <= 100; i++) { + assertEquals(1 << ((i % 32)), ROR4(1, i)); + assertEquals(1 << ((i % 32)), ROR4(1, i)); + %OptimizeFunctionOnNextCall(ROR4); + assertEquals(1 << ((i % 32)), ROR4(1, i)); +} diff --git a/deps/v8/test/mjsunit/constant-folding-2.js b/deps/v8/test/mjsunit/constant-folding-2.js new file mode 100644 index 000000000..6dbb4abeb --- /dev/null +++ b/deps/v8/test/mjsunit/constant-folding-2.js @@ -0,0 +1,258 @@ +// Copyright 2013 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: --nodead-code-elimination --fold-constants --allow-natives-syntax + +function test(f) { + f(); + f(); + %OptimizeFunctionOnNextCall(f); + f(); + // Assert that there has been no deopt. + assertTrue(%GetOptimizationStatus(f) != 2); +} + +test(function add() { + assertEquals(2, 1 + 1); + assertEquals(2.5, 1.25 + 1.25); + assertEquals("Infinity", String(Infinity + Infinity)); + assertEquals("Infinity", String(Infinity + 3)); + assertEquals("NaN", String(Infinity + (-Infinity))); + assertEquals("NaN", String(NaN + 2)); + assertEquals("-Infinity", String(1 / (-0.0 + (-0.0)))); + assertEquals("Infinity", String(1 / (-0.0 + 0.0))); +}); + +test(function inc() { + var a = 1; + var b = Infinity; + var c = -Infinity; + var d = NaN; + assertEquals(2, ++a); + assertEquals("Infinity", String(++b)); + assertEquals("-Infinity", String(++c)); + assertEquals("NaN", String(++d)); +}); + +test(function dec() { + var a = 1; + var b = Infinity; + var c = -Infinity; + var d = NaN; + assertEquals(0, --a); + assertEquals("Infinity", String(--b)); + assertEquals("-Infinity", String(--c)); + assertEquals("NaN", String(--d)); +}); + +test(function sub() { + assertEquals(0, 1 - 1); + assertEquals(0.5, 1.5 - 1); + assertEquals("Infinity", String(Infinity - (-Infinity))); + assertEquals("Infinity", String(Infinity - 3)); + assertEquals("NaN", String(Infinity - Infinity)); + assertEquals("NaN", String(NaN - 2)); + assertEquals("-Infinity", String(1 / (-0.0 - 0.0))); + assertEquals("Infinity", String(1 / (0.0 - 0.0))); +}); + +test(function mul() { + assertEquals(1, 1 * 1); + assertEquals(2.25, 1.5 * 1.5); + assertEquals("Infinity", String(Infinity * Infinity)); + assertEquals("-Infinity", String(Infinity * (-Infinity))); + assertEquals("Infinity", String(Infinity * 3)); + assertEquals("-Infinity", String(Infinity * (-3))); + assertEquals("NaN", String(NaN * 3)); + assertEquals("-Infinity", String(1 / (-0.0 * 0.0))); + assertEquals("Infinity", String(1 / (0.0 * 0.0))); +}); + +test(function div() { + assertEquals(1, 1 / 1); + assertEquals(1.5, 2.25 / 1.5); + assertEquals("NaN", String(Infinity / Infinity)); + assertEquals("Infinity", String(Infinity / 3)); + assertEquals("-Infinity", String(Infinity / (-3))); + assertEquals("NaN", String(NaN / 3)); + assertEquals("-Infinity", String(1 / (-0.0))); + assertEquals("Infinity", String(Infinity/0.0)); +}); + +test(function mathMin() { + assertEquals(1, Math.min(1, 10)); + assertEquals(1.5, Math.min(1.5, 2.5)); + assertEquals(0, Math.min(Infinity, 0)); + assertEquals("Infinity", String(Math.min(Infinity, Infinity))); + assertEquals("-Infinity", String(Math.min(Infinity, -Infinity))); + assertEquals("NaN", String(Math.min(NaN, 1))); + assertEquals("Infinity", String(1 / Math.min(0.0, 0.0))); + assertEquals("-Infinity", String(1 / Math.min(-0.0, -0.0))); + assertEquals("-Infinity", String(1 / Math.min(0.0, -0.0))); +}); + +test(function mathMax() { + assertEquals(10, Math.max(1, 10)); + assertEquals(2.5, Math.max(1.5, 2.5)); + assertEquals(Infinity, Math.max(Infinity, 0)); + assertEquals("-Infinity", String(Math.max(-Infinity, -Infinity))); + assertEquals("Infinity", String(Math.max(Infinity, -Infinity))); + assertEquals("NaN", String(Math.max(NaN, 1))); + assertEquals("Infinity", String(1 / Math.max(0.0, 0.0))); + assertEquals("-Infinity", String(1 / Math.max(-0.0, -0.0))); + assertEquals("Infinity", String(1 / Math.max(0.0, -0.0))); +}); + +test(function mathSin() { + assertEquals(0.0, Math.sin(0.0)); + assertTrue(0.8 < Math.sin(1) && Math.sin(1) < 0.9); + assertEquals("NaN", String(Math.sin(Infinity))); + assertEquals("NaN", String(Math.sin(-Infinity))); + assertEquals("NaN", String(Math.sin(NaN))); +}); + +test(function mathCos() { + assertEquals(1.0, Math.cos(0.0)); + assertTrue(0.5 < Math.cos(1) && Math.cos(1) < 0.6); + assertEquals("NaN", String(Math.cos(Infinity))); + assertEquals("NaN", String(Math.cos(-Infinity))); + assertEquals("NaN", String(Math.cos(NaN))); +}); + +test(function mathTan() { + assertEquals(0.0, Math.tan(0.0)); + assertTrue(1.5 < Math.tan(1) && Math.tan(1) < 1.6); + assertEquals("NaN", String(Math.tan(Infinity))); + assertEquals("NaN", String(Math.tan(-Infinity))); + assertEquals("NaN", String(Math.tan(NaN))); +}); + +test(function mathExp() { + assertEquals(1.0, Math.exp(0.0)); + assertTrue(2.7 < Math.exp(1) && Math.exp(1) < 2.8); + assertEquals("Infinity", String(Math.exp(Infinity))); + assertEquals("0", String(Math.exp(-Infinity))); + assertEquals("NaN", String(Math.exp(NaN))); +}); + +test(function mathLog() { + assertEquals(0.0, Math.log(1.0)); + assertTrue(1 < Math.log(3) && Math.log(3) < 1.5); + assertEquals("Infinity", String(Math.log(Infinity))); + assertEquals("NaN", String(Math.log(-Infinity))); + assertEquals("NaN", String(Math.exp(NaN))); +}); + +test(function mathSqrt() { + assertEquals(1.0, Math.sqrt(1.0)); + assertEquals("NaN", String(Math.sqrt(-1.0))); + assertEquals("Infinity", String(Math.sqrt(Infinity))); + assertEquals("NaN", String(Math.sqrt(-Infinity))); + assertEquals("NaN", String(Math.sqrt(NaN))); +}); + +test(function mathPowHalf() { + assertEquals(1.0, Math.pow(1.0, 0.5)); + assertEquals("NaN", String(Math.sqrt(-1.0))); + assertEquals("Infinity", String(Math.pow(Infinity, 0.5))); + assertEquals("NaN", String(Math.sqrt(-Infinity, 0.5))); + assertEquals(0, Math.pow(Infinity, -0.5)); + assertEquals("NaN", String(Math.sqrt(-Infinity, -0.5))); + assertEquals("NaN", String(Math.sqrt(NaN, 0.5))); +}); + +test(function mathAbs() { + assertEquals(1.5, Math.abs(1.5)); + assertEquals(1.5, Math.abs(-1.5)); + assertEquals("Infinity", String(Math.abs(Infinity))); + assertEquals("Infinity", String(Math.abs(-Infinity))); + assertEquals("NaN", String(Math.abs(NaN))); +}); + +test(function mathRound() { + assertEquals(2, Math.round(1.5)); + assertEquals(-1, Math.round(-1.5)); + assertEquals("Infinity", String(Math.round(Infinity))); + assertEquals("-Infinity", String(Math.round(-Infinity))); + assertEquals("Infinity", String(1 / Math.round(0.0))); + assertEquals("-Infinity", String(1 / Math.round(-0.0))); + assertEquals("NaN", String(Math.round(NaN))); + assertEquals(Math.pow(2, 52) + 1, Math.round(Math.pow(2, 52) + 1)); +}); + +test(function mathFloor() { + assertEquals(1, Math.floor(1.5)); + assertEquals(-2, Math.floor(-1.5)); + assertEquals("Infinity", String(Math.floor(Infinity))); + assertEquals("-Infinity", String(Math.floor(-Infinity))); + assertEquals("Infinity", String(1 / Math.floor(0.0))); + assertEquals("-Infinity", String(1 / Math.floor(-0.0))); + assertEquals("NaN", String(Math.floor(NaN))); + assertEquals(Math.pow(2, 52) + 1, Math.floor(Math.pow(2, 52) + 1)); +}); + +test(function mathPow() { + assertEquals(2.25, Math.pow(1.5, 2)); + assertTrue(1.8 < Math.pow(1.5, 1.5) && Math.pow(1.5, 1.5) < 1.9); + assertEquals("Infinity", String(Math.pow(Infinity, 0.5))); + assertEquals("Infinity", String(Math.pow(-Infinity, 0.5))); + assertEquals(0, Math.pow(Infinity, -0.5)); + assertEquals(0, Math.pow(Infinity, -0.5)); + assertEquals("Infinity", String(Math.pow(Infinity, Infinity))); + assertEquals(0, Math.pow(Infinity, -Infinity)); + assertEquals("NaN", String(Math.pow(Infinity, NaN))); + assertEquals("NaN", String(Math.pow(NaN, 2))); +}); + +test(function stringAdd() { + assertEquals("", "" + ""); + assertEquals("folded constant", "folded " + "constant"); + assertEquals("not folded constant1", "not folded constant" + 1); +}); + +test(function stringLength() { + assertEquals(6, "abcdef".length); + assertEquals(0, "".length); + assertEquals(-5, { length: -5 }.length); +}); + +test(function stringCharCodeAt() { + assertEquals(99, "abc".charCodeAt(2)); + assertEquals("NaN", String("abc".charCodeAt(-1))); + assertEquals("NaN", String("abc".charCodeAt(4))); + assertEquals(98, "abc".charCodeAt(1.1)); + assertEquals("NaN", String("abc".charCodeAt(4.1))); +}); + +test(function stringCharAt() { + assertEquals("c", "abc".charAt(2)); + assertEquals("", "abc".charAt(-1)); + assertEquals("", "abc".charAt(4)); + assertEquals("b", "abc".charAt(1.1)); + assertEquals("", "abc".charAt(4.1)); +}); diff --git a/deps/v8/test/mjsunit/debug-liveedit-compile-error.js b/deps/v8/test/mjsunit/debug-liveedit-compile-error.js new file mode 100644 index 000000000..99ac0314a --- /dev/null +++ b/deps/v8/test/mjsunit/debug-liveedit-compile-error.js @@ -0,0 +1,58 @@ +// Copyright 2012 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: --expose-debug-as debug +// Get the Debug object exposed from the debug context global object. + +Debug = debug.Debug + +eval("var something1 = 25; \n" + + " function ChooseAnimal() { return 'Cat'; } \n" + + " ChooseAnimal.Helper = function() { return 'Help!'; }\n"); + +assertEquals("Cat", ChooseAnimal()); + +var script = Debug.findScript(ChooseAnimal); + +var orig_animal = "Cat"; +var patch_pos = script.source.indexOf(orig_animal); +var new_animal_patch = "Cap' + ) + 'bara"; + +var change_log = new Array(); +var caught_exception = null; +try { + Debug.LiveEdit.TestApi.ApplySingleChunkPatch(script, patch_pos, + orig_animal.length, new_animal_patch, change_log); +} catch (e) { + caught_exception = e; +} + +assertNotNull(caught_exception); +assertEquals("Unexpected token )", + caught_exception.details.syntaxErrorMessage); + +assertEquals(2, caught_exception.details.position.start.line); diff --git a/deps/v8/test/mjsunit/debug-liveedit-literals.js b/deps/v8/test/mjsunit/debug-liveedit-literals.js new file mode 100644 index 000000000..5f9217e83 --- /dev/null +++ b/deps/v8/test/mjsunit/debug-liveedit-literals.js @@ -0,0 +1,94 @@ +// Copyright 2010 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: --expose-debug-as debug +// Get the Debug object exposed from the debug context global object. + +Debug = debug.Debug + +function Test(old_expression, new_expression) { + // Generate several instances of function to test that we correctly fix + // all functions in memory. + var function_instance_number = 11; + eval("var t1 =1;\n" + + "ChooseAnimalArray = [];\n" + + "for (var i = 0; i < function_instance_number; i++) {\n" + + " ChooseAnimalArray.push(\n" + + " function ChooseAnimal() {\n" + + " return " + old_expression + ";\n" + + " });\n" + + "}\n" + + "var t2 =1;\n"); + + for (var i = 0; i < ChooseAnimalArray.length; i++) { + assertEquals("Cat", ChooseAnimalArray[i]()); + } + + var script = Debug.findScript(ChooseAnimalArray[0]); + + var patch_pos = script.source.indexOf(old_expression); + var new_animal_patch = new_expression; + + var change_log = new Array(); + Debug.LiveEdit.TestApi.ApplySingleChunkPatch(script, patch_pos, + old_expression.length, new_expression, change_log); + + for (var i = 0; i < ChooseAnimalArray.length; i++) { + assertEquals("Capybara", ChooseAnimalArray[i]()); + } +} + +// Check that old literal boilerplate was reset. +Test("['Cat'][0]", "['Capybara'][0]"); +Test("['Cat'][0]", "{a:'Capybara'}.a"); + +// No literals -> 1 literal. +Test("'Cat'", "['Capybara'][0]"); + +// No literals -> 2 literals. +Test("'Cat'", "['Capy'][0] + {a:'bara'}.a"); + +// 1 literal -> no literals. +Test("['Cat'][0]", "'Capybara'"); + +// 2 literals -> no literals. +Test("['Ca'][0] + {a:'t'}.a", "'Capybara'"); + +// No literals -> regexp. +Test("'Cat'", "(/.A.Y.A.A/i).exec('Capybara')[0]"); + +// Array literal -> regexp. +Test("['Cat'][0]", "(/.A.Y.A.A/i).exec('Capybara')[0]"); + +// Regexp -> object literal. +Test("(/.A./i).exec('Cat')[0]", "{c:'Capybara'}.c"); + +// No literals -> regexp. +Test("'Cat'", "(/.A.Y.A.A/i).exec('Capybara')[0]"); + +// Regexp -> no literals. +Test("(/.A./i).exec('Cat')[0]", "'Capybara'"); diff --git a/deps/v8/test/mjsunit/debug-set-variable-value.js b/deps/v8/test/mjsunit/debug-set-variable-value.js new file mode 100644 index 000000000..4667a71d6 --- /dev/null +++ b/deps/v8/test/mjsunit/debug-set-variable-value.js @@ -0,0 +1,308 @@ +// Copyright 2012 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: --expose-debug-as debug + +// Get the Debug object exposed from the debug context global object. +var Debug = debug.Debug; + +// Accepts a function/closure 'fun' that must have a debugger statement inside. +// A variable 'variable_name' must be initialized before debugger statement +// and returned after the statement. The test will alter variable value when +// on debugger statement and check that returned value reflects the change. +function RunPauseTest(scope_number, expected_old_result, variable_name, + new_value, expected_new_result, fun) { + var actual_old_result = fun(); + assertEquals(expected_old_result, actual_old_result); + + var listener_delegate; + var listener_called = false; + var exception = null; + + function listener_delegate(exec_state) { + var scope = exec_state.frame(0).scope(scope_number); + scope.setVariableValue(variable_name, new_value); + } + + function listener(event, exec_state, event_data, data) { + try { + if (event == Debug.DebugEvent.Break) { + listener_called = true; + listener_delegate(exec_state); + } + } catch (e) { + exception = e; + } + } + + // Add the debug event listener. + Debug.setListener(listener); + + var actual_new_value; + try { + actual_new_result = fun(); + } finally { + Debug.setListener(null); + } + + if (exception != null) { + assertUnreachable("Exception in listener\n" + exception.stack); + } + assertTrue(listener_called); + + assertEquals(expected_new_result, actual_new_result); +} + +// Accepts a closure 'fun' that returns a variable from it's outer scope. +// The test changes the value of variable via the handle to function and checks +// that the return value changed accordingly. +function RunClosureTest(scope_number, expected_old_result, variable_name, + new_value, expected_new_result, fun) { + var actual_old_result = fun(); + assertEquals(expected_old_result, actual_old_result); + + var fun_mirror = Debug.MakeMirror(fun); + + var scope = fun_mirror.scope(scope_number); + scope.setVariableValue(variable_name, new_value); + + var actual_new_result = fun(); + + assertEquals(expected_new_result, actual_new_result); +} + + +function ClosureTestCase(scope_index, old_result, variable_name, new_value, + new_result, success_expected, factory) { + this.scope_index_ = scope_index; + this.old_result_ = old_result; + this.variable_name_ = variable_name; + this.new_value_ = new_value; + this.new_result_ = new_result; + this.success_expected_ = success_expected; + this.factory_ = factory; +} + +ClosureTestCase.prototype.run_pause_test = function() { + var th = this; + var fun = this.factory_(true); + this.run_and_catch_(function() { + RunPauseTest(th.scope_index_ + 1, th.old_result_, th.variable_name_, + th.new_value_, th.new_result_, fun); + }); +} + +ClosureTestCase.prototype.run_closure_test = function() { + var th = this; + var fun = this.factory_(false); + this.run_and_catch_(function() { + RunClosureTest(th.scope_index_, th.old_result_, th.variable_name_, + th.new_value_, th.new_result_, fun); + }); +} + +ClosureTestCase.prototype.run_and_catch_ = function(runnable) { + if (this.success_expected_) { + runnable(); + } else { + assertThrows(runnable); + } +} + + +// Test scopes visible from closures. + +var closure_test_cases = [ + new ClosureTestCase(0, 'cat', 'v1', 5, 5, true, + function Factory(debug_stop) { + var v1 = 'cat'; + return function() { + if (debug_stop) debugger; + return v1; + } + }), + + new ClosureTestCase(0, 4, 't', 7, 9, true, function Factory(debug_stop) { + var t = 2; + var r = eval("t"); + return function() { + if (debug_stop) debugger; + return r + t; + } + }), + + new ClosureTestCase(0, 6, 't', 10, 13, true, function Factory(debug_stop) { + var t = 2; + var r = eval("t = 3"); + return function() { + if (debug_stop) debugger; + return r + t; + } + }), + + new ClosureTestCase(0, 17, 's', 'Bird', 'Bird', true, + function Factory(debug_stop) { + eval("var s = 17"); + return function() { + if (debug_stop) debugger; + return s; + } + }), + + new ClosureTestCase(2, 'capybara', 'foo', 77, 77, true, + function Factory(debug_stop) { + var foo = "capybara"; + return (function() { + var bar = "fish"; + try { + throw {name: "test exception"}; + } catch (e) { + return function() { + if (debug_stop) debugger; + bar = "beast"; + return foo; + } + } + })(); + }), + + new ClosureTestCase(0, 'AlphaBeta', 'eee', 5, '5Beta', true, + function Factory(debug_stop) { + var foo = "Beta"; + return (function() { + var bar = "fish"; + try { + throw "Alpha"; + } catch (eee) { + return function() { + if (debug_stop) debugger; + return eee + foo; + } + } + })(); + }) +]; + +for (var i = 0; i < closure_test_cases.length; i++) { + closure_test_cases[i].run_pause_test(); +} + +for (var i = 0; i < closure_test_cases.length; i++) { + closure_test_cases[i].run_closure_test(); +} + + +// Test local scope. + +RunPauseTest(0, 'HelloYou', 'u', 'We', 'HelloWe', (function Factory() { + return function() { + var u = "You"; + var v = "Hello"; + debugger; + return v + u; + } +})()); + +RunPauseTest(0, 'Helloworld', 'p', 'GoodBye', 'HelloGoodBye', + (function Factory() { + function H(p) { + var v = "Hello"; + debugger; + return v + p; + } + return function() { + return H("world"); + } +})()); + +RunPauseTest(0, 'mouse', 'v1', 'dog', 'dog', (function Factory() { + return function() { + var v1 = 'cat'; + eval("v1 = 'mouse'"); + debugger; + return v1; + } +})()); + +RunPauseTest(0, 'mouse', 'v1', 'dog', 'dog', (function Factory() { + return function() { + eval("var v1 = 'mouse'"); + debugger; + return v1; + } +})()); + + +// Check that we correctly update local variable that +// is referenced from an inner closure. +RunPauseTest(0, 'Blue', 'v', 'Green', 'Green', (function Factory() { + return function() { + function A() { + var v = "Blue"; + function Inner() { + return void v; + } + debugger; + return v; + } + return A(); + } +})()); + +// Check that we correctly update parameter, that is known to be stored +// both on stack and in heap. +RunPauseTest(0, 5, 'p', 2012, 2012, (function Factory() { + return function() { + function A(p) { + function Inner() { + return void p; + } + debugger; + return p; + } + return A(5); + } +})()); + + +// Test value description protocol JSON + +assertEquals(true, Debug.TestApi.CommandProcessorResolveValue({value: true})); + +assertSame(null, Debug.TestApi.CommandProcessorResolveValue({type: "null"})); +assertSame(undefined, + Debug.TestApi.CommandProcessorResolveValue({type: "undefined"})); + +assertSame("123", Debug.TestApi.CommandProcessorResolveValue( + {type: "string", stringDescription: "123"})); +assertSame(123, Debug.TestApi.CommandProcessorResolveValue( + {type: "number", stringDescription: "123"})); + +assertSame(Number, Debug.TestApi.CommandProcessorResolveValue( + {handle: Debug.MakeMirror(Number).handle()})); +assertSame(RunClosureTest, Debug.TestApi.CommandProcessorResolveValue( + {handle: Debug.MakeMirror(RunClosureTest).handle()})); diff --git a/deps/v8/test/mjsunit/elements-kind.js b/deps/v8/test/mjsunit/elements-kind.js index b74a21243..d95255605 100644 --- a/deps/v8/test/mjsunit/elements-kind.js +++ b/deps/v8/test/mjsunit/elements-kind.js @@ -26,6 +26,11 @@ // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // Flags: --allow-natives-syntax --smi-only-arrays --expose-gc +// Flags: --notrack_allocation_sites + +// Limit the number of stress runs to reduce polymorphism it defeats some of +// they assumptions made about how elements transitions work because transition +// stubs end up going generic. Flags: --stress-runs=2 // Test element kind of objects. // Since --smi-only-arrays affects builtins, its default setting at compile @@ -321,8 +326,7 @@ if (support_smi_only_arrays) { assertKind(elements_kind.fast_double, b); var c = a.concat(b); assertEquals([1, 2, 4.5, 5.5], c); - // TODO(1810): Change implementation so that we get DOUBLE elements here? - assertKind(elements_kind.fast, c); + assertKind(elements_kind.fast_double, c); } // Test that Array.push() correctly handles SMI elements. diff --git a/deps/v8/test/mjsunit/elements-length-no-holey.js b/deps/v8/test/mjsunit/elements-length-no-holey.js new file mode 100644 index 000000000..5bac296e1 --- /dev/null +++ b/deps/v8/test/mjsunit/elements-length-no-holey.js @@ -0,0 +1,33 @@ +// Copyright 2012 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 + +a = [1,2,3]; +a.length = 1; +assertFalse(%HasFastHoleyElements(a)); +assertTrue(%HasFastSmiElements(a)); diff --git a/deps/v8/test/mjsunit/elements-transition.js b/deps/v8/test/mjsunit/elements-transition.js index 0dffd3723..e28f3c3d6 100644 --- a/deps/v8/test/mjsunit/elements-transition.js +++ b/deps/v8/test/mjsunit/elements-transition.js @@ -25,7 +25,7 @@ // (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 --smi-only-arrays +// Flags: --allow-natives-syntax --smi-only-arrays --notrack-allocation-sites support_smi_only_arrays = %HasFastSmiElements(new Array(1,2,3,4,5,6,7,8)); diff --git a/deps/v8/test/mjsunit/error-accessors.js b/deps/v8/test/mjsunit/error-accessors.js new file mode 100644 index 000000000..cdaf080a3 --- /dev/null +++ b/deps/v8/test/mjsunit/error-accessors.js @@ -0,0 +1,53 @@ +// Copyright 2012 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. + +// Test that the message property of error objects is a data property. + +var o; + +// message is constructed using the constructor. +var error1 = new Error("custom message"); +o = {}; +o.__proto__ = error1; + +assertEquals("custom message", + Object.getOwnPropertyDescriptor(error1, "message").value); +o.message = "another message"; +assertEquals("another message", o.message); +assertEquals("custom message", error1.message); + +// message is constructed by the runtime. +var error2; +try { x.x } catch (e) { error2 = e; } +o = {}; +o.__proto__ = error2; + +assertEquals("x is not defined", + Object.getOwnPropertyDescriptor(error2, "message").value); +o.message = "another message"; +assertEquals("another message", o.message); +assertEquals("x is not defined", error2.message); diff --git a/deps/v8/test/mjsunit/error-constructors.js b/deps/v8/test/mjsunit/error-constructors.js index 107164df5..84c6bbfd0 100644 --- a/deps/v8/test/mjsunit/error-constructors.js +++ b/deps/v8/test/mjsunit/error-constructors.js @@ -36,10 +36,6 @@ assertFalse(desc['enumerable']); var e = new Error("foobar"); desc = Object.getOwnPropertyDescriptor(e, 'message'); assertFalse(desc['enumerable']); -desc = Object.getOwnPropertyDescriptor(e, 'arguments'); -assertFalse(desc['enumerable']); -desc = Object.getOwnPropertyDescriptor(e, 'type'); -assertFalse(desc['enumerable']); desc = Object.getOwnPropertyDescriptor(e, 'stack'); assertFalse(desc['enumerable']); @@ -57,26 +53,17 @@ for (var v in e) { function fail() { assertUnreachable(); }; ReferenceError.prototype.__defineSetter__('name', fail); ReferenceError.prototype.__defineSetter__('message', fail); -ReferenceError.prototype.__defineSetter__('type', fail); -ReferenceError.prototype.__defineSetter__('arguments', fail); ReferenceError.prototype.__defineSetter__('stack', fail); var e = new ReferenceError(); assertTrue(e.hasOwnProperty('stack')); -assertTrue(e.hasOwnProperty('type')); -assertTrue(e.hasOwnProperty('arguments')); var e = new ReferenceError('123'); assertTrue(e.hasOwnProperty('message')); assertTrue(e.hasOwnProperty('stack')); -assertTrue(e.hasOwnProperty('type')); -assertTrue(e.hasOwnProperty('arguments')); var e = %MakeReferenceError("my_test_error", [0, 1]); assertTrue(e.hasOwnProperty('stack')); -assertTrue(e.hasOwnProperty('type')); -assertTrue(e.hasOwnProperty('arguments')); -assertEquals("my_test_error", e.type) // Check that intercepting property access from toString is prevented for // compiler errors. This is not specified, but allowing interception @@ -86,7 +73,7 @@ var errors = [SyntaxError, ReferenceError, TypeError]; for (var i in errors) { var name = errors[i].prototype.toString(); // Monkey-patch prototype. - var props = ["name", "message", "type", "arguments", "stack"]; + var props = ["name", "message", "stack"]; for (var j in props) { errors[i].prototype.__defineGetter__(props[j], fail); } diff --git a/deps/v8/test/mjsunit/error-tostring.js b/deps/v8/test/mjsunit/error-tostring.js index a28564144..8a8a96908 100644 --- a/deps/v8/test/mjsunit/error-tostring.js +++ b/deps/v8/test/mjsunit/error-tostring.js @@ -83,3 +83,11 @@ assertEquals(["Error: e2",[1,3,4]], testErrorToString(undefined, "e2")); assertEquals(["null: e2",[1,2,3,4]], testErrorToString(null, "e2")); assertEquals(["e2",[1,2,3,4]], testErrorToString("", "e2")); assertEquals(["e1: e2",[1,2,3,4]], testErrorToString("e1", "e2")); + +var obj = { + get constructor () { + assertUnreachable(); + } +}; + +assertThrows(function() { obj.x(); }); diff --git a/deps/v8/test/mjsunit/eval-stack-trace.js b/deps/v8/test/mjsunit/eval-stack-trace.js index 723d522c7..d83b84c16 100644 --- a/deps/v8/test/mjsunit/eval-stack-trace.js +++ b/deps/v8/test/mjsunit/eval-stack-trace.js @@ -26,12 +26,13 @@ // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // Return the stack frames of an Error object. + +Error.prepareStackTrace = function(error, frames) { + return frames; +} + Error.prototype.getFrames = function() { - Error.prepareStackTrace = function(error, frames) { - return frames; - } var frames = this.stack; - Error.prepareStackTrace = undefined; return frames; } diff --git a/deps/v8/test/mjsunit/fast-prototype.js b/deps/v8/test/mjsunit/fast-prototype.js index 7fd73a4e1..83bcffe44 100644 --- a/deps/v8/test/mjsunit/fast-prototype.js +++ b/deps/v8/test/mjsunit/fast-prototype.js @@ -27,6 +27,10 @@ // Flags: --allow-natives-syntax +// TODO(mstarzinger): This test does not succeed when GCs happen in +// between prototype transitions, we disable GC stress for now. +// Flags: --noincremental-marking + // Check that objects that are used for prototypes are in the fast mode. function Super() { diff --git a/deps/v8/test/mjsunit/function-call.js b/deps/v8/test/mjsunit/function-call.js index 26890ed11..92792ac82 100644 --- a/deps/v8/test/mjsunit/function-call.js +++ b/deps/v8/test/mjsunit/function-call.js @@ -67,8 +67,7 @@ var should_throw_on_null_and_undefined = String.prototype.toLocaleLowerCase, String.prototype.toUpperCase, String.prototype.toLocaleUpperCase, - String.prototype.trim, - Number.prototype.toLocaleString]; + String.prototype.trim]; // Non generic natives do not work on any input other than the specific // type, but since this change will allow call to be invoked with undefined @@ -150,6 +149,11 @@ var reducing_functions = [Array.prototype.reduce, Array.prototype.reduceRight]; +function checkExpectedMessage(e) { + assertTrue(e.message.indexOf("called on null or undefined") >= 0 || + e.message.indexOf("Cannot convert null to object") >= 0); +} + // Test that all natives using the ToObject call throw the right exception. for (var i = 0; i < should_throw_on_null_and_undefined.length; i++) { // Sanity check that all functions are correct @@ -166,8 +170,7 @@ for (var i = 0; i < should_throw_on_null_and_undefined.length; i++) { should_throw_on_null_and_undefined[i].call(null); } catch (e) { exception = true; - assertTrue("called_on_null_or_undefined" == e.type || - "null_to_object" == e.type); + checkExpectedMessage(e); } assertTrue(exception); @@ -176,8 +179,7 @@ for (var i = 0; i < should_throw_on_null_and_undefined.length; i++) { should_throw_on_null_and_undefined[i].call(undefined); } catch (e) { exception = true; - assertTrue("called_on_null_or_undefined" == e.type || - "null_to_object" == e.type); + checkExpectedMessage(e); } assertTrue(exception); @@ -186,8 +188,7 @@ for (var i = 0; i < should_throw_on_null_and_undefined.length; i++) { should_throw_on_null_and_undefined[i].apply(null); } catch (e) { exception = true; - assertTrue("called_on_null_or_undefined" == e.type || - "null_to_object" == e.type); + checkExpectedMessage(e); } assertTrue(exception); @@ -196,8 +197,7 @@ for (var i = 0; i < should_throw_on_null_and_undefined.length; i++) { should_throw_on_null_and_undefined[i].apply(undefined); } catch (e) { exception = true; - assertTrue("called_on_null_or_undefined" == e.type || - "null_to_object" == e.type); + checkExpectedMessage(e); } assertTrue(exception); } @@ -257,8 +257,7 @@ for (var j = 0; j < mapping_functions.length; j++) { null); } catch (e) { exception = true; - assertTrue("called_on_null_or_undefined" == e.type || - "null_to_object" == e.type); + checkExpectedMessage(e); } assertTrue(exception); @@ -269,8 +268,7 @@ for (var j = 0; j < mapping_functions.length; j++) { undefined); } catch (e) { exception = true; - assertTrue("called_on_null_or_undefined" == e.type || - "null_to_object" == e.type); + checkExpectedMessage(e); } assertTrue(exception); } @@ -311,8 +309,7 @@ for (var j = 0; j < reducing_functions.length; j++) { reducing_functions[j].call(array, should_throw_on_null_and_undefined[i]); } catch (e) { exception = true; - assertTrue("called_on_null_or_undefined" == e.type || - "null_to_object" == e.type); + checkExpectedMessage(e); } assertTrue(exception); @@ -321,8 +318,7 @@ for (var j = 0; j < reducing_functions.length; j++) { reducing_functions[j].call(array, should_throw_on_null_and_undefined[i]); } catch (e) { exception = true; - assertTrue("called_on_null_or_undefined" == e.type || - "null_to_object" == e.type); + checkExpectedMessage(e); } assertTrue(exception); } diff --git a/deps/v8/test/mjsunit/fuzz-natives-part1.js b/deps/v8/test/mjsunit/fuzz-natives-part1.js index 6941d806c..8b290d582 100644 --- a/deps/v8/test/mjsunit/fuzz-natives-part1.js +++ b/deps/v8/test/mjsunit/fuzz-natives-part1.js @@ -147,10 +147,13 @@ var knownProblems = { "PushWithContext": true, "PushCatchContext": true, "PushBlockContext": true, + "PushModuleContext": true, "LazyCompile": true, "LazyRecompile": true, "ParallelRecompile": true, + "InstallRecompiledCode": true, "NotifyDeoptimized": true, + "NotifyStubFailure": true, "NotifyOSR": true, "CreateObjectLiteralBoilerplate": true, "CloneLiteralBoilerplate": true, @@ -195,7 +198,9 @@ var knownProblems = { // Only applicable to strings. "_HasCachedArrayIndex": true, - "_GetCachedArrayIndex": true + "_GetCachedArrayIndex": true, + "_OneByteSeqStringSetChar": true, + "_TwoByteSeqStringSetChar": true, }; var currentlyUncallable = { diff --git a/deps/v8/test/mjsunit/fuzz-natives-part2.js b/deps/v8/test/mjsunit/fuzz-natives-part2.js index ea8a2cfe1..50ca5c2c7 100644 --- a/deps/v8/test/mjsunit/fuzz-natives-part2.js +++ b/deps/v8/test/mjsunit/fuzz-natives-part2.js @@ -147,9 +147,11 @@ var knownProblems = { "PushWithContext": true, "PushCatchContext": true, "PushBlockContext": true, + "PushModuleContext": true, "LazyCompile": true, "LazyRecompile": true, "ParallelRecompile": true, + "InstallRecompiledCode": true, "NotifyDeoptimized": true, "NotifyOSR": true, "CreateObjectLiteralBoilerplate": true, @@ -195,7 +197,9 @@ var knownProblems = { // Only applicable to strings. "_HasCachedArrayIndex": true, - "_GetCachedArrayIndex": true + "_GetCachedArrayIndex": true, + "_OneByteSeqStringSetChar": true, + "_TwoByteSeqStringSetChar": true, }; var currentlyUncallable = { diff --git a/deps/v8/test/mjsunit/fuzz-natives-part3.js b/deps/v8/test/mjsunit/fuzz-natives-part3.js index ecfdf9737..05d32e9ae 100644 --- a/deps/v8/test/mjsunit/fuzz-natives-part3.js +++ b/deps/v8/test/mjsunit/fuzz-natives-part3.js @@ -147,9 +147,11 @@ var knownProblems = { "PushWithContext": true, "PushCatchContext": true, "PushBlockContext": true, + "PushModuleContext": true, "LazyCompile": true, "LazyRecompile": true, "ParallelRecompile": true, + "InstallRecompiledCode": true, "NotifyDeoptimized": true, "NotifyOSR": true, "CreateObjectLiteralBoilerplate": true, @@ -195,7 +197,9 @@ var knownProblems = { // Only applicable to strings. "_HasCachedArrayIndex": true, - "_GetCachedArrayIndex": true + "_GetCachedArrayIndex": true, + "_OneByteSeqStringSetChar": true, + "_TwoByteSeqStringSetChar": true, }; var currentlyUncallable = { diff --git a/deps/v8/test/mjsunit/fuzz-natives-part4.js b/deps/v8/test/mjsunit/fuzz-natives-part4.js index da045963f..e627065d6 100644 --- a/deps/v8/test/mjsunit/fuzz-natives-part4.js +++ b/deps/v8/test/mjsunit/fuzz-natives-part4.js @@ -147,9 +147,11 @@ var knownProblems = { "PushWithContext": true, "PushCatchContext": true, "PushBlockContext": true, + "PushModuleContext": true, "LazyCompile": true, "LazyRecompile": true, "ParallelRecompile": true, + "InstallRecompiledCode": true, "NotifyDeoptimized": true, "NotifyOSR": true, "CreateObjectLiteralBoilerplate": true, @@ -195,7 +197,9 @@ var knownProblems = { // Only applicable to strings. "_HasCachedArrayIndex": true, - "_GetCachedArrayIndex": true + "_GetCachedArrayIndex": true, + "_OneByteSeqStringSetChar": true, + "_TwoByteSeqStringSetChar": true, }; var currentlyUncallable = { diff --git a/deps/v8/test/mjsunit/generated-transition-stub.js b/deps/v8/test/mjsunit/generated-transition-stub.js new file mode 100644 index 000000000..dd1043b1c --- /dev/null +++ b/deps/v8/test/mjsunit/generated-transition-stub.js @@ -0,0 +1,218 @@ +// Copyright 2013 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 --compiled_transitions + +try {} catch (e) {} + +var iteration_count = 1; + +function transition1(a, i, v) { + a[i] = v; +} + +// +// Test PACKED SMI -> PACKED DOUBLE +// + +var a1 = [0, 1, 2, 3, 4]; +transition1(a1, 0, 2.5); +var a2 = [0, 1, 2, 3, 4]; +transition1(a2, 0, 2.5); +assertFalse(%HasFastHoleyElements(a2)); +%OptimizeFunctionOnNextCall(transition1); + +var a3 = [0, 1, 2, 3, 4]; +assertTrue(%HasFastSmiElements(a3)); +transition1(a3, 0, 2.5); +assertFalse(%HasFastHoleyElements(a3)); +assertEquals(4, a3[4]); +assertEquals(2.5, a3[0]); + +// Test handling of hole. +var a4 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; +a4.length = 7; +assertTrue(%HasFastSmiElements(a4)); +transition1(a4, 0, 2.5); +assertFalse(%HasFastHoleyElements(a4)); +assertEquals(2.5, a4[0]); +assertEquals(undefined, a4[8]); + +// Large array should deopt to runtimea +for (j = 0; j < iteration_count; ++j) { + a5 = new Array(); + for (i = 0; i < 0x40000; ++i) { + a5[i] = 0; + } + assertTrue(%HasFastSmiElements(a5)); + transition1(a5, 0, 2.5); + assertEquals(2.5, a5[0]); +} + +// +// Test HOLEY SMI -> HOLEY DOUBLE +// + +function transition2(a, i, v) { + a[i] = v; +} + +var b1 = [0, 1, 2, , 4]; +transition2(b1, 0, 2.5); +var b2 = [0, 1, 2, , 4]; +transition2(b2, 0, 2.5); +assertTrue(%HasFastHoleyElements(b2)); +%OptimizeFunctionOnNextCall(transition2); + +var b3 = [0, 1, 2, , 4]; +assertTrue(%HasFastSmiElements(b3)); +assertTrue(%HasFastHoleyElements(b3)); +transition2(b3, 0, 2.5); +assertTrue(%HasFastHoleyElements(b3)); +assertEquals(4, b3[4]); +assertEquals(2.5, b3[0]); + +// Large array should deopt to runtime +for (j = 0; j < iteration_count; ++j) { + b4 = [0, ,0]; + for (i = 3; i < 0x40000; ++i) { + b4[i] = 0; + } + assertTrue(%HasFastSmiElements(b4)); + transition2(b4, 0, 2.5); + assertEquals(2.5, b4[0]); +} + +// +// Test PACKED DOUBLE -> PACKED OBJECT +// + +function transition3(a, i, v) { + a[i] = v; +} + +var c1 = [0, 1, 2, 3.5, 4]; +transition3(c1, 0, new Object()); +var c2 = [0, 1, 2, 3.5, 4]; +transition3(c2, 0, new Object()); +assertTrue(%HasFastObjectElements(c2)); +assertTrue(!%HasFastHoleyElements(c2)); +%OptimizeFunctionOnNextCall(transition3); + +var c3 = [0, 1, 2, 3.5, 4]; +assertTrue(%HasFastDoubleElements(c3)); +assertTrue(!%HasFastHoleyElements(c3)); +transition3(c3, 0, new Array()); +assertTrue(!%HasFastHoleyElements(c3)); +assertTrue(%HasFastObjectElements(c3)); +assertEquals(4, c3[4]); +assertEquals(0, c3[0].length); + +// Large array under the deopt threshold should be able to trigger GC without +// causing crashes. +for (j = 0; j < iteration_count; ++j) { + c4 = [0, 2.5, 0]; + for (i = 3; i < 0xa000; ++i) { + c4[i] = 0; + } + assertTrue(%HasFastDoubleElements(c4)); + assertTrue(!%HasFastHoleyElements(c4)); + transition3(c4, 0, new Array(5)); + assertTrue(!%HasFastHoleyElements(c4)); + assertTrue(%HasFastObjectElements(c4)); + assertEquals(5, c4[0].length); +} + +// Large array should deopt to runtime +for (j = 0; j < iteration_count; ++j) { + c5 = [0, 2.5, 0]; + for (i = 3; i < 0x40000; ++i) { + c5[i] = 0; + } + assertTrue(%HasFastDoubleElements(c5)); + assertTrue(!%HasFastHoleyElements(c5)); + transition3(c5, 0, new Array(5)); + assertTrue(!%HasFastHoleyElements(c5)); + assertTrue(%HasFastObjectElements(c5)); + assertEquals(5, c5[0].length); +} + +// +// Test HOLEY DOUBLE -> HOLEY OBJECT +// + +function transition4(a, i, v) { + a[i] = v; +} + +var d1 = [0, 1, , 3.5, 4]; +transition4(d1, 0, new Object()); +var d2 = [0, 1, , 3.5, 4]; +transition4(d2, 0, new Object()); +assertTrue(%HasFastObjectElements(d2)); +assertTrue(%HasFastHoleyElements(d2)); +%OptimizeFunctionOnNextCall(transition4); + +var d3 = [0, 1, , 3.5, 4]; +assertTrue(%HasFastDoubleElements(d3)); +assertTrue(%HasFastHoleyElements(d3)); +transition4(d3, 0, new Array()); +assertTrue(%HasFastHoleyElements(d3)); +assertTrue(%HasFastObjectElements(d3)); +assertEquals(4, d3[4]); +assertEquals(0, d3[0].length); + +// Large array under the deopt threshold should be able to trigger GC without +// causing crashes. +for (j = 0; j < iteration_count; ++j) { + d4 = [, 2.5, ,]; + for (i = 3; i < 0xa000; ++i) { + d4[i] = 0; + } + assertTrue(%HasFastDoubleElements(d4)); + assertTrue(%HasFastHoleyElements(d4)); + transition4(d4, 0, new Array(5)); + assertTrue(%HasFastHoleyElements(d4)); + assertTrue(%HasFastObjectElements(d4)); + assertEquals(5, d4[0].length); + assertEquals(undefined, d4[2]); +} + +// Large array should deopt to runtime +for (j = 0; j < iteration_count; ++j) { + d5 = [, 2.5, ,]; + for (i = 3; i < 0x40000; ++i) { + d5[i] = 0; + } + assertTrue(%HasFastDoubleElements(d5)); + assertTrue(%HasFastHoleyElements(d5)); + transition4(d5, 0, new Array(5)); + assertTrue(%HasFastHoleyElements(d5)); + assertTrue(%HasFastObjectElements(d5)); + assertEquals(5, d5[0].length); + assertEquals(undefined, d5[2]); +} diff --git a/deps/v8/test/mjsunit/harmony/collections.js b/deps/v8/test/mjsunit/harmony/collections.js index f3db7ea2b..0219f3936 100644 --- a/deps/v8/test/mjsunit/harmony/collections.js +++ b/deps/v8/test/mjsunit/harmony/collections.js @@ -313,4 +313,60 @@ TestBogusReceivers(bogusReceiversTestSet); // Stress Test // There is a proposed stress-test available at the es-discuss mailing list // which cannot be reasonably automated. Check it out by hand if you like: -// https://mail.mozilla.org/pipermail/es-discuss/2011-May/014096.html
\ No newline at end of file +// https://mail.mozilla.org/pipermail/es-discuss/2011-May/014096.html + + +// Set and Map size getters +var setSizeDescriptor = Object.getOwnPropertyDescriptor(Set.prototype, 'size'); +assertEquals(undefined, setSizeDescriptor.value); +assertEquals(undefined, setSizeDescriptor.set); +assertTrue(setSizeDescriptor.get instanceof Function); +assertEquals(undefined, setSizeDescriptor.get.prototype); +assertFalse(setSizeDescriptor.enumerable); +assertTrue(setSizeDescriptor.configurable); + +var s = new Set(); +assertFalse(s.hasOwnProperty('size')); +for (var i = 0; i < 10; i++) { + assertEquals(i, s.size); + s.add(i); +} +for (var i = 9; i >= 0; i--) { + s.delete(i); + assertEquals(i, s.size); +} + + +var mapSizeDescriptor = Object.getOwnPropertyDescriptor(Map.prototype, 'size'); +assertEquals(undefined, mapSizeDescriptor.value); +assertEquals(undefined, mapSizeDescriptor.set); +assertTrue(mapSizeDescriptor.get instanceof Function); +assertEquals(undefined, mapSizeDescriptor.get.prototype); +assertFalse(mapSizeDescriptor.enumerable); +assertTrue(mapSizeDescriptor.configurable); + +var m = new Map(); +assertFalse(m.hasOwnProperty('size')); +for (var i = 0; i < 10; i++) { + assertEquals(i, m.size); + m.set(i, i); +} +for (var i = 9; i >= 0; i--) { + m.delete(i); + assertEquals(i, m.size); +} + +// Test clear +var a = new Set(); +s.add(42); +assertTrue(s.has(42)); +s.clear(); +assertFalse(s.has(42)); +assertEquals(0, s.size); + +var m = new Map(); +m.set(42, true); +assertTrue(m.has(42)); +m.clear(); +assertFalse(m.has(42)); +assertEquals(0, m.size); diff --git a/deps/v8/test/mjsunit/harmony/module-linking.js b/deps/v8/test/mjsunit/harmony/module-linking.js index a4b272f46..3c0f18c37 100644 --- a/deps/v8/test/mjsunit/harmony/module-linking.js +++ b/deps/v8/test/mjsunit/harmony/module-linking.js @@ -112,7 +112,7 @@ module R { assertThrows(function() { eval("c = -1") }, SyntaxError) assertThrows(function() { R.c = -2 }, TypeError) - // Initialize first bunch or variables. + // Initialize first bunch of variables. export var v = 1 export let l = 2 export const c = 3 diff --git a/deps/v8/test/mjsunit/harmony/object-observe.js b/deps/v8/test/mjsunit/harmony/object-observe.js new file mode 100644 index 000000000..584d9e82d --- /dev/null +++ b/deps/v8/test/mjsunit/harmony/object-observe.js @@ -0,0 +1,1056 @@ +// Copyright 2012 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: --harmony-observation --harmony-proxies --harmony-collections +// Flags: --allow-natives-syntax + +var allObservers = []; +function reset() { + allObservers.forEach(function(observer) { observer.reset(); }); +} + +function stringifyNoThrow(arg) { + try { + return JSON.stringify(arg); + } catch (e) { + return '{<circular reference>}'; + } +} + +function createObserver() { + "use strict"; // So that |this| in callback can be undefined. + + var observer = { + records: undefined, + callbackCount: 0, + reset: function() { + this.records = undefined; + this.callbackCount = 0; + }, + assertNotCalled: function() { + assertEquals(undefined, this.records); + assertEquals(0, this.callbackCount); + }, + assertCalled: function() { + assertEquals(1, this.callbackCount); + }, + assertRecordCount: function(count) { + this.assertCalled(); + assertEquals(count, this.records.length); + }, + assertCallbackRecords: function(recs) { + this.assertRecordCount(recs.length); + for (var i = 0; i < recs.length; i++) { + if ('name' in recs[i]) recs[i].name = String(recs[i].name); + print(i, stringifyNoThrow(this.records[i]), stringifyNoThrow(recs[i])); + assertSame(this.records[i].object, recs[i].object); + assertEquals('string', typeof recs[i].type); + assertPropertiesEqual(this.records[i], recs[i]); + } + } + }; + + observer.callback = function(r) { + assertEquals(undefined, this); + assertEquals('object', typeof r); + assertTrue(r instanceof Array) + observer.records = r; + observer.callbackCount++; + }; + + observer.reset(); + allObservers.push(observer); + return observer; +} + +var observer = createObserver(); +assertEquals("function", typeof observer.callback); +var obj = {}; + +function frozenFunction() {} +Object.freeze(frozenFunction); +var nonFunction = {}; +var changeRecordWithAccessor = { type: 'foo' }; +var recordCreated = false; +Object.defineProperty(changeRecordWithAccessor, 'name', { + get: function() { + recordCreated = true; + return "bar"; + }, + enumerable: true +}) + + +// Object.observe +assertThrows(function() { Object.observe("non-object", observer.callback); }, TypeError); +assertThrows(function() { Object.observe(obj, nonFunction); }, TypeError); +assertThrows(function() { Object.observe(obj, frozenFunction); }, TypeError); +assertEquals(obj, Object.observe(obj, observer.callback)); + + +// Object.unobserve +assertThrows(function() { Object.unobserve(4, observer.callback); }, TypeError); +assertThrows(function() { Object.unobserve(obj, nonFunction); }, TypeError); +assertEquals(obj, Object.unobserve(obj, observer.callback)); + + +// Object.getNotifier +var notifier = Object.getNotifier(obj); +assertSame(notifier, Object.getNotifier(obj)); +assertEquals(null, Object.getNotifier(Object.freeze({}))); +assertFalse(notifier.hasOwnProperty('notify')); +assertEquals([], Object.keys(notifier)); +var notifyDesc = Object.getOwnPropertyDescriptor(notifier.__proto__, 'notify'); +assertTrue(notifyDesc.configurable); +assertTrue(notifyDesc.writable); +assertFalse(notifyDesc.enumerable); +assertThrows(function() { notifier.notify({}); }, TypeError); +assertThrows(function() { notifier.notify({ type: 4 }); }, TypeError); +var notify = notifier.notify; +assertThrows(function() { notify.call(undefined, { type: 'a' }); }, TypeError); +assertThrows(function() { notify.call(null, { type: 'a' }); }, TypeError); +assertThrows(function() { notify.call(5, { type: 'a' }); }, TypeError); +assertThrows(function() { notify.call('hello', { type: 'a' }); }, TypeError); +assertThrows(function() { notify.call(false, { type: 'a' }); }, TypeError); +assertThrows(function() { notify.call({}, { type: 'a' }); }, TypeError); +assertFalse(recordCreated); +notifier.notify(changeRecordWithAccessor); +assertFalse(recordCreated); // not observed yet + + +// Object.deliverChangeRecords +assertThrows(function() { Object.deliverChangeRecords(nonFunction); }, TypeError); + +Object.observe(obj, observer.callback); + + +// notify uses to [[CreateOwnProperty]] to create changeRecord; +reset(); +var protoExpandoAccessed = false; +Object.defineProperty(Object.prototype, 'protoExpando', + { + configurable: true, + set: function() { protoExpandoAccessed = true; } + } +); +notifier.notify({ type: 'foo', protoExpando: 'val'}); +assertFalse(protoExpandoAccessed); +delete Object.prototype.protoExpando; +Object.deliverChangeRecords(observer.callback); + + +// Multiple records are delivered. +reset(); +notifier.notify({ + type: 'updated', + name: 'foo', + expando: 1 +}); + +notifier.notify({ + object: notifier, // object property is ignored + type: 'deleted', + name: 'bar', + expando2: 'str' +}); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: obj, name: 'foo', type: 'updated', expando: 1 }, + { object: obj, name: 'bar', type: 'deleted', expando2: 'str' } +]); + + +// No delivery takes place if no records are pending +reset(); +Object.deliverChangeRecords(observer.callback); +observer.assertNotCalled(); + + +// Multiple observation has no effect. +reset(); +Object.observe(obj, observer.callback); +Object.observe(obj, observer.callback); +Object.getNotifier(obj).notify({ + type: 'foo', +}); +Object.deliverChangeRecords(observer.callback); +observer.assertCalled(); + + +// Observation can be stopped. +reset(); +Object.unobserve(obj, observer.callback); +Object.getNotifier(obj).notify({ + type: 'foo', +}); +Object.deliverChangeRecords(observer.callback); +observer.assertNotCalled(); + + +// Multiple unobservation has no effect +reset(); +Object.unobserve(obj, observer.callback); +Object.unobserve(obj, observer.callback); +Object.getNotifier(obj).notify({ + type: 'foo', +}); +Object.deliverChangeRecords(observer.callback); +observer.assertNotCalled(); + + +// Re-observation works and only includes changeRecords after of call. +reset(); +Object.getNotifier(obj).notify({ + type: 'foo', +}); +Object.observe(obj, observer.callback); +Object.getNotifier(obj).notify({ + type: 'foo', +}); +records = undefined; +Object.deliverChangeRecords(observer.callback); +observer.assertRecordCount(1); + + +// Observing a continuous stream of changes, while itermittantly unobserving. +reset(); +Object.observe(obj, observer.callback); +Object.getNotifier(obj).notify({ + type: 'foo', + val: 1 +}); + +Object.unobserve(obj, observer.callback); +Object.getNotifier(obj).notify({ + type: 'foo', + val: 2 +}); + +Object.observe(obj, observer.callback); +Object.getNotifier(obj).notify({ + type: 'foo', + val: 3 +}); + +Object.unobserve(obj, observer.callback); +Object.getNotifier(obj).notify({ + type: 'foo', + val: 4 +}); + +Object.observe(obj, observer.callback); +Object.getNotifier(obj).notify({ + type: 'foo', + val: 5 +}); + +Object.unobserve(obj, observer.callback); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: obj, type: 'foo', val: 1 }, + { object: obj, type: 'foo', val: 3 }, + { object: obj, type: 'foo', val: 5 } +]); + + +// Observing multiple objects; records appear in order. +reset(); +var obj2 = {}; +var obj3 = {} +Object.observe(obj, observer.callback); +Object.observe(obj3, observer.callback); +Object.observe(obj2, observer.callback); +Object.getNotifier(obj).notify({ + type: 'foo1', +}); +Object.getNotifier(obj2).notify({ + type: 'foo2', +}); +Object.getNotifier(obj3).notify({ + type: 'foo3', +}); +Object.observe(obj3, observer.callback); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: obj, type: 'foo1' }, + { object: obj2, type: 'foo2' }, + { object: obj3, type: 'foo3' } +]); + + +// Recursive observation. +var obj = {a: 1}; +var callbackCount = 0; +function recursiveObserver(r) { + assertEquals(1, r.length); + ++callbackCount; + if (r[0].oldValue < 100) ++obj[r[0].name]; +} +Object.observe(obj, recursiveObserver); +++obj.a; +Object.deliverChangeRecords(recursiveObserver); +assertEquals(100, callbackCount); + +var obj1 = {a: 1}; +var obj2 = {a: 1}; +var recordCount = 0; +function recursiveObserver2(r) { + recordCount += r.length; + if (r[0].oldValue < 100) { + ++obj1.a; + ++obj2.a; + } +} +Object.observe(obj1, recursiveObserver2); +Object.observe(obj2, recursiveObserver2); +++obj1.a; +Object.deliverChangeRecords(recursiveObserver2); +assertEquals(199, recordCount); + + +// Observing named properties. +reset(); +var obj = {a: 1} +Object.observe(obj, observer.callback); +obj.a = 2; +obj["a"] = 3; +delete obj.a; +obj.a = 4; +obj.a = 4; // ignored +obj.a = 5; +Object.defineProperty(obj, "a", {value: 6}); +Object.defineProperty(obj, "a", {writable: false}); +obj.a = 7; // ignored +Object.defineProperty(obj, "a", {value: 8}); +Object.defineProperty(obj, "a", {value: 7, writable: true}); +Object.defineProperty(obj, "a", {get: function() {}}); +Object.defineProperty(obj, "a", {get: frozenFunction}); +Object.defineProperty(obj, "a", {get: frozenFunction}); // ignored +Object.defineProperty(obj, "a", {get: frozenFunction, set: frozenFunction}); +Object.defineProperty(obj, "a", {set: frozenFunction}); // ignored +Object.defineProperty(obj, "a", {get: undefined, set: frozenFunction}); +delete obj.a; +delete obj.a; +Object.defineProperty(obj, "a", {get: function() {}, configurable: true}); +Object.defineProperty(obj, "a", {value: 9, writable: true}); +obj.a = 10; +++obj.a; +obj.a++; +obj.a *= 3; +delete obj.a; +Object.defineProperty(obj, "a", {value: 11, configurable: true}); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: obj, name: "a", type: "updated", oldValue: 1 }, + { object: obj, name: "a", type: "updated", oldValue: 2 }, + { object: obj, name: "a", type: "deleted", oldValue: 3 }, + { object: obj, name: "a", type: "new" }, + { object: obj, name: "a", type: "updated", oldValue: 4 }, + { object: obj, name: "a", type: "updated", oldValue: 5 }, + { object: obj, name: "a", type: "reconfigured" }, + { object: obj, name: "a", type: "updated", oldValue: 6 }, + { object: obj, name: "a", type: "reconfigured", oldValue: 8 }, + { object: obj, name: "a", type: "reconfigured", oldValue: 7 }, + { object: obj, name: "a", type: "reconfigured" }, + { object: obj, name: "a", type: "reconfigured" }, + { object: obj, name: "a", type: "reconfigured" }, + { object: obj, name: "a", type: "deleted" }, + { object: obj, name: "a", type: "new" }, + { object: obj, name: "a", type: "reconfigured" }, + { object: obj, name: "a", type: "updated", oldValue: 9 }, + { object: obj, name: "a", type: "updated", oldValue: 10 }, + { object: obj, name: "a", type: "updated", oldValue: 11 }, + { object: obj, name: "a", type: "updated", oldValue: 12 }, + { object: obj, name: "a", type: "deleted", oldValue: 36 }, + { object: obj, name: "a", type: "new" }, +]); + + +// Observing indexed properties. +reset(); +var obj = {'1': 1} +Object.observe(obj, observer.callback); +obj[1] = 2; +obj[1] = 3; +delete obj[1]; +obj[1] = 4; +obj[1] = 4; // ignored +obj[1] = 5; +Object.defineProperty(obj, "1", {value: 6}); +Object.defineProperty(obj, "1", {writable: false}); +obj[1] = 7; // ignored +Object.defineProperty(obj, "1", {value: 8}); +Object.defineProperty(obj, "1", {value: 7, writable: true}); +Object.defineProperty(obj, "1", {get: function() {}}); +Object.defineProperty(obj, "1", {get: frozenFunction}); +Object.defineProperty(obj, "1", {get: frozenFunction}); // ignored +Object.defineProperty(obj, "1", {get: frozenFunction, set: frozenFunction}); +Object.defineProperty(obj, "1", {set: frozenFunction}); // ignored +Object.defineProperty(obj, "1", {get: undefined, set: frozenFunction}); +delete obj[1]; +delete obj[1]; +Object.defineProperty(obj, "1", {get: function() {}, configurable: true}); +Object.defineProperty(obj, "1", {value: 9, writable: true}); +obj[1] = 10; +++obj[1]; +obj[1]++; +obj[1] *= 3; +delete obj[1]; +Object.defineProperty(obj, "1", {value: 11, configurable: true}); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: obj, name: "1", type: "updated", oldValue: 1 }, + { object: obj, name: "1", type: "updated", oldValue: 2 }, + { object: obj, name: "1", type: "deleted", oldValue: 3 }, + { object: obj, name: "1", type: "new" }, + { object: obj, name: "1", type: "updated", oldValue: 4 }, + { object: obj, name: "1", type: "updated", oldValue: 5 }, + { object: obj, name: "1", type: "reconfigured" }, + { object: obj, name: "1", type: "updated", oldValue: 6 }, + { object: obj, name: "1", type: "reconfigured", oldValue: 8 }, + { object: obj, name: "1", type: "reconfigured", oldValue: 7 }, + { object: obj, name: "1", type: "reconfigured" }, + { object: obj, name: "1", type: "reconfigured" }, + { object: obj, name: "1", type: "reconfigured" }, + { object: obj, name: "1", type: "deleted" }, + { object: obj, name: "1", type: "new" }, + { object: obj, name: "1", type: "reconfigured" }, + { object: obj, name: "1", type: "updated", oldValue: 9 }, + { object: obj, name: "1", type: "updated", oldValue: 10 }, + { object: obj, name: "1", type: "updated", oldValue: 11 }, + { object: obj, name: "1", type: "updated", oldValue: 12 }, + { object: obj, name: "1", type: "deleted", oldValue: 36 }, + { object: obj, name: "1", type: "new" }, +]); + + +// Test all kinds of objects generically. +function TestObserveConfigurable(obj, prop) { + reset(); + obj[prop] = 1; + Object.observe(obj, observer.callback); + obj[prop] = 2; + obj[prop] = 3; + delete obj[prop]; + obj[prop] = 4; + obj[prop] = 4; // ignored + obj[prop] = 5; + Object.defineProperty(obj, prop, {value: 6}); + Object.defineProperty(obj, prop, {writable: false}); + obj[prop] = 7; // ignored + Object.defineProperty(obj, prop, {value: 8}); + Object.defineProperty(obj, prop, {value: 7, writable: true}); + Object.defineProperty(obj, prop, {get: function() {}}); + Object.defineProperty(obj, prop, {get: frozenFunction}); + Object.defineProperty(obj, prop, {get: frozenFunction}); // ignored + Object.defineProperty(obj, prop, {get: frozenFunction, set: frozenFunction}); + Object.defineProperty(obj, prop, {set: frozenFunction}); // ignored + Object.defineProperty(obj, prop, {get: undefined, set: frozenFunction}); + obj.__defineSetter__(prop, frozenFunction); // ignored + obj.__defineSetter__(prop, function() {}); + obj.__defineGetter__(prop, function() {}); + delete obj[prop]; + delete obj[prop]; // ignored + obj.__defineGetter__(prop, function() {}); + delete obj[prop]; + Object.defineProperty(obj, prop, {get: function() {}, configurable: true}); + Object.defineProperty(obj, prop, {value: 9, writable: true}); + obj[prop] = 10; + ++obj[prop]; + obj[prop]++; + obj[prop] *= 3; + delete obj[prop]; + Object.defineProperty(obj, prop, {value: 11, configurable: true}); + Object.deliverChangeRecords(observer.callback); + observer.assertCallbackRecords([ + { object: obj, name: prop, type: "updated", oldValue: 1 }, + { object: obj, name: prop, type: "updated", oldValue: 2 }, + { object: obj, name: prop, type: "deleted", oldValue: 3 }, + { object: obj, name: prop, type: "new" }, + { object: obj, name: prop, type: "updated", oldValue: 4 }, + { object: obj, name: prop, type: "updated", oldValue: 5 }, + { object: obj, name: prop, type: "reconfigured" }, + { object: obj, name: prop, type: "updated", oldValue: 6 }, + { object: obj, name: prop, type: "reconfigured", oldValue: 8 }, + { object: obj, name: prop, type: "reconfigured", oldValue: 7 }, + { object: obj, name: prop, type: "reconfigured" }, + { object: obj, name: prop, type: "reconfigured" }, + { object: obj, name: prop, type: "reconfigured" }, + { object: obj, name: prop, type: "reconfigured" }, + { object: obj, name: prop, type: "reconfigured" }, + { object: obj, name: prop, type: "deleted" }, + { object: obj, name: prop, type: "new" }, + { object: obj, name: prop, type: "deleted" }, + { object: obj, name: prop, type: "new" }, + { object: obj, name: prop, type: "reconfigured" }, + { object: obj, name: prop, type: "updated", oldValue: 9 }, + { object: obj, name: prop, type: "updated", oldValue: 10 }, + { object: obj, name: prop, type: "updated", oldValue: 11 }, + { object: obj, name: prop, type: "updated", oldValue: 12 }, + { object: obj, name: prop, type: "deleted", oldValue: 36 }, + { object: obj, name: prop, type: "new" }, + ]); + Object.unobserve(obj, observer.callback); + delete obj[prop]; +} + +function TestObserveNonConfigurable(obj, prop, desc) { + reset(); + obj[prop] = 1; + Object.observe(obj, observer.callback); + obj[prop] = 4; + obj[prop] = 4; // ignored + obj[prop] = 5; + Object.defineProperty(obj, prop, {value: 6}); + Object.defineProperty(obj, prop, {value: 6}); // ignored + Object.defineProperty(obj, prop, {value: 7}); + Object.defineProperty(obj, prop, {enumerable: desc.enumerable}); // ignored + Object.defineProperty(obj, prop, {writable: false}); + obj[prop] = 7; // ignored + Object.deliverChangeRecords(observer.callback); + observer.assertCallbackRecords([ + { object: obj, name: prop, type: "updated", oldValue: 1 }, + { object: obj, name: prop, type: "updated", oldValue: 4 }, + { object: obj, name: prop, type: "updated", oldValue: 5 }, + { object: obj, name: prop, type: "updated", oldValue: 6 }, + { object: obj, name: prop, type: "reconfigured" }, + ]); + Object.unobserve(obj, observer.callback); +} + +function createProxy(create, x) { + var handler = { + getPropertyDescriptor: function(k) { + for (var o = this.target; o; o = Object.getPrototypeOf(o)) { + var desc = Object.getOwnPropertyDescriptor(o, k); + if (desc) return desc; + } + return undefined; + }, + getOwnPropertyDescriptor: function(k) { + return Object.getOwnPropertyDescriptor(this.target, k); + }, + defineProperty: function(k, desc) { + var x = Object.defineProperty(this.target, k, desc); + Object.deliverChangeRecords(this.callback); + return x; + }, + delete: function(k) { + var x = delete this.target[k]; + Object.deliverChangeRecords(this.callback); + return x; + }, + getPropertyNames: function() { + return Object.getOwnPropertyNames(this.target); + }, + target: {isProxy: true}, + callback: function(changeRecords) { + print("callback", stringifyNoThrow(handler.proxy), stringifyNoThrow(got)); + for (var i in changeRecords) { + var got = changeRecords[i]; + var change = {object: handler.proxy, name: got.name, type: got.type}; + if ("oldValue" in got) change.oldValue = got.oldValue; + Object.getNotifier(handler.proxy).notify(change); + } + }, + }; + Object.observe(handler.target, handler.callback); + return handler.proxy = create(handler, x); +} + +var objects = [ + {}, + [], + this, // global object + function(){}, + (function(){ return arguments })(), + (function(){ "use strict"; return arguments })(), + Object(1), Object(true), Object("bla"), + new Date(), + Object, Function, Date, RegExp, + new Set, new Map, new WeakMap, + new ArrayBuffer(10), new Int32Array(5), + createProxy(Proxy.create, null), + createProxy(Proxy.createFunction, function(){}), +]; +var properties = ["a", "1", 1, "length", "prototype", "name", "caller"]; + +// Cases that yield non-standard results. +function blacklisted(obj, prop) { + return (obj instanceof Int32Array && prop == 1) || + (obj instanceof Int32Array && prop === "length") || + (obj instanceof ArrayBuffer && prop == 1) +} + +for (var i in objects) for (var j in properties) { + var obj = objects[i]; + var prop = properties[j]; + if (blacklisted(obj, prop)) continue; + var desc = Object.getOwnPropertyDescriptor(obj, prop); + print("***", typeof obj, stringifyNoThrow(obj), prop); + if (!desc || desc.configurable) + TestObserveConfigurable(obj, prop); + else if (desc.writable) + TestObserveNonConfigurable(obj, prop, desc); +} + + +// Observing array length (including truncation) +reset(); +var arr = ['a', 'b', 'c', 'd']; +var arr2 = ['alpha', 'beta']; +var arr3 = ['hello']; +arr3[2] = 'goodbye'; +arr3.length = 6; +var slow_arr = new Array(1000000000); +slow_arr[500000000] = 'hello'; +Object.defineProperty(arr, '0', {configurable: false}); +Object.defineProperty(arr, '2', {get: function(){}}); +Object.defineProperty(arr2, '0', {get: function(){}, configurable: false}); +Object.observe(arr, observer.callback); +Object.observe(arr2, observer.callback); +Object.observe(arr3, observer.callback); +Object.observe(slow_arr, observer.callback); +arr.length = 2; +arr.length = 0; +arr.length = 10; +Object.defineProperty(arr, 'length', {writable: false}); +arr2.length = 0; +arr2.length = 1; // no change expected +Object.defineProperty(arr2, 'length', {value: 1, writable: false}); +arr3.length = 0; +++arr3.length; +arr3.length++; +arr3.length /= 2; +Object.defineProperty(arr3, 'length', {value: 5}); +Object.defineProperty(arr3, 'length', {value: 10, writable: false}); +slow_arr.length = 100; +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: arr, name: '3', type: 'deleted', oldValue: 'd' }, + { object: arr, name: '2', type: 'deleted' }, + { object: arr, name: 'length', type: 'updated', oldValue: 4 }, + { object: arr, name: '1', type: 'deleted', oldValue: 'b' }, + { object: arr, name: 'length', type: 'updated', oldValue: 2 }, + { object: arr, name: 'length', type: 'updated', oldValue: 1 }, + { object: arr, name: 'length', type: 'reconfigured' }, + { object: arr2, name: '1', type: 'deleted', oldValue: 'beta' }, + { object: arr2, name: 'length', type: 'updated', oldValue: 2 }, + { object: arr2, name: 'length', type: 'reconfigured', oldValue: 1 }, + { object: arr3, name: '2', type: 'deleted', oldValue: 'goodbye' }, + { object: arr3, name: '0', type: 'deleted', oldValue: 'hello' }, + { object: arr3, name: 'length', type: 'updated', oldValue: 6 }, + { object: arr3, name: 'length', type: 'updated', oldValue: 0 }, + { object: arr3, name: 'length', type: 'updated', oldValue: 1 }, + { object: arr3, name: 'length', type: 'updated', oldValue: 2 }, + { object: arr3, name: 'length', type: 'updated', oldValue: 1 }, + { object: arr3, name: 'length', type: 'reconfigured', oldValue: 5 }, + { object: slow_arr, name: '500000000', type: 'deleted', oldValue: 'hello' }, + { object: slow_arr, name: 'length', type: 'updated', oldValue: 1000000000 }, +]); + + +// Assignments in loops (checking different IC states). +reset(); +var obj = {}; +Object.observe(obj, observer.callback); +for (var i = 0; i < 5; i++) { + obj["a" + i] = i; +} +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: obj, name: "a0", type: "new" }, + { object: obj, name: "a1", type: "new" }, + { object: obj, name: "a2", type: "new" }, + { object: obj, name: "a3", type: "new" }, + { object: obj, name: "a4", type: "new" }, +]); + +reset(); +var obj = {}; +Object.observe(obj, observer.callback); +for (var i = 0; i < 5; i++) { + obj[i] = i; +} +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: obj, name: "0", type: "new" }, + { object: obj, name: "1", type: "new" }, + { object: obj, name: "2", type: "new" }, + { object: obj, name: "3", type: "new" }, + { object: obj, name: "4", type: "new" }, +]); + + +// Adding elements past the end of an array should notify on length +reset(); +var arr = [1, 2, 3]; +Object.observe(arr, observer.callback); +arr[3] = 10; +arr[100] = 20; +Object.defineProperty(arr, '200', {value: 7}); +Object.defineProperty(arr, '400', {get: function(){}}); +arr[50] = 30; // no length change expected +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: arr, name: '3', type: 'new' }, + { object: arr, name: 'length', type: 'updated', oldValue: 3 }, + { object: arr, name: '100', type: 'new' }, + { object: arr, name: 'length', type: 'updated', oldValue: 4 }, + { object: arr, name: '200', type: 'new' }, + { object: arr, name: 'length', type: 'updated', oldValue: 101 }, + { object: arr, name: '400', type: 'new' }, + { object: arr, name: 'length', type: 'updated', oldValue: 201 }, + { object: arr, name: '50', type: 'new' }, +]); + + +// Tests for array methods, first on arrays and then on plain objects +// +// === ARRAYS === +// +// Push +reset(); +var array = [1, 2]; +Object.observe(array, observer.callback); +array.push(3, 4); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: array, name: '2', type: 'new' }, + { object: array, name: 'length', type: 'updated', oldValue: 2 }, + { object: array, name: '3', type: 'new' }, + { object: array, name: 'length', type: 'updated', oldValue: 3 }, +]); + +// Pop +reset(); +var array = [1, 2]; +Object.observe(array, observer.callback); +array.pop(); +array.pop(); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: array, name: '1', type: 'deleted', oldValue: 2 }, + { object: array, name: 'length', type: 'updated', oldValue: 2 }, + { object: array, name: '0', type: 'deleted', oldValue: 1 }, + { object: array, name: 'length', type: 'updated', oldValue: 1 }, +]); + +// Shift +reset(); +var array = [1, 2]; +Object.observe(array, observer.callback); +array.shift(); +array.shift(); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: array, name: '0', type: 'updated', oldValue: 1 }, + { object: array, name: '1', type: 'deleted', oldValue: 2 }, + { object: array, name: 'length', type: 'updated', oldValue: 2 }, + { object: array, name: '0', type: 'deleted', oldValue: 2 }, + { object: array, name: 'length', type: 'updated', oldValue: 1 }, +]); + +// Unshift +reset(); +var array = [1, 2]; +Object.observe(array, observer.callback); +array.unshift(3, 4); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: array, name: '3', type: 'new' }, + { object: array, name: 'length', type: 'updated', oldValue: 2 }, + { object: array, name: '2', type: 'new' }, + { object: array, name: '0', type: 'updated', oldValue: 1 }, + { object: array, name: '1', type: 'updated', oldValue: 2 }, +]); + +// Splice +reset(); +var array = [1, 2, 3]; +Object.observe(array, observer.callback); +array.splice(1, 1, 4, 5); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: array, name: '3', type: 'new' }, + { object: array, name: 'length', type: 'updated', oldValue: 3 }, + { object: array, name: '1', type: 'updated', oldValue: 2 }, + { object: array, name: '2', type: 'updated', oldValue: 3 }, +]); + + +// +// === PLAIN OBJECTS === +// +// Push +reset() +var array = {0: 1, 1: 2, length: 2} +Object.observe(array, observer.callback); +Array.prototype.push.call(array, 3, 4); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: array, name: '2', type: 'new' }, + { object: array, name: '3', type: 'new' }, + { object: array, name: 'length', type: 'updated', oldValue: 2 }, +]); + +// Pop +reset() +var array = {0: 1, 1: 2, length: 2}; +Object.observe(array, observer.callback); +Array.prototype.pop.call(array); +Array.prototype.pop.call(array); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: array, name: '1', type: 'deleted', oldValue: 2 }, + { object: array, name: 'length', type: 'updated', oldValue: 2 }, + { object: array, name: '0', type: 'deleted', oldValue: 1 }, + { object: array, name: 'length', type: 'updated', oldValue: 1 }, +]); + +// Shift +reset() +var array = {0: 1, 1: 2, length: 2}; +Object.observe(array, observer.callback); +Array.prototype.shift.call(array); +Array.prototype.shift.call(array); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: array, name: '0', type: 'updated', oldValue: 1 }, + { object: array, name: '1', type: 'deleted', oldValue: 2 }, + { object: array, name: 'length', type: 'updated', oldValue: 2 }, + { object: array, name: '0', type: 'deleted', oldValue: 2 }, + { object: array, name: 'length', type: 'updated', oldValue: 1 }, +]); + +// Unshift +reset() +var array = {0: 1, 1: 2, length: 2}; +Object.observe(array, observer.callback); +Array.prototype.unshift.call(array, 3, 4); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: array, name: '3', type: 'new' }, + { object: array, name: '2', type: 'new' }, + { object: array, name: '0', type: 'updated', oldValue: 1 }, + { object: array, name: '1', type: 'updated', oldValue: 2 }, + { object: array, name: 'length', type: 'updated', oldValue: 2 }, +]); + +// Splice +reset() +var array = {0: 1, 1: 2, 2: 3, length: 3}; +Object.observe(array, observer.callback); +Array.prototype.splice.call(array, 1, 1, 4, 5); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: array, name: '3', type: 'new' }, + { object: array, name: '1', type: 'updated', oldValue: 2 }, + { object: array, name: '2', type: 'updated', oldValue: 3 }, + { object: array, name: 'length', type: 'updated', oldValue: 3 }, +]); + +// Exercise StoreIC_ArrayLength +reset(); +var dummy = {}; +Object.observe(dummy, observer.callback); +Object.unobserve(dummy, observer.callback); +var array = [0]; +Object.observe(array, observer.callback); +array.splice(0, 1); +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: array, name: '0', type: 'deleted', oldValue: 0 }, + { object: array, name: 'length', type: 'updated', oldValue: 1}, +]); + + +// __proto__ +reset(); +var obj = {}; +Object.observe(obj, observer.callback); +var p = {foo: 'yes'}; +var q = {bar: 'no'}; +obj.__proto__ = p; +obj.__proto__ = p; // ignored +obj.__proto__ = null; +obj.__proto__ = q; // the __proto__ accessor is gone +// TODO(adamk): Add tests for objects with hidden prototypes +// once we support observing the global object. +Object.deliverChangeRecords(observer.callback); +observer.assertCallbackRecords([ + { object: obj, name: '__proto__', type: 'prototype', + oldValue: Object.prototype }, + { object: obj, name: '__proto__', type: 'prototype', oldValue: p }, + { object: obj, name: '__proto__', type: 'new' }, +]); + + +// Function.prototype +reset(); +var fun = function(){}; +Object.observe(fun, observer.callback); +var myproto = {foo: 'bar'}; +fun.prototype = myproto; +fun.prototype = 7; +fun.prototype = 7; // ignored +Object.defineProperty(fun, 'prototype', {value: 8}); +Object.deliverChangeRecords(observer.callback); +observer.assertRecordCount(3); +// Manually examine the first record in order to test +// lazy creation of oldValue +assertSame(fun, observer.records[0].object); +assertEquals('prototype', observer.records[0].name); +assertEquals('updated', observer.records[0].type); +// The only existing reference to the oldValue object is in this +// record, so to test that lazy creation happened correctly +// we compare its constructor to our function (one of the invariants +// ensured when creating an object via AllocateFunctionPrototype). +assertSame(fun, observer.records[0].oldValue.constructor); +observer.records.splice(0, 1); +observer.assertCallbackRecords([ + { object: fun, name: 'prototype', type: 'updated', oldValue: myproto }, + { object: fun, name: 'prototype', type: 'updated', oldValue: 7 }, +]); + +// Function.prototype should not be observable except on the object itself +reset(); +var fun = function(){}; +var obj = { __proto__: fun }; +Object.observe(obj, observer.callback); +obj.prototype = 7; +Object.deliverChangeRecords(observer.callback); +observer.assertNotCalled(); + + +// Check that changes in observation status are detected in all IC states and +// in optimized code, especially in cases usually using fast elements. +var mutation = [ + "a[i] = v", + "a[i] ? ++a[i] : a[i] = v", + "a[i] ? a[i]++ : a[i] = v", + "a[i] ? a[i] += 1 : a[i] = v", + "a[i] ? a[i] -= -1 : a[i] = v", +]; + +var props = [1, "1", "a"]; + +function TestFastElements(prop, mutation, prepopulate, polymorphic, optimize) { + var setElement = eval( + "(function setElement(a, i, v) { " + mutation + "; " + + "/* " + [].join.call(arguments, " ") + " */" + + "})" + ); + print("TestFastElements:", setElement); + + var arr = prepopulate ? [1, 2, 3, 4, 5] : [0]; + if (prepopulate) arr[prop] = 2; // for non-element case + setElement(arr, prop, 3); + setElement(arr, prop, 4); + if (polymorphic) setElement(["M", "i", "l", "n", "e", "r"], 0, "m"); + if (optimize) %OptimizeFunctionOnNextCall(setElement); + setElement(arr, prop, 5); + + reset(); + Object.observe(arr, observer.callback); + setElement(arr, prop, 989898); + Object.deliverChangeRecords(observer.callback); + observer.assertCallbackRecords([ + { object: arr, name: "" + prop, type: 'updated', oldValue: 5 } + ]); +} + +for (var b1 = 0; b1 < 2; ++b1) + for (var b2 = 0; b2 < 2; ++b2) + for (var b3 = 0; b3 < 2; ++b3) + for (var i in props) + for (var j in mutation) + TestFastElements(props[i], mutation[j], b1 != 0, b2 != 0, b3 != 0); + + +var mutation = [ + "a.length = v", + "a.length += newSize - oldSize", + "a.length -= oldSize - newSize", +]; + +var mutationByIncr = [ + "++a.length", + "a.length++", +]; + +function TestFastElementsLength( + mutation, polymorphic, optimize, oldSize, newSize) { + var setLength = eval( + "(function setLength(a, v) { " + mutation + "; " + + "/* " + [].join.call(arguments, " ") + " */" + + "})" + ); + print("TestFastElementsLength:", setLength); + + function array(n) { + var arr = new Array(n); + for (var i = 0; i < n; ++i) arr[i] = i; + return arr; + } + + setLength(array(oldSize), newSize); + setLength(array(oldSize), newSize); + if (polymorphic) setLength(array(oldSize).map(isNaN), newSize); + if (optimize) %OptimizeFunctionOnNextCall(setLength); + setLength(array(oldSize), newSize); + + reset(); + var arr = array(oldSize); + Object.observe(arr, observer.callback); + setLength(arr, newSize); + Object.deliverChangeRecords(observer.callback); + if (oldSize === newSize) { + observer.assertNotCalled(); + } else { + var count = oldSize > newSize ? oldSize - newSize : 0; + observer.assertRecordCount(count + 1); + var lengthRecord = observer.records[count]; + assertSame(arr, lengthRecord.object); + assertEquals('length', lengthRecord.name); + assertEquals('updated', lengthRecord.type); + assertSame(oldSize, lengthRecord.oldValue); + } +} + +for (var b1 = 0; b1 < 2; ++b1) + for (var b2 = 0; b2 < 2; ++b2) + for (var n1 = 0; n1 < 3; ++n1) + for (var n2 = 0; n2 < 3; ++n2) + for (var i in mutation) + TestFastElementsLength(mutation[i], b1 != 0, b2 != 0, 20*n1, 20*n2); + +for (var b1 = 0; b1 < 2; ++b1) + for (var b2 = 0; b2 < 2; ++b2) + for (var n = 0; n < 3; ++n) + for (var i in mutationByIncr) + TestFastElementsLength(mutationByIncr[i], b1 != 0, b2 != 0, 7*n, 7*n+1); diff --git a/deps/v8/test/mjsunit/harmony/proxies-json.js b/deps/v8/test/mjsunit/harmony/proxies-json.js new file mode 100644 index 000000000..539c5a84c --- /dev/null +++ b/deps/v8/test/mjsunit/harmony/proxies-json.js @@ -0,0 +1,178 @@ +// Copyright 2012 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: --harmony + +function testStringify(expected, object) { + // Test fast case that bails out to slow case. + assertEquals(expected, JSON.stringify(object)); + // Test slow case. + assertEquals(expected, JSON.stringify(object, undefined, 0)); +} + +// Test serializing a proxy, function proxy and objects that contain them. +var handler1 = { + get: function(target, name) { + return name.toUpperCase(); + }, + enumerate: function(target) { + return ['a', 'b', 'c']; + }, + getOwnPropertyDescriptor: function(target, name) { + return { enumerable: true }; + } +} + +var proxy1 = Proxy.create(handler1); +testStringify('{"a":"A","b":"B","c":"C"}', proxy1); + +var proxy_fun = Proxy.createFunction(handler1, function() { return 1; }); +testStringify(undefined, proxy_fun); +testStringify('[1,null]', [1, proxy_fun]); + +var parent1a = { b: proxy1 }; +testStringify('{"b":{"a":"A","b":"B","c":"C"}}', parent1a); + +var parent1b = { a: 123, b: proxy1, c: true }; +testStringify('{"a":123,"b":{"a":"A","b":"B","c":"C"},"c":true}', parent1b); + +var parent1c = [123, proxy1, true]; +testStringify('[123,{"a":"A","b":"B","c":"C"},true]', parent1c); + +// Proxy with side effect. +var handler2 = { + get: function(target, name) { + delete parent2.c; + return name.toUpperCase(); + }, + enumerate: function(target) { + return ['a', 'b', 'c']; + }, + getOwnPropertyDescriptor: function(target, name) { + return { enumerable: true }; + } +} + +var proxy2 = Proxy.create(handler2); +var parent2 = { a: "delete", b: proxy2, c: "remove" }; +var expected2 = '{"a":"delete","b":{"a":"A","b":"B","c":"C"}}'; +assertEquals(expected2, JSON.stringify(parent2)); +parent2.c = "remove"; // Revert side effect. +assertEquals(expected2, JSON.stringify(parent2, undefined, 0)); + +// Proxy with a get function that uses the first argument. +var handler3 = { + get: function(target, name) { + if (name == 'valueOf') return function() { return "proxy" }; + return name + "(" + target + ")"; + }, + enumerate: function(target) { + return ['a', 'b', 'c']; + }, + getOwnPropertyDescriptor: function(target, name) { + return { enumerable: true }; + } +} + +var proxy3 = Proxy.create(handler3); +var parent3 = { x: 123, y: proxy3 } +testStringify('{"x":123,"y":{"a":"a(proxy)","b":"b(proxy)","c":"c(proxy)"}}', + parent3); + +// Empty proxy. +var handler4 = { + get: function(target, name) { + return 0; + }, + enumerate: function(target) { + return []; + }, + getOwnPropertyDescriptor: function(target, name) { + return { enumerable: false }; + } +} + +var proxy4 = Proxy.create(handler4); +testStringify('{}', proxy4); +testStringify('{"a":{}}', { a: proxy4 }); + +// Proxy that provides a toJSON function that uses this. +var handler5 = { + get: function(target, name) { + if (name == 'z') return 97000; + return function(key) { return key.charCodeAt(0) + this.z; }; + }, + enumerate: function(target) { + return ['toJSON', 'z']; + }, + getOwnPropertyDescriptor: function(target, name) { + return { enumerable: true }; + } +} + +var proxy5 = Proxy.create(handler5); +testStringify('{"a":97097}', { a: proxy5 }); + +// Proxy that provides a toJSON function that returns undefined. +var handler6 = { + get: function(target, name) { + return function(key) { return undefined; }; + }, + enumerate: function(target) { + return ['toJSON']; + }, + getOwnPropertyDescriptor: function(target, name) { + return { enumerable: true }; + } +} + +var proxy6 = Proxy.create(handler6); +testStringify('[1,null,true]', [1, proxy6, true]); +testStringify('{"a":1,"c":true}', {a: 1, b: proxy6, c: true}); + +// Object containing a proxy that changes the parent's properties. +var handler7 = { + get: function(target, name) { + delete parent7.a; + delete parent7.c; + parent7.e = "5"; + return name.toUpperCase(); + }, + enumerate: function(target) { + return ['a', 'b', 'c']; + }, + getOwnPropertyDescriptor: function(target, name) { + return { enumerable: true }; + } +} + +var proxy7 = Proxy.create(handler7); +var parent7 = { a: "1", b: proxy7, c: "3", d: "4" }; +assertEquals('{"a":"1","b":{"a":"A","b":"B","c":"C"},"d":"4"}', + JSON.stringify(parent7)); +assertEquals('{"b":{"a":"A","b":"B","c":"C"},"d":"4","e":"5"}', + JSON.stringify(parent7)); diff --git a/deps/v8/test/mjsunit/harmony/proxies.js b/deps/v8/test/mjsunit/harmony/proxies.js index 7170ffd9c..f68e3bd15 100644 --- a/deps/v8/test/mjsunit/harmony/proxies.js +++ b/deps/v8/test/mjsunit/harmony/proxies.js @@ -649,6 +649,11 @@ function TestSetForDerived2(create, trap) { TestSetForDerived( function(k) { + // TODO(yangguo): issue 2398 - throwing an error causes formatting of + // the message string, which can be observable through this handler. + // We ignore keys that occur when formatting the message string. + if (k == "toString" || k == "valueOf") return; + key = k; switch (k) { case "p_writable": return {writable: true, configurable: true} @@ -2289,7 +2294,6 @@ function TestConstructorWithProxyPrototype2(create, handler) { C.prototype = create(handler); var o = new C; - assertSame(C.prototype, o.__proto__); assertSame(C.prototype, Object.getPrototypeOf(o)); } diff --git a/deps/v8/test/mjsunit/harmony/symbols.js b/deps/v8/test/mjsunit/harmony/symbols.js new file mode 100644 index 000000000..cdc63628a --- /dev/null +++ b/deps/v8/test/mjsunit/harmony/symbols.js @@ -0,0 +1,244 @@ +// Copyright 2013 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: --harmony-symbols --harmony-collections +// Flags: --expose-gc --allow-natives-syntax + +var symbols = [] + +// Test different forms of constructor calls, all equivalent. +function TestNew() { + function IndirectSymbol() { return new Symbol } + function indirect() { return new IndirectSymbol() } + for (var i = 0; i < 10; ++i) { + symbols.push(new Symbol) + symbols.push(new Symbol()) + symbols.push(Symbol()) + symbols.push(indirect()) + } + %OptimizeFunctionOnNextCall(indirect) + indirect() // Call once before GC throws away type feedback. + gc() // Promote existing symbols and then allocate some more. + for (var i = 0; i < 10; ++i) { + symbols.push(new Symbol) + symbols.push(new Symbol()) + symbols.push(Symbol()) + symbols.push(indirect()) + } +} +TestNew() + + +function TestType() { + for (var i in symbols) { + assertTrue(%_IsSymbol(symbols[i])) + assertEquals("object", typeof symbols[i]) + assertTrue(typeof symbols[i] === "object") + assertEquals("[object Symbol]", Object.prototype.toString.call(symbols[i])) + } +} +TestType() + + +function TestEquality() { + // Every symbol should equal itself. + for (var i in symbols) { + assertSame(symbols[i], symbols[i]) + assertEquals(symbols[i], symbols[i]) + assertTrue(Object.is(symbols[i], symbols[i])) + assertTrue(symbols[i] === symbols[i]) + assertTrue(symbols[i] == symbols[i]) + } + + // All symbols should be distinct. + for (var i = 0; i < symbols.length; ++i) { + for (var j = i + 1; j < symbols.length; ++j) { + assertFalse(Object.is(symbols[i], symbols[j])) + assertFalse(symbols[i] === symbols[j]) + assertFalse(symbols[i] == symbols[j]) + } + } +} +TestEquality() + + +function TestGet() { + for (var i in symbols) { + assertEquals("[object Symbol]", symbols[i].toString()) + assertEquals(undefined, symbols[i].valueOf) + assertEquals(undefined, symbols[i].a) + assertEquals(undefined, symbols[i]["a" + "b"]) + assertEquals(undefined, symbols[i]["" + "1"]) + assertEquals(undefined, symbols[i][62]) + } +} +TestGet() + + +function TestSet() { + for (var i in symbols) { + symbols[i].toString = 0 + assertEquals("[object Symbol]", symbols[i].toString()) + symbols[i].a = 0 + assertEquals(undefined, symbols[i].a) + symbols[i]["a" + "b"] = 0 + assertEquals(undefined, symbols[i]["a" + "b"]) + symbols[i][62] = 0 + assertEquals(undefined, symbols[i][62]) + } +} +TestSet() + + +function TestCollections() { + var set = new Set + var map = new Map + var weakmap = new WeakMap + for (var i in symbols) { + set.add(symbols[i]) + map.set(symbols[i], i) + weakmap.set(symbols[i], i) + } + assertEquals(symbols.length, set.size) + assertEquals(symbols.length, map.size) + for (var i in symbols) { + assertTrue(set.has(symbols[i])) + assertTrue(map.has(symbols[i])) + assertTrue(weakmap.has(symbols[i])) + assertEquals(i, map.get(symbols[i])) + assertEquals(i, weakmap.get(symbols[i])) + } + for (var i in symbols) { + assertTrue(set.delete(symbols[i])) + assertTrue(map.delete(symbols[i])) + assertTrue(weakmap.delete(symbols[i])) + } + assertEquals(0, set.size) + assertEquals(0, map.size) +} +TestCollections() + + + +function TestKeySet(obj) { + // Set the even symbols via assignment. + for (var i = 0; i < symbols.length; i += 2) { + obj[symbols[i]] = i + } +} + + +function TestKeyDefine(obj) { + // Set the odd symbols via defineProperty (as non-enumerable). + for (var i = 1; i < symbols.length; i += 2) { + Object.defineProperty(obj, symbols[i], {value: i, configurable: true}) + } +} + + +function TestKeyGet(obj) { + var obj2 = Object.create(obj) + for (var i in symbols) { + assertEquals(i|0, obj[symbols[i]]) + assertEquals(i|0, obj2[symbols[i]]) + } +} + + +function TestKeyHas() { + for (var i in symbols) { + assertTrue(symbols[i] in obj) + assertTrue(Object.hasOwnProperty.call(obj, symbols[i])) + } +} + + +function TestKeyEnum(obj) { + for (var name in obj) { + assertFalse(%_IsSymbol(name)) + } +} + + +function TestKeyNames(obj) { + assertEquals(0, Object.keys(obj).length) + + var names = Object.getOwnPropertyNames(obj) + assertTrue(symbols.length <= names.length) + // TODO(rossberg): once we have iterators, the following would be: + // var expected = new Set(symbols) + var expected = new Set + for (var i = 0; i < symbols.length; ++i) expected.add(symbols[i]) + for (var i = 0; i < names.length; ++i) { + var name = names[i] + var asString = String(name) + if (asString !== name) { + assertEquals("[object Symbol]", asString) + assertTrue(expected.has(name)) + expected.delete(name) + } + } + assertEquals(0, expected.size) +} + + +function TestKeyDescriptor(obj) { + for (var i in symbols) { + var desc = Object.getOwnPropertyDescriptor(obj, symbols[i]); + assertEquals(i|0, desc.value) + assertTrue(desc.configurable) + assertEquals(i % 2 == 0, desc.writable) + assertEquals(i % 2 == 0, desc.enumerable) + assertEquals(i % 2 == 0, + Object.prototype.propertyIsEnumerable.call(obj, symbols[i])) + } +} + + +function TestKeyDelete(obj) { + for (var i in symbols) { + delete obj[symbols[i]] + } + for (var i in symbols) { + assertEquals(undefined, Object.getOwnPropertyDescriptor(obj, symbols[i])) + } +} + + +var objs = [{}, [], Object.create(null), Object(1), new Map, function(){}] + +for (var i in objs) { + var obj = objs[i] + TestKeySet(obj) + TestKeyDefine(obj) + TestKeyGet(obj) + TestKeyHas(obj) + TestKeyEnum(obj) + TestKeyNames(obj) + TestKeyDescriptor(obj) + TestKeyDelete(obj) +} diff --git a/deps/v8/test/mjsunit/json-parser-recursive.js b/deps/v8/test/mjsunit/json-parser-recursive.js new file mode 100644 index 000000000..1e00c83c8 --- /dev/null +++ b/deps/v8/test/mjsunit/json-parser-recursive.js @@ -0,0 +1,33 @@ +// Copyright 2012 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. + +var str = "[1]"; +for (var i = 0; i < 100000; i++) { + str = "[1," + str + "]"; +} + +assertThrows(function() { JSON.parse(str); }, RangeError); diff --git a/deps/v8/test/mjsunit/json-stringify-recursive.js b/deps/v8/test/mjsunit/json-stringify-recursive.js new file mode 100644 index 000000000..31aa0027c --- /dev/null +++ b/deps/v8/test/mjsunit/json-stringify-recursive.js @@ -0,0 +1,52 @@ +// Copyright 2012 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. + +var a = {}; +for (i = 0; i < 10000; i++) { + var current = {}; + current.a = a; + a = current; +} + +function rec(a,b,c,d,e,f,g,h,i,j,k,l,m,n) { + JSON.stringify(a); + rec(a,b,c,d,e,f,g,h,i,j,k,l,m,n); +} + +assertThrows(function() { rec(1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4) }, + RangeError); + + +var depth = 10000; +var deepArray = []; +for (var i = 0; i < depth; i++) deepArray = [deepArray]; +assertThrows(function() { JSON.stringify(deepArray); }, RangeError); + + +var deepObject = {}; +for (var i = 0; i < depth; i++) deepObject = { next: deepObject }; +assertThrows(function() { JSON.stringify(deepObject); }, RangeError); diff --git a/deps/v8/test/mjsunit/json.js b/deps/v8/test/mjsunit/json.js index 54fa1854f..79826dbef 100644 --- a/deps/v8/test/mjsunit/json.js +++ b/deps/v8/test/mjsunit/json.js @@ -257,6 +257,42 @@ assertEquals("[1,2,[3,[4],5],6,7]", assertEquals("[2,4,[6,[8],10],12,14]", JSON.stringify([1, 2, [3, [4], 5], 6, 7], DoubleNumbers)); assertEquals('["a","ab","abc"]', JSON.stringify(["a","ab","abc"])); +assertEquals('{"a":1,"c":true}', + JSON.stringify({ a : 1, + b : function() { 1 }, + c : true, + d : function() { 2 } })); +assertEquals('[1,null,true,null]', + JSON.stringify([1, function() { 1 }, true, function() { 2 }])); +assertEquals('"toJSON 123"', + JSON.stringify({ toJSON : function() { return 'toJSON 123'; } })); +assertEquals('{"a":321}', + JSON.stringify({ a : { toJSON : function() { return 321; } } })); +var counter = 0; +assertEquals('{"getter":123}', + JSON.stringify({ get getter() { counter++; return 123; } })); +assertEquals(1, counter); +assertEquals('{"a":"abc","b":"\u1234bc"}', + JSON.stringify({ a : "abc", b : "\u1234bc" })); + + +var a = { a : 1, b : 2 }; +delete a.a; +assertEquals('{"b":2}', JSON.stringify(a)); + +var b = {}; +b.__proto__ = { toJSON : function() { return 321;} }; +assertEquals("321", JSON.stringify(b)); + +var array = [""]; +var expected = '""'; +for (var i = 0; i < 10000; i++) { + array.push(""); + expected = '"",' + expected; +} +expected = '[' + expected + ']'; +assertEquals(expected, JSON.stringify(array)); + var circular = [1, 2, 3]; circular[2] = circular; @@ -417,16 +453,23 @@ falseNum.__proto__ = Number.prototype; falseNum.toString = function() { return 42; }; assertEquals('"42"', JSON.stringify(falseNum)); -// We don't currently allow plain properties called __proto__ in JSON -// objects in JSON.parse. Instead we read them as we would JS object -// literals. If we change that, this test should change with it. -// -// Parse a non-object value as __proto__. This must not create a -// __proto__ property different from the original, and should not -// change the original. -var o = JSON.parse('{"__proto__":5}'); -assertEquals(Object.prototype, o.__proto__); // __proto__ isn't changed. -assertEquals(0, Object.keys(o).length); // __proto__ isn't added as enumerable. +// Parse an object value as __proto__. +var o1 = JSON.parse('{"__proto__":[]}'); +assertEquals([], o1.__proto__); +assertEquals(["__proto__"], Object.keys(o1)); +assertEquals([], Object.getOwnPropertyDescriptor(o1, "__proto__").value); +assertEquals(["__proto__"], Object.getOwnPropertyNames(o1)); +assertTrue(o1.hasOwnProperty("__proto__")); +assertTrue(Object.prototype.isPrototypeOf(o1)); + +// Parse a non-object value as __proto__. +var o2 = JSON.parse('{"__proto__":5}'); +assertEquals(5, o2.__proto__); +assertEquals(["__proto__"], Object.keys(o2)); +assertEquals(5, Object.getOwnPropertyDescriptor(o2, "__proto__").value); +assertEquals(["__proto__"], Object.getOwnPropertyNames(o2)); +assertTrue(o2.hasOwnProperty("__proto__")); +assertTrue(Object.prototype.isPrototypeOf(o2)); var json = '{"stuff before slash\\\\stuff after slash":"whatever"}'; assertEquals(json, JSON.stringify(JSON.parse(json))); diff --git a/deps/v8/test/mjsunit/json2.js b/deps/v8/test/mjsunit/json2.js new file mode 100644 index 000000000..4c0b8f58c --- /dev/null +++ b/deps/v8/test/mjsunit/json2.js @@ -0,0 +1,153 @@ +// Copyright 2012 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 + +// Test JSON.stringify on the global object. +var a = 12345; +assertTrue(JSON.stringify(this).indexOf('"a":12345') > 0); + +// Test JSON.stringify of array in dictionary mode. +var array_1 = []; +var array_2 = []; +array_1[100000] = 1; +array_2[100000] = function() { return 1; }; +var nulls = ""; +for (var i = 0; i < 100000; i++) { + nulls += 'null,'; +} +expected_1 = '[' + nulls + '1]'; +expected_2 = '[' + nulls + 'null]'; +assertEquals(expected_1, JSON.stringify(array_1)); +assertEquals(expected_2, JSON.stringify(array_2)); + +// Test JSValue with custom prototype. +var num_wrapper = Object(42); +num_wrapper.__proto__ = { __proto__: null, + toString: function() { return true; } }; +assertEquals('1', JSON.stringify(num_wrapper)); + +var str_wrapper = Object('2'); +str_wrapper.__proto__ = { __proto__: null, + toString: function() { return true; } }; +assertEquals('"true"', JSON.stringify(str_wrapper)); + +var bool_wrapper = Object(false); +bool_wrapper.__proto__ = { __proto__: null, + toString: function() { return true; } }; +// Note that toString function is not evaluated here! +assertEquals('false', JSON.stringify(bool_wrapper)); + +// Test getters. +var counter = 0; +var getter_obj = { get getter() { + counter++; + return 123; + } }; +assertEquals('{"getter":123}', JSON.stringify(getter_obj)); +assertEquals(1, counter); + +// Test toJSON function. +var tojson_obj = { toJSON: function() { + counter++; + return [1, 2]; + }, + a: 1}; +assertEquals('[1,2]', JSON.stringify(tojson_obj)); +assertEquals(2, counter); + +// Test that we don't recursively look for the toJSON function. +var tojson_proto_obj = { a: 'fail' }; +tojson_proto_obj.__proto__ = { toJSON: function() { + counter++; + return tojson_obj; + } }; +assertEquals('{"a":1}', JSON.stringify(tojson_proto_obj)); + +// Test toJSON produced by a getter. +var tojson_via_getter = { get toJSON() { + return function(x) { + counter++; + return 321; + }; + }, + a: 1 }; +assertEquals('321', JSON.stringify(tojson_via_getter)); + +// Test toJSON with key. +tojson_obj = { toJSON: function(key) { return key + key; } }; +var tojson_with_key_1 = { a: tojson_obj, b: tojson_obj }; +assertEquals('{"a":"aa","b":"bb"}', JSON.stringify(tojson_with_key_1)); +var tojson_with_key_2 = [ tojson_obj, tojson_obj ]; +assertEquals('["00","11"]', JSON.stringify(tojson_with_key_2)); + +// Test toJSON with exception. +var tojson_ex = { toJSON: function(key) { throw "123" } }; +assertThrows(function() { JSON.stringify(tojson_ex); }); + +// Test toJSON with access to this. +var obj = { toJSON: function(key) { return this.a + key; }, a: "x" }; +assertEquals('{"y":"xy"}', JSON.stringify({y: obj})); + +// Test holes in arrays. +var fast_smi = [1, 2, 3, 4]; +fast_smi.__proto__ = [7, 7, 7, 7]; +delete fast_smi[2]; +assertTrue(%HasFastSmiElements(fast_smi)); +assertEquals("[1,2,7,4]", JSON.stringify(fast_smi)); + +var fast_double = [1.1, 2, 3, 4]; +fast_double.__proto__ = [7, 7, 7, 7]; + +delete fast_double[2]; +assertTrue(%HasFastDoubleElements(fast_double)); +assertEquals("[1.1,2,7,4]", JSON.stringify(fast_double)); + +var fast_obj = [1, 2, {}, {}]; +fast_obj.__proto__ = [7, 7, 7, 7]; + +delete fast_obj[2]; +assertTrue(%HasFastObjectElements(fast_obj)); +assertEquals("[1,2,7,{}]", JSON.stringify(fast_obj)); + +var getter_side_effect = { a: 1, + get b() { + delete this.a; + delete this.c; + this.e = 5; + return 2; + }, + c: 3, + d: 4 }; +assertEquals('{"a":1,"b":2,"d":4}', JSON.stringify(getter_side_effect)); +assertEquals('{"b":2,"d":4,"e":5}', JSON.stringify(getter_side_effect)); + +var non_enum = {}; +non_enum.a = 1; +Object.defineProperty(non_enum, "b", { value: 2, enumerable: false }); +non_enum.c = 3; +assertEquals('{"a":1,"c":3}', JSON.stringify(non_enum)); diff --git a/deps/v8/test/mjsunit/manual-parallel-recompile.js b/deps/v8/test/mjsunit/manual-parallel-recompile.js new file mode 100644 index 000000000..8d660e047 --- /dev/null +++ b/deps/v8/test/mjsunit/manual-parallel-recompile.js @@ -0,0 +1,62 @@ +// Copyright 2012 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 --expose-gc --parallel-recompilation + +function assertUnoptimized(fun) { + assertTrue(%GetOptimizationStatus(fun) != 1); +} + +function f(x) { + var xx = x * x; + var xxstr = xx.toString(); + return xxstr.length; +} + +function g(x) { + var xxx = Math.sqrt(x) | 0; + var xxxstr = xxx.toString(); + return xxxstr.length; +} + +function k(x) { + return x * x; +} + +f(g(1)); +assertUnoptimized(f); +assertUnoptimized(g); + +%OptimizeFunctionOnNextCall(f, "parallel"); +%OptimizeFunctionOnNextCall(g, "parallel"); +f(g(2)); + +assertUnoptimized(f); +assertUnoptimized(g); + +%WaitUntilOptimized(f); +%WaitUntilOptimized(g); diff --git a/deps/v8/test/mjsunit/math-exp-precision.js b/deps/v8/test/mjsunit/math-exp-precision.js new file mode 100644 index 000000000..ace7edc58 --- /dev/null +++ b/deps/v8/test/mjsunit/math-exp-precision.js @@ -0,0 +1,64 @@ +// Copyright 2012 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. + +// Tests that the --fast-math implementation of Math.exp() has +// reasonable precision. + +function exp(x) { + return Math.exp(x); +} + +var first_call_result = exp(Math.PI); +var second_call_result = exp(Math.PI); + +function assertAlmostEquals(expected, actual, x) { + if (expected == 0 && actual == 0) return; // OK + if (expected == Number.POSITIVE_INFINITY && + actual == Number.POSITIVE_INFINITY) { + return; // OK + } + relative_diff = Math.abs(expected/actual - 1); + assertTrue(relative_diff < 1e-12, "relative difference of " + relative_diff + + " for input " + x); +} + +var increment = Math.PI / 35; // Roughly 0.1, but we want to try many + // different mantissae. +for (var x = -708; x < 710; x += increment) { + var ex = exp(x); + var reference = Math.pow(Math.E, x); + assertAlmostEquals(reference, ex, x); + if (ex > 0 && isFinite(ex)) { + var back = Math.log(ex); + assertAlmostEquals(x, back, x + " (backwards)"); + } +} + +// Make sure optimizing the function does not alter the result. +var last_call_result = exp(Math.PI); +assertEquals(first_call_result, second_call_result); +assertEquals(first_call_result, last_call_result); diff --git a/deps/v8/test/mjsunit/math-floor-of-div-minus-zero.js b/deps/v8/test/mjsunit/math-floor-of-div-minus-zero.js index 274349084..734916585 100644 --- a/deps/v8/test/mjsunit/math-floor-of-div-minus-zero.js +++ b/deps/v8/test/mjsunit/math-floor-of-div-minus-zero.js @@ -35,6 +35,7 @@ function test_div_no_deopt_minus_zero() { } test_div_no_deopt_minus_zero(); +test_div_no_deopt_minus_zero(); %OptimizeFunctionOnNextCall(test_div_no_deopt_minus_zero); test_div_no_deopt_minus_zero(); assertTrue(2 != %GetOptimizationStatus(test_div_no_deopt_minus_zero)); diff --git a/deps/v8/test/mjsunit/math-floor-of-div-nosudiv.js b/deps/v8/test/mjsunit/math-floor-of-div-nosudiv.js new file mode 100644 index 000000000..3ce966cb2 --- /dev/null +++ b/deps/v8/test/mjsunit/math-floor-of-div-nosudiv.js @@ -0,0 +1,288 @@ +// Copyright 2012 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 --nouse_inlining --noenable_sudiv + +// Use this function as reference. Make sure it is not inlined. +function div(a, b) { + return a / b; +} + +var limit = 0x1000000; +var exhaustive_limit = 100; +var step = 10; +var values = [0x10000001, + 0x12345678, + -0x789abcdf, // 0x87654321 + 0x01234567, + 0x76543210, + -0x80000000, // 0x80000000 + 0x7fffffff, + -0x0fffffff, // 0xf0000001 + 0x00000010, + -0x01000000 // 0xff000000 + ]; + +function test_div() { + var c = 0; + for (var k = 0; k <= limit; k++) { + if (k > exhaustive_limit) { c += step; k += c; } + assertEquals(Math.floor(div(k, 1)), Math.floor(k / 1)); + assertEquals(Math.floor(div(k, -1)), Math.floor(k / -1)); + assertEquals(Math.floor(div(k, 2)), Math.floor(k / 2)); + assertEquals(Math.floor(div(k, -2)), Math.floor(k / -2)); + assertEquals(Math.floor(div(k, 3)), Math.floor(k / 3)); + assertEquals(Math.floor(div(k, -3)), Math.floor(k / -3)); + assertEquals(Math.floor(div(k, 4)), Math.floor(k / 4)); + assertEquals(Math.floor(div(k, -4)), Math.floor(k / -4)); + assertEquals(Math.floor(div(k, 5)), Math.floor(k / 5)); + assertEquals(Math.floor(div(k, -5)), Math.floor(k / -5)); + assertEquals(Math.floor(div(k, 6)), Math.floor(k / 6)); + assertEquals(Math.floor(div(k, -6)), Math.floor(k / -6)); + assertEquals(Math.floor(div(k, 7)), Math.floor(k / 7)); + assertEquals(Math.floor(div(k, -7)), Math.floor(k / -7)); + assertEquals(Math.floor(div(k, 8)), Math.floor(k / 8)); + assertEquals(Math.floor(div(k, -8)), Math.floor(k / -8)); + assertEquals(Math.floor(div(k, 9)), Math.floor(k / 9)); + assertEquals(Math.floor(div(k, -9)), Math.floor(k / -9)); + assertEquals(Math.floor(div(k, 10)), Math.floor(k / 10)); + assertEquals(Math.floor(div(k, -10)), Math.floor(k / -10)); + assertEquals(Math.floor(div(k, 11)), Math.floor(k / 11)); + assertEquals(Math.floor(div(k, -11)), Math.floor(k / -11)); + assertEquals(Math.floor(div(k, 12)), Math.floor(k / 12)); + assertEquals(Math.floor(div(k, -12)), Math.floor(k / -12)); + assertEquals(Math.floor(div(k, 13)), Math.floor(k / 13)); + assertEquals(Math.floor(div(k, -13)), Math.floor(k / -13)); + assertEquals(Math.floor(div(k, 14)), Math.floor(k / 14)); + assertEquals(Math.floor(div(k, -14)), Math.floor(k / -14)); + assertEquals(Math.floor(div(k, 15)), Math.floor(k / 15)); + assertEquals(Math.floor(div(k, -15)), Math.floor(k / -15)); + assertEquals(Math.floor(div(k, 16)), Math.floor(k / 16)); + assertEquals(Math.floor(div(k, -16)), Math.floor(k / -16)); + assertEquals(Math.floor(div(k, 17)), Math.floor(k / 17)); + assertEquals(Math.floor(div(k, -17)), Math.floor(k / -17)); + assertEquals(Math.floor(div(k, 18)), Math.floor(k / 18)); + assertEquals(Math.floor(div(k, -18)), Math.floor(k / -18)); + assertEquals(Math.floor(div(k, 19)), Math.floor(k / 19)); + assertEquals(Math.floor(div(k, -19)), Math.floor(k / -19)); + assertEquals(Math.floor(div(k, 20)), Math.floor(k / 20)); + assertEquals(Math.floor(div(k, -20)), Math.floor(k / -20)); + assertEquals(Math.floor(div(k, 21)), Math.floor(k / 21)); + assertEquals(Math.floor(div(k, -21)), Math.floor(k / -21)); + assertEquals(Math.floor(div(k, 22)), Math.floor(k / 22)); + assertEquals(Math.floor(div(k, -22)), Math.floor(k / -22)); + assertEquals(Math.floor(div(k, 23)), Math.floor(k / 23)); + assertEquals(Math.floor(div(k, -23)), Math.floor(k / -23)); + assertEquals(Math.floor(div(k, 24)), Math.floor(k / 24)); + assertEquals(Math.floor(div(k, -24)), Math.floor(k / -24)); + assertEquals(Math.floor(div(k, 25)), Math.floor(k / 25)); + assertEquals(Math.floor(div(k, -25)), Math.floor(k / -25)); + assertEquals(Math.floor(div(k, 125)), Math.floor(k / 125)); + assertEquals(Math.floor(div(k, -125)), Math.floor(k / -125)); + assertEquals(Math.floor(div(k, 625)), Math.floor(k / 625)); + assertEquals(Math.floor(div(k, -625)), Math.floor(k / -625)); + } + c = 0; + for (var k = 0; k <= limit; k++) { + if (k > exhaustive_limit) { c += step; k += c; } + assertEquals(Math.floor(div(-k, 1)), Math.floor(-k / 1)); + assertEquals(Math.floor(div(-k, -1)), Math.floor(-k / -1)); + assertEquals(Math.floor(div(-k, 2)), Math.floor(-k / 2)); + assertEquals(Math.floor(div(-k, -2)), Math.floor(-k / -2)); + assertEquals(Math.floor(div(-k, 3)), Math.floor(-k / 3)); + assertEquals(Math.floor(div(-k, -3)), Math.floor(-k / -3)); + assertEquals(Math.floor(div(-k, 4)), Math.floor(-k / 4)); + assertEquals(Math.floor(div(-k, -4)), Math.floor(-k / -4)); + assertEquals(Math.floor(div(-k, 5)), Math.floor(-k / 5)); + assertEquals(Math.floor(div(-k, -5)), Math.floor(-k / -5)); + assertEquals(Math.floor(div(-k, 6)), Math.floor(-k / 6)); + assertEquals(Math.floor(div(-k, -6)), Math.floor(-k / -6)); + assertEquals(Math.floor(div(-k, 7)), Math.floor(-k / 7)); + assertEquals(Math.floor(div(-k, -7)), Math.floor(-k / -7)); + assertEquals(Math.floor(div(-k, 8)), Math.floor(-k / 8)); + assertEquals(Math.floor(div(-k, -8)), Math.floor(-k / -8)); + assertEquals(Math.floor(div(-k, 9)), Math.floor(-k / 9)); + assertEquals(Math.floor(div(-k, -9)), Math.floor(-k / -9)); + assertEquals(Math.floor(div(-k, 10)), Math.floor(-k / 10)); + assertEquals(Math.floor(div(-k, -10)), Math.floor(-k / -10)); + assertEquals(Math.floor(div(-k, 11)), Math.floor(-k / 11)); + assertEquals(Math.floor(div(-k, -11)), Math.floor(-k / -11)); + assertEquals(Math.floor(div(-k, 12)), Math.floor(-k / 12)); + assertEquals(Math.floor(div(-k, -12)), Math.floor(-k / -12)); + assertEquals(Math.floor(div(-k, 13)), Math.floor(-k / 13)); + assertEquals(Math.floor(div(-k, -13)), Math.floor(-k / -13)); + assertEquals(Math.floor(div(-k, 14)), Math.floor(-k / 14)); + assertEquals(Math.floor(div(-k, -14)), Math.floor(-k / -14)); + assertEquals(Math.floor(div(-k, 15)), Math.floor(-k / 15)); + assertEquals(Math.floor(div(-k, -15)), Math.floor(-k / -15)); + assertEquals(Math.floor(div(-k, 16)), Math.floor(-k / 16)); + assertEquals(Math.floor(div(-k, -16)), Math.floor(-k / -16)); + assertEquals(Math.floor(div(-k, 17)), Math.floor(-k / 17)); + assertEquals(Math.floor(div(-k, -17)), Math.floor(-k / -17)); + assertEquals(Math.floor(div(-k, 18)), Math.floor(-k / 18)); + assertEquals(Math.floor(div(-k, -18)), Math.floor(-k / -18)); + assertEquals(Math.floor(div(-k, 19)), Math.floor(-k / 19)); + assertEquals(Math.floor(div(-k, -19)), Math.floor(-k / -19)); + assertEquals(Math.floor(div(-k, 20)), Math.floor(-k / 20)); + assertEquals(Math.floor(div(-k, -20)), Math.floor(-k / -20)); + assertEquals(Math.floor(div(-k, 21)), Math.floor(-k / 21)); + assertEquals(Math.floor(div(-k, -21)), Math.floor(-k / -21)); + assertEquals(Math.floor(div(-k, 22)), Math.floor(-k / 22)); + assertEquals(Math.floor(div(-k, -22)), Math.floor(-k / -22)); + assertEquals(Math.floor(div(-k, 23)), Math.floor(-k / 23)); + assertEquals(Math.floor(div(-k, -23)), Math.floor(-k / -23)); + assertEquals(Math.floor(div(-k, 24)), Math.floor(-k / 24)); + assertEquals(Math.floor(div(-k, -24)), Math.floor(-k / -24)); + assertEquals(Math.floor(div(-k, 25)), Math.floor(-k / 25)); + assertEquals(Math.floor(div(-k, -25)), Math.floor(-k / -25)); + assertEquals(Math.floor(div(-k, 125)), Math.floor(-k / 125)); + assertEquals(Math.floor(div(-k, -125)), Math.floor(-k / -125)); + assertEquals(Math.floor(div(-k, 625)), Math.floor(-k / 625)); + assertEquals(Math.floor(div(-k, -625)), Math.floor(-k / -625)); + } + // Test for edge cases. + // Use (values[key] | 0) to force the integer type. + for (var i = 0; i < values.length; i++) { + for (var j = 0; j < values.length; j++) { + assertEquals(Math.floor(div((values[i] | 0), (values[j] | 0))), + Math.floor((values[i] | 0) / (values[j] | 0))); + assertEquals(Math.floor(div(-(values[i] | 0), (values[j] | 0))), + Math.floor(-(values[i] | 0) / (values[j] | 0))); + assertEquals(Math.floor(div((values[i] | 0), -(values[j] | 0))), + Math.floor((values[i] | 0) / -(values[j] | 0))); + assertEquals(Math.floor(div(-(values[i] | 0), -(values[j] | 0))), + Math.floor(-(values[i] | 0) / -(values[j] | 0))); + } + } +} + +test_div(); +%OptimizeFunctionOnNextCall(test_div); +test_div(); + +// Test for flooring correctness. +var values2 = [1, 3, 10, 99, 100, 101, 0x7fffffff]; +function test_div2() { + for (var i = 0; i < values2.length; i++) { + for (var j = 0; j < values2.length; j++) { + assertEquals(Math.floor(div((values2[i] | 0), (values2[j] | 0))), + Math.floor((values2[i] | 0) / (values2[j] | 0))); + assertEquals(Math.floor(div(-(values2[i] | 0), (values2[j] | 0))), + Math.floor(-(values2[i] | 0) / (values2[j] | 0))); + assertEquals(Math.floor(div((values2[i] | 0), -(values2[j] | 0))), + Math.floor((values2[i] | 0) / -(values2[j] | 0))); + assertEquals(Math.floor(div(-(values2[i] | 0), -(values2[j] | 0))), + Math.floor(-(values2[i] | 0) / -(values2[j] | 0))); + } + } +} + +test_div2(); +%OptimizeFunctionOnNextCall(test_div2); +test_div2(); + + +// Test for negative zero, overflow and division by 0. +// Separate the tests to prevent deoptimizations from making the other optimized +// test unreachable. + +// We box the value in an array to avoid constant propagation. +var neg_one_in_array = [-1]; +var zero_in_array = [0]; +var min_int_in_array = [-2147483648]; + +// Test for dividing by constant. +function IsNegativeZero(x) { + assertTrue(x == 0); // Is 0 or -0. + var y = 1 / x; + assertFalse(isFinite(y)); + return y < 0; +} + +function test_div_deopt_minus_zero() { + for (var i = 0; i < 2; ++i) { + assertTrue(IsNegativeZero(Math.floor((zero_in_array[0] | 0) / -1))); + } +} + +function test_div_deopt_overflow() { + for (var i = 0; i < 2; ++i) { + // We use '| 0' to force the representation to int32. + assertEquals(-min_int_in_array[0], + Math.floor((min_int_in_array[0] | 0) / -1)); + } +} + +function test_div_deopt_div_by_zero() { + for (var i = 0; i < 2; ++i) { + assertEquals(div(i, 0), + Math.floor(i / 0)); + } +} + +test_div_deopt_minus_zero(); +test_div_deopt_overflow(); +test_div_deopt_div_by_zero(); +%OptimizeFunctionOnNextCall(test_div_deopt_minus_zero); +%OptimizeFunctionOnNextCall(test_div_deopt_overflow); +%OptimizeFunctionOnNextCall(test_div_deopt_div_by_zero); +test_div_deopt_minus_zero(); +test_div_deopt_overflow(); +test_div_deopt_div_by_zero(); + +// Test for dividing by variable. +function test_div_deopt_minus_zero_v() { + for (var i = 0; i < 2; ++i) { + assertTrue(IsNegativeZero(Math.floor((zero_in_array[0] | 0) / + neg_one_in_array[0]))); + } +} + +function test_div_deopt_overflow_v() { + for (var i = 0; i < 2; ++i) { + // We use '| 0' to force the representation to int32. + assertEquals(-min_int_in_array[0], + Math.floor((min_int_in_array[0] | 0) / neg_one_in_array[0])); + } +} + +function test_div_deopt_div_by_zero_v() { + for (var i = 0; i < 2; ++i) { + assertEquals(div(i, 0), + Math.floor(i / zero_in_array[0])); + } +} + +test_div_deopt_minus_zero_v(); +test_div_deopt_overflow_v(); +test_div_deopt_div_by_zero_v(); +%OptimizeFunctionOnNextCall(test_div_deopt_minus_zero_v); +%OptimizeFunctionOnNextCall(test_div_deopt_overflow_v); +%OptimizeFunctionOnNextCall(test_div_deopt_div_by_zero_v); +test_div_deopt_minus_zero_v(); +test_div_deopt_overflow_v(); +test_div_deopt_div_by_zero_v(); diff --git a/deps/v8/test/mjsunit/math-floor-of-div.js b/deps/v8/test/mjsunit/math-floor-of-div.js index e917182c7..d528b8510 100644 --- a/deps/v8/test/mjsunit/math-floor-of-div.js +++ b/deps/v8/test/mjsunit/math-floor-of-div.js @@ -25,7 +25,7 @@ // (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 --nouse_inlining +// Flags: --allow-natives-syntax --nouse_inlining --enable_sudiv // Use this function as reference. Make sure it is not inlined. function div(a, b) { @@ -184,10 +184,38 @@ test_div(); %OptimizeFunctionOnNextCall(test_div); test_div(); -// Test for negative zero and overflow. +// Test for flooring correctness. +var values2 = [1, 3, 10, 99, 100, 101, 0x7fffffff]; +function test_div2() { + for (var i = 0; i < values2.length; i++) { + for (var j = 0; j < values2.length; j++) { + assertEquals(Math.floor(div((values2[i] | 0), (values2[j] | 0))), + Math.floor((values2[i] | 0) / (values2[j] | 0))); + assertEquals(Math.floor(div(-(values2[i] | 0), (values2[j] | 0))), + Math.floor(-(values2[i] | 0) / (values2[j] | 0))); + assertEquals(Math.floor(div((values2[i] | 0), -(values2[j] | 0))), + Math.floor((values2[i] | 0) / -(values2[j] | 0))); + assertEquals(Math.floor(div(-(values2[i] | 0), -(values2[j] | 0))), + Math.floor(-(values2[i] | 0) / -(values2[j] | 0))); + } + } +} + +test_div2(); +%OptimizeFunctionOnNextCall(test_div2); +test_div2(); + + +// Test for negative zero, overflow and division by 0. // Separate the tests to prevent deoptimizations from making the other optimized // test unreachable. +// We box the value in an array to avoid constant propagation. +var neg_one_in_array = [-1]; +var zero_in_array = [0]; +var min_int_in_array = [-2147483648]; + +// Test for dividing by constant. function IsNegativeZero(x) { assertTrue(x == 0); // Is 0 or -0. var y = 1 / x; @@ -196,21 +224,65 @@ function IsNegativeZero(x) { } function test_div_deopt_minus_zero() { - var zero_in_array = [0]; - assertTrue(IsNegativeZero(Math.floor((zero_in_array[0] | 0) / -1))); + for (var i = 0; i < 2; ++i) { + assertTrue(IsNegativeZero(Math.floor((zero_in_array[0] | 0) / -1))); + } } function test_div_deopt_overflow() { - // We box the value in an array to avoid constant propagation. - var min_int_in_array = [-2147483648]; - // We use '| 0' to force the representation to int32. - assertEquals(-min_int_in_array[0], - Math.floor((min_int_in_array[0] | 0) / -1)); + for (var i = 0; i < 2; ++i) { + // We use '| 0' to force the representation to int32. + assertEquals(-min_int_in_array[0], + Math.floor((min_int_in_array[0] | 0) / -1)); + } +} + +function test_div_deopt_div_by_zero() { + for (var i = 0; i < 2; ++i) { + assertEquals(div(i, 0), + Math.floor(i / 0)); + } } test_div_deopt_minus_zero(); test_div_deopt_overflow(); +test_div_deopt_div_by_zero(); %OptimizeFunctionOnNextCall(test_div_deopt_minus_zero); %OptimizeFunctionOnNextCall(test_div_deopt_overflow); +%OptimizeFunctionOnNextCall(test_div_deopt_div_by_zero); test_div_deopt_minus_zero(); test_div_deopt_overflow(); +test_div_deopt_div_by_zero(); + +// Test for dividing by variable. +function test_div_deopt_minus_zero_v() { + for (var i = 0; i < 2; ++i) { + assertTrue(IsNegativeZero(Math.floor((zero_in_array[0] | 0) / + neg_one_in_array[0]))); + } +} + +function test_div_deopt_overflow_v() { + for (var i = 0; i < 2; ++i) { + // We use '| 0' to force the representation to int32. + assertEquals(-min_int_in_array[0], + Math.floor((min_int_in_array[0] | 0) / neg_one_in_array[0])); + } +} + +function test_div_deopt_div_by_zero_v() { + for (var i = 0; i < 2; ++i) { + assertEquals(div(i, 0), + Math.floor(i / zero_in_array[0])); + } +} + +test_div_deopt_minus_zero_v(); +test_div_deopt_overflow_v(); +test_div_deopt_div_by_zero_v(); +%OptimizeFunctionOnNextCall(test_div_deopt_minus_zero_v); +%OptimizeFunctionOnNextCall(test_div_deopt_overflow_v); +%OptimizeFunctionOnNextCall(test_div_deopt_div_by_zero_v); +test_div_deopt_minus_zero_v(); +test_div_deopt_overflow_v(); +test_div_deopt_div_by_zero_v(); diff --git a/deps/v8/test/mjsunit/mjsunit.status b/deps/v8/test/mjsunit/mjsunit.status index 037093bf7..1c3602c40 100644 --- a/deps/v8/test/mjsunit/mjsunit.status +++ b/deps/v8/test/mjsunit/mjsunit.status @@ -40,10 +40,14 @@ regress/regress-524: SKIP # Skip long running test in debug and allow it to timeout in release mode. # regress/regress-524: (PASS || TIMEOUT), SKIP if $mode == debug +# Deferred stack trace formatting is temporarily disabled. +stack-traces-gc: PASS || FAIL + ############################################################################## # Too slow in debug mode with --stress-opt compiler/regress-stacktrace-methods: PASS, SKIP if $mode == debug compiler/regress-funcaller: PASS, SKIP if $mode == debug +regress/regress-2318: PASS, SKIP if $mode == debug regress/regress-create-exception: PASS, SKIP if $mode == debug ############################################################################## @@ -60,6 +64,16 @@ array-constructor: PASS || TIMEOUT unicode-case-overoptimization: PASS, TIMEOUT if ($arch == arm || $arch == android_arm || $arch == mipsel) ############################################################################## +# This test expects to reach a certain recursion depth, which may not work +# for debug mode. +json-recursive: PASS, (PASS || FAIL) if $mode == debug + +############################################################################## +# Skip long running test that times out in debug mode or goes OOM on android. +regress/regress-crbug-160010: PASS, SKIP if ($mode == debug || $arch == android_arm) +generated-transition-stub: PASS, SKIP if $mode == debug + +############################################################################## # This test sets the umask on a per-process basis and hence cannot be # used in multi-threaded runs. # On android there is no /tmp directory. @@ -67,6 +81,10 @@ d8-os: PASS, SKIP if ($isolates || $arch == android_arm || $arch == android_ia32 tools/tickprocessor: PASS, SKIP if ($arch == android_arm || $arch == android_ia32) ############################################################################## +# Long running test that reproduces memory leak and should be run manually. +regress/regress-2073: SKIP + +############################################################################## [ $arch == arm || $arch == android_arm ] # Slow tests which times out in debug mode. diff --git a/deps/v8/test/mjsunit/new-function.js b/deps/v8/test/mjsunit/new-function.js index 9e8cc2776..794bd765e 100644 --- a/deps/v8/test/mjsunit/new-function.js +++ b/deps/v8/test/mjsunit/new-function.js @@ -25,10 +25,10 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -var x; +var x = 0; try { Function("}), x = this, (function() {"); } catch(e) { print("Caught " + e); } -assertTrue(x == "[object global]"); +assertTrue(x === 0); diff --git a/deps/v8/test/mjsunit/object-get-own-property-names.js b/deps/v8/test/mjsunit/object-get-own-property-names.js index 33aa85ef1..64607c6b9 100644 --- a/deps/v8/test/mjsunit/object-get-own-property-names.js +++ b/deps/v8/test/mjsunit/object-get-own-property-names.js @@ -77,6 +77,16 @@ propertyNames.sort(); assertEquals(1, propertyNames.length); assertEquals("getter", propertyNames[0]); +// Check that implementation does not access Array.prototype. +var savedConcat = Array.prototype.concat; +Array.prototype.concat = function() { return []; } +propertyNames = Object.getOwnPropertyNames({0: 'foo', bar: 'baz'}); +assertEquals(2, propertyNames.length); +assertEquals('0', propertyNames[0]); +assertEquals('bar', propertyNames[1]); +assertSame(Array.prototype, propertyNames.__proto__); +Array.prototype.concat = savedConcat; + try { Object.getOwnPropertyNames(4); assertTrue(false); diff --git a/deps/v8/test/mjsunit/parallel-optimize-disabled.js b/deps/v8/test/mjsunit/parallel-optimize-disabled.js new file mode 100644 index 000000000..86b375c53 --- /dev/null +++ b/deps/v8/test/mjsunit/parallel-optimize-disabled.js @@ -0,0 +1,46 @@ +// Copyright 2013 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: --nodead-code-elimination --parallel-recompilation +// Flags: --allow-natives-syntax + +function g() { // g() cannot be optimized. + const x = 1; + x++; +} + +function f(x) { + g(); +} + +f(); +f(); +%OptimizeFunctionOnNextCall(f); +%OptimizeFunctionOnNextCall(g, "parallel"); +f(0); // g() is disabled for optimization on inlining attempt. +// Attempt to optimize g() should not run into any assertion. +%WaitUntilOptimized(g); diff --git a/deps/v8/test/mjsunit/regexp-capture-3.js b/deps/v8/test/mjsunit/regexp-capture-3.js index b676f01c2..4c27ea454 100755 --- a/deps/v8/test/mjsunit/regexp-capture-3.js +++ b/deps/v8/test/mjsunit/regexp-capture-3.js @@ -165,23 +165,22 @@ function NoHang(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/)); diff --git a/deps/v8/test/mjsunit/regress/regress-1122.js b/deps/v8/test/mjsunit/regress/regress-1122.js index 815511d18..8f0bfb674 100644 --- a/deps/v8/test/mjsunit/regress/regress-1122.js +++ b/deps/v8/test/mjsunit/regress/regress-1122.js @@ -62,7 +62,5 @@ assertEquals('prefix 16000 suffix', assertEquals('prefix undefined suffix', function_with_n_params_and_m_args(32000, 10000)); -assertThrows("function_with_n_params_and_m_args(35000, 35000)"); -assertThrows("function_with_n_params_and_m_args(100000, 100000)"); -assertThrows("function_with_n_params_and_m_args(35000, 30000)"); -assertThrows("function_with_n_params_and_m_args(30000, 35000)"); +assertThrows("function_with_n_params_and_m_args(66000, 30000)"); +assertThrows("function_with_n_params_and_m_args(30000, 66000)"); diff --git a/deps/v8/test/mjsunit/regress/regress-121407.js b/deps/v8/test/mjsunit/regress/regress-121407.js index 25033fb52..440370818 100644 --- a/deps/v8/test/mjsunit/regress/regress-121407.js +++ b/deps/v8/test/mjsunit/regress/regress-121407.js @@ -37,4 +37,4 @@ a[2000000] = 2000000; a.length=2000; for (var i = 0; i <= 256; i++) { a[i] = new Object(); -}
\ No newline at end of file +} diff --git a/deps/v8/test/mjsunit/regress/regress-147497.js b/deps/v8/test/mjsunit/regress/regress-147497.js new file mode 100644 index 000000000..92e29d125 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-147497.js @@ -0,0 +1,45 @@ +// Copyright 2013 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: --expose-debug-as debug + +Debug = debug.Debug; + +function listener(event, exec_state, event_data, data) { + if (event == Debug.DebugEvent.Break) { + exec_state.prepareStep(Debug.StepAction.StepNext, 10); + } +}; + +Debug.setListener(listener); + +var statement = ""; +for (var i = 0; i < 1024; i++) statement += "z"; +statement = 'with(0)' + statement + '=function foo(){}'; + +debugger; +eval(statement); diff --git a/deps/v8/test/mjsunit/regress/regress-164442.js b/deps/v8/test/mjsunit/regress/regress-164442.js new file mode 100644 index 000000000..1160d874f --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-164442.js @@ -0,0 +1,45 @@ +// Copyright 2012 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 + +// Should not take a very long time (n^2 algorithms are bad) + + +function ensureNotNegative(x) { + return Math.max(0, x | 0); +} + + +ensureNotNegative(1); +ensureNotNegative(2); + +%OptimizeFunctionOnNextCall(ensureNotNegative); + +var r = ensureNotNegative(-1); + +assertEquals(0, r); diff --git a/deps/v8/test/mjsunit/regress/regress-165637.js b/deps/v8/test/mjsunit/regress/regress-165637.js new file mode 100644 index 000000000..72af528a8 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-165637.js @@ -0,0 +1,61 @@ +// Copyright 2012 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 + +// Should not take a very long time (n^2 algorithms are bad) + +function do_slices() { + var data = new Array(1024 * 12); // 12kB + + for (var i = 0; i < data.length; i++) { + data[i] = 255; + } + + var start = Date.now(); + + for (i = 0; i < 20000; i++) { + data.slice(4, 1); + } + + return Date.now() - start; +} + +// Reset the GC stress mode to be off. Needed so that the runtime of this test +// stays within bounds even if we run in GC stress mode. +%SetFlags("--gc-interval=-1 --noforce-marking-deque-overflows"); + +// Should never take more than 3 seconds (if the bug is fixed, the test takes +// considerably less time than 3 seconds). +assertTrue(do_slices() < (3 * 1000)); + +// Make sure that packed and unpacked array slices are still properly handled +var holey_array = [1, 2, 3, 4, 5,,,,,,]; +assertFalse(%HasFastHoleyElements(holey_array.slice(6, 1))); +assertEquals(undefined, holey_array.slice(6, 7)[0]) +assertFalse(%HasFastHoleyElements(holey_array.slice(2, 1))); +assertEquals(3, holey_array.slice(2, 3)[0]) diff --git a/deps/v8/test/mjsunit/regress/regress-166379.js b/deps/v8/test/mjsunit/regress/regress-166379.js new file mode 100644 index 000000000..2cda61182 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-166379.js @@ -0,0 +1,38 @@ +// Copyright 2012 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 + +function mod(a, b) { return a % b; } + +// Feed integer type info and optimize. +assertEquals(0, mod(4, 2)); +assertEquals(1, mod(3, 2)); +%OptimizeFunctionOnNextCall(mod); + +// Surprise mod with overflow. +assertEquals(-Infinity, 1/mod(-2147483648, -1)); diff --git a/deps/v8/test/mjsunit/regress/regress-166553.js b/deps/v8/test/mjsunit/regress/regress-166553.js new file mode 100644 index 000000000..acaf34f4e --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-166553.js @@ -0,0 +1,33 @@ +// Copyright 2012 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: --expose_gc + +JSON.stringify(String.fromCharCode(1, -11).toString()) +gc(); +var s = String.fromCharCode(1, -11) +assertEquals(65525, s.charCodeAt(1)) diff --git a/deps/v8/test/mjsunit/regress/regress-1692.js b/deps/v8/test/mjsunit/regress/regress-1692.js index 06bd66cf7..32be87f98 100644 --- a/deps/v8/test/mjsunit/regress/regress-1692.js +++ b/deps/v8/test/mjsunit/regress/regress-1692.js @@ -82,7 +82,7 @@ var o = Object("string"); // Non-string property on String object. o[10] = 42; assertTrue(o.propertyIsEnumerable(10)); -assertFalse(o.propertyIsEnumerable(0)); +assertTrue(o.propertyIsEnumerable(0)); // Fast elements. var o = [1,2,3,4,5]; diff --git a/deps/v8/test/mjsunit/regress/regress-171641.js b/deps/v8/test/mjsunit/regress/regress-171641.js new file mode 100644 index 000000000..8db678182 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-171641.js @@ -0,0 +1,40 @@ +// Copyright 2013 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 + +function foo(k, p) { + for (var i = 0; i < 1; i++) { + p = Math.min(p, i); + } + m = Math.floor((k | 0) / p); +} + +foo(0, 1); +foo(0, 1); +%OptimizeFunctionOnNextCall(foo); +foo(0, 1); diff --git a/deps/v8/test/mjsunit/regress/regress-1980.js b/deps/v8/test/mjsunit/regress/regress-1980.js index 49dfd063b..d87ff4507 100644 --- a/deps/v8/test/mjsunit/regress/regress-1980.js +++ b/deps/v8/test/mjsunit/regress/regress-1980.js @@ -34,7 +34,7 @@ for (var i = 0; i < invalid_this.length; i++) { Error.prototype.toString.call(invalid_this[i]); } catch (e) { exception = true; - assertTrue("called_on_non_object" == e.type); + assertEquals("Error.prototype.toString called on non-object", e.message); } assertTrue(exception); } diff --git a/deps/v8/test/mjsunit/regress/regress-2073.js b/deps/v8/test/mjsunit/regress/regress-2073.js new file mode 100644 index 000000000..4e40b044c --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-2073.js @@ -0,0 +1,99 @@ +// Copyright 2013 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. + +// Running this test with --trace_gc will show heap size growth due to +// leaking objects via embedded maps in optimized code. + +var counter = 0; + +function nextid() { + counter += 1; + return counter; +} + +function Scope() { + this.id = nextid(); + this.parent = null; + this.left = null; + this.right = null; + this.head = null; + this.tail = null; + this.counter = 0; +} + +Scope.prototype = { + new: function() { + var Child, + child; + Child = function() {}; + Child.prototype = this; + child = new Child(); + child.id = nextid(); + child.parent = this; + child.left = this.last; + child.right = null; + child.head = null; + child.tail = null; + child.counter = 0; + if (this.head) { + this.tail.right = child; + this.tail = child; + } else { + this.head = this.tail = child; + } + return child; + }, + + destroy: function() { + if ($root == this) return; + var parent = this.parent; + if (parent.head == this) parent.head = this.right; + if (parent.tail == this) parent.tail = this.left; + if (this.left) this.left.right = this.right; + if (this.right) this.right.left = this.left; + } +}; + +function inc(scope) { + scope.counter = scope.counter + 1; +} + +var $root = new Scope(); + +n = 100000; +m = 10; + +function doit() { + var a = $root.new(); + var b = a.new(); + inc(b); + if (i > m) $root.head.destroy(); +} + +for (var i = 0; i < n; i++) { + doit(); +} diff --git a/deps/v8/test/mjsunit/regress/regress-2185.js b/deps/v8/test/mjsunit/regress/regress-2185.js index 895f322fc..9b91066f3 100644 --- a/deps/v8/test/mjsunit/regress/regress-2185.js +++ b/deps/v8/test/mjsunit/regress/regress-2185.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: --noenable-slow-asserts + var a = []; for (var i = 0; i < 2; i++) { diff --git a/deps/v8/test/mjsunit/regress/regress-2243.js b/deps/v8/test/mjsunit/regress/regress-2243.js new file mode 100644 index 000000000..31c2e55fe --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-2243.js @@ -0,0 +1,31 @@ +// Copyright 2012 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: --harmony-scoping + +assertThrows("'use strict'; (function f() { f = 123; })", SyntaxError); +assertThrows("(function f() { 'use strict'; f = 123; })", SyntaxError); diff --git a/deps/v8/test/mjsunit/regress/regress-2263.js b/deps/v8/test/mjsunit/regress/regress-2263.js new file mode 100644 index 000000000..9a9db5877 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-2263.js @@ -0,0 +1,30 @@ +// Copyright 2012 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. + +var obj = { length: { valueOf: function(){ throw { type: "length" }}}}; +var sep = { toString: function(){ throw { type: "toString" }}}; +assertThrows("Array.prototype.join.call(obj, sep)", undefined, "length"); diff --git a/deps/v8/test/mjsunit/regress/regress-2398.js b/deps/v8/test/mjsunit/regress/regress-2398.js new file mode 100644 index 000000000..1c66e7f84 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-2398.js @@ -0,0 +1,41 @@ +// Copyright 2012 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. + +"use strict"; + +var observed = false; + +var object = { get toString() { observed = true; } }; +Object.defineProperty(object, "ro", { value: 1 }); + +try { + object.ro = 2; // TypeError caused by trying to write to read-only. +} catch (e) { + e.message; // Forces formatting of the message object. +} + +assertFalse(observed); diff --git a/deps/v8/test/mjsunit/regress/regress-2410.js b/deps/v8/test/mjsunit/regress/regress-2410.js new file mode 100644 index 000000000..c16fd14cd --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-2410.js @@ -0,0 +1,36 @@ +// Copyright 2012 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. + +// Object.prototype should be ignored in Object.getOwnPropertyNames +// +// See http://code.google.com/p/v8/issues/detail?id=2410 for details. + +Object.defineProperty(Object.prototype, + 'thrower', + { get: function() { throw Error('bug') } }); +var obj = { thrower: 'local' }; +assertEquals(['thrower'], Object.getOwnPropertyNames(obj)); diff --git a/deps/v8/test/mjsunit/regress/regress-2416.js b/deps/v8/test/mjsunit/regress/regress-2416.js new file mode 100644 index 000000000..02afeb9a5 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-2416.js @@ -0,0 +1,75 @@ +// Copyright 2012 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. + +assertFalse(2147483647 < -2147483648) +assertFalse(2147483647 <= -2147483648) +assertFalse(2147483647 == -2147483648) +assertTrue(2147483647 >= -2147483648) +assertTrue(2147483647 > -2147483648) + +assertTrue(-2147483648 < 2147483647) +assertTrue(-2147483648 <= 2147483647) +assertFalse(-2147483648 == 2147483647) +assertFalse(-2147483648 >= 2147483647) +assertFalse(-2147483648 > 2147483647) + +assertFalse(2147483647 < 2147483647) +assertTrue(2147483647 <= 2147483647) +assertTrue(2147483647 == 2147483647) +assertTrue(2147483647 >= 2147483647) +assertFalse(2147483647 > 2147483647) + +assertFalse(-2147483648 < -2147483648) +assertTrue(-2147483648 <= -2147483648) +assertTrue(-2147483648 == -2147483648) +assertTrue(-2147483648 >= -2147483648) +assertFalse(-2147483648 > -2147483648) + + +assertFalse(1073741823 < -1073741824) +assertFalse(1073741823 <= -1073741824) +assertFalse(1073741823 == -1073741824) +assertTrue(1073741823 >= -1073741824) +assertTrue(1073741823 > -1073741824) + +assertTrue(-1073741824 < 1073741823) +assertTrue(-1073741824 <= 1073741823) +assertFalse(-1073741824 == 1073741823) +assertFalse(-1073741824 >= 1073741823) +assertFalse(-1073741824 > 1073741823) + +assertFalse(1073741823 < 1073741823) +assertTrue(1073741823 <= 1073741823) +assertTrue(1073741823 == 1073741823) +assertTrue(1073741823 >= 1073741823) +assertFalse(1073741823 > 1073741823) + +assertFalse(-1073741824 < -1073741824) +assertTrue(-1073741824 <= -1073741824) +assertTrue(-1073741824 == -1073741824) +assertTrue(-1073741824 >= -1073741824) +assertFalse(-1073741824 > -1073741824) diff --git a/deps/v8/test/mjsunit/regress/regress-2419.js b/deps/v8/test/mjsunit/regress/regress-2419.js new file mode 100644 index 000000000..4ffafbe6e --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-2419.js @@ -0,0 +1,36 @@ +// Copyright 2012 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. + +var a = [5, 4, 3, 2, 1, 0]; +Object.freeze(a); +a.sort(); +assertArrayEquals([5, 4, 3, 2, 1, 0], a); + +var b = {0: 5, 1: 4, 2: 3, 3: 2, 4: 1, 5: 0, length: 6}; +Object.freeze(b); +Array.prototype.sort.call(b); +assertPropertiesEqual({0: 5, 1: 4, 2: 3, 3: 2, 4: 1, 5: 0, length: 6}, b); diff --git a/deps/v8/test/mjsunit/regress/regress-2433.js b/deps/v8/test/mjsunit/regress/regress-2433.js new file mode 100644 index 000000000..dfe7131b5 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-2433.js @@ -0,0 +1,36 @@ +// Copyright 2012 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. + +// Transitioning from a PackedSmi to PackedDouble should fill the destination +// with holes. +// +// See http://code.google.com/p/v8/issues/detail?id=2433 for details. + +arr = []; +arr[0] = 0; +arr[0] = 1.1; +assertEquals(undefined, arr[1]); diff --git a/deps/v8/test/mjsunit/regress/regress-2437.js b/deps/v8/test/mjsunit/regress/regress-2437.js new file mode 100644 index 000000000..c82293ae3 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-2437.js @@ -0,0 +1,156 @@ +// Copyright 2012 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. + +// Summary of the spec: lastIndex is reset to 0 if +// - a regexp fails to match, regardless of global or non-global. +// - a global regexp is used in a function that returns multiple results, +// such as String.prototype.replace or String.prototype.match, since it +// repeats the regexp until it fails to match. +// Otherwise lastIndex is only set when a global regexp matches, to the index +// after the match. + +// Test Regexp.prototype.exec +r = /a/; +r.lastIndex = 1; +r.exec("zzzz"); +assertEquals(0, r.lastIndex); + +// Test Regexp.prototype.test +r = /a/; +r.lastIndex = 1; +r.test("zzzz"); +assertEquals(0, r.lastIndex); + +// Test String.prototype.match +r = /a/; +r.lastIndex = 1; +"zzzz".match(r); +assertEquals(0, r.lastIndex); + +// Test String.prototype.replace with atomic regexp and empty string. +r = /a/; +r.lastIndex = 1; +"zzzz".replace(r, ""); +assertEquals(0, r.lastIndex); + +// Test String.prototype.replace with non-atomic regexp and empty string. +r = /\d/; +r.lastIndex = 1; +"zzzz".replace(r, ""); +assertEquals(0, r.lastIndex); + +// Test String.prototype.replace with atomic regexp and non-empty string. +r = /a/; +r.lastIndex = 1; +"zzzz".replace(r, "a"); +assertEquals(0, r.lastIndex); + +// Test String.prototype.replace with non-atomic regexp and non-empty string. +r = /\d/; +r.lastIndex = 1; +"zzzz".replace(r, "a"); +assertEquals(0, r.lastIndex); + +// Test String.prototype.replace with replacement function +r = /a/; +r.lastIndex = 1; +"zzzz".replace(r, function() { return ""; }); +assertEquals(0, r.lastIndex); + +// Regexp functions that returns multiple results: +// A global regexp always resets lastIndex regardless of whether it matches. +r = /a/g; +r.lastIndex = -1; +"0123abcd".replace(r, "x"); +assertEquals(0, r.lastIndex); + +r.lastIndex = -1; +"01234567".replace(r, "x"); +assertEquals(0, r.lastIndex); + +r.lastIndex = -1; +"0123abcd".match(r); +assertEquals(0, r.lastIndex); + +r.lastIndex = -1; +"01234567".match(r); +assertEquals(0, r.lastIndex); + +// A non-global regexp resets lastIndex iff it does not match. +r = /a/; +r.lastIndex = -1; +"0123abcd".replace(r, "x"); +assertEquals(-1, r.lastIndex); + +r.lastIndex = -1; +"01234567".replace(r, "x"); +assertEquals(0, r.lastIndex); + +r.lastIndex = -1; +"0123abcd".match(r); +assertEquals(-1, r.lastIndex); + +r.lastIndex = -1; +"01234567".match(r); +assertEquals(0, r.lastIndex); + +// Also test RegExp.prototype.exec and RegExp.prototype.test +r = /a/g; +r.lastIndex = 1; +r.exec("01234567"); +assertEquals(0, r.lastIndex); + +r.lastIndex = 1; +r.exec("0123abcd"); +assertEquals(5, r.lastIndex); + +r = /a/; +r.lastIndex = 1; +r.exec("01234567"); +assertEquals(0, r.lastIndex); + +r.lastIndex = 1; +r.exec("0123abcd"); +assertEquals(1, r.lastIndex); + +r = /a/g; +r.lastIndex = 1; +r.test("01234567"); +assertEquals(0, r.lastIndex); + +r.lastIndex = 1; +r.test("0123abcd"); +assertEquals(5, r.lastIndex); + +r = /a/; +r.lastIndex = 1; +r.test("01234567"); +assertEquals(0, r.lastIndex); + +r.lastIndex = 1; +r.test("0123abcd"); +assertEquals(1, r.lastIndex); diff --git a/deps/v8/test/mjsunit/regress/regress-2438.js b/deps/v8/test/mjsunit/regress/regress-2438.js new file mode 100644 index 000000000..7be7e7168 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-2438.js @@ -0,0 +1,51 @@ +// Copyright 2012 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. + +function testSideEffects(subject, re) { + var counter = 0; + var side_effect_object = { valueOf: function() { return counter++; } }; + re.lastIndex = side_effect_object; + re.exec(subject); + assertEquals(1, counter); + + re.lastIndex = side_effect_object; + re.test(subject); + assertEquals(2, counter); + + re.lastIndex = side_effect_object; + subject.match(re); + assertEquals(3, counter); + + re.lastIndex = side_effect_object; + subject.replace(re, ""); + assertEquals(4, counter); +} + +testSideEffects("zzzz", /a/); +testSideEffects("zzzz", /a/g); +testSideEffects("xaxa", /a/); +testSideEffects("xaxa", /a/g); diff --git a/deps/v8/test/mjsunit/regress/regress-2441.js b/deps/v8/test/mjsunit/regress/regress-2441.js new file mode 100644 index 000000000..72ce2484c --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-2441.js @@ -0,0 +1,31 @@ +// Copyright 2013 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. + +var o = {}; +Object.preventExtensions(o); +assertThrows("Object.defineProperty(o, 'foobarloo', {value:{}});", TypeError); +assertThrows("Object.defineProperty(o, '__proto__', {value:{}});", TypeError); diff --git a/deps/v8/test/mjsunit/regress/regress-2443.js b/deps/v8/test/mjsunit/regress/regress-2443.js new file mode 100644 index 000000000..0800c45c0 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-2443.js @@ -0,0 +1,129 @@ +// Copyright 2012 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. + +// Number.prototype methods on non-Numbers. + +assertThrows(function() { Number.prototype.toExponential.call({}) }, + TypeError); + +assertThrows(function() { Number.prototype.toPrecision.call({}) }, + TypeError); + +assertThrows(function() { Number.prototype.toFixed.call({}) }, + TypeError); + +assertThrows(function() { Number.prototype.toString.call({}) }, + TypeError); + +assertThrows(function() { Number.prototype.toLocaleString.call({}) }, + TypeError); + +assertThrows(function() { Number.prototype.ValueOf.call({}) }, + TypeError); + + +// Call on Number objects with custom valueOf method. + +var x_obj = new Number(1); +x_obj.valueOf = function() { assertUnreachable(); }; + +assertEquals("1.00e+0", + Number.prototype.toExponential.call(x_obj, 2)); + +assertEquals("1.0", + Number.prototype.toPrecision.call(x_obj, 2)); + +assertEquals("1.00", + Number.prototype.toFixed.call(x_obj, 2)); + +// Call on primitive numbers. +assertEquals("1.00e+0", + Number.prototype.toExponential.call(1, 2)); + +assertEquals("1.0", + Number.prototype.toPrecision.call(1, 2)); + +assertEquals("1.00", + Number.prototype.toFixed.call(1, 2)); + + +// toExponential and toPrecision does following steps in order +// 1) convert the argument using ToInteger +// 2) check for non-finite receiver, on which it returns, +// 3) check argument range and throw exception if out of range. +// Note that the the last two steps are reversed for toFixed. +// Luckily, the receiver is expected to be a number or number +// wrapper, so that getting its value is not observable. + +var f_flag = false; +var f_obj = { valueOf: function() { f_flag = true; return 1000; } }; + +assertEquals("NaN", + Number.prototype.toExponential.call(NaN, f_obj)); +assertTrue(f_flag); + +f_flag = false; +assertEquals("Infinity", + Number.prototype.toExponential.call(1/0, f_obj)); +assertTrue(f_flag); + +f_flag = false; +assertEquals("-Infinity", + Number.prototype.toExponential.call(-1/0, f_obj)); +assertTrue(f_flag); + +f_flag = false; +assertEquals("NaN", + Number.prototype.toPrecision.call(NaN, f_obj)); +assertTrue(f_flag); + +f_flag = false; +assertEquals("Infinity", + Number.prototype.toPrecision.call(1/0, f_obj)); +assertTrue(f_flag); + +f_flag = false; +assertEquals("-Infinity", + Number.prototype.toPrecision.call(-1/0, f_obj)); +assertTrue(f_flag); + +// The odd man out: toFixed. + +f_flag = false; +assertThrows(function() { Number.prototype.toFixed.call(NaN, f_obj) }, + RangeError); +assertTrue(f_flag); + +f_flag = false; +assertThrows(function() { Number.prototype.toFixed.call(1/0, f_obj) }, + RangeError); +assertTrue(f_flag); + +f_flag = false; +assertThrows(function() { Number.prototype.toFixed.call(-1/0, f_obj) }, + RangeError); +assertTrue(f_flag); diff --git a/deps/v8/test/mjsunit/regress/regress-2444.js b/deps/v8/test/mjsunit/regress/regress-2444.js new file mode 100644 index 000000000..41b6a95e7 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-2444.js @@ -0,0 +1,118 @@ +// Copyright 2012 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. + + +var flags; + +function resetFlags(size) { + flags = Array(size); + while (size--) flags[size] = 0; +} + +function assertFlags(array) { + assertArrayEquals(array, flags); +} + +function object_factory(flag_index, value, expected_flags) { + var obj = {}; + obj.valueOf = function() { + assertFlags(expected_flags); + flags[flag_index]++; + return value; + } + return obj; +} + + +assertEquals(-Infinity, Math.max()); + +resetFlags(1); +assertEquals(NaN, + Math.max(object_factory(0, NaN, [0]))); +assertFlags([1]); + +resetFlags(2); +assertEquals(NaN, + Math.max(object_factory(0, NaN, [0, 0]), + object_factory(1, 0, [1, 0]))); +assertFlags([1, 1]); + +resetFlags(3); +assertEquals(NaN, + Math.max(object_factory(0, NaN, [0, 0, 0]), + object_factory(1, 0, [1, 0, 0]), + object_factory(2, 1, [1, 1, 0]))); +assertFlags([1, 1, 1]); + +resetFlags(3); +assertEquals(NaN, + Math.max(object_factory(0, 2, [0, 0, 0]), + object_factory(1, 0, [1, 0, 0]), + object_factory(2, NaN, [1, 1, 0]))); +assertFlags([1, 1, 1]); + +resetFlags(3); +assertEquals(2, + Math.max(object_factory(0, 2, [0, 0, 0]), + object_factory(1, 0, [1, 0, 0]), + object_factory(2, 1, [1, 1, 0]))); +assertFlags([1, 1, 1]); + + +assertEquals(+Infinity, Math.min()); + +resetFlags(1); +assertEquals(NaN, + Math.min(object_factory(0, NaN, [0]))); +assertFlags([1]); + +resetFlags(2); +assertEquals(NaN, + Math.min(object_factory(0, NaN, [0, 0]), + object_factory(1, 0, [1, 0]))); +assertFlags([1, 1]); + +resetFlags(3); +assertEquals(NaN, + Math.min(object_factory(0, NaN, [0, 0, 0]), + object_factory(1, 0, [1, 0, 0]), + object_factory(2, 1, [1, 1, 0]))); +assertFlags([1, 1, 1]); + +resetFlags(3); +assertEquals(NaN, + Math.min(object_factory(0, 2, [0, 0, 0]), + object_factory(1, 0, [1, 0, 0]), + object_factory(2, NaN, [1, 1, 0]))); +assertFlags([1, 1, 1]); + +resetFlags(3); +assertEquals(0, + Math.min(object_factory(0, 2, [0, 0, 0]), + object_factory(1, 0, [1, 0, 0]), + object_factory(2, 1, [1, 1, 0]))); +assertFlags([1, 1, 1]); diff --git a/deps/v8/test/mjsunit/regress/regress-2451.js b/deps/v8/test/mjsunit/regress/regress-2451.js new file mode 100644 index 000000000..cc087e75e --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-2451.js @@ -0,0 +1,40 @@ +// Copyright 2013 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 + +function f() { + assertEquals(-1.0, Math.round(-1.5)); + assertEquals(-2.0, Math.round(-2.5)); + assertEquals(-1.0, Math.round(-0.5000000000000001)); +} + +f(); +f(); +%OptimizeFunctionOnNextCall(f); +f(); +assertTrue(%GetOptimizationStatus(f) != 2); diff --git a/deps/v8/test/mjsunit/regress/regress-2470.js b/deps/v8/test/mjsunit/regress/regress-2470.js new file mode 100644 index 000000000..29a0b250a --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-2470.js @@ -0,0 +1,47 @@ +// Copyright 2013 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. + +// Test whether the opening parenthesis can be eaten up by a comment. +assertThrows('Function("/*", "*/){");', SyntaxError); + +// Test whether the function literal can be closed prematurely. +assertThrows('Function("});(function(){");', SyntaxError); + +// Test whether block comments are handled correctly. +assertDoesNotThrow('Function("/*", "*/", "/**/");'); +assertDoesNotThrow('Function("/*", "a", "*/", "/**/");'); +assertThrows('Function("a", "/*", "*/", "/**/");', SyntaxError); + +// Test whether line comments are handled correctly. +assertDoesNotThrow('Function("//", "//")'); +assertDoesNotThrow('Function("//", "//", "//")'); +assertThrows('Function("a", "//", "//")', SyntaxError); + +// Some embedders rely on the string representation of the resulting +// function in cases where no formal parameters are specified. +var asString = Function("return 23").toString(); +assertSame("function anonymous() {\nreturn 23\n}", asString); diff --git a/deps/v8/test/mjsunit/regress/regress-2499.js b/deps/v8/test/mjsunit/regress/regress-2499.js new file mode 100644 index 000000000..52aad874d --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-2499.js @@ -0,0 +1,40 @@ +// Copyright 2013 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 + +function foo(word, nBits) { + return (word[1] >>> nBits) | (word[0] << (32 - nBits)); +} + +word = [0x1001, 0]; + +var expected = foo(word, 1); +foo(word, 1); +%OptimizeFunctionOnNextCall(foo); +var optimized = foo(word, 1); +assertEquals(expected, optimized) diff --git a/deps/v8/test/mjsunit/regress/regress-2537.js b/deps/v8/test/mjsunit/regress/regress-2537.js new file mode 100644 index 000000000..c6b5af949 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-2537.js @@ -0,0 +1,45 @@ +// Copyright 2013 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 + +var large_int = 0x40000000; + +function foo(x, expected) { + assertEquals(expected, x); // This succeeds. + x += 0; // Force int32 representation so that CompareIDAndBranch is used. + if (3 != x) { + x += 0; // Poor man's "iDef". + // Fails due to Smi-tagging without overflow check. + assertEquals(expected, x); + } +} + +foo(1, 1); +foo(3, 3); +%OptimizeFunctionOnNextCall(foo); +foo(large_int, large_int); diff --git a/deps/v8/test/mjsunit/regress/regress-2539.js b/deps/v8/test/mjsunit/regress/regress-2539.js new file mode 100644 index 000000000..5d263f891 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-2539.js @@ -0,0 +1,55 @@ +// Copyright 2013 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 + +"use strict"; +var dispatcher = {}; +dispatcher.func = C; + +function A() { + B(10, 11); +} + +function B(x,y) { + x = 0; y = 0; + dispatcher.func.apply(this, arguments); + assertSame(2, arguments.length); + assertSame(10, arguments[0]); + assertSame(11, arguments[1]); +} + +function C(x,y) { + assertSame(2, arguments.length); + assertSame(10, arguments[0]); + assertSame(11, arguments[1]); +} + +A(); +A(); +%OptimizeFunctionOnNextCall(A); +A(); diff --git a/deps/v8/test/mjsunit/regress/regress-2565.js b/deps/v8/test/mjsunit/regress/regress-2565.js new file mode 100644 index 000000000..a77806a62 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-2565.js @@ -0,0 +1,32 @@ +// Copyright 2013 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. + +Object.freeze(Object.prototype); +var p = {}; +var o = Object.create(p); +assertSame(p, o.__proto__); +assertSame(p, Object.getPrototypeOf(o)); diff --git a/deps/v8/test/mjsunit/regress/regress-2566.js b/deps/v8/test/mjsunit/regress/regress-2566.js new file mode 100644 index 000000000..582bad979 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-2566.js @@ -0,0 +1,34 @@ +// Copyright 2013 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. + +function setProp(obj, prop, val) { + obj[prop] = val; +} +var obj = []; +setProp(obj, 'length', 1); +setProp(obj, 0, 5); +assertEquals(1, obj.length); diff --git a/deps/v8/test/mjsunit/regress/regress-2568.js b/deps/v8/test/mjsunit/regress/regress-2568.js new file mode 100644 index 000000000..7918e148c --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-2568.js @@ -0,0 +1,46 @@ +// Copyright 2013 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. + +function pluck1(a, key) { + return a.map(function(item) { return item[key]; }); +}; +assertArrayEquals([2, 2], pluck1([[0, 0], [0, 0]], 'length')); +assertArrayEquals([1, 3], pluck1([[1, 2], [3, 4]], '0')); + +function pluck2(a, key) { + return a.map(function(item) { return item[key]; }); +}; +assertArrayEquals([2, 2], pluck2(["ab", "cd"], 'length')); +assertArrayEquals(["a", "c"], pluck2(["ab", "cd"], '0')); + +function pluck3(a, key) { + return a.map(function(item) { return item[key]; }); +}; +f = function() { 1 }; +f.prototype = g = function() { 2 }; +assertArrayEquals([g, g], pluck3([f, f], 'prototype')); +assertArrayEquals([undefined, undefined], pluck3([f, f], '0')); diff --git a/deps/v8/test/mjsunit/regress/regress-2570.js b/deps/v8/test/mjsunit/regress/regress-2570.js new file mode 100644 index 000000000..f9060e8c0 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-2570.js @@ -0,0 +1,31 @@ +// Copyright 2013 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. + +var o = ["\u56e7", // Switch JSON stringifier to two-byte mode. + "\u00e6"]; // Latin-1 character. + +assertEquals('["\u56e7","\u00e6"]', JSON.stringify(o)); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-146910.js b/deps/v8/test/mjsunit/regress/regress-crbug-146910.js index 120f80973..1b2a60af7 100644 --- a/deps/v8/test/mjsunit/regress/regress-crbug-146910.js +++ b/deps/v8/test/mjsunit/regress/regress-crbug-146910.js @@ -1,4 +1,4 @@ -// Copyright 2012 the V8 project authors. All rights reserved. +// Copyright 2013 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: @@ -25,14 +25,9 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -var x = []; -assertSame(0, x.length); -assertSame(undefined, x[0]); +assertEquals(String.fromCharCode(97, 220, 256), 'a' + '\u00DC' + '\u0100'); +assertEquals(String.fromCharCode(97, 220, 256), 'a\u00DC\u0100'); -Object.defineProperty(x, '0', { value: 7, configurable: false }); -assertSame(1, x.length); -assertSame(7, x[0]); +assertEquals(['a', 'b', '\xdc'], ['b', '\xdc', 'a'].sort()); +assertEquals(['\xfc\xdc', '\xfc'], new RegExp('(\xdc)\\1', 'i').exec('\xfc\xdc')); -x.length = 0; -assertSame(1, x.length); -assertSame(7, x[0]); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-160010.js b/deps/v8/test/mjsunit/regress/regress-crbug-160010.js new file mode 100644 index 000000000..586bddd7c --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-160010.js @@ -0,0 +1,35 @@ +// Copyright 2012 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 + +var str = "a"; +for (var i = 0; i < 28; i++) { + str += str; + %FlattenString(str); // Evil performance hack +} +JSON.stringify(str); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-162085.js b/deps/v8/test/mjsunit/regress/regress-crbug-162085.js new file mode 100644 index 000000000..a53b2c998 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-162085.js @@ -0,0 +1,71 @@ +// Copyright 2012 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. + +// Ensure extending an empty packed smi array with a double initializes the +// array with holes. +var a = [1,2,3]; +a.length = 0; +a[0] = 1.4; +assertEquals(1.4, a[0]); +assertEquals(undefined, a[1]); +assertEquals(undefined, a[2]); +assertEquals(undefined, a[3]); + +// Ensure the double array growstub initializes the array with holes. +function grow_store(a,i,v) { + a[i] = v; +} + +var a2 = [1.3]; +grow_store(a2,1,1.4); +a2.length = 0; +grow_store(a2,0,1.5); +assertEquals(1.5, a2[0]); +assertEquals(undefined, a2[1]); +assertEquals(undefined, a2[2]); +assertEquals(undefined, a2[3]); + +// Check storing objects using the double grow stub. +var a3 = [1.3]; +var o = {}; +grow_store(a3, 1, o); +assertEquals(1.3, a3[0]); +assertEquals(o, a3[1]); + +// Ensure the double array growstub initializes the array with holes. +function grow_store2(a,i,v) { + a[i] = v; +} + +var a4 = [1.3]; +grow_store2(a4,1,1.4); +a4.length = 0; +grow_store2(a4,0,1); +assertEquals(1, a4[0]); +assertEquals(undefined, a4[1]); +assertEquals(undefined, a4[2]); +assertEquals(undefined, a4[3]); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-163530.js b/deps/v8/test/mjsunit/regress/regress-crbug-163530.js new file mode 100644 index 000000000..7abae14a8 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-163530.js @@ -0,0 +1,80 @@ +// Copyright 2013 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 + +// Test materialization of an arguments object with unknown argument +// values in non-strict mode (length has to be zero). +(function() { + var deoptimize = { deopt:true }; + var object = {}; + + object.a = function A(x, y, z) { + assertSame(0, arguments.length); + return this.b(); + }; + + object.b = function B() { + assertSame(0, arguments.length); + deoptimize.deopt; + return arguments.length; + }; + + assertSame(0, object.a()); + assertSame(0, object.a()); + %OptimizeFunctionOnNextCall(object.a); + assertSame(0, object.a()); + delete deoptimize.deopt; + assertSame(0, object.a()); +})(); + + +// Test materialization of an arguments object with unknown argument +// values in strict mode (length is allowed to exceed stack size). +(function() { + 'use strict'; + var deoptimize = { deopt:true }; + var object = {}; + + object.a = function A(x, y, z) { + assertSame(0, arguments.length); + return this.b(1, 2, 3, 4, 5, 6, 7, 8); + }; + + object.b = function B(a, b, c, d, e, f, g, h) { + assertSame(8, arguments.length); + deoptimize.deopt; + return arguments.length; + }; + + assertSame(8, object.a()); + assertSame(8, object.a()); + %OptimizeFunctionOnNextCall(object.a); + assertSame(8, object.a()); + delete deoptimize.deopt; + assertSame(8, object.a()); +})(); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-168545.js b/deps/v8/test/mjsunit/regress/regress-crbug-168545.js new file mode 100644 index 000000000..acc065e41 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-168545.js @@ -0,0 +1,34 @@ +// Copyright 2013 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. + +var o = {}; +Object.defineProperty(o, "length", { get: function() { throw "bail"; }}); +assertThrows("new Int16Array(o);"); + +var a = []; +Object.defineProperty(a, "0", { get: function() { throw "bail"; }}); +assertThrows("new Int16Array(a);"); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-170856.js b/deps/v8/test/mjsunit/regress/regress-crbug-170856.js new file mode 100644 index 000000000..2e73b12ca --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-170856.js @@ -0,0 +1,33 @@ +// Copyright 2013 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. + +r = new RegExp("a"); +for (var i = 0; i < 100; i++) { + r["abc" + i] = i; +} +"zzzz".replace(r, ""); +assertEquals(0, r.lastIndex); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-172345.js b/deps/v8/test/mjsunit/regress/regress-crbug-172345.js new file mode 100644 index 000000000..711501caa --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-172345.js @@ -0,0 +1,34 @@ +// Copyright 2013 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. + +function f(a,i) { + return a[i]; +} + +f([1,2,3], "length"); +f([1,2,3], "length"); +f([1,2,3], 2); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-173907.js b/deps/v8/test/mjsunit/regress/regress-crbug-173907.js new file mode 100644 index 000000000..9f92fefa7 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-173907.js @@ -0,0 +1,88 @@ +// Copyright 2013 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 + +var X = 1.1; +var K = 0.5; + +var O = 0; +var result = new Float64Array(2); + +function spill() { + try { } catch (e) { } +} + +function buggy() { + var v = X; + var phi1 = v + K; + var phi2 = v - K; + + spill(); // At this point initial values for phi1 and phi2 are spilled. + + var xmm1 = v; + var xmm2 = v*v*v; + var xmm3 = v*v*v*v; + var xmm4 = v*v*v*v*v; + var xmm5 = v*v*v*v*v*v; + var xmm6 = v*v*v*v*v*v*v; + var xmm7 = v*v*v*v*v*v*v*v; + var xmm8 = v*v*v*v*v*v*v*v*v; + + // All registers are blocked and phis for phi1 and phi2 are spilled because + // their left (incoming) value is spilled, there are no free registers, + // and phis themselves have only ANY-policy uses. + + for (var x = 0; x < 2; x++) { + xmm1 += xmm1 * xmm6; + xmm2 += xmm1 * xmm5; + xmm3 += xmm1 * xmm4; + xmm4 += xmm1 * xmm3; + xmm5 += xmm1 * xmm2; + + // Now swap values of phi1 and phi2 to create cycle between phis. + var t = phi1; + phi1 = phi2; + phi2 = t; + } + + // Now we want to get values of phi1 and phi2. However we would like to + // do it in a way that does not produce any uses of phi1&phi2 that have + // a register beneficial policy. How? We just hide these uses behind phis. + result[0] = (O === 0) ? phi1 : phi2; + result[1] = (O !== 0) ? phi1 : phi2; +} + +function test() { + buggy(); + assertArrayEquals([X + K, X - K], result); +} + +test(); +test(); +%OptimizeFunctionOnNextCall(buggy); +test(); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-173974.js b/deps/v8/test/mjsunit/regress/regress-crbug-173974.js new file mode 100644 index 000000000..905bd6058 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-173974.js @@ -0,0 +1,36 @@ +// Copyright 2013 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 + +function f() { + var count = ""; + count[0] --; +} +f(); +%OptimizeFunctionOnNextCall(f); +f(); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-178790.js b/deps/v8/test/mjsunit/regress/regress-crbug-178790.js new file mode 100644 index 000000000..25cc96b85 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-178790.js @@ -0,0 +1,51 @@ +// Copyright 2013 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. + +// Create a regexp in the form of a?a?...a? so that fully +// traversing the entire graph would be prohibitively expensive. +// This should not cause time out. +var r1 = ""; +for (var i = 0; i < 1000; i++) { + r1 += "a?"; +} +"test".match(RegExp(r1)); + +var r2 = ""; +for (var i = 0; i < 100; i++) { + r2 += "(a?|b?|c?|d?|e?|f?|g?)"; +} +"test".match(RegExp(r2)); + +// Create a regexp in the form of ((..(a)a..)a. +// Compiling it causes EatsAtLeast to reach the maximum +// recursion depth possible with a given budget. +// This should not cause a stack overflow. +var r3 = "a"; +for (var i = 0; i < 1000; i++) { + r3 = "(" + r3 + ")a"; +} +"test".match(RegExp(r3)); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-181422.js b/deps/v8/test/mjsunit/regress/regress-crbug-181422.js new file mode 100644 index 000000000..52826f311 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-181422.js @@ -0,0 +1,32 @@ +// Copyright 2013 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. + +assertArrayEquals(["\u00a0"], "ab\u00a0cd".match(/\s/)); +assertArrayEquals(["a", "b", "c", "d"], "ab\u00a0cd".match(/\S/g)); + +assertArrayEquals(["\u00a0"], "\u2604b\u00a0cd".match(/\s/)); +assertArrayEquals(["\u2604", "b", "c", "d"], "\u2604b\u00a0cd".match(/\S/g)); diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-18639.js b/deps/v8/test/mjsunit/regress/regress-crbug-18639.js index 23e225a4f..4f4bb7c79 100644 --- a/deps/v8/test/mjsunit/regress/regress-crbug-18639.js +++ b/deps/v8/test/mjsunit/regress/regress-crbug-18639.js @@ -27,8 +27,12 @@ // See http://crbug.com/18639 -toString = toString; -__defineGetter__("z", (0).toLocaleString); -z; -z; -((0).toLocaleString)(); +try { + toString = toString; + __defineGetter__("z", (0).toLocaleString); + z; + z; + ((0).toLocaleString)(); +} catch (e) { + assertInstanceof(e, TypeError); +}
\ No newline at end of file diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-196583.js b/deps/v8/test/mjsunit/regress/regress-crbug-196583.js new file mode 100644 index 000000000..c486158e2 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-crbug-196583.js @@ -0,0 +1,52 @@ +// Copyright 2013 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 + +var a = 1; +a.__proto__.f = 1; +a.__proto__.f = function() { return 1; } + +// Create some polymorphism. +function B() {} +B.prototype = {f: function() { return 2; }}; +var b = new B(); +function C() {} +C.prototype = {g: "foo", f: function() { return 3; }}; +var c = new C(); + +function crash(obj) { + return obj.f(); +} + +for (var i = 0; i < 2; i++) { + crash(a); + crash(b); + crash(c); +} +%OptimizeFunctionOnNextCall(crash); +assertEquals(1, crash(a)); diff --git a/deps/v8/test/mjsunit/regress/regress-delete-empty-double.js b/deps/v8/test/mjsunit/regress/regress-delete-empty-double.js new file mode 100644 index 000000000..f7af2b1e3 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-delete-empty-double.js @@ -0,0 +1,40 @@ +// Copyright 2012 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 + +a = [1.1,2.2,3.3]; +a.length = 1; +delete a[1]; + +assertTrue(%HasFastDoubleElements(a)); +assertFalse(%HasFastHoleyElements(a)); + +delete a[0]; + +assertTrue(%HasFastDoubleElements(a)); +assertTrue(%HasFastHoleyElements(a)); diff --git a/deps/v8/test/mjsunit/regress/regress-json-stringify-gc.js b/deps/v8/test/mjsunit/regress/regress-json-stringify-gc.js new file mode 100644 index 000000000..46c3dbf12 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-json-stringify-gc.js @@ -0,0 +1,40 @@ +// Copyright 2012 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. + +var a = []; +var new_space_string = ""; +for (var i = 0; i < 128; i++) { + new_space_string += String.fromCharCode((Math.random() * 26 + 65) | 0); +} +for (var i = 0; i < 10000; i++) a.push(new_space_string); + +// At some point during the first stringify, allocation causes a GC and +// new_space_string is moved to old space. Make sure that this does not +// screw up reading from the correct location. +json1 = JSON.stringify(a); +json2 = JSON.stringify(a); +assertTrue(json1 == json2, "GC caused JSON.stringify to fail."); diff --git a/deps/v8/test/mjsunit/regress/regress-latin-1.js b/deps/v8/test/mjsunit/regress/regress-latin-1.js new file mode 100644 index 000000000..a988ebd36 --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-latin-1.js @@ -0,0 +1,90 @@ +// Copyright 2013 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. + +assertEquals(String.fromCharCode(97, 220, 256), 'a' + '\u00DC' + '\u0100'); +assertEquals(String.fromCharCode(97, 220, 256), 'a\u00DC\u0100'); + +assertEquals(0x80, JSON.stringify("\x80").charCodeAt(1)); + +assertEquals(['a', 'b', '\xdc'], ['b', '\xdc', 'a'].sort()); + +assertEquals(['\xfc\xdc', '\xfc'], new RegExp('(\xdc)\\1', 'i').exec('\xfc\xdc')); +// Same test but for all values in Latin-1 range. +var total_lo = 0; +for (var i = 0; i < 0xff; i++) { + var base = String.fromCharCode(i); + var escaped = base; + if (base == '(' || base == ')' || base == '*' || base == '+' || + base == '?' || base == '[' || base == ']' || base == '\\' || + base == '$' || base == '^' || base == '|') { + escaped = '\\' + base; + } + var lo = String.fromCharCode(i + 0x20); + base_result = new RegExp('(' + escaped + ')\\1', 'i').exec(base + base); + assertEquals( base_result, [base + base, base]); + lo_result = new RegExp('(' + escaped + ')\\1', 'i').exec(base + lo); + if (base.toLowerCase() == lo) { + assertEquals([base + lo, base], lo_result); + total_lo++; + } else { + assertEquals(null, lo_result); + } +} +// Should have hit the branch for the following char codes: +// [A-Z], [192-222] but not 215 +assertEquals((90-65+1)+(222-192-1+1), total_lo); + +// Latin-1 whitespace character +assertEquals( 1, +(String.fromCharCode(0xA0) + '1') ); + +// Latin-1 \W characters +assertEquals(["+\u00a3", "=="], "+\u00a3==".match(/\W\W/g)); + +// Latin-1 character that uppercases out of Latin-1. +assertTrue(/\u0178/i.test('\u00ff')); + +// Unicode equivalence +assertTrue(/\u039c/i.test('\u00b5')); +assertTrue(/\u039c/i.test('\u03bc')); +assertTrue(/\u00b5/i.test('\u03bc')); +// Unicode equivalence ranges +assertTrue(/[\u039b-\u039d]/i.test('\u00b5')); +assertFalse(/[^\u039b-\u039d]/i.test('\u00b5')); +assertFalse(/[\u039b-\u039d]/.test('\u00b5')); +assertTrue(/[^\u039b-\u039d]/.test('\u00b5')); + +// Check a regression in QuoteJsonSlow and WriteQuoteJsonString +for (var testNumber = 0; testNumber < 2; testNumber++) { + var testString = "\xdc"; + var loopLength = testNumber == 0 ? 0 : 20; + for (var i = 0; i < loopLength; i++ ) { + testString += testString; + } + var stringified = JSON.stringify({"test" : testString}, null, 0); + var stringifiedExpected = '{"test":"' + testString + '"}'; + assertEquals(stringifiedExpected, stringified); +} diff --git a/deps/v8/test/mjsunit/regress/regress-observe-empty-double-array.js b/deps/v8/test/mjsunit/regress/regress-observe-empty-double-array.js new file mode 100644 index 000000000..4b651694a --- /dev/null +++ b/deps/v8/test/mjsunit/regress/regress-observe-empty-double-array.js @@ -0,0 +1,38 @@ +// Copyright 2012 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: --harmony-observation --allow-natives-syntax +// +// Test passes if it does not crash. + +arr = [1.1]; +Object.observe(arr, function(){}); +arr.length = 0; +// TODO(observe): we currently disallow fast elements for observed object. +// assertTrue(%HasFastDoubleElements(arr)); +// Should not crash +arr.push(1.1); diff --git a/deps/v8/test/mjsunit/shift-for-integer-div.js b/deps/v8/test/mjsunit/shift-for-integer-div.js new file mode 100644 index 000000000..d3c9d2b49 --- /dev/null +++ b/deps/v8/test/mjsunit/shift-for-integer-div.js @@ -0,0 +1,58 @@ +// Copyright 2012 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. + +function divp4(x) { + return x / 4; +} + +for (var i = 0; i < 10000; i+=4) { + assertEquals(i >> 2, divp4(i)); +} + +assertEquals(0.5, divp4(2)); + +function divn4(x) { + return x / (-4); +} + +for (var i = 0; i < 10000; i+=4) { + assertEquals(-(i >> 2), divn4(i)); +} + +assertEquals(-0, divn4(0)); + + +function divn1(x) { + return x / (-1); +} + +for (var i = 0; i < 10000; i++) { + assertEquals(-i, divn1(i)); +} + +var min_int = -(0x7FFFFFFF)-1; +assertEquals(-min_int, divn1(min_int)); diff --git a/deps/v8/test/mjsunit/stack-traces-gc.js b/deps/v8/test/mjsunit/stack-traces-gc.js new file mode 100644 index 000000000..dd878f23b --- /dev/null +++ b/deps/v8/test/mjsunit/stack-traces-gc.js @@ -0,0 +1,119 @@ +// Copyright 2012 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: --expose-gc --allow-natives-syntax + +var fired = []; +for (var i = 0; i < 100; i++) fired[i] = false; + +function getter_function(i) { + return %MarkOneShotGetter( function() { fired[i] = true; } ); +} + +// Error objects that die young. +for (var i = 0; i < 100; i++) { + var error = new Error(); + // Replace the getter to observe whether it has been fired, + // and disguise it as original getter. + var getter = getter_function(i); + error.__defineGetter__("stack", getter); + + error = undefined; +} + +gc(); +for (var i = 0; i < 100; i++) { + assertFalse(fired[i]); +} + +// Error objects that are kept alive. +var array = []; +for (var i = 0; i < 100; i++) { + var error = new Error(); + var getter = getter_function(i); + // Replace the getter to observe whether it has been fired, + // and disguise it as original getter. + error.__defineGetter__("stack", getter); + + array.push(error); + error = undefined; +} + +gc(); +// We don't expect all stack traces to be formatted after only one GC. +assertTrue(fired[0]); + +for (var i = 0; i < 10; i++) gc(); +for (var i = 0; i < 100; i++) assertTrue(fired[i]); + +// Error objects with custom stack getter. +var custom_error = new Error(); +var custom_getter_fired = false; +custom_error.__defineGetter__("stack", + function() { custom_getter_fired = true; }); +gc(); +assertFalse(custom_getter_fired); + +// Check that formatting caused by GC is not somehow observable. +var error; + +var obj = { foo: function foo() { throw new Error(); } }; + +try { + obj.foo(); +} catch (e) { + delete obj.foo; + Object.defineProperty(obj, 'foo', { + get: function() { assertUnreachable(); } + }); + error = e; +} + +gc(); + +Object.defineProperty(Array.prototype, '0', { + get: function() { assertUnreachable(); } +}); + +try { + throw new Error(); +} catch (e) { + error = e; +} + +gc(); + +String.prototype.indexOf = function() { assertUnreachable(); }; +String.prototype.lastIndexOf = function() { assertUnreachable(); }; +var obj = { method: function() { throw Error(); } }; +try { + obj.method(); +} catch (e) { + error = e; +} + +gc(); diff --git a/deps/v8/test/mjsunit/stack-traces-overflow.js b/deps/v8/test/mjsunit/stack-traces-overflow.js new file mode 100644 index 000000000..7722e93bd --- /dev/null +++ b/deps/v8/test/mjsunit/stack-traces-overflow.js @@ -0,0 +1,122 @@ +// Copyright 2012 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. + +function rec1(a) { rec1(a+1); } +function rec2(a) { rec3(a+1); } +function rec3(a) { rec2(a+1); } + +// Test stack trace getter and setter. +try { + rec1(0); +} catch (e) { + assertTrue(e.stack.indexOf("rec1") > 0); + e.stack = "123"; + assertEquals("123", e.stack); +} + +// Test setter w/o calling the getter. +try { + rec2(0); +} catch (e) { + assertTrue(e.stack.indexOf("rec2") > 0); + assertTrue(e.stack.indexOf("rec3") > 0); + e.stack = "123"; + assertEquals("123", e.stack); +} + +// Test getter to make sure setter does not affect the boilerplate. +try { + rec1(0); +} catch (e) { + assertTrue(e.stack.indexOf("rec1") > 0); + assertInstanceof(e, RangeError); +} + + +// Check setting/getting stack property on the prototype chain. +function testErrorPrototype(prototype) { + var object = {}; + object.__proto__ = prototype; + object.stack = "123"; + assertEquals("123", object.stack); + assertTrue("123" != prototype.stack); +} + +try { + rec1(0); +} catch (e) { + e.stack; + testErrorPrototype(e); +} + +try { + rec1(0); +} catch (e) { + testErrorPrototype(e); +} + +try { + throw new Error(); +} catch (e) { + testErrorPrototype(e); +} + +Error.stackTraceLimit = 3; +try { + rec1(0); +} catch (e) { + assertEquals(4, e.stack.split('\n').length); +} + +Error.stackTraceLimit = 25.9; +try { + rec1(0); +} catch (e) { + assertEquals(26, e.stack.split('\n').length); +} + +Error.stackTraceLimit = NaN; +try { + rec1(0); +} catch (e) { + assertEquals(1, e.stack.split('\n').length); +} + +Error.stackTraceLimit = "not a number"; +try { + rec1(0); +} catch (e) { + assertEquals(undefined, e.stack); +} + +Error.stackTraceLimit = 3; +Error = ""; // Overwrite Error in the global object. +try { + rec1(0); +} catch (e) { + assertEquals(4, e.stack.split('\n').length); +} diff --git a/deps/v8/test/mjsunit/stack-traces.js b/deps/v8/test/mjsunit/stack-traces.js index 438eec979..b5d58fa07 100644 --- a/deps/v8/test/mjsunit/stack-traces.js +++ b/deps/v8/test/mjsunit/stack-traces.js @@ -288,4 +288,42 @@ testOmittedBuiltin(function(){ [thrower, 2].sort(function (a,b) { }, "QuickSort"); // Omitted because ADD from runtime.js is non-native builtin. -testOmittedBuiltin(function(){ thrower + 2; }, "ADD");
\ No newline at end of file +testOmittedBuiltin(function(){ thrower + 2; }, "ADD"); + +var error = new Error(); +error.toString = function() { assertUnreachable(); }; +error.stack; + +error = new Error(); +error.name = { toString: function() { assertUnreachable(); }}; +error.message = { toString: function() { assertUnreachable(); }}; +error.stack; + +error = new Error(); +Array.prototype.push = function(x) { assertUnreachable(); }; +Array.prototype.join = function(x) { assertUnreachable(); }; +error.stack; + +var fired = false; +error = new Error({ toString: function() { fired = true; } }); +assertTrue(fired); +error.stack; +assertTrue(fired); + +// Check that throwing exception in a custom stack trace formatting function +// does not lead to recursion. +Error.prepareStackTrace = function() { throw new Error("abc"); }; +var message; +try { + throw new Error(); +} catch (e) { + message = e.message; +} + +assertEquals("abc", message); + +// Test that modifying Error.prepareStackTrace by itself works. +Error.prepareStackTrace = function() { Error.prepareStackTrace = "custom"; }; +new Error(); + +assertEquals("custom", Error.prepareStackTrace); diff --git a/deps/v8/test/mjsunit/strict-mode.js b/deps/v8/test/mjsunit/strict-mode.js index 9c9bdfd52..5fb404a79 100644 --- a/deps/v8/test/mjsunit/strict-mode.js +++ b/deps/v8/test/mjsunit/strict-mode.js @@ -1141,9 +1141,9 @@ function CheckPillDescriptor(func, name) { function strict() { "use strict"; - return_my_caller(); + return return_my_caller(); } - assertThrows(strict, TypeError); + assertSame(null, strict()); function non_strict() { return return_my_caller(); @@ -1155,32 +1155,57 @@ function CheckPillDescriptor(func, name) { (function TestNonStrictFunctionCallerPill() { function strict(n) { "use strict"; - non_strict(n); + return non_strict(n); } function recurse(n, then) { if (n > 0) { - recurse(n - 1); + return recurse(n - 1, then); } else { return then(); } } function non_strict(n) { - recurse(n, function() { non_strict.caller; }); + return recurse(n, function() { return non_strict.caller; }); } function test(n) { - try { - recurse(n, function() { strict(n); }); - } catch(e) { - return e instanceof TypeError; + return recurse(n, function() { return strict(n); }); + } + + for (var i = 0; i < 10; i ++) { + assertSame(null, test(i)); + } +})(); + + +(function TestNonStrictFunctionCallerDescriptorPill() { + function strict(n) { + "use strict"; + return non_strict(n); + } + + function recurse(n, then) { + if (n > 0) { + return recurse(n - 1, then); + } else { + return then(); } - return false; + } + + function non_strict(n) { + return recurse(n, function() { + return Object.getOwnPropertyDescriptor(non_strict, "caller").value; + }); + } + + function test(n) { + return recurse(n, function() { return strict(n); }); } for (var i = 0; i < 10; i ++) { - assertEquals(test(i), true); + assertSame(null, test(i)); } })(); diff --git a/deps/v8/test/mjsunit/string-natives.js b/deps/v8/test/mjsunit/string-natives.js new file mode 100644 index 000000000..12fa65dcb --- /dev/null +++ b/deps/v8/test/mjsunit/string-natives.js @@ -0,0 +1,71 @@ +// Copyright 2012 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: --expose-gc --allow-natives-syntax + +function test() { + var s1 = %NewString(26, true); + for (i = 0; i < 26; i++) %_OneByteSeqStringSetChar(s1, i, i+65); + assertEquals("ABCDEFGHIJKLMNOPQRSTUVWXYZ", s1); + s1 = %TruncateString(s1, 13); + assertEquals("ABCDEFGHIJKLM", s1); + + var s2 = %NewString(26, false); + for (i = 0; i < 26; i++) %_TwoByteSeqStringSetChar(s2, i, i+65); + assertEquals("ABCDEFGHIJKLMNOPQRSTUVWXYZ", s2); + s2 = %TruncateString(s1, 13); + assertEquals("ABCDEFGHIJKLM", s2); + + var s3 = %NewString(26, false); + for (i = 0; i < 26; i++) %_TwoByteSeqStringSetChar(s3, i, i+1000); + for (i = 0; i < 26; i++) assertEquals(s3[i], String.fromCharCode(i+1000)); + + var a = []; + for (var i = 0; i < 1000; i++) { + var s = %NewString(10000, i % 2 == 1); + a.push(s); + } + + gc(); + + for (var i = 0; i < 1000; i++) { + assertEquals(10000, a[i].length); + a[i] = %TruncateString(a[i], 5000); + } + + gc(); + + for (var i = 0; i < 1000; i++) { + assertEquals(5000, a[i].length); + } +} + + +test(); +test(); +%OptimizeFunctionOnNextCall(test); +test(); diff --git a/deps/v8/test/mjsunit/string-replace.js b/deps/v8/test/mjsunit/string-replace.js index 6b022df30..de9211557 100644 --- a/deps/v8/test/mjsunit/string-replace.js +++ b/deps/v8/test/mjsunit/string-replace.js @@ -212,3 +212,64 @@ var str = 'She sells seashells by the seashore.'; var re = /sh/g; assertEquals('She sells sea$schells by the sea$schore.', str.replace(re,"$$" + 'sch')) + + +var replace_obj = { length: 0, toString: function() { return "x"; }}; +assertEquals("axc", "abc".replace(/b/, replace_obj)); +assertEquals("axc", "abc".replace(/b/g, replace_obj)); + +var search_obj = { length: 1, toString: function() { return "b"; }}; +assertEquals("axc", "abc".replace(search_obj, function() { return "x"; })); + +var side_effect_flag = false; +var replace_obj_side_effects = { + toString: function() { side_effect_flag = true; return "x" } +} +assertEquals("abc", "abc".replace(/z/g, replace_obj_side_effects)); +assertTrue(side_effect_flag); // Side effect triggers even without a match. + +var regexp99pattern = ""; +var subject = ""; +for (var i = 0; i < 99; i++) { + regexp99pattern += "(.)"; + subject += String.fromCharCode(i + 24); +} + +function testIndices99(re) { + // Test $1 .. $99 + for (var i = 1; i < 100; i++) { + assertEquals(String.fromCharCode(i + 23), + subject.replace(re, "$" + i)); + } + + // Test $01 .. $09 + for (var i = 1; i < 10; i++) { + assertEquals(String.fromCharCode(i + 23), + subject.replace(re, "$0" + i)); + } + + assertEquals("$0", subject.replace(re, "$0")); + assertEquals("$00", subject.replace(re, "$00")); + assertEquals(String.fromCharCode(10 + 23) + "0", + subject.replace(re, "$100")); +} + +testIndices99(new RegExp(regexp99pattern)); +testIndices99(new RegExp(regexp99pattern, "g")); + +var regexp59pattern = ""; +for (var i = 0; i < 59; i++) regexp59pattern += "(.)"; + +function testIndices59(re) { + // Test $60 .. $99. Captures reach up to 59. Per spec, how to deal + // with this is implementation-dependent. We interpret $60 as $6 + // followed by "0", $61 as $6, followed by "1" and so on. + var tail = subject.substr(59); + for (var i = 60; i < 100; i++) { + assertEquals(String.fromCharCode(i / 10 + 23) + (i % 10) + tail, + subject.replace(re, "$" + i)); + } +} + +testIndices59(new RegExp(regexp59pattern)); +testIndices59(new RegExp(regexp59pattern, "g")); diff --git a/deps/v8/test/mjsunit/string-split.js b/deps/v8/test/mjsunit/string-split.js index d8412f0ee..1308244ca 100644 --- a/deps/v8/test/mjsunit/string-split.js +++ b/deps/v8/test/mjsunit/string-split.js @@ -66,6 +66,23 @@ assertArrayEquals(["div", "#i", "d", ".class"], "div#id.class".split(/(?=[d#.])/ assertArrayEquals(["a", "b", "c"], "abc".split(/(?=.)/)); +assertArrayEquals(["Wenige", "sind", "auserwählt."], + "Wenige sind auserwählt.".split(" ")); + +assertArrayEquals([], "Wenige sind auserwählt.".split(" ", 0)); + +assertArrayEquals(["Wenige"], "Wenige sind auserwählt.".split(" ", 1)); + +assertArrayEquals(["Wenige", "sind"], "Wenige sind auserwählt.".split(" ", 2)); + +assertArrayEquals(["Wenige", "sind", "auserwählt."], + "Wenige sind auserwählt.".split(" ", 3)); + +assertArrayEquals(["Wenige sind auserw", "hlt."], + "Wenige sind auserwählt.".split("ä")); + +assertArrayEquals(["Wenige sind ", "."], + "Wenige sind auserwählt.".split("auserwählt")); /* "ab".split(/((?=.))/) * diff --git a/deps/v8/test/mjsunit/testcfg.py b/deps/v8/test/mjsunit/testcfg.py index 21139562e..00d4500f1 100644 --- a/deps/v8/test/mjsunit/testcfg.py +++ b/deps/v8/test/mjsunit/testcfg.py @@ -57,11 +57,10 @@ class MjsunitTestSuite(testsuite.TestSuite): def GetFlagsForTestCase(self, testcase, context): source = self.GetSourceForTest(testcase) - flags = [] + flags = [] + context.mode_flags flags_match = re.findall(FLAGS_PATTERN, source) for match in flags_match: flags += match.strip().split() - flags += context.mode_flags files_list = [] # List of file names to append to command arguments. files_match = FILES_PATTERN.search(source); @@ -76,7 +75,7 @@ class MjsunitTestSuite(testsuite.TestSuite): for f in files_list ] testfilename = os.path.join(self.root, testcase.path + self.suffix()) if SELF_SCRIPT_PATTERN.search(source): - env = ["-e", "TEST_FILE_NAME=\"%s\"" % testfilename] + env = ["-e", "TEST_FILE_NAME=\"%s\"" % testfilename.replace("\\", "\\\\")] files = env + files files.append(os.path.join(self.root, "mjsunit.js")) files.append(testfilename) diff --git a/deps/v8/test/mjsunit/tools/tickprocessor-test.log b/deps/v8/test/mjsunit/tools/tickprocessor-test.log deleted file mode 100644 index db8be79fa..000000000 --- a/deps/v8/test/mjsunit/tools/tickprocessor-test.log +++ /dev/null @@ -1,25 +0,0 @@ -shared-library,"shell",0x08048000,0x081ee000 -shared-library,"/lib32/libm-2.7.so",0xf7db6000,0xf7dd9000 -shared-library,"ffffe000-fffff000",0xffffe000,0xfffff000 -profiler,"begin",1 -code-creation,Stub,0xf540a100,474,"CEntryStub" -code-creation,Script,0xf541cd80,736,"exp.js" -code-creation,Stub,0xf541d0e0,47,"RuntimeStub_Math_exp" -code-creation,LazyCompile,0xf541d120,145,"exp native math.js:41" -function-creation,0xf441d280,0xf541d120 -code-creation,LoadIC,0xf541d280,117,"j" -code-creation,LoadIC,0xf541d360,63,"i" -tick,0x80f82d1,0xffdfe880,0,0,0,0xf541ce5c -tick,0x80f89a1,0xffdfecf0,0,0,0,0xf541ce5c -tick,0x8123b5c,0xffdff1a0,0,0,0,0xf541d1a1,0xf541ceea -tick,0x8123b65,0xffdff1a0,0,0,0,0xf541d1a1,0xf541ceea -tick,0xf541d2be,0xffdff1e4,0,0,0 -tick,0xf541d320,0xffdff1dc,0,0,0 -tick,0xf541d384,0xffdff1d8,0,0,0 -tick,0xf7db94da,0xffdff0ec,0,0,0,0xf541d1a1,0xf541ceea -tick,0xf7db951c,0xffdff0f0,0,0,0,0xf541d1a1,0xf541ceea -tick,0xf7dbc508,0xffdff14c,0,0,0,0xf541d1a1,0xf541ceea -tick,0xf7dbff21,0xffdff198,0,0,0,0xf541d1a1,0xf541ceea -tick,0xf7edec90,0xffdff0ec,0,0,0,0xf541d1a1,0xf541ceea -tick,0xffffe402,0xffdff488,0,0,0 -profiler,"end" diff --git a/deps/v8/test/mjsunit/tools/tickprocessor.js b/deps/v8/test/mjsunit/tools/tickprocessor.js index c48d9f3a5..00e8f6e73 100644 --- a/deps/v8/test/mjsunit/tools/tickprocessor.js +++ b/deps/v8/test/mjsunit/tools/tickprocessor.js @@ -380,7 +380,10 @@ function driveTickProcessorTest( separateIc, TickProcessor.CALL_GRAPH_SIZE, ignoreUnknown, - stateFilter); + stateFilter, + undefined, + "0", + "auto,auto"); var pm = new PrintMonitor(testsPath + refOutput); tp.processLogFileInTest(testsPath + logInput); tp.printStatistics(); diff --git a/deps/v8/test/mjsunit/uri.js b/deps/v8/test/mjsunit/uri.js index 178ff1f2a..fae349f43 100644 --- a/deps/v8/test/mjsunit/uri.js +++ b/deps/v8/test/mjsunit/uri.js @@ -76,3 +76,15 @@ assertEquals(cc8_2, decodeURI(encodeURI(s8)).charCodeAt(1)); assertEquals(cc9_1, decodeURI(encodeURI(s9)).charCodeAt(0)); assertEquals(cc9_2, decodeURI(encodeURI(s9)).charCodeAt(1)); assertEquals(cc10, decodeURI(encodeURI(s10)).charCodeAt(0)); + +assertEquals("", decodeURI("")); +assertEquals("", encodeURI("")); + +function test(string) { + assertEquals(string, decodeURI(encodeURI(string))); +} + +test("\u1234\u0123\uabcd"); +test("abcd"); +test("ab<\u1234\u0123"); +test("ab\u1234<\u0123"); |