1 /*
   2  * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package jdk.nashorn.api.javaaccess.test;
  27 
  28 import static org.testng.AssertJUnit.assertEquals;
  29 import static org.testng.AssertJUnit.assertFalse;
  30 import static org.testng.AssertJUnit.assertNull;
  31 import static org.testng.AssertJUnit.assertTrue;
  32 import java.util.Arrays;
  33 import java.util.List;
  34 import javax.script.ScriptContext;
  35 import javax.script.ScriptEngine;
  36 import javax.script.ScriptEngineManager;
  37 import javax.script.ScriptException;
  38 import org.testng.TestNG;
  39 import org.testng.annotations.AfterClass;
  40 import org.testng.annotations.BeforeClass;
  41 import org.testng.annotations.Test;
  42 
  43 /**
  44  * @test
  45  * @run testng/othervm jdk.nashorn.api.javaaccess.test.ArrayConversionTest
  46  */
  47 @SuppressWarnings("javadoc")
  48 public class ArrayConversionTest {
  49     private static ScriptEngine e = null;
  50 
  51     public static void main(final String[] args) {
  52         TestNG.main(args);
  53     }
  54 
  55     @BeforeClass
  56     public static void setUpClass() {
  57         e = new ScriptEngineManager().getEngineByName("nashorn");
  58     }
  59 
  60     @AfterClass
  61     public static void tearDownClass() {
  62         e = null;
  63     }
  64 
  65     @Test
  66     public void testIntArrays() throws ScriptException {
  67         runTest("assertNullIntArray", "null");
  68         runTest("assertEmptyIntArray", "[]");
  69         runTest("assertSingle42IntArray", "[42]");
  70         runTest("assertSingle42IntArray", "['42']");
  71         runTest("assertIntArrayConversions", "[false, true, NaN, Infinity, -Infinity, 0.4, 0.6, null, undefined, [], {}, [1], [1, 2]]");
  72     }
  73 
  74     @Test
  75     public void testIntIntArrays() throws ScriptException {
  76         runTest("assertNullIntIntArray", "null");
  77         runTest("assertEmptyIntIntArray", "[]");
  78         runTest("assertSingleEmptyIntIntArray", "[[]]");
  79         runTest("assertSingleNullIntIntArray", "[null]");
  80         runTest("assertLargeIntIntArray", "[[false], [1], [2, 3], [4, 5, 6], ['7', {valueOf: function() { return 8 }}]]");
  81     }
  82 
  83     @Test
  84     public void testObjectObjectArrays() throws ScriptException {
  85         runTest("assertLargeObjectObjectArray", "[[false], [1], ['foo', 42.3], [{x: 17}]]");
  86     }
  87 
  88     @Test
  89     public void testBooleanArrays() throws ScriptException {
  90         runTest("assertBooleanArrayConversions", "[false, true, '', 'false', 0, 1, 0.4, 0.6, {}, [], [false], [true], NaN, Infinity, null, undefined]");
  91     }
  92 
  93     @Test
  94     public void testArrayAmbiguity() throws ScriptException {
  95         runTest("x", "'abc'");
  96         runTest("x", "['foo', 'bar']");
  97     }
  98 
  99     @Test
 100     public void testListArrays() throws ScriptException {
 101         runTest("assertListArray", "[['foo', 'bar'], ['apple', 'orange']]");
 102     }
 103 
 104     @Test
 105     public void testVarArgs() throws ScriptException {
 106         // Sole NativeArray in vararg position becomes vararg array itself
 107         runTest("assertVarArg_42_17", "[42, 17]");
 108         // NativeArray in vararg position becomes an argument if there are more arguments
 109         runTest("assertVarArg_array_17", "[42], 18");
 110         // Only NativeArray is converted to vararg array, other objects (e.g. a function) aren't
 111         runTest("assertVarArg_function", "function() { return 'Hello' }");
 112     }
 113 
 114     private static void runTest(final String testMethodName, final String argument) throws ScriptException {
 115         e.eval("Java.type('" + ArrayConversionTest.class.getName() + "')." + testMethodName + "(" + argument + ")");
 116     }
 117 
 118     public static void assertNullIntArray(final int[] array) {
 119         assertNull(array);
 120     }
 121 
 122     public static void assertNullIntIntArray(final int[][] array) {
 123         assertNull(array);
 124     }
 125 
 126     public static void assertEmptyIntArray(final int[] array) {
 127         assertEquals(0, array.length);
 128     }
 129 
 130     public static void assertSingle42IntArray(final int[] array) {
 131         assertEquals(1, array.length);
 132         assertEquals(42, array[0]);
 133     }
 134 
 135 
 136     public static void assertIntArrayConversions(final int[] array) {
 137         assertEquals(13, array.length);
 138         assertEquals(0, array[0]); // false
 139         assertEquals(1, array[1]); // true
 140         assertEquals(0, array[2]); // NaN
 141         assertEquals(0, array[3]); // Infinity
 142         assertEquals(0, array[4]); // -Infinity
 143         assertEquals(0, array[5]); // 0.4
 144         assertEquals(0, array[6]); // 0.6 - floor, not round
 145         assertEquals(0, array[7]); // null
 146         assertEquals(0, array[8]); // undefined
 147         assertEquals(0, array[9]); // []
 148         assertEquals(0, array[10]); // {}
 149         assertEquals(1, array[11]); // [1]
 150         assertEquals(0, array[12]); // [1, 2]
 151     }
 152 
 153     public static void assertEmptyIntIntArray(final int[][] array) {
 154         assertEquals(0, array.length);
 155     }
 156 
 157     public static void assertSingleEmptyIntIntArray(final int[][] array) {
 158         assertEquals(1, array.length);
 159         assertTrue(Arrays.equals(new int[0], array[0]));
 160     }
 161 
 162     public static void assertSingleNullIntIntArray(final int[][] array) {
 163         assertEquals(1, array.length);
 164         assertNull(null, array[0]);
 165     }
 166 
 167     public static void assertLargeIntIntArray(final int[][] array) {
 168         assertEquals(5, array.length);
 169         assertTrue(Arrays.equals(new int[] { 0 }, array[0]));
 170         assertTrue(Arrays.equals(new int[] { 1 }, array[1]));
 171         assertTrue(Arrays.equals(new int[] { 2, 3 }, array[2]));
 172         assertTrue(Arrays.equals(new int[] { 4, 5, 6 }, array[3]));
 173         assertTrue(Arrays.equals(new int[] { 7, 8 }, array[4]));
 174     }
 175 
 176     public static void assertLargeObjectObjectArray(final Object[][] array) throws ScriptException {
 177         assertEquals(4, array.length);
 178         assertTrue(Arrays.equals(new Object[] { Boolean.FALSE }, array[0]));
 179         assertTrue(Arrays.equals(new Object[] { 1 }, array[1]));
 180         assertTrue(Arrays.equals(new Object[] { "foo", 42.3d }, array[2]));
 181         assertEquals(1, array[3].length);
 182         e.getBindings(ScriptContext.ENGINE_SCOPE).put("obj", array[3][0]);
 183         assertEquals(17, e.eval("obj.x"));
 184     }
 185 
 186     public static void assertBooleanArrayConversions(final boolean[] array) {
 187         assertEquals(16, array.length);
 188         assertFalse(array[0]); // false
 189         assertTrue(array[1]); // true
 190         assertFalse(array[2]); // ''
 191         assertTrue(array[3]); // 'false' (yep, every non-empty string converts to true)
 192         assertFalse(array[4]); // 0
 193         assertTrue(array[5]); // 1
 194         assertTrue(array[6]); // 0.4
 195         assertTrue(array[7]); // 0.6
 196         assertTrue(array[8]); // {}
 197         assertTrue(array[9]); // []
 198         assertTrue(array[10]); // [false]
 199         assertTrue(array[11]); // [true]
 200         assertFalse(array[12]); // NaN
 201         assertTrue(array[13]); // Infinity
 202         assertFalse(array[14]); // null
 203         assertFalse(array[15]); // undefined
 204     }
 205 
 206     public static void assertListArray(final List<?>[] array) {
 207         assertEquals(2, array.length);
 208         assertEquals(Arrays.asList("foo", "bar"), array[0]);
 209         assertEquals(Arrays.asList("apple", "orange"), array[1]);
 210     }
 211 
 212     public static void assertVarArg_42_17(final Object... args) {
 213         assertEquals(2, args.length);
 214         assertEquals(42, ((Number)args[0]).intValue());
 215         assertEquals(17, ((Number)args[1]).intValue());
 216     }
 217 
 218     public static void assertVarArg_array_17(final Object... args) throws ScriptException {
 219         assertEquals(2, args.length);
 220         e.getBindings(ScriptContext.ENGINE_SCOPE).put("arr", args[0]);
 221         assertTrue((Boolean)e.eval("arr instanceof Array && arr.length == 1 && arr[0] == 42"));
 222         assertEquals(18, ((Number)args[1]).intValue());
 223     }
 224 
 225     public static void assertVarArg_function(final Object... args) throws ScriptException {
 226         assertEquals(1, args.length);
 227         e.getBindings(ScriptContext.ENGINE_SCOPE).put("fn", args[0]);
 228         assertEquals("Hello", e.eval("fn()"));
 229     }
 230 
 231 
 232 
 233     public static void x(final String y) {
 234         assertEquals("abc", y);
 235     }
 236     public static void x(final String[] y) {
 237         assertTrue(Arrays.equals(new String[] { "foo", "bar"}, y));
 238     }
 239 }