jdk8-mips64-public/nashorn: test/script/basic/JDK-8035712.js@58791cd01bc9 (annotated)

test/script/basic/JDK-8035712.js@58791cd01bc9 (annotated)

test/script/basic/JDK-8035712.js

Tue, 28 Jul 2015 14:52:34 +0530

author: sundar
date: Tue, 28 Jul 2015 14:52:34 +0530
changeset 1482: 58791cd01bc9
parent 1252: a79ab34ef127
permissions: -rw-r--r--

8132092: Nashorn copyright has to be updated
Reviewed-by: jlaskey, hannesw, mhaupt

 /*
  * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 /**
  * JDK-8035712: Restore some of the RuntimeCallSite specializations
  *
  * @test
  * @run
  */
 if ((typeof Assert) == "undefined") {
     Assert = {
         assertTrue: function(x) { if(!x) { throw "expected true" } },
         assertFalse: function(x) { if(x) { throw "expected false" } },
     };
 }
 function nop() {}
 function EQ(x, y) {
     // Exercise normal evaluation
     Assert.assertTrue (x == y);
     Assert.assertTrue (y == x);
     Assert.assertFalse(x != y);
     Assert.assertFalse(y != x);
     // Exercise the branch optimizer
     if (x == y) { nop(); } else { Assert.fail(); }
     if (y == x) { nop(); } else { Assert.fail(); }
     if (x != y) { Assert.fail(); } else { nop(); }
     if (y != x) { Assert.fail(); } else { nop(); }
 }
 function NE(x, y) {
     // Exercise normal evaluation
     Assert.assertTrue (x != y);
     Assert.assertTrue (y != x);
     Assert.assertFalse(x == y);
     Assert.assertFalse(y == x);
     // Exercise the branch optimizer
     if (x != y) { nop(); } else { Assert.fail(); }
     if (y != x) { nop(); } else { Assert.fail(); }
     if (x == y) { Assert.fail(); } else { nop(); }
     if (y == x) { Assert.fail(); } else { nop(); }
 }
 function STRICT_EQ(x, y) {
     // Exercise normal evaluation
     Assert.assertTrue (x === y);
     Assert.assertTrue (y === x);
     Assert.assertFalse(x !== y);
     Assert.assertFalse(y !== x);
     // Exercise the branch optimizer
     if (x === y) { nop(); } else { Assert.fail(); }
     if (y === x) { nop(); } else { Assert.fail(); }
     if (x !== y) { Assert.fail(); } else { nop(); }
     if (y !== x) { Assert.fail(); } else { nop(); }
 }
 function STRICT_NE(x, y) {
     // Exercise normal evaluation
     Assert.assertTrue (x !== y);
     Assert.assertTrue (y !== x);
     Assert.assertFalse(x === y);
     Assert.assertFalse(y === x);
     // Exercise the branch optimizer
     if (x !== y) { nop(); } else { Assert.fail(); }
     if (y !== x) { nop(); } else { Assert.fail(); }
     if (x === y) { Assert.fail(); } else { nop(); }
     if (y === x) { Assert.fail(); } else { nop(); }
 }
 function cmpToAnyNumber(cmp, value) {
     cmp(1, value);
     cmp(4294967296, value);
     cmp(1.2, value);
     cmp(Infinity, value);
     cmp(-Infinity, value);
     cmp(1/Infinity, value);
     cmp(0, value);
     cmp(-0, value);
     cmp(true, value);
     cmp(false, value);
 }
 function notEqualToAnyNumber(value) {
     cmpToAnyNumber(NE, value);
     cmpToAnyNumber(STRICT_NE, value);
 }
 notEqualToAnyNumber(null);
 notEqualToAnyNumber(void 0);
 notEqualToAnyNumber("abc");
 notEqualToAnyNumber({});
 notEqualToAnyNumber(["xyz"]);
 function objectWithPrimitiveFunctionNotEqualToAnyNumber(fnName) {
     var obj = {
         count: 0
     };
     obj[fnName] = function() { this.count++; return "foo"; };
     notEqualToAnyNumber(obj);
     // Every NE will invoke it 8 times; cmpToAnyNumber has 10 comparisons
     // STRICT_NE doesn't invoke toString.
     Assert.assertTrue(80 === obj.count);
 }
 objectWithPrimitiveFunctionNotEqualToAnyNumber("valueOf");
 objectWithPrimitiveFunctionNotEqualToAnyNumber("toString");
 function objectEqualButNotStrictlyEqual(val, obj) {
     EQ(val, obj);
     STRICT_NE(val, obj);
 }
 function numberEqualButNotStrictlyEqualToObject(num, obj) {
     objectEqualButNotStrictlyEqual(num, obj);
     objectEqualButNotStrictlyEqual(num, [obj]);
     objectEqualButNotStrictlyEqual(num, [[obj]]);
 }
 function numberEqualButNotStrictlyEqualToZeroObjects(num) {
     numberEqualButNotStrictlyEqualToObject(num, [0]);
     numberEqualButNotStrictlyEqualToObject(num, "");
     numberEqualButNotStrictlyEqualToObject(num, []);
     numberEqualButNotStrictlyEqualToObject(num, "0");
 }
 numberEqualButNotStrictlyEqualToZeroObjects(0);
 numberEqualButNotStrictlyEqualToZeroObjects(1/Infinity);
 numberEqualButNotStrictlyEqualToZeroObjects(false);
 function numberEqualButNotStrictlyEqualToObjectEquivalent(num) {
     var str = String(num);
     objectEqualButNotStrictlyEqual(num, str);
     objectEqualButNotStrictlyEqual(num, { valueOf:  function() { return str }});
     objectEqualButNotStrictlyEqual(num, { toString: function() { return str }});
     objectEqualButNotStrictlyEqual(num, { valueOf:  function() { return num }});
     objectEqualButNotStrictlyEqual(num, { toString: function() { return num }});
 }
 numberEqualButNotStrictlyEqualToObjectEquivalent(1);
 numberEqualButNotStrictlyEqualToObjectEquivalent(4294967296);
 numberEqualButNotStrictlyEqualToObjectEquivalent(1.2);
 numberEqualButNotStrictlyEqualToObjectEquivalent(Infinity);
 numberEqualButNotStrictlyEqualToObjectEquivalent(-Infinity);
 numberEqualButNotStrictlyEqualToObjectEquivalent(1/Infinity);
 numberEqualButNotStrictlyEqualToObjectEquivalent(0);
 numberEqualButNotStrictlyEqualToObjectEquivalent(-0);
 STRICT_EQ(1, new java.lang.Integer(1));
 STRICT_EQ(1, new java.lang.Double(1));
 STRICT_EQ(1.2, new java.lang.Double(1.2));
 function LE(x, y) {
     // Exercise normal evaluation
     Assert.assertTrue(x <= y);
     Assert.assertTrue(y >= x);
     Assert.assertFalse(x > y);
     Assert.assertFalse(x < y);
     // Exercise the branch optimizer
     if (x <= y) { nop(); } else { Assert.fail(); }
     if (y >= x) { nop(); } else { Assert.fail(); }
     if (x > y) { Assert.fail(); } else { nop(); }
     if (y < x) { Assert.fail(); } else { nop(); }
 }
 function mutuallyLessThanOrEqual(x, y) {
     LE(x, y);
     LE(y, x);
 }
 mutuallyLessThanOrEqual(0, null);
 mutuallyLessThanOrEqual(false, null);
 mutuallyLessThanOrEqual(1/Infinity, null);
 function mutuallyLessThanEqualToObjectWithValue(num, val) {
     mutuallyLessThanOrEqual(num, { valueOf: function() { return val } });
     mutuallyLessThanOrEqual(num, { toString: function() { return val } });
 }
 mutuallyLessThanEqualToObjectWithValue(false, 0);
 mutuallyLessThanEqualToObjectWithValue(false, "");
 mutuallyLessThanEqualToObjectWithValue(true, 1);
 mutuallyLessThanEqualToObjectWithValue(true, "1");
 function lessThanEqualToObjectEquivalent(num) {
     var str = String(num);
     mutuallyLessThanOrEqual(num, str);
     mutuallyLessThanEqualToObjectWithValue(num, num);
     mutuallyLessThanEqualToObjectWithValue(num, str);
 }
 lessThanEqualToObjectEquivalent(1);
 lessThanEqualToObjectEquivalent(4294967296);
 lessThanEqualToObjectEquivalent(1.2);
 lessThanEqualToObjectEquivalent(Infinity);
 lessThanEqualToObjectEquivalent(-Infinity);
 lessThanEqualToObjectEquivalent(1/Infinity);
 lessThanEqualToObjectEquivalent(0);
 lessThanEqualToObjectEquivalent(-0);
 function INCOMPARABLE(x, y) {
     // Exercise normal evaluation
     Assert.assertFalse(x < y);
     Assert.assertFalse(x > y);
     Assert.assertFalse(x <= y);
     Assert.assertFalse(x >= y);
     Assert.assertFalse(y < x);
     Assert.assertFalse(y > x);
     Assert.assertFalse(y <= x);
     Assert.assertFalse(y >= x);
     // Exercise the branch optimizer
     if (x < y) { Assert.fail(); } else { nop(); }
     if (x > y) { Assert.fail(); } else { nop(); }
     if (x <= y) { Assert.fail(); } else { nop(); }
     if (x >= y) { Assert.fail(); } else { nop(); }
     if (y < x) { Assert.fail(); } else { nop(); }
     if (y > x) { Assert.fail(); } else { nop(); }
     if (y <= x) { Assert.fail(); } else { nop(); }
     if (y >= x) { Assert.fail(); } else { nop(); }
 }
 function isIncomparable(value) {
     cmpToAnyNumber(INCOMPARABLE, value);
 }
 isIncomparable(void 0);
 isIncomparable({ valueOf: function() { return NaN }});
 isIncomparable({ toString: function() { return NaN }});
 // Force ScriptRuntime.LT(Object, Object) etc. comparisons
 function cmpObj(fn, x, y) {
     fn({valueOf: function() { return x }}, {valueOf: function() { return y }});
 }
 function LT(x, y) {
     Assert.assertTrue(x < y);
     Assert.assertTrue(y > x);
     Assert.assertFalse(x >= y);
     Assert.assertFalse(y <= x);
 }
 cmpObj(LT, 1, 2);
 cmpObj(LT, 1, "2");
 cmpObj(LT, "1", 2);
 cmpObj(LT, "a", "b");
 cmpObj(LT, -Infinity, 0);
 cmpObj(LT, 0, Infinity);
 cmpObj(LT, -Infinity, Infinity);
 cmpObj(INCOMPARABLE, 1, NaN);
 cmpObj(INCOMPARABLE, NaN, NaN);
 cmpObj(INCOMPARABLE, "boo", NaN);
 cmpObj(INCOMPARABLE, 1, "boo"); // boo number value will be NaN
 // Test that a comparison call site can deoptimize from (int, int) to (object, object)
 (function(){
     var x = [1,  2,  "a"];
     var y = [2, "3", "b"];
     for(var i = 0; i < 3; ++i) {
         Assert.assertTrue(x[i] < y[i]);
     }
 })();