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.assertTrue; 30 import javax.script.ScriptEngine; 31 import javax.script.ScriptEngineManager; 32 import javax.script.ScriptException; 33 import org.testng.TestNG; 34 import org.testng.annotations.AfterClass; 35 import org.testng.annotations.BeforeClass; 36 import org.testng.annotations.Test; 37 38 /** 39 * @test 40 * @build jdk.nashorn.api.javaaccess.test.SharedObject jdk.nashorn.api.javaaccess.test.Person jdk.nashorn.api.javaaccess.test.NumberBoxingTest 41 * @run testng/othervm jdk.nashorn.api.javaaccess.test.NumberBoxingTest 42 */ 43 @SuppressWarnings("javadoc") 44 public class NumberBoxingTest { 45 46 private static ScriptEngine e; 47 private static SharedObject o; 48 49 public static void main(final String[] args) { 50 TestNG.main(args); 51 } 52 53 @BeforeClass 54 public static void setUpClass() throws ScriptException { 55 final ScriptEngineManager m = new ScriptEngineManager(); 56 e = m.getEngineByName("nashorn"); 57 o = new SharedObject(); 58 e.put("o", o); 59 e.eval("var SharedObject = Packages.jdk.nashorn.api.javaaccess.test.SharedObject;"); 60 } 61 62 @AfterClass 63 public static void tearDownClass() { 64 e = null; 65 o = null; 66 } 67 68 // --------------------------------long 69 // tests------------------------------------ 70 @Test 71 public void accessFieldLongBoxing() throws ScriptException { 72 e.eval("var p_long = o.publicLongBox;"); 73 assertEquals(o.publicLongBox.longValue(), ((Number) e.get("p_long")).longValue()); 74 e.eval("o.publicLongBox = 12;"); 75 assertEquals(Long.valueOf(12), o.publicLongBox); 76 } 77 78 @Test 79 public void accessStaticFieldLongBoxing() throws ScriptException { 80 e.eval("var ps_long = SharedObject.publicStaticLongBox;"); 81 assertEquals(SharedObject.publicStaticLongBox.longValue(), ((Number) e.get("ps_long")).longValue()); 82 e.eval("SharedObject.publicStaticLongBox = 120;"); 83 assertEquals(120L, SharedObject.publicStaticLongBox.longValue()); 84 } 85 86 @Test 87 public void accessFinalFieldLongBoxing() throws ScriptException { 88 e.eval("var pf_long = o.publicFinalLongBox;"); 89 assertEquals(o.publicFinalLongBox.longValue(), ((Number) e.get("pf_long")).longValue()); 90 e.eval("o.publicFinalLongBox = 120;"); 91 assertEquals(Long.valueOf(9377333334L), o.publicFinalLongBox); 92 } 93 94 @Test 95 public void accessStaticFinalFieldLongBoxing() throws ScriptException { 96 e.eval("var psf_long = SharedObject.publicStaticFinalLong;"); 97 assertEquals(SharedObject.publicStaticFinalLong, ((Number) e.get("psf_long")).longValue()); 98 e.eval("SharedObject.publicStaticFinalLong = 120;"); 99 assertEquals(8333333333333L, SharedObject.publicStaticFinalLong); 100 } 101 102 // --------------------------------int 103 // tests------------------------------------ 104 @Test 105 public void accessFieldIntBoxing() throws ScriptException { 106 e.eval("var p_int = o.publicIntBox;"); 107 assertEquals(o.publicIntBox, e.get("p_int")); 108 e.eval("o.publicIntBox = 14;"); 109 assertEquals(Integer.valueOf(14), o.publicIntBox); 110 } 111 112 @Test 113 public void accessStaticFieldIntBoxing() throws ScriptException { 114 e.eval("var ps_int = SharedObject.publicStaticInt;"); 115 assertEquals(SharedObject.publicStaticInt, e.get("ps_int")); 116 e.eval("SharedObject.publicStaticInt = 140;"); 117 assertEquals(140, SharedObject.publicStaticInt); 118 } 119 120 @Test 121 public void accessFinalFieldIntBoxing() throws ScriptException { 122 e.eval("var pf_int = o.publicFinalIntBox;"); 123 assertEquals(o.publicFinalIntBox, e.get("pf_int")); 124 e.eval("o.publicFinalIntBox = 10;"); 125 assertEquals(Integer.valueOf(207512301), o.publicFinalIntBox); 126 } 127 128 @Test 129 public void accessStaticFinalFieldIntBoxing() throws ScriptException { 130 e.eval("var psf_int = SharedObject.publicStaticFinalInt;"); 131 assertEquals(SharedObject.publicStaticFinalInt, e.get("psf_int")); 132 e.eval("SharedObject.publicStaticFinalInt = 140;"); 133 assertEquals(207182023, SharedObject.publicStaticFinalInt); 134 } 135 136 // --------------------------------byte 137 // tests------------------------------------ 138 @Test 139 public void accessFieldByteBoxing() throws ScriptException { 140 e.eval("var p_byte = o.publicByteBox;"); 141 assertEqualsDouble(o.publicByteBox, "p_byte"); 142 e.eval("o.publicByteBox = 16;"); 143 assertEquals(Byte.valueOf((byte)16), o.publicByteBox); 144 } 145 146 @Test 147 public void accessStaticFieldByteBoxing() throws ScriptException { 148 e.eval("var ps_byte = SharedObject.publicStaticByte;"); 149 assertEqualsDouble(SharedObject.publicStaticByte, "ps_byte"); 150 e.eval("SharedObject.publicStaticByte = 16;"); 151 assertEquals(16, SharedObject.publicStaticByte); 152 } 153 154 @Test 155 public void accessFinalFieldByteBoxing() throws ScriptException { 156 e.eval("var pf_byte = o.publicFinalByteBox;"); 157 assertEqualsDouble(o.publicFinalByteBox, "pf_byte"); 158 e.eval("o.publicFinalByteBox = 16;"); 159 assertEquals(Byte.valueOf((byte)19), o.publicFinalByteBox); 160 } 161 162 @Test 163 public void accessStaticFinalFieldByteBoxing() throws ScriptException { 164 e.eval("var psf_byte = SharedObject.publicStaticFinalByte;"); 165 assertEqualsDouble(SharedObject.publicStaticFinalByte, "psf_byte"); 166 e.eval("SharedObject.publicStaticFinalByte = 16;"); 167 assertEquals(-70, SharedObject.publicStaticFinalByte); 168 } 169 170 // --------------------------------short 171 // tests------------------------------------ 172 @Test 173 public void accessFieldShortBoxing() throws ScriptException { 174 e.eval("var p_short = o.publicShortBox;"); 175 assertEqualsDouble(o.publicShortBox, "p_short"); 176 e.eval("o.publicShortBox = 18;"); 177 assertEquals(Short.valueOf((short)18), o.publicShortBox); 178 } 179 180 private static void assertEqualsDouble(final Number n, final String name) { 181 assertEquals(n.doubleValue(), ((Number)e.get(name)).doubleValue()); 182 } 183 184 @Test 185 public void accessStaticFieldShortBoxing() throws ScriptException { 186 e.eval("var ps_short = SharedObject.publicStaticShort;"); 187 assertEqualsDouble(SharedObject.publicStaticShort, "ps_short"); 188 e.eval("SharedObject.publicStaticShort = 180;"); 189 assertEquals(180, SharedObject.publicStaticShort); 190 } 191 192 @Test 193 public void accessFinalFieldShortBoxing() throws ScriptException { 194 e.eval("var pf_short = o.publicFinalShortBox;"); 195 assertEqualsDouble(o.publicFinalShortBox, "pf_short"); 196 e.eval("o.publicFinalShortBox = 180;"); 197 assertEquals(Short.valueOf((short)-26777), o.publicFinalShortBox); 198 } 199 200 @Test 201 public void accessStaticFinalFieldShortBoxing() throws ScriptException { 202 e.eval("var psf_short = SharedObject.publicStaticFinalShort;"); 203 assertEqualsDouble(SharedObject.publicStaticFinalShort, "psf_short"); 204 e.eval("SharedObject.publicStaticFinalShort = 180;"); 205 assertEquals(8888, SharedObject.publicStaticFinalShort); 206 } 207 208 // --------------------------------char 209 // tests------------------------------------ 210 @Test 211 public void accessFieldCharBoxing() throws ScriptException { 212 e.eval("var p_char = o.publicCharBox;"); 213 assertEquals(o.publicCharBox, e.get("p_char")); 214 e.eval("o.publicCharBox = 'S';"); 215 assertEquals(Character.valueOf('S'), o.publicCharBox); 216 e.eval("try {" + 217 " o.publicCharBox = 'Big string';" + 218 "} catch(e) {" + 219 " var isThrown = true;" + 220 "}"); 221 assertEquals("Exception thrown", true, e.get("isThrown")); 222 assertEquals(Character.valueOf('S'), o.publicCharBox); 223 } 224 225 @Test 226 public void accessStaticFieldCharBoxing() throws ScriptException { 227 e.eval("var ps_char = SharedObject.publicStaticChar;"); 228 assertEquals(SharedObject.publicStaticChar, e.get("ps_char")); 229 e.eval("SharedObject.publicStaticChar = 'Z';"); 230 assertEquals('Z', SharedObject.publicStaticChar); 231 } 232 233 @Test 234 public void accessFinalFieldCharBoxing() throws ScriptException { 235 e.eval("var pf_char = o.publicFinalCharBox;"); 236 assertEquals(o.publicFinalCharBox, e.get("pf_char")); 237 e.eval("o.publicFinalCharBox = 'S';"); 238 assertEquals(Character.valueOf('F'), o.publicFinalCharBox); 239 } 240 241 @Test 242 public void accessStaticFinalFieldCharBoxing() throws ScriptException { 243 e.eval("var psf_char = SharedObject.publicStaticFinalChar;"); 244 assertEquals(SharedObject.publicStaticFinalChar, e.get("psf_char")); 245 e.eval("SharedObject.publicStaticFinalChar = 'Z';"); 246 assertEquals('K', SharedObject.publicStaticFinalChar); 247 } 248 249 // --------------------------------float 250 // tests------------------------------------ 251 @Test 252 public void accessFieldFloatBoxing() throws ScriptException { 253 e.eval("var p_float = o.publicFloatBox;"); 254 assertEqualsDouble(o.publicFloatBox, "p_float"); 255 o.publicFloatBox = 0.0f / 0.0f; 256 assertEquals(true, e.eval("isNaN(o.publicFloatBox)")); 257 o.publicFloatBox = 1.0f / 0.0f; 258 assertEquals(true, e.eval("Number.POSITIVE_INFINITY === o.publicFloatBox")); 259 o.publicFloatBox = -1.0f / 0.0f; 260 assertEquals(true, e.eval("Number.NEGATIVE_INFINITY === o.publicFloatBox")); 261 e.eval("o.publicFloatBox = 20;"); 262 assertEquals(20, o.publicFloatBox, 1e-10); 263 e.eval("o.publicFloatBox = 0.0/0.0;"); 264 assertTrue(Float.isNaN(o.publicFloatBox)); 265 e.eval("o.publicFloatBox = 1.0/0.0;"); 266 assertEquals(Float.floatToIntBits(Float.POSITIVE_INFINITY), Float.floatToIntBits(o.publicFloatBox)); 267 e.eval("o.publicFloatBox = -1.0/0.0;"); 268 assertEquals(Float.NEGATIVE_INFINITY, o.publicFloatBox, 1e-10); 269 } 270 271 @Test 272 public void accessStaticFieldFloatBoxing() throws ScriptException { 273 e.eval("var ps_float = SharedObject.publicStaticFloat;"); 274 assertEqualsDouble(SharedObject.publicStaticFloat, "ps_float"); 275 SharedObject.publicStaticFloat = 0.0f / 0.0f; 276 assertEquals(true, e.eval("isNaN(SharedObject.publicStaticFloat)")); 277 SharedObject.publicStaticFloat = 1.0f / 0.0f; 278 assertEquals(true, e.eval("Number.POSITIVE_INFINITY === SharedObject.publicStaticFloat")); 279 SharedObject.publicStaticFloat = -1.0f / 0.0f; 280 assertEquals(true, e.eval("Number.NEGATIVE_INFINITY === SharedObject.publicStaticFloat")); 281 e.eval("SharedObject.publicStaticFloat = 20.0;"); 282 assertEquals(20.0f, SharedObject.publicStaticFloat, 1e-10); 283 e.eval("SharedObject.publicStaticFloat = 0.0/0.0;"); 284 assertTrue(Float.isNaN(SharedObject.publicStaticFloat)); 285 e.eval("SharedObject.publicStaticFloat = 1.0/0.0;"); 286 assertEquals(Float.floatToIntBits(Float.POSITIVE_INFINITY), Float.floatToIntBits(SharedObject.publicStaticFloat)); 287 e.eval("SharedObject.publicStaticFloat = -1.0/0.0;"); 288 assertEquals(Float.floatToIntBits(Float.NEGATIVE_INFINITY), Float.floatToIntBits(SharedObject.publicStaticFloat)); 289 } 290 291 @Test 292 public void accessFinalFloatBoxing() throws ScriptException { 293 e.eval("var pf_float = o.publicFinalFloatBox;"); 294 assertEqualsDouble(o.publicFinalFloatBox, "pf_float"); 295 e.eval("o.publicFinalFloatBox = 20.0;"); 296 assertEquals(1.372e4f, o.publicFinalFloatBox, 1e-10); 297 } 298 299 @Test 300 public void accessStaticFinalFieldFloatBoxing() throws ScriptException { 301 e.eval("var psf_float = SharedObject.publicStaticFinalFloat;"); 302 assertEqualsDouble(SharedObject.publicStaticFinalFloat, "psf_float"); 303 e.eval("SharedObject.publicStaticFinalFloat = 20.0;"); 304 assertEquals(0.72e8f, SharedObject.publicStaticFinalFloat, 1e-10); 305 } 306 307 // --------------------------------double 308 // tests------------------------------------ 309 @Test 310 public void accessFieldDoubleBoxing() throws ScriptException { 311 e.eval("var p_double = o.publicDoubleBox;"); 312 assertEquals(o.publicDoubleBox, e.get("p_double")); 313 o.publicDoubleBox = 0.0 / 0.0; 314 assertEquals(true, e.eval("isNaN(o.publicDoubleBox)")); 315 o.publicDoubleBox = 1.0 / 0.0; 316 assertEquals(true, e.eval("Number.POSITIVE_INFINITY === o.publicDoubleBox")); 317 o.publicDoubleBox = -1.0 / 0.0; 318 assertEquals(true, e.eval("Number.NEGATIVE_INFINITY === o.publicDoubleBox")); 319 e.eval("o.publicDoubleBox = 30;"); 320 assertEquals(Double.doubleToLongBits(30.0), Double.doubleToLongBits(o.publicDoubleBox)); 321 e.eval("o.publicDoubleBox = 0.0/0.0;"); 322 assertTrue(Double.isNaN(o.publicDoubleBox)); 323 e.eval("o.publicDoubleBox = 1.0/0.0;"); 324 assertEquals(Double.doubleToLongBits(Double.POSITIVE_INFINITY), Double.doubleToLongBits(o.publicDoubleBox)); 325 e.eval("o.publicDoubleBox = -1.0/0.0;"); 326 assertEquals(Double.doubleToLongBits(Double.NEGATIVE_INFINITY), Double.doubleToLongBits(o.publicDoubleBox)); 327 } 328 329 @Test 330 public void accessStaticFieldDoubleBoxing() throws ScriptException { 331 e.eval("var ps_double = SharedObject.publicStaticDouble;"); 332 assertEquals(SharedObject.publicStaticDouble, e.get("ps_double")); 333 SharedObject.publicStaticDouble = 0.0 / 0.0; 334 assertEquals(true, e.eval("isNaN(SharedObject.publicStaticDouble)")); 335 SharedObject.publicStaticDouble = 1.0 / 0.0; 336 assertEquals(true, e.eval("Number.POSITIVE_INFINITY === SharedObject.publicStaticDouble")); 337 SharedObject.publicStaticDouble = -1.0 / 0.0; 338 assertEquals(true, e.eval("Number.NEGATIVE_INFINITY === SharedObject.publicStaticDouble")); 339 e.eval("SharedObject.publicStaticDouble = 40.0;"); 340 assertEquals(Double.doubleToLongBits(40.0), Double.doubleToLongBits(SharedObject.publicStaticDouble)); 341 e.eval("SharedObject.publicStaticDouble = 0.0/0.0;"); 342 assertTrue(Double.isNaN(SharedObject.publicStaticDouble)); 343 e.eval("SharedObject.publicStaticDouble = 1.0/0.0;"); 344 assertEquals(Double.doubleToLongBits(Double.POSITIVE_INFINITY), Double.doubleToLongBits(SharedObject.publicStaticDouble)); 345 e.eval("SharedObject.publicStaticDouble = -1.0/0.0;"); 346 assertEquals(Double.doubleToLongBits(Double.NEGATIVE_INFINITY), Double.doubleToLongBits(SharedObject.publicStaticDouble)); 347 } 348 349 @Test 350 public void accessFinalFieldDoubleBoxing() throws ScriptException { 351 e.eval("var pf_double = o.publicFinalDoubleBox;"); 352 assertEquals(o.publicFinalDoubleBox, e.get("pf_double")); 353 e.eval("o.publicFinalDoubleBox = 30.0;"); 354 assertEquals(Double.doubleToLongBits(1.412e-12), Double.doubleToLongBits(o.publicFinalDoubleBox)); 355 } 356 357 @Test 358 public void accessStaticFinalFieldDoubleBoxing() throws ScriptException { 359 e.eval("var psf_double = SharedObject.publicStaticFinalDouble;"); 360 assertEquals(SharedObject.publicStaticFinalDouble, e.get("psf_double")); 361 e.eval("SharedObject.publicStaticFinalDouble = 40.0;"); 362 assertEquals(Double.doubleToLongBits(1.8e12), Double.doubleToLongBits(SharedObject.publicStaticFinalDouble)); 363 } 364 365 }