| /* |
| * Copyright 2008 Google Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| * use this file except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| * License for the specific language governing permissions and limitations under |
| * the License. |
| */ |
| package com.google.gwt.dev.jjs.test; |
| |
| import com.google.gwt.junit.client.GWTTestCase; |
| |
| /** |
| * Tests autoboxing. |
| */ |
| public class AutoboxTest extends GWTTestCase { |
| |
| private Boolean boxedBoolean = Boolean.TRUE; |
| |
| private Byte boxedByte = new Byte((byte) 0xAB); |
| |
| private Character boxedChar = new Character('c'); |
| |
| private Double boxedDouble = new Double(1.2323); |
| |
| private Float boxedFloat = new Float(1.2F); |
| |
| private Integer boxedInt = new Integer(20000000); |
| |
| private Long boxedLong = new Long(1231231231231L); |
| |
| private Short boxedShort = new Short((short) 6550); |
| |
| private boolean unboxedBoolean = true; |
| |
| private byte unboxedByte = (byte) 0xAB; |
| |
| private char unboxedChar = 'c'; |
| |
| private double unboxedDouble = 1.2323; |
| |
| private float unboxedFloat = 1.2F; |
| |
| private int unboxedInt = 20000000; |
| |
| private long unboxedLong = 1231231231231L; |
| |
| private short unboxedShort = 6550; |
| |
| @Override |
| public String getModuleName() { |
| return "com.google.gwt.dev.jjs.CompilerSuite"; |
| } |
| |
| public void testBoxing() { |
| Boolean boolean_ = unboxedBoolean; |
| assertTrue(boolean_.booleanValue() == unboxedBoolean); |
| Byte byte_ = unboxedByte; |
| assertTrue(byte_.byteValue() == unboxedByte); |
| Character char_ = unboxedChar; |
| assertTrue(char_.charValue() == unboxedChar); |
| Short short_ = unboxedShort; |
| assertTrue(short_.shortValue() == unboxedShort); |
| Integer int_ = unboxedInt; |
| assertTrue(int_.intValue() == unboxedInt); |
| Long long_ = unboxedLong; |
| assertTrue(long_.longValue() == unboxedLong); |
| Float float_ = unboxedFloat; |
| assertTrue(float_.floatValue() == unboxedFloat); |
| Double double_ = unboxedDouble; |
| assertTrue(double_.doubleValue() == unboxedDouble); |
| |
| // test boxing of return values |
| assertTrue(box(unboxedBoolean).booleanValue() == unboxedBoolean); |
| assertTrue(box(unboxedByte).byteValue() == unboxedByte); |
| assertTrue(box(unboxedShort).shortValue() == unboxedShort); |
| assertTrue(box(unboxedChar).charValue() == unboxedChar); |
| assertTrue(box(unboxedInt).intValue() == unboxedInt); |
| assertTrue(box(unboxedLong).longValue() == unboxedLong); |
| assertTrue(box(unboxedFloat).floatValue() == unboxedFloat); |
| assertTrue(box(unboxedDouble).doubleValue() == unboxedDouble); |
| |
| // test boxing of parameters |
| assertTrue(unbox(unboxedBoolean) == unboxedBoolean); |
| assertTrue(unbox(unboxedByte) == unboxedByte); |
| assertTrue(unbox(unboxedShort) == unboxedShort); |
| assertTrue(unbox(unboxedChar) == unboxedChar); |
| assertTrue(unbox(unboxedInt) == unboxedInt); |
| assertTrue(unbox(unboxedLong) == unboxedLong); |
| assertTrue(unbox(unboxedFloat) == unboxedFloat); |
| assertTrue(unbox(unboxedDouble) == unboxedDouble); |
| } |
| |
| /** |
| * JLS 5.2 has a special case for assignment of a constant to a variable of |
| * type Byte, Short, or Character. Such an assignment is allowed so long as |
| * the constant fits within the type's range. In such cases, the box type can |
| * be different from the type of the constant. |
| */ |
| public void testBoxingDifferentType() { |
| Character c = 1; |
| assertEquals(Character.valueOf((char) 1), c); |
| |
| Byte b = 2; |
| assertEquals(Byte.valueOf((byte) 2), b); |
| |
| Short s = 3; |
| assertEquals(Short.valueOf((short) 3), s); |
| } |
| |
| /** |
| * Verify that .valueOf() methods return identical references for types within |
| * certain ranges. |
| */ |
| public void testCaching() { |
| assertSame((byte) 3, (byte) 3); |
| assertSame('A', 'A'); |
| assertSame((short) 120, (short) 120); |
| assertSame(-13, -13); |
| assertSame(7L, 7L); |
| } |
| |
| /** |
| * Test ++, --, and compound assignments like += when the left-hand side is a |
| * boxed Integer. Use assertNotSame to ensure that a new Integer is created |
| * instead of modifying the original integer in place. (Issue 2446). |
| */ |
| public void testCompoundAssignmentsWithInteger() { |
| { |
| Integer operand, original, result; |
| original = operand = 0; |
| result = operand++; |
| // operand must be different object now. |
| assertNotSame("[o++] original != operand, ", original, operand); |
| assertSame("[o++] original == result, ", original, result); |
| assertNotSame("[o++] result != operand, ", result, operand); |
| // checks against boxedvalues cached object. |
| assertSame("[o++] valueOf(n) == operand, ", 1, operand); |
| // checks cached object's value. |
| assertEquals("[o++] n == operand.value, ", 1, operand.intValue()); |
| } |
| |
| { |
| Integer operand, original, result; |
| original = operand = 2; |
| result = ++operand; |
| assertNotSame("[++o] original != operand, ", original, operand); |
| assertNotSame("[++o] original != result, ", original, result); |
| assertSame("[++o] result == operand, ", result, operand); |
| assertSame("[++o] valueOf(n) == operand, ", 3, operand); |
| assertEquals("[++o] n == operand.value, ", 3, operand.intValue()); |
| } |
| |
| { |
| Integer operand, original, result; |
| original = operand = 5; |
| result = operand--; |
| assertNotSame("[o--] original != operand, ", original, operand); |
| assertSame("[o--] original == result, ", original, result); |
| assertNotSame("[o--] result != operand, ", result, operand); |
| assertSame("[o--] valueOf(n) == operand, ", 4, operand); |
| assertEquals("[o--] n == operand.value, ", 4, operand.intValue()); |
| } |
| |
| { |
| Integer operand, original, result; |
| original = operand = 7; |
| result = --operand; |
| assertNotSame("[--o] original != operand, ", original, operand); |
| assertNotSame("[--o] original != result, ", original, result); |
| assertSame("[--o] result == operand, ", result, operand); |
| assertSame("[--o] valueOf(n) == operand, ", 6, operand); |
| assertEquals("[--o] n == operand.value, ", 6, operand.intValue()); |
| } |
| |
| { |
| Integer operand, original; |
| original = operand = 8; |
| operand += 2; |
| assertNotSame("[+=] original != operand, ", original, operand); |
| assertSame("[+=] valueOf(n) == operand, ", 10, operand); |
| assertEquals("[+=] n == operand.value, ", 10, operand.intValue()); |
| } |
| |
| { |
| Integer operand, original; |
| original = operand = 11; |
| operand -= 2; |
| assertNotSame("[-=] original != operand, ", original, operand); |
| assertSame("[-=] valueOf(n) == operand, ", 9, operand); |
| assertEquals("[-=] n == operand.value, ", 9, operand.intValue()); |
| } |
| |
| { |
| Integer operand, original; |
| original = operand = 21; |
| operand *= 2; |
| assertNotSame("[*=] original != operand, ", original, operand); |
| assertSame("[*=] valueOf(n) == operand, ", 42, operand); |
| assertEquals("[*=] n == operand.value, ", 42, operand.intValue()); |
| } |
| |
| { |
| Integer operand, original; |
| original = operand = 30; |
| operand /= 2; |
| assertNotSame("[/=] original != operand, ", original, operand); |
| assertSame("[/=] valueOf(n) == operand, ", 15, operand); |
| assertEquals("[/=] n == operand.value, ", 15, operand.intValue()); |
| } |
| |
| { |
| Integer operand, original; |
| original = operand = 123; |
| operand %= 100; |
| assertNotSame("[%=] original != operand, ", original, operand); |
| assertSame("[%=] valueOf(n) == operand, ", 23, operand); |
| assertEquals("[%=] n == operand.value, ", 23, operand.intValue()); |
| } |
| |
| { |
| Integer operand, original; |
| original = operand = 0x55; |
| operand &= 0xF; |
| assertNotSame("[&=] original != operand, ", original, operand); |
| assertSame("[&=] valueOf(n) == operand, ", 0x5, operand); |
| assertEquals("[&=] n == operand.value, ", 0x5, operand.intValue()); |
| } |
| |
| { |
| Integer operand, original; |
| original = operand = 0x55; |
| operand |= 0xF; |
| assertNotSame("[|=] original != operand, ", original, operand); |
| assertSame("[|=] valueOf(n) == operand, ", 0x5F, operand); |
| assertEquals("[|=] n == operand.value, ", 0x5F, operand.intValue()); |
| } |
| |
| { |
| Integer operand, original; |
| original = operand = 0x55; |
| operand ^= 0xF; |
| assertNotSame("[&=] original != operand, ", original, operand); |
| assertSame("[&=] valueOf(n) == operand, ", 0x5A, operand); |
| assertEquals("[&=] n == operand.value, ", 0x5A, operand.intValue()); |
| } |
| |
| { |
| Integer operand, original; |
| original = operand = 0x3F; |
| operand <<= 1; |
| assertNotSame("[<<=] original != operand, ", original, operand); |
| assertSame("[<<=] valueOf(n) == operand, ", 0x7E, operand); |
| assertEquals("[<<=] n == operand.value, ", 0x7E, operand.intValue()); |
| } |
| |
| { |
| Integer operand, original; |
| original = operand = -16; |
| operand >>= 1; |
| assertNotSame("[>>=] original != operand, ", original, operand); |
| assertSame("[>>=] valueOf(n) == operand, ", -8, operand); |
| assertEquals("[>>=] n == operand.value, ", -8, operand.intValue()); |
| } |
| |
| { |
| Integer operand, original; |
| original = operand = -1; |
| operand >>>= 1; |
| assertNotSame("[>>>=] original != operand, ", original, operand); |
| assertEquals("[>>>=] valueOf(n).equals(operand), ", |
| Integer.valueOf(0x7FFFFFFF), operand); |
| assertEquals("[>>>=] n == operand.value, ", 0x7FFFFFFF, |
| operand.intValue()); |
| } |
| } |
| |
| /** |
| * Tests operations like += and *= where the left-hand side is a boxed Long. |
| */ |
| public void testCompoundAssignmentsWithLong() { |
| { |
| Long long1 = 10L; |
| Long long2 = long1; |
| long2 += 5; |
| assertEquals(10L, (long) long1); |
| assertEquals(15L, (long) long2); |
| } |
| { |
| Long long1 = 10L; |
| Long long2 = long1; |
| long2 += 1; |
| assertEquals(10, (long) long1); |
| assertEquals(11, (long) long2); |
| } |
| { |
| Long long1 = 10L; |
| Long long2 = long1; |
| long2 -= 1; |
| assertEquals(10, (long) long1); |
| assertEquals(9, (long) long2); |
| } |
| { |
| Long long1 = 10L; |
| Long long2 = long1; |
| long2 *= 2; |
| assertEquals(10, (long) long1); |
| assertEquals(20, (long) long2); |
| } |
| { |
| Long long1 = 10L; |
| Long long2 = long1; |
| long2 /= 2; |
| assertEquals(10, (long) long1); |
| assertEquals(5, (long) long2); |
| } |
| { |
| Long long1 = 10L; |
| Long long2 = long1; |
| long2 %= 3; |
| assertEquals(10, (long) long1); |
| assertEquals(1, (long) long2); |
| } |
| { |
| Long long1 = 10L; |
| Long long2 = long1; |
| long2 <<= 1; |
| assertEquals(10, (long) long1); |
| assertEquals(20, (long) long2); |
| } |
| { |
| Long long1 = 10L; |
| Long long2 = long1; |
| long2 >>= 1; |
| assertEquals(10, (long) long1); |
| assertEquals(5, (long) long2); |
| } |
| { |
| Long long1 = 10L; |
| Long long2 = long1; |
| long2 >>>= 1; |
| assertEquals(10, (long) long1); |
| assertEquals(5, (long) long2); |
| } |
| { |
| Long long1 = 10L; |
| Long long2 = long1; |
| long2 &= 8; |
| assertEquals(10, (long) long1); |
| assertEquals(8, (long) long2); |
| } |
| { |
| Long long1 = 10L; |
| Long long2 = long1; |
| long2 |= 1; |
| assertEquals(10, (long) long1); |
| assertEquals(11, (long) long2); |
| } |
| { |
| Long long1 = 10L; |
| Long long2 = long1; |
| long2 ^= 1; |
| assertEquals(10, (long) long1); |
| assertEquals(11, (long) long2); |
| } |
| } |
| |
| /** |
| * Tests ++ and -- on all boxed types. Use assertNotSame to ensure that a new |
| * wrapper is created instead of modifying the original boxed value in place. |
| * (Issue 2446). |
| */ |
| public void testIncrDecr() { |
| { |
| // these initial tests are miscellaneous one-off tests |
| Byte originalBoxedByte = boxedByte; |
| |
| assertEquals(unboxedByte, (byte) boxedByte++); |
| assertEquals(unboxedByte + 1, (byte) boxedByte); |
| boxedByte = originalBoxedByte; |
| |
| Integer[] ary = new Integer[] {0, 10, 20, 30, 40, 50}; |
| Integer idx = 2; |
| assertEquals(20, (int) ary[idx++]++); |
| assertEquals(21, (int) ary[2]); |
| assertEquals(3, (int) idx); |
| assertEquals(40, (int) ary[idx += 1]); |
| assertEquals(4, (int) idx); |
| } |
| // the rest of this method tests all boxed types under ++ and -- |
| { |
| Byte originalBoxedByte = boxedByte; |
| boxedByte++; |
| assertNotSame("Boxed byte modified in place", boxedByte, |
| originalBoxedByte); |
| assertEquals(unboxedByte + 1, (byte) boxedByte); |
| boxedByte = originalBoxedByte; |
| ++boxedByte; |
| assertNotSame("Boxed byte modified in place", boxedByte, |
| originalBoxedByte); |
| assertEquals(unboxedByte + 1, (byte) boxedByte); |
| boxedByte = originalBoxedByte; |
| boxedByte--; |
| assertNotSame("Boxed byte modified in place", boxedByte, |
| originalBoxedByte); |
| assertEquals(unboxedByte - 1, (byte) boxedByte); |
| boxedByte = originalBoxedByte; |
| --boxedByte; |
| assertNotSame("Boxed byte modified in place", boxedByte, |
| originalBoxedByte); |
| assertEquals(unboxedByte - 1, (byte) boxedByte); |
| boxedByte = originalBoxedByte; |
| } |
| { |
| Character originalBoxedChar = boxedChar; |
| boxedChar++; |
| assertNotSame("Boxed character modified in place", boxedChar, |
| originalBoxedChar); |
| assertEquals(unboxedChar + 1, (char) boxedChar); |
| boxedChar = originalBoxedChar; |
| ++boxedChar; |
| assertNotSame("Boxed character modified in place", boxedChar, |
| originalBoxedChar); |
| assertEquals(unboxedChar + 1, (char) boxedChar); |
| boxedChar = originalBoxedChar; |
| boxedChar--; |
| assertNotSame("Boxed character modified in place", boxedChar, |
| originalBoxedChar); |
| assertEquals(unboxedChar - 1, (char) boxedChar); |
| boxedChar = originalBoxedChar; |
| --boxedChar; |
| assertNotSame("Boxed character modified in place", boxedChar, |
| originalBoxedChar); |
| assertEquals(unboxedChar - 1, (char) boxedChar); |
| boxedChar = originalBoxedChar; |
| } |
| { |
| Short originalBoxedShort = boxedShort; |
| boxedShort++; |
| assertNotSame("Boxed short modified in place", boxedShort, |
| originalBoxedShort); |
| assertEquals(unboxedShort + 1, (short) boxedShort); |
| boxedShort = originalBoxedShort; |
| ++boxedShort; |
| assertNotSame("Boxed short modified in place", boxedShort, |
| originalBoxedShort); |
| assertEquals(unboxedShort + 1, (short) boxedShort); |
| boxedShort = originalBoxedShort; |
| boxedShort--; |
| assertNotSame("Boxed short modified in place", boxedShort, |
| originalBoxedShort); |
| assertEquals(unboxedShort - 1, (short) boxedShort); |
| boxedShort = originalBoxedShort; |
| --boxedShort; |
| assertNotSame("Boxed short modified in place", boxedShort, |
| originalBoxedShort); |
| assertEquals(unboxedShort - 1, (short) boxedShort); |
| boxedShort = originalBoxedShort; |
| } |
| { |
| Integer originalBoxedInt = boxedInt; |
| boxedInt++; |
| assertNotSame("Boxed int modified in place", boxedInt, originalBoxedInt); |
| assertEquals(unboxedInt + 1, (int) boxedInt); |
| boxedInt = originalBoxedInt; |
| ++boxedInt; |
| assertNotSame("Boxed int modified in place", boxedInt, originalBoxedInt); |
| assertEquals(unboxedInt + 1, (int) boxedInt); |
| boxedInt = originalBoxedInt; |
| boxedInt--; |
| assertNotSame("Boxed int modified in place", boxedInt, originalBoxedInt); |
| assertEquals(unboxedInt - 1, (int) boxedInt); |
| boxedInt = originalBoxedInt; |
| --boxedInt; |
| assertNotSame("Boxed int modified in place", boxedInt, originalBoxedInt); |
| assertEquals(unboxedInt - 1, (int) boxedInt); |
| boxedInt = originalBoxedInt; |
| } |
| { |
| Long originalBoxedLong = boxedLong; |
| boxedLong++; |
| assertNotSame("Boxed long modified in place", boxedLong, |
| originalBoxedLong); |
| assertEquals(unboxedLong + 1, (long) boxedLong); |
| boxedLong = originalBoxedLong; |
| ++boxedLong; |
| assertNotSame("Boxed long modified in place", boxedLong, |
| originalBoxedLong); |
| assertEquals(unboxedLong + 1, (long) boxedLong); |
| boxedLong = originalBoxedLong; |
| boxedLong--; |
| assertNotSame("Boxed long modified in place", boxedLong, |
| originalBoxedLong); |
| assertEquals(unboxedLong - 1, (long) boxedLong); |
| boxedLong = originalBoxedLong; |
| --boxedLong; |
| assertNotSame("Boxed long modified in place", boxedLong, |
| originalBoxedLong); |
| assertEquals(unboxedLong - 1, (long) boxedLong); |
| boxedLong = originalBoxedLong; |
| } |
| { |
| Float originalBoxedFloat = boxedFloat; |
| boxedFloat++; |
| assertNotSame("Boxed float modified in place", boxedFloat, |
| originalBoxedFloat); |
| assertEquals(unboxedFloat + 1, (float) boxedFloat); |
| boxedFloat = originalBoxedFloat; |
| ++boxedFloat; |
| assertNotSame("Boxed float modified in place", boxedFloat, |
| originalBoxedFloat); |
| assertEquals(unboxedFloat + 1, (float) boxedFloat); |
| boxedFloat = originalBoxedFloat; |
| boxedFloat--; |
| assertNotSame("Boxed float modified in place", boxedFloat, |
| originalBoxedFloat); |
| assertEquals(unboxedFloat - 1, (float) boxedFloat); |
| boxedFloat = originalBoxedFloat; |
| --boxedFloat; |
| assertNotSame("Boxed float modified in place", boxedFloat, |
| originalBoxedFloat); |
| assertEquals(unboxedFloat - 1, (float) boxedFloat); |
| boxedFloat = originalBoxedFloat; |
| } |
| { |
| Double originalBoxedDouble = boxedDouble; |
| boxedDouble++; |
| assertNotSame("Boxed double modified in place", boxedDouble, |
| originalBoxedDouble); |
| assertEquals(unboxedDouble + 1, (double) boxedDouble); |
| boxedDouble = originalBoxedDouble; |
| ++boxedDouble; |
| assertNotSame("Boxed double modified in place", boxedDouble, |
| originalBoxedDouble); |
| assertEquals(unboxedDouble + 1, (double) boxedDouble); |
| boxedDouble = originalBoxedDouble; |
| boxedDouble--; |
| assertNotSame("Boxed double modified in place", boxedDouble, |
| originalBoxedDouble); |
| assertEquals(unboxedDouble - 1, (double) boxedDouble); |
| boxedDouble = originalBoxedDouble; |
| --boxedDouble; |
| assertNotSame("Boxed double modified in place", boxedDouble, |
| originalBoxedDouble); |
| assertEquals(unboxedDouble - 1, (double) boxedDouble); |
| boxedDouble = originalBoxedDouble; |
| } |
| } |
| |
| public void testUnboxing() { |
| boolean boolean_ = boxedBoolean; |
| assertTrue(boolean_ == boxedBoolean.booleanValue()); |
| byte byte_ = boxedByte; |
| assertTrue(byte_ == boxedByte.byteValue()); |
| char char_ = boxedChar; |
| assertTrue(char_ == boxedChar.charValue()); |
| short short_ = boxedShort; |
| assertTrue(short_ == boxedShort.shortValue()); |
| int int_ = boxedInt; |
| assertTrue(int_ == boxedInt.intValue()); |
| long long_ = boxedLong; |
| assertTrue(long_ == boxedLong.longValue()); |
| float float_ = boxedFloat; |
| assertTrue(float_ == boxedFloat.floatValue()); |
| double double_ = boxedDouble; |
| assertTrue(double_ == boxedDouble.doubleValue()); |
| |
| // test unboxing of return values |
| assertTrue(unbox(boxedBoolean) == unboxedBoolean); |
| assertTrue(unbox(boxedByte) == unboxedByte); |
| assertTrue(unbox(boxedShort) == unboxedShort); |
| assertTrue(unbox(boxedChar) == unboxedChar); |
| assertTrue(unbox(boxedInt) == unboxedInt); |
| assertTrue(unbox(boxedLong) == unboxedLong); |
| assertTrue(unbox(boxedFloat) == unboxedFloat); |
| assertTrue(unbox(boxedDouble) == unboxedDouble); |
| |
| // test unboxing of parameters |
| assertTrue(box(boxedBoolean).booleanValue() == unboxedBoolean); |
| assertTrue(box(boxedByte).byteValue() == unboxedByte); |
| assertTrue(box(boxedShort).shortValue() == unboxedShort); |
| assertTrue(box(boxedChar).charValue() == unboxedChar); |
| assertTrue(box(boxedInt).intValue() == unboxedInt); |
| assertTrue(box(boxedLong).longValue() == unboxedLong); |
| assertTrue(box(boxedFloat).floatValue() == unboxedFloat); |
| assertTrue(box(boxedDouble).doubleValue() == unboxedDouble); |
| } |
| |
| public void testUnboxingDifferentType() { |
| { |
| short short_ = boxedByte; |
| assertTrue(short_ == boxedByte.byteValue()); |
| int int_ = boxedByte; |
| assertTrue(int_ == boxedByte.byteValue()); |
| long long_ = boxedByte; |
| assertTrue(long_ == boxedByte.byteValue()); |
| float float_ = boxedByte; |
| assertTrue(float_ == boxedByte.byteValue()); |
| double double_ = boxedByte; |
| assertTrue(double_ == boxedByte.byteValue()); |
| } |
| |
| { |
| int int_ = boxedShort; |
| assertTrue(int_ == boxedShort.shortValue()); |
| long long_ = boxedShort; |
| assertTrue(long_ == boxedShort.shortValue()); |
| float float_ = boxedShort; |
| assertTrue(float_ == boxedShort.shortValue()); |
| double double_ = boxedShort; |
| assertTrue(double_ == boxedShort.shortValue()); |
| } |
| |
| { |
| int int_ = boxedChar; |
| assertTrue(int_ == boxedChar.charValue()); |
| long long_ = boxedChar; |
| assertTrue(long_ == boxedChar.charValue()); |
| float float_ = boxedChar; |
| assertTrue(float_ == boxedChar.charValue()); |
| double double_ = boxedChar; |
| assertTrue(double_ == boxedChar.charValue()); |
| } |
| |
| { |
| long long_ = boxedInt; |
| assertTrue(long_ == boxedInt.intValue()); |
| float float_ = boxedInt; |
| assertTrue(float_ == boxedInt.intValue()); |
| double double_ = boxedInt; |
| assertTrue(double_ == boxedInt.intValue()); |
| } |
| } |
| |
| private Boolean box(boolean b) { |
| return b; |
| } |
| |
| private Byte box(byte b) { |
| return b; |
| } |
| |
| private Character box(char c) { |
| return c; |
| } |
| |
| private Double box(double d) { |
| return d; |
| } |
| |
| private Float box(float f) { |
| return f; |
| } |
| |
| private Integer box(int i) { |
| return i; |
| } |
| |
| private Long box(long l) { |
| return l; |
| } |
| |
| private Short box(short s) { |
| return s; |
| } |
| |
| private boolean unbox(Boolean b) { |
| return b; |
| } |
| |
| private byte unbox(Byte b) { |
| return b; |
| } |
| |
| private char unbox(Character c) { |
| return c; |
| } |
| |
| private double unbox(Double d) { |
| return d; |
| } |
| |
| private float unbox(Float f) { |
| return f; |
| } |
| |
| private int unbox(Integer i) { |
| return i; |
| } |
| |
| private long unbox(Long l) { |
| return l; |
| } |
| |
| private short unbox(Short s) { |
| return s; |
| } |
| } |