| package groovy |
| |
| class ArrayTest extends GroovyTestCase { |
| |
| void testFixedSize() { |
| def array = new String[10] |
| assert array.size() == 10 |
| array[0] = "Hello" |
| assert array[0] == "Hello" |
| } |
| |
| void testArrayWithInitializer() { |
| String[] array = ["nice", "cheese", "gromit"] |
| assert array.size() == 3 |
| assert array[0] == "nice", array.inspect() |
| assert array[1] == "cheese" |
| assert array[2] == "gromit" |
| } |
| |
| void testCharArrayCreate() { |
| def array = new char[3] |
| assert array.size() == 3 |
| } |
| |
| void testCharArrayAssignToElement() { |
| char[] ca = new char[1] |
| |
| // Assignments statements. |
| ca[0] = 'b' as char |
| assert ca[0] == 'b' |
| |
| ca[0] = '\u00A1' as char |
| assert ca[0] == '\u00A1' |
| |
| ca[0] = 'a' |
| assert ca[0] == 'a' |
| |
| ca[0] = '\u00A0' |
| assert ca[0] == '\u00A0' |
| |
| def foo = 'z' |
| |
| ca[0] = "$foo" |
| assert ca[0] == 'z' |
| |
| // Assignment in value context. |
| assert (ca[0] = 'b' as char) == 'b' |
| assert ca[0] == 'b' |
| |
| assert (ca[0] = '\u00A1' as char) == '\u00A1' |
| assert ca[0] == '\u00A1' |
| |
| assert (ca[0] = 'a') == 'a' |
| assert ca[0] == 'a' |
| |
| assert (ca[0] = '\u00A0') == '\u00A0' |
| assert ca[0] == '\u00A0' |
| |
| assert (ca[0] = "$foo") == 'z' |
| assert ca[0] == 'z' |
| } |
| |
| void testCharArrayWithInitializer() { |
| def bar = 'c' |
| char[] array = ['a', 'b', "$bar"] |
| assert array.size() == 3 |
| assert array[0] == 'a', array.inspect() |
| assert array[1] == 'b' |
| assert array[2] == 'c' |
| } |
| |
| void testByteArrayCreate() { |
| def array = new byte[100] |
| assert array.size() == 100; |
| } |
| |
| void testByteArrayWithInitializer() { |
| byte[] array = [0, 1, 2, 3] |
| assert array.size() == 4 |
| assert array[0] == 0, array.inspect() |
| assert array[1] == 1 |
| assert array[2] == 2 |
| assert array[3] == 3 |
| } |
| |
| void testByteArrayWithInitializerAndAssignmentOfNumber() { |
| byte[] array = [2, 4] |
| assert array.size() == 2 |
| assert array[0] == 2 |
| assert array[1] == 4 |
| |
| array[0] = 76 |
| array[1] = 32 |
| assert array[0] == 76 |
| assert array[1] == 32 |
| |
| array.putAt(0, 45) |
| array.putAt(1, 67) |
| assert array[0] == 45 |
| assert array[1] == 67 |
| } |
| |
| void testEachByteForByteArray() { |
| byte[] array1 = [2, 4] |
| def sum = 0 |
| array1.eachByte { sum += it } |
| assert sum == 6 |
| Byte[] array2 = [2, 4] |
| def result = 1 |
| array2.eachByte { result *= it } |
| assert result == 8 |
| } |
| |
| void testDoubleArrayCreate() { |
| def array = new double[3] |
| assert array.size() == 3 |
| } |
| |
| void testDoubleArrayWithInitializer() { |
| double[] array = [1.3, 3.14, 2.7] |
| assert array.size() == 3 |
| assert array[0] == 1.3, array.inspect() |
| assert array[1] == 3.14 |
| assert array[2] == 2.7 |
| } |
| |
| void testIntArrayCreate() { |
| def array = new int[5] |
| assert array.size() == 5 |
| } |
| |
| void testIntArrayWithInitializer() { |
| int[] array = [42, -5, 360] |
| assert array.size() == 3 |
| assert array[0] == 42, array.inspect() |
| assert array[1] == -5 |
| assert array[2] == 360 |
| } |
| |
| void testArrayDeclaration() { |
| String[] array = ["a", "b", "c"] |
| assert array.class == String[].class |
| assert array.size() == 3 |
| assert array[0] == "a" |
| assert array[1] == "b" |
| assert array[2] == "c" |
| } |
| |
| void testArrayAssignmentShouldHonorInheritance() { |
| String[] array = ["a", "b", "c"] |
| Object[] other = array |
| assert other.class == String[].class |
| assert other.hashCode() == array.hashCode() |
| } |
| |
| void testSimpleArrayEquals() { |
| Integer[] arr1 = [1, 2, 3, 4] |
| Integer[] arr2 = [1, 2, 3, 4] |
| assert arr1 == arr2 |
| int[] primarr1 = [1, 2, 3, 4] |
| int[] primarr2 = [1, 2, 3, 4] |
| assert primarr1 == primarr2 |
| assert primarr1 == arr2 |
| double[] primarr3 = [1, 2, 3, 4] |
| long[] primarr4 = [1, 2, 3, 4] |
| assert primarr3 == primarr4 |
| assert primarr3 == primarr1 |
| assert primarr2 == primarr4 |
| def list1 = [1, 2, 3, 4] |
| assert list1 == arr1 |
| assert arr1 == list1 |
| assert list1 == primarr1 |
| assert primarr1 == list1 |
| boolean[] bools1 = [true, true, false] |
| boolean[] bools2 = [true, true, false] |
| assert bools1 == bools2 |
| assert bools1 == [true, true, false] as boolean[] |
| } |
| |
| void testComplexArrayEquals() { |
| def a = [1, 2] as Integer[] |
| def b = [1, 2] |
| assert a == b |
| assert [[1, 2], [3, 4]] == [[1, 2], [3, 4]] |
| def x = [[1, 2] as Integer[]] |
| Object[] y = [[1, 2]] |
| assert y == x |
| assert [[1, 2], [3, 4]] as int[][] == [[1, 2], [3, 4]] as int[][] |
| assert [[[5, 6], [7, 8]]] as int[][][] == [[[5, 6], [7, 8]]] as Long[][][] |
| assert [[1, 2], [3, 4]] as long[][] == [[1, 2], [3, 4]] as long[][] |
| assert [[1, 2], [3, 4]] as long[][] == [[1, 2], [3, 4]] as Long[][] |
| assert [[1, 2], [3, 4]] as long[][] == [[1, 2], [3, 4]] |
| assert [[1, 2], [3, 4]] as long[][] == [[1, 2] as short[], [3, 4] as short[]] |
| int[][] intsA = [[1, 2], [3, 4]] |
| assert intsA == [[1, 2], [3, 4]] as int[][] |
| int[][] intsB = [[1, 2], [3, 4]] |
| assert intsA == intsB |
| boolean[][] boolsA = [[true, true], [false, true], [false]] |
| boolean[][] boolsB = [[true, true], [false, true], [false]] |
| assert boolsA == boolsB |
| } |
| |
| void testNumberWrapperArrayAssignToElement() { |
| Byte[] bytes = [1, 2] |
| bytes[0] = (byte) 20 |
| bytes[1] = 50 |
| assertEquals 20, bytes[0] |
| assertEquals 50, bytes[1] |
| |
| Short[] shorts = [1, 2] |
| shorts[1] = 50 |
| assertEquals 50, shorts[1] |
| |
| Float[] floats = [1.0f, 2.0f] |
| floats[1] = 50.0d |
| assertEquals 50.0d, floats[1] |
| |
| Double[] doubles = [1.0d, 2.0d] |
| doubles[0] = new BigDecimal(100) |
| doubles[1] = 50 |
| |
| assertEquals 100, doubles[0] |
| assertEquals 50, doubles[1] |
| } |
| |
| void testCharacterArrayElementAssignments() { |
| Character[] ca = new Character[1] |
| |
| // Assignments statements. |
| ca[0] = 'b' as char |
| assert ca[0] == 'b' |
| |
| ca[0] = '\u00A1' as char |
| assert ca[0] == '\u00A1' |
| |
| ca[0] = 'a' |
| assert ca[0] == 'a' |
| |
| ca[0] = '\u00A0' |
| assert ca[0] == '\u00A0' |
| |
| def foo = 'z' |
| |
| ca[0] = "$foo" |
| assert ca[0] == 'z' |
| } |
| |
| void testAssignmentOfSingleCharStringToNumberArrays() { |
| def x = 'x' |
| def gx = "$x" |
| |
| Short[] sa = new Short[1] |
| sa[0] = 'c' as char |
| assert sa[0] == 99 |
| sa[0] = 'd' |
| assert sa[0] == 100 |
| sa[0] = gx |
| assert sa[0] == 120 |
| shouldFail { |
| sa[0] = 'zz' |
| } |
| |
| Integer[] ca = new Integer[1] |
| ca[0] = 'c' as char |
| assert ca[0] == 99 |
| ca[0] = 'd' |
| assert ca[0] == 100 |
| ca[0] = gx |
| assert ca[0] == 120 |
| shouldFail { |
| ca[0] = 'zz' |
| } |
| |
| Long[] la = new Long[1] |
| la[0] = 'c' as char |
| assert la[0] == 99 |
| la[0] = 'd' |
| assert la[0] == 100 |
| la[0] = gx |
| assert la[0] == 120 |
| shouldFail { |
| la[0] = 'zz' |
| } |
| |
| Float[] fa = new Float[1] |
| fa[0] = 'c' as char |
| assert fa[0] == 99.0f |
| fa[0] = 'd' |
| assert fa[0] == 100.0f |
| fa[0] = gx |
| assert fa[0] == 120.0f |
| shouldFail { |
| fa[0] = 'zz' |
| } |
| |
| Double[] da = new Double[1] |
| da[0] = 'c' as char |
| assert da[0] == 99.0d |
| da[0] = 'd' |
| assert da[0] == 100.0d |
| da[0] = gx |
| assert da[0] == 120.0d |
| shouldFail { |
| da[0] = 'zz' |
| } |
| |
| BigInteger[] bia = new BigInteger[1] |
| bia[0] = 'c' as char |
| assert bia[0] == new BigInteger("99") |
| bia[0] = 'd' |
| assert bia[0] == new BigInteger("100") |
| bia[0] = gx |
| assert bia[0] == new BigInteger("120") |
| shouldFail { |
| bia[0] = 'zz' |
| } |
| |
| BigDecimal[] bda = new BigDecimal[1] |
| bda[0] = 'c' as char |
| assert bda[0] == new BigDecimal("99") |
| bda[0] = 'd' |
| assert bda[0] == new BigDecimal("100") |
| bda[0] = gx |
| assert bda[0] == new BigDecimal("120") |
| shouldFail { |
| bda[0] = 'zz' |
| } |
| |
| short[] sap = new short[1] |
| sap[0] = 'c' as char |
| assert sap[0] == 99 |
| sap[0] = 'd' |
| assert sap[0] == 100 |
| sap[0] = gx |
| assert sap[0] == 120 |
| shouldFail { |
| sap[0] = 'zz' |
| } |
| |
| int[] iap = new int[1] |
| iap[0] = 'c' as char |
| assert iap[0] == 99 |
| iap[0] = 'd' |
| assert iap[0] == 100 |
| iap[0] = gx |
| assert iap[0] == 120 |
| shouldFail { |
| iap[0] = 'zz' |
| } |
| |
| long[] lap = new long[1] |
| lap[0] = 'c' as char |
| assert lap[0] == 99 |
| lap[0] = 'd' |
| assert lap[0] == 100 |
| lap[0] = gx |
| assert lap[0] == 120 |
| shouldFail { |
| lap[0] = 'zz' |
| } |
| |
| float[] fap = new float[1] |
| fap[0] = 'c' as char |
| assert fap[0] == 99.0f |
| fap[0] = 'd' |
| assert fap[0] == 100.0f |
| fap[0] = gx |
| assert fap[0] == 120.0f |
| shouldFail { |
| fap[0] = 'zz' |
| } |
| |
| double[] dap = new double[1] |
| dap[0] = 'c' as char |
| assert dap[0] == 99.0d |
| dap[0] = 'd' |
| assert dap[0] == 100.0d |
| dap[0] = gx |
| assert dap[0] == 120.0d |
| shouldFail { |
| dap[0] = 'zz' |
| } |
| } |
| |
| void testFlattenArray() { |
| def orig = "onetwo".toList().toArray() |
| def flat = orig.flatten() |
| assert flat == ["o", "n", "e", "t", "w", "o"] |
| } |
| |
| void testFlattenArrayOfLists() { |
| def orig = ["one".toList(), "two".toList()] as Object[] |
| def flat = orig.flatten() |
| assert flat == ["o", "n", "e", "t", "w", "o"] |
| } |
| |
| void testFlattenArrayOfArrays() { |
| def orig = ["one".toList().toArray(), "two".toList().toArray()] as Object[] |
| def flat = orig.flatten() |
| assert flat == ["o", "n", "e", "t", "w", "o"] |
| } |
| |
| void testFlattenPrimitiveArray() { |
| def orig = [1, 2, 3] as int[] |
| def flat = orig.flatten() |
| assert flat == [1, 2, 3] |
| } |
| |
| void testFlattenArrayOfPrimitiveArrays() { |
| def orig = [[1, 2, 3] as int[], [4, 5, 6] as int[]] as int[][] |
| def flat = orig.flatten() |
| assert flat == [1, 2, 3, 4, 5, 6] |
| } |
| |
| void testGroovy5402ArrayPlus() { |
| Integer[] a = [ 1, 2, 3 ] |
| Integer[] b = [ 3, 4, 5 ] |
| def result = a + b |
| assert result == [ 1, 2, 3, 3, 4, 5 ] |
| assert result.class.isArray() |
| // check the originals are untouched |
| assert a == [ 1, 2, 3 ] |
| assert b == [ 3, 4, 5 ] |
| |
| result = a + 4 |
| assert result == [ 1, 2, 3, 4 ] |
| assert result.class.isArray() |
| |
| result = a + [ 4, 5 ] |
| assert result == [ 1, 2, 3, 4, 5 ] |
| assert result.class.isArray() |
| } |
| |
| void doSomething(long[] values){ |
| values[1] += 5 |
| } |
| |
| void testLongArrayIncrement() { |
| long[] l = [1l,0l] |
| doSomething(l) |
| assert l[0]==1 |
| assert l[1]==5 |
| } |
| } |