| /* |
| * Copyright 2017 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.emultest.java.lang.reflect; |
| |
| import com.google.gwt.junit.client.GWTTestCase; |
| |
| import java.lang.reflect.Array; |
| |
| /** Tests for java.lang.reflect.Array. */ |
| public final class ArrayTest extends GWTTestCase { |
| |
| @Override |
| public String getModuleName() { |
| return "com.google.gwt.emultest.EmulSuite"; |
| } |
| |
| public void testGet() { |
| try { |
| Array.get(null, 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| try { |
| Array.get(new Object(), 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| assertEquals("1", Array.get(new Object[] {"1"}, 0)); |
| assertEquals(Boolean.TRUE, Array.get(new boolean[] {true}, 0)); |
| assertEquals(new Byte((byte) 1), Array.get(new byte[] {1}, 0)); |
| assertEquals(new Character('1'), Array.get(new char[] {'1'}, 0)); |
| assertEquals(new Double(1.0d), Array.get(new double[] {1}, 0)); |
| assertEquals(new Float(1.0f), Array.get(new float[] {1.0f}, 0)); |
| assertEquals(new Integer(1), Array.get(new int[] {1}, 0)); |
| assertEquals(new Long(1L), Array.get(new long[] {1}, 0)); |
| assertEquals(new Short((short) 1), Array.get(new short[] {1}, 0)); |
| } |
| |
| public void testGetBoolean() { |
| try { |
| Array.getBoolean(null, 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| try { |
| Array.getBoolean(new Object(), 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| try { |
| Array.getBoolean(new Boolean[] {true}, 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| assertTrue(Array.getBoolean(new boolean[] {true}, 0)); |
| assertFalse(Array.getBoolean(new boolean[] {false}, 0)); |
| assertTrue(Array.getBoolean(new boolean[] {Boolean.TRUE}, 0)); |
| assertFalse(Array.getBoolean(new boolean[] {Boolean.FALSE}, 0)); |
| } |
| |
| public void testGetByte() { |
| try { |
| Array.getByte(null, 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| try { |
| Array.getByte(new Object(), 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| try { |
| Array.getByte(new Byte[] {(byte) 0}, 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| assertEquals((byte) 1, Array.getByte(new byte[] {(byte) 1}, 0)); |
| assertEquals((byte) 1, Array.getByte(new byte[] {(byte) 1}, 0)); |
| assertEquals((byte) 1, Array.getByte(new byte[] {(byte) 1}, 0)); |
| assertEquals((byte) 1, Array.getByte(new byte[] {(byte) 1}, 0)); |
| } |
| |
| public void testGetChar() { |
| try { |
| Array.getChar(null, 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| try { |
| Array.getChar(new Object(), 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| try { |
| Array.getChar(new Character[] {'0'}, 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| assertEquals('1', Array.getChar(new char[] {'1'}, 0)); |
| } |
| |
| public void testGetDouble() { |
| try { |
| Array.getDouble(null, 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| try { |
| Array.getDouble(new Object(), 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| try { |
| Array.getDouble(new Double[] {0d}, 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| assertEquals(1.0d, Array.getDouble(new double[] {1.0d}, 0)); |
| assertEquals(1.0d, Array.getDouble(new float[] {1.0f}, 0)); |
| assertEquals(1.0d, Array.getDouble(new byte[] {1}, 0)); |
| assertEquals(1.0d, Array.getDouble(new char[] {1}, 0)); |
| assertEquals(1.0d, Array.getDouble(new int[] {1}, 0)); |
| assertEquals(1.0d, Array.getDouble(new long[] {1}, 0)); |
| assertEquals(1.0d, Array.getDouble(new short[] {1}, 0)); |
| } |
| |
| public void testGetFloat() { |
| try { |
| Array.getFloat(null, 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| try { |
| Array.getFloat(new Object(), 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| try { |
| Array.getFloat(new Float[] {0f}, 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| assertEquals(1.0f, Array.getFloat(new float[] {1.0f}, 0)); |
| assertEquals(1.0f, Array.getFloat(new byte[] {1}, 0)); |
| assertEquals(1.0f, Array.getFloat(new char[] {1}, 0)); |
| assertEquals(1.0f, Array.getFloat(new int[] {1}, 0)); |
| assertEquals(1.0f, Array.getFloat(new long[] {1}, 0)); |
| assertEquals(1.0f, Array.getFloat(new short[] {1}, 0)); |
| } |
| |
| public void testGetInt() { |
| try { |
| Array.getInt(null, 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| try { |
| Array.getInt(new Object(), 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| try { |
| Array.getInt(new Integer[] {0}, 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| assertEquals(1, Array.getInt(new int[] {1}, 0)); |
| assertEquals(1, Array.getInt(new byte[] {1}, 0)); |
| assertEquals(1, Array.getInt(new char[] {1}, 0)); |
| assertEquals(1, Array.getInt(new short[] {1}, 0)); |
| } |
| |
| public void testGetLength() { |
| try { |
| Array.getLength(null); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| assertEquals(0, Array.getLength(new Object[0])); |
| assertEquals(1, Array.getLength(new Object[1])); |
| |
| assertEquals(0, Array.getLength(new int[0])); |
| assertEquals(1, Array.getLength(new int[1])); |
| } |
| |
| public void testGetLong() { |
| try { |
| Array.getLong(null, 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| try { |
| Array.getLong(new Object(), 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| try { |
| Array.getLong(new Long[] {0L}, 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| assertEquals(1L, Array.getLong(new long[] {1L}, 0)); |
| assertEquals(1L, Array.getLong(new byte[] {1}, 0)); |
| assertEquals(1L, Array.getLong(new char[] {1}, 0)); |
| assertEquals(1L, Array.getLong(new int[] {1}, 0)); |
| assertEquals(1L, Array.getLong(new short[] {1}, 0)); |
| } |
| |
| public void testGetShort() { |
| try { |
| Array.getShort(null, 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| try { |
| Array.getShort(new Object(), 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| try { |
| Array.getShort(new Short[] {(short) 1}, 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| assertEquals((short) 1, Array.getShort(new short[] {(short) 1}, 0)); |
| assertEquals((short) 1, Array.getShort(new short[] {1}, 0)); |
| } |
| |
| public void testSet() { |
| try { |
| Array.set(null, 0, true); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| try { |
| Array.set(new Object(), 0, true); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| Object[] objectArray = new Object[1]; |
| Array.set(objectArray, 0, "1"); |
| assertEquals("1", objectArray[0]); |
| |
| boolean[] booleanArray = new boolean[1]; |
| Array.set(booleanArray, 0, true); |
| assertTrue(booleanArray[0]); |
| |
| byte[] byteArray = new byte[1]; |
| Array.set(byteArray, 0, (byte) 1); |
| assertEquals((byte) 1, byteArray[0]); |
| |
| char[] charArray = new char[1]; |
| Array.set(charArray, 0, 'a'); |
| assertEquals('a', charArray[0]); |
| |
| double[] doubleArray = new double[1]; |
| Array.set(doubleArray, 0, 1.0d); |
| assertEquals(1.0d, doubleArray[0]); |
| |
| float[] floatArray = new float[1]; |
| Array.set(floatArray, 0, 1.0f); |
| assertEquals(1.0f, floatArray[0]); |
| |
| int[] intArray = new int[1]; |
| Array.set(intArray, 0, 1); |
| assertEquals(1, intArray[0]); |
| |
| long[] longArray = new long[1]; |
| Array.set(longArray, 0, 1L); |
| assertEquals(1L, longArray[0]); |
| |
| short[] shortArray = new short[1]; |
| Array.set(shortArray, 0, (short) 1); |
| assertEquals((short) 1, shortArray[0]); |
| |
| // test widening |
| long[] otherLongArray = new long[10]; |
| Array.set(otherLongArray, 0, (byte) 2); |
| assertEquals(2L, otherLongArray[0]); |
| |
| Array.set(otherLongArray, 1, (short) 3); |
| assertEquals(3L, otherLongArray[1]); |
| |
| Array.set(otherLongArray, 2, (char) 4); |
| assertEquals(4L, otherLongArray[2]); |
| |
| Array.set(otherLongArray, 3, 5); |
| assertEquals(5L, otherLongArray[3]); |
| |
| double[] otherDoubleArray = new double[10]; |
| Array.set(otherDoubleArray, 0, (byte) 2); |
| assertEquals(2d, otherDoubleArray[0], 0.00001); |
| |
| Array.set(otherDoubleArray, 1, (short) 3); |
| assertEquals(3d, otherDoubleArray[1], 0.00001); |
| |
| Array.set(otherDoubleArray, 2, (char) 4); |
| assertEquals(4d, otherDoubleArray[2], 0.00001); |
| |
| Array.set(otherDoubleArray, 3, 5); |
| assertEquals(5d, otherDoubleArray[3], 0.00001); |
| |
| Array.set(otherDoubleArray, 4, (float) 6); |
| assertEquals(6d, otherDoubleArray[4], 0.00001); |
| |
| Array.set(otherDoubleArray, 5, (double) 7); |
| assertEquals(7d, otherDoubleArray[5], 0.00001); |
| } |
| |
| public void testSetBoolean() { |
| try { |
| Array.setBoolean(null, 0, true); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| try { |
| Array.setBoolean(new Object(), 0, true); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| boolean[] array = new boolean[1]; |
| |
| Array.setBoolean(array, 0, true); |
| assertTrue(array[0]); |
| } |
| |
| public void testSetByte() { |
| try { |
| Array.setByte(null, 0, (byte) 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| try { |
| Array.setByte(new Object(), 0, (byte) 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| byte[] bArray = new byte[1]; |
| Array.setByte(bArray, 0, (byte) 1); |
| assertEquals((byte) 1, bArray[0]); |
| |
| double[] dArray = new double[1]; |
| Array.setByte(dArray, 0, (byte) 1); |
| assertEquals((byte) 1, (byte) dArray[0]); |
| |
| float[] fArray = new float[1]; |
| Array.setByte(fArray, 0, (byte) 1); |
| assertEquals((byte) 1, (byte) fArray[0]); |
| |
| int[] iArray = new int[1]; |
| Array.setByte(iArray, 0, (byte) 1); |
| assertEquals((byte) 1, (byte) iArray[0]); |
| |
| long[] lArray = new long[1]; |
| Array.setByte(lArray, 0, (byte) 1); |
| assertEquals((byte) 1, (byte) lArray[0]); |
| |
| short[] sArray = new short[1]; |
| Array.setByte(sArray, 0, (byte) 1); |
| assertEquals((byte) 1, (byte) sArray[0]); |
| } |
| |
| public void testSetChar() { |
| try { |
| Array.setChar(null, 0, 'a'); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| try { |
| Array.setChar(new Object(), 0, 'a'); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| char[] array = new char[1]; |
| |
| Array.setChar(array, 0, 'a'); |
| assertEquals('a', array[0]); |
| |
| double[] dArray = new double[1]; |
| Array.setChar(dArray, 0, (char) 1); |
| assertEquals((byte) 1, (byte) dArray[0]); |
| |
| float[] fArray = new float[1]; |
| Array.setChar(fArray, 0, (char) 1); |
| assertEquals((byte) 1, (byte) fArray[0]); |
| |
| int[] iArray = new int[1]; |
| Array.setChar(iArray, 0, (char) 1); |
| assertEquals((byte) 1, (byte) iArray[0]); |
| |
| long[] lArray = new long[1]; |
| Array.setChar(lArray, 0, (char) 1); |
| assertEquals((byte) 1, (byte) lArray[0]); |
| } |
| |
| public void testSetDouble() { |
| try { |
| Array.setDouble(null, 0, 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| try { |
| Array.setDouble(new Object(), 0, 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| double[] array = new double[1]; |
| |
| Array.setDouble(array, 0, 1d); |
| assertEquals(1d, array[0]); |
| } |
| |
| public void testSetFloat() { |
| try { |
| Array.setFloat(null, 0, 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| try { |
| Array.setFloat(new Object(), 0, 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| float[] array = new float[1]; |
| |
| Array.setFloat(array, 0, 1.0f); |
| assertEquals(1.0f, array[0]); |
| |
| double[] dArray = new double[1]; |
| Array.setFloat(dArray, 0, 1); |
| assertEquals((float) 1, (float) dArray[0]); |
| } |
| |
| public void testSetInt() { |
| try { |
| Array.setInt(null, 0, 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| try { |
| Array.setInt(new Object(), 0, 0); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| int[] array = new int[1]; |
| |
| Array.setInt(array, 0, 1); |
| assertEquals(1, array[0]); |
| |
| double[] dArray = new double[1]; |
| Array.setInt(dArray, 0, 1); |
| assertEquals(1, (int) dArray[0]); |
| |
| float[] fArray = new float[1]; |
| Array.setInt(fArray, 0, 1); |
| assertEquals(1, (int) fArray[0]); |
| |
| long[] lArray = new long[1]; |
| Array.setInt(lArray, 0, 1); |
| assertEquals(1, (int) lArray[0]); |
| } |
| |
| public void testSetLong() { |
| try { |
| Array.setLong(null, 0, 0L); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| try { |
| Array.setLong(new Object(), 0, 0L); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| long[] array = new long[1]; |
| |
| Array.setLong(array, 0, 1L); |
| assertEquals(1L, array[0]); |
| |
| double[] dArray = new double[1]; |
| Array.setLong(dArray, 0, 1); |
| assertEquals(1L, (long) dArray[0]); |
| |
| float[] fArray = new float[1]; |
| Array.setLong(fArray, 0, 1); |
| assertEquals(1L, (long) fArray[0]); |
| } |
| |
| public void testSetShort() { |
| try { |
| Array.setShort(null, 0, (short) 1); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| try { |
| Array.setShort(new Object(), 0, (short) 1); |
| fail(); |
| } catch (RuntimeException expected) { |
| } |
| |
| short[] array = new short[1]; |
| |
| Array.setShort(array, 0, (short) 1); |
| assertEquals((short) 1, array[0]); |
| |
| int[] iArray = new int[1]; |
| Array.setShort(iArray, 0, (short) 1); |
| assertEquals((short) 1, (short) iArray[0]); |
| |
| double[] dArray = new double[1]; |
| Array.setShort(dArray, 0, (short) 1); |
| assertEquals((short) 1, (short) dArray[0]); |
| |
| float[] fArray = new float[1]; |
| Array.setShort(fArray, 0, (short) 1); |
| assertEquals((short) 1, (short) fArray[0]); |
| |
| long[] lArray = new long[1]; |
| Array.setShort(lArray, 0, (short) 1); |
| assertEquals((short) 1, (short) lArray[0]); |
| } |
| } |