Tue, 13 Oct 2015 18:43:30 +0300
Merge
jlaskey@3 | 1 | /* |
jlaskey@7 | 2 | * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved. |
jlaskey@3 | 3 | * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
attila@962 | 4 | * |
jlaskey@3 | 5 | * This code is free software; you can redistribute it and/or modify it |
jlaskey@3 | 6 | * under the terms of the GNU General Public License version 2 only, as |
jlaskey@3 | 7 | * published by the Free Software Foundation. |
attila@962 | 8 | * |
jlaskey@3 | 9 | * This code is distributed in the hope that it will be useful, but WITHOUT |
jlaskey@3 | 10 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
jlaskey@3 | 11 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
jlaskey@3 | 12 | * version 2 for more details (a copy is included in the LICENSE file that |
jlaskey@3 | 13 | * accompanied this code). |
attila@962 | 14 | * |
jlaskey@3 | 15 | * You should have received a copy of the GNU General Public License version |
jlaskey@3 | 16 | * 2 along with this work; if not, write to the Free Software Foundation, |
jlaskey@3 | 17 | * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
attila@962 | 18 | * |
jlaskey@3 | 19 | * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
jlaskey@3 | 20 | * or visit www.oracle.com if you need additional information or have any |
jlaskey@3 | 21 | * questions. |
jlaskey@3 | 22 | */ |
jlaskey@3 | 23 | |
jlaskey@3 | 24 | /** |
jlaskey@3 | 25 | * Tests for conversion of JavaScript arrays to Java arrays and the other |
attila@962 | 26 | * way round. Also generally useful as a JavaScript-to-Java type conversion |
jlaskey@3 | 27 | * test. |
jlaskey@3 | 28 | * |
jlaskey@3 | 29 | * @test |
jlaskey@3 | 30 | * @run |
jlaskey@3 | 31 | */ |
jlaskey@3 | 32 | |
jlaskey@3 | 33 | var x; // used for undefined |
jlaskey@3 | 34 | var testCount = 0; |
jlaskey@3 | 35 | |
jlaskey@3 | 36 | function testF(inputValue, type, testFn) { |
attila@279 | 37 | var x = Java.to([inputValue], type + "[]")[0]; |
jlaskey@3 | 38 | if(!testFn(x)) { |
jlaskey@3 | 39 | throw ("unexpected value: " + x) |
jlaskey@3 | 40 | } |
jlaskey@3 | 41 | ++testCount; |
jlaskey@3 | 42 | } |
jlaskey@3 | 43 | |
jlaskey@3 | 44 | function test(inputValue, type, expectedValue) { |
jlaskey@3 | 45 | testF(inputValue, type, function(x) { return x === expectedValue }) |
jlaskey@3 | 46 | } |
jlaskey@3 | 47 | |
jlaskey@3 | 48 | function testNaN(inputValue, type) { |
jlaskey@3 | 49 | testF(inputValue, type, isNaN) |
jlaskey@3 | 50 | } |
jlaskey@3 | 51 | |
attila@962 | 52 | // Those labeled "Correct?" are not clearly correct conversions. Those |
attila@962 | 53 | // labeled "TypeError maybe?" could actually throw a TypeError, or only |
attila@962 | 54 | // throw a TypeError when in strict mode. |
jlaskey@3 | 55 | // The case of ("false", "boolean") => true is particularly amusing. |
jlaskey@3 | 56 | |
jlaskey@3 | 57 | test(x, "int", 0) // Correct? TypeError maybe? |
jlaskey@3 | 58 | test(null, "int", 0) // Correct? TypeError maybe? |
jlaskey@3 | 59 | test(1234, "int", 1234) |
jlaskey@3 | 60 | test("1234", "int", 1234) |
jlaskey@3 | 61 | test("1234.49", "int", 1234) |
jlaskey@3 | 62 | test("1234.51", "int", 1234) // truncates, not rounds |
jlaskey@3 | 63 | test(true, "int", 1) |
jlaskey@3 | 64 | test(false, "int", 0) |
jlaskey@3 | 65 | test("foo", "int", 0) // Correct? TypeError maybe? |
jlaskey@3 | 66 | |
jlaskey@3 | 67 | test(x, "boolean", false) // Correct? TypeError maybe? |
jlaskey@3 | 68 | test(null, "boolean", false) // Correct? TypeError maybe? |
jlaskey@3 | 69 | test(0, "boolean", false) |
jlaskey@3 | 70 | test(1234, "boolean", true) |
jlaskey@3 | 71 | test("foo", "boolean", true) |
jlaskey@3 | 72 | test("", "boolean", false) |
jlaskey@3 | 73 | test("false", "boolean", true) // Correct? false maybe? |
jlaskey@3 | 74 | |
jlaskey@3 | 75 | test(x, "java.lang.String", "undefined") // Correct? TypeError maybe? |
jlaskey@3 | 76 | test(null, "java.lang.String", null) |
jlaskey@3 | 77 | test(1234, "java.lang.String", "1234") |
jlaskey@3 | 78 | test(1234.5, "java.lang.String", "1234.5") |
jlaskey@3 | 79 | test(true, "java.lang.String", "true") |
jlaskey@3 | 80 | test(false, "java.lang.String", "false") |
jlaskey@3 | 81 | |
jlaskey@3 | 82 | test(x, "java.lang.Integer", null) // Correct? TypeError maybe? |
jlaskey@3 | 83 | test(null, "java.lang.Integer", null) |
jlaskey@3 | 84 | test(1234, "java.lang.Integer", 1234) |
jlaskey@3 | 85 | test("1234", "java.lang.Integer", 1234) |
jlaskey@3 | 86 | test("1234.49", "java.lang.Integer", 1234) |
jlaskey@3 | 87 | test("1234.51", "java.lang.Integer", 1234) // truncates, not rounds |
jlaskey@3 | 88 | test(true, "java.lang.Integer", 1) |
jlaskey@3 | 89 | test(false, "java.lang.Integer", 0) |
jlaskey@3 | 90 | test("foo", "java.lang.Integer", 0) // Correct? TypeError maybe? |
jlaskey@3 | 91 | |
jlaskey@3 | 92 | test(x, "java.lang.Boolean", null) // Correct? TypeError maybe? |
jlaskey@3 | 93 | test(null, "java.lang.Boolean", null) |
jlaskey@3 | 94 | test(0, "java.lang.Boolean", false) |
jlaskey@3 | 95 | test(1234, "java.lang.Boolean", true) |
jlaskey@3 | 96 | test("foo", "java.lang.Boolean", true) |
jlaskey@3 | 97 | test("", "java.lang.Boolean", false) |
jlaskey@3 | 98 | test("false", "java.lang.Boolean", true) // Correct? false maybe? |
jlaskey@3 | 99 | |
jlaskey@3 | 100 | testNaN(x, "double") |
jlaskey@3 | 101 | test(null, "double", 0) |
jlaskey@3 | 102 | test(1234, "double", 1234) |
jlaskey@3 | 103 | test("1234", "double", 1234) |
jlaskey@3 | 104 | test("1234.5", "double", 1234.5) |
jlaskey@3 | 105 | test(true, "double", 1) |
jlaskey@3 | 106 | test(false, "double", 0) |
jlaskey@3 | 107 | testNaN("foo", "double") |
jlaskey@3 | 108 | |
jlaskey@3 | 109 | testNaN(x, "java.lang.Double") |
jlaskey@3 | 110 | test(null, "java.lang.Double", null) |
jlaskey@3 | 111 | test(1234, "java.lang.Double", 1234) |
jlaskey@3 | 112 | test("1234", "java.lang.Double", 1234) |
jlaskey@3 | 113 | test("1234.5", "java.lang.Double", 1234.5) |
jlaskey@3 | 114 | test(true, "java.lang.Double", 1) |
jlaskey@3 | 115 | test(false, "java.lang.Double", 0) |
jlaskey@3 | 116 | testNaN("foo", "java.lang.Double") |
jlaskey@3 | 117 | |
jlaskey@3 | 118 | test({ valueOf: function() { return 42; } }, "int", 42) |
jlaskey@3 | 119 | test({ valueOf: function() { return "42"; } }, "int", 42) |
jlaskey@3 | 120 | // If there's no valueOf, toString is used |
jlaskey@3 | 121 | test({ toString: function() { return "42"; } }, "int", 42) |
jlaskey@3 | 122 | // For numbers, valueOf takes precedence over toString |
jlaskey@3 | 123 | test({ valueOf: function() { return "42"; }, toString: function() { return "43"; } }, "int", 42) |
jlaskey@3 | 124 | |
jlaskey@3 | 125 | test({ toString: function() { return "foo"; } }, "java.lang.String", "foo") |
jlaskey@3 | 126 | // Yep, even if we have valueOf, toString from prototype takes precedence |
jlaskey@3 | 127 | test({ valueOf: function() { return 42; } }, "java.lang.String", "[object Object]") |
jlaskey@3 | 128 | // Converting to string, toString takes precedence over valueOf |
jlaskey@3 | 129 | test({ valueOf: function() { return "42"; }, toString: function() { return "43"; } }, "java.lang.String", "43") |
jlaskey@3 | 130 | |
jlaskey@3 | 131 | function assertCantConvert(sourceType, targetType) { |
jlaskey@3 | 132 | try { |
attila@279 | 133 | Java.to([new Java.type(sourceType)()], targetType + "[]") |
jlaskey@3 | 134 | throw "no TypeError encountered" |
jlaskey@3 | 135 | } catch(e) { |
jlaskey@3 | 136 | if(!(e instanceof TypeError)) { |
jlaskey@3 | 137 | throw e; |
jlaskey@3 | 138 | } |
jlaskey@3 | 139 | ++testCount; |
jlaskey@3 | 140 | } |
jlaskey@3 | 141 | } |
jlaskey@3 | 142 | |
jlaskey@3 | 143 | // Arbitrary POJOs can't be converted to Java values |
jlaskey@3 | 144 | assertCantConvert("java.util.BitSet", "int") |
jlaskey@3 | 145 | assertCantConvert("java.util.BitSet", "double") |
jlaskey@3 | 146 | assertCantConvert("java.util.BitSet", "long") |
jlaskey@3 | 147 | assertCantConvert("java.util.BitSet", "boolean") |
jlaskey@3 | 148 | assertCantConvert("java.util.BitSet", "java.lang.String") |
jlaskey@3 | 149 | assertCantConvert("java.util.BitSet", "java.lang.Double") |
jlaskey@3 | 150 | assertCantConvert("java.util.BitSet", "java.lang.Long") |
jlaskey@3 | 151 | |
jlaskey@3 | 152 | /*************************************************************************** |
jlaskey@3 | 153 | * Now testing the other way round - Java arrays & collections to JavaScript |
jlaskey@3 | 154 | **************************************************************************/ |
jlaskey@3 | 155 | |
jlaskey@3 | 156 | function assert(x) { |
jlaskey@3 | 157 | if(!x) { |
jlaskey@3 | 158 | throw "Assertion failed" |
jlaskey@3 | 159 | } |
jlaskey@3 | 160 | ++testCount; |
jlaskey@3 | 161 | } |
jlaskey@3 | 162 | |
jlaskey@3 | 163 | var intArray = new (Java.type("int[]"))(3) |
jlaskey@3 | 164 | intArray[0] = 1234; |
jlaskey@3 | 165 | intArray[1] = 42; |
jlaskey@3 | 166 | intArray[2] = 5; |
attila@279 | 167 | var jsIntArray = Java.from(intArray) |
jlaskey@3 | 168 | assert(jsIntArray instanceof Array); |
jlaskey@3 | 169 | assert(jsIntArray[0] === 1234); |
jlaskey@3 | 170 | assert(jsIntArray[1] === 42); |
jlaskey@3 | 171 | assert(jsIntArray[2] === 5); |
jlaskey@3 | 172 | |
jlaskey@3 | 173 | // The arrays are copies, they don't reflect each other |
jlaskey@3 | 174 | intArray[2] = 6; |
jlaskey@3 | 175 | assert(jsIntArray[2] === 5); |
jlaskey@3 | 176 | jsIntArray[2] = 7; |
jlaskey@3 | 177 | assert(intArray[2] === 6); |
jlaskey@3 | 178 | |
jlaskey@3 | 179 | var byteArray = new (Java.type("byte[]"))(2) |
jlaskey@3 | 180 | byteArray[0] = -128; |
jlaskey@3 | 181 | byteArray[1] = 127; |
attila@279 | 182 | var jsByteArray = Java.from(byteArray) |
jlaskey@3 | 183 | assert(jsByteArray instanceof Array); |
jlaskey@3 | 184 | assert(jsByteArray[0] === -128); |
jlaskey@3 | 185 | assert(jsByteArray[1] === 127); |
jlaskey@3 | 186 | |
jlaskey@3 | 187 | var shortArray = new (Java.type("short[]"))(2) |
jlaskey@3 | 188 | shortArray[0] = -32768; |
jlaskey@3 | 189 | shortArray[1] = 32767; |
attila@279 | 190 | var jsShortArray = Java.from(shortArray) |
jlaskey@3 | 191 | assert(jsShortArray instanceof Array); |
jlaskey@3 | 192 | assert(jsShortArray[0] === -32768); |
jlaskey@3 | 193 | assert(jsShortArray[1] === 32767); |
jlaskey@3 | 194 | |
jlaskey@3 | 195 | var floatArray = new (Java.type("float[]"))(2) |
jlaskey@3 | 196 | floatArray[0] = java.lang.Float.MIN_VALUE; |
jlaskey@3 | 197 | floatArray[1] = java.lang.Float.MAX_VALUE; |
attila@279 | 198 | var jsFloatArray = Java.from(floatArray) |
jlaskey@3 | 199 | assert(jsFloatArray instanceof Array); |
jlaskey@3 | 200 | assert(jsFloatArray[0] == java.lang.Float.MIN_VALUE); |
jlaskey@3 | 201 | assert(jsFloatArray[1] == java.lang.Float.MAX_VALUE); |
jlaskey@3 | 202 | |
jlaskey@3 | 203 | var charArray = new (Java.type("char[]"))(3) |
jlaskey@3 | 204 | charArray[0] = "a"; |
jlaskey@3 | 205 | charArray[1] = "b"; |
jlaskey@3 | 206 | charArray[2] = "1"; |
attila@279 | 207 | var jsCharArray = Java.from(charArray) |
jlaskey@3 | 208 | assert(jsCharArray instanceof Array); |
jlaskey@3 | 209 | assert(jsCharArray[0] === 97); |
jlaskey@3 | 210 | assert(jsCharArray[1] === 98); |
jlaskey@3 | 211 | assert(jsCharArray[2] === 49); |
jlaskey@3 | 212 | |
jlaskey@3 | 213 | var booleanArray = new (Java.type("boolean[]"))(2) |
jlaskey@3 | 214 | booleanArray[0] = true; |
jlaskey@3 | 215 | booleanArray[1] = false; |
attila@279 | 216 | var jsBooleanArray = Java.from(booleanArray) |
jlaskey@3 | 217 | assert(jsBooleanArray instanceof Array); |
jlaskey@3 | 218 | assert(jsBooleanArray[0] === true); |
jlaskey@3 | 219 | assert(jsBooleanArray[1] === false); |
jlaskey@3 | 220 | |
jlaskey@3 | 221 | print(testCount + " tests completed ok") |