ArrayConversionTest.java revision 1806:b4e57ead3fae 
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
26package jdk.nashorn.api.javaaccess.test;
27
28import static org.testng.AssertJUnit.assertEquals;
29import static org.testng.AssertJUnit.assertFalse;
30import static org.testng.AssertJUnit.assertNull;
31import static org.testng.AssertJUnit.assertTrue;
32import java.util.Arrays;
33import java.util.List;
34import javax.script.ScriptContext;
35import javax.script.ScriptEngine;
36import javax.script.ScriptEngineManager;
37import javax.script.ScriptException;
38import org.testng.TestNG;
39import org.testng.annotations.AfterClass;
40import org.testng.annotations.BeforeClass;
41import org.testng.annotations.Test;
42
43/**
44 * @test
45 * @run testng/othervm jdk.nashorn.api.javaaccess.test.ArrayConversionTest
46 */
47@SuppressWarnings("javadoc")
48public 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("assertVarArgWith42And17", "[42, 17]");
108        // NativeArray in vararg position becomes an argument if there are more arguments
109        runTest("assertVarArgArray7", "[42], 18");
110        // Only NativeArray is converted to vararg array, other objects (e.g. a function) aren't
111        runTest("assertVarArgFunction", "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 assertVarArgWith42And17(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 assertVarArgArray7(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 assertVarArgFunction(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}
240