--- /dev/null
+/* tests/regression/base/TestArrayClasses.java
+
+ Copyright (C) 2008
+ CACAOVM - Verein zur Foerderung der freien virtuellen Maschine CACAO
+
+ This file is part of CACAO.
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as
+ published by the Free Software Foundation; either version 2, or (at
+ your option) any later version.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301, USA.
+
+*/
+
+
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+import java.io.Serializable;
+
+public class TestArrayClasses {
+ public static class Foo {
+ }
+
+ public static class FooChild extends Foo {
+ }
+
+ private void doStore(Object[] array, Object obj, boolean oktostore, String msg) {
+ try {
+ array[0] = obj;
+ assertTrue(msg, oktostore);
+ }
+ catch (ArrayStoreException x) {
+ assertFalse(msg, oktostore);
+ }
+ }
+
+ @Test
+ public void testClone() {
+ int[] ia1 = new int[100];
+ Integer[] Ia1 = new Integer[ia1.length];
+ int i;
+
+ for (i=0; i<ia1.length; ++i) {
+ ia1[i] = i*i;
+ Ia1[i] = new Integer(ia1[i]);
+ }
+
+ int[] ia2 = (int[]) ia1.clone();
+
+ assertEquals("cloned int array length", ia1.length, ia2.length);
+
+ boolean eq = true;
+ for (i=0; i<ia1.length; ++i) {
+ if (ia2[i] != ia1[i])
+ eq = false;
+ // System.out.println(ia2[i]);
+ }
+ assertTrue("cloned int array data", eq);
+
+ Integer[] Ia2 = (Integer[]) Ia1.clone();
+
+ assertEquals("cloned Integer array length", Ia1.length, Ia2.length);
+
+ eq = true;
+ for (i=0; i<ia1.length; ++i) {
+ if (Ia2[i].intValue() != ia1[i])
+ eq = false;
+ // System.out.println(ia2[i]);
+ }
+ assertTrue("cloned Integer array data", eq);
+ }
+
+ @Test
+ public void testArraycopy() {
+ int len;
+ int i;
+
+ long[] la1 = new long[1024];
+ long[] la2 = (long[]) la1.clone();
+ int size = la1.length;
+ Long[] La1 = new Long[size];
+ Long[] La2 = (Long[]) La1.clone();
+ Number[] Na2 = new Number[size];
+
+ for (i=0; i<la1.length; ++i) {
+ la1[i] = i*i;
+ La1[i] = new Long(la1[i]);
+ }
+
+ i = size;
+ while (i>1) {
+ if ((i & 1) != 0)
+ System.err.println("ERROR: arracopy test only works for powers of two");
+ i >>= 1;
+ }
+
+ // reverse array
+ len = size / 2;
+ while (len>0) {
+ for (int j=0;j<(size/2)/len;++j) {
+ // System.err.println(len);
+ // System.err.println(j);
+ System.arraycopy(la1,(2*j+1)*len,la2,2*j*len,len);
+ System.arraycopy(la1,2*j*len,la1,(2*j+1)*len,len);
+ System.arraycopy(la2,2*j*len,la1,2*j*len,len);
+ }
+ len /= 2;
+ }
+
+ boolean eq = true;
+ for (i=0; i<size; ++i) {
+ if (la1[i] != (size-i-1)*(size-i-1))
+ eq = false;
+ // System.out.println(la1[i]);
+ }
+ assertTrue("arraycopy primitive", eq);
+
+ // reverse array
+ len = size / 2;
+ while (len>0) {
+ for (int j=0;j<(size/2)/len;++j) {
+ // System.err.println(len);
+ // System.err.println(j);
+ System.arraycopy(La1,(2*j+1)*len,La2,2*j*len,len);
+ System.arraycopy(La1,2*j*len,La1,(2*j+1)*len,len);
+ System.arraycopy(La2,2*j*len,La1,2*j*len,len);
+ }
+ len /= 2;
+ }
+
+ eq = true;
+ for (i=0; i<size; ++i) {
+ if (La1[i].intValue() != (size-i-1)*(size-i-1))
+ eq = false;
+ }
+ assertTrue("arraycopy ref", eq);
+
+ // reverse array
+ len = size / 2;
+ while (len>0) {
+ for (int j=0;j<(size/2)/len;++j) {
+ // System.err.println(len);
+ // System.err.println(j);
+ System.arraycopy(La1,(2*j+1)*len,Na2,2*j*len,len);
+ System.arraycopy(La1,2*j*len,La1,(2*j+1)*len,len);
+ System.arraycopy(Na2,2*j*len,La1,2*j*len,len);
+ }
+ len /= 2;
+ }
+
+ eq = true;
+ for (i=0; i<size; ++i) {
+ if (La1[i].intValue() != i*i)
+ eq = false;
+ }
+ assertTrue("arraycopy ref different classes", eq);
+
+ Integer[] Ia = new Integer[size];
+
+ try {
+ System.arraycopy(Ia,0,Na2,0,1);
+ assertTrue("arraycopy Integer to Number", true);
+ }
+ catch (ArrayStoreException x) {
+ fail("arraycopy Integer to Number");
+ }
+
+ try {
+ System.arraycopy(Na2,1,Ia,1,1);
+ fail("!arraycopy Number to Integer");
+ }
+ catch (ArrayStoreException x) {
+ assertTrue("!arraycopy Number to Integer", true);
+ }
+ }
+
+ @Test
+ public void testMain() {
+ int[] ia = new int[5];
+ Object[] oa = new Object[2];
+ Object[][] oaa = new Object[1][1];
+ String[] sa = new String[3];
+ String[][] saa = new String[1][1];
+ String[][] saa2 = new String[2][];
+ String[][][] saaa = new String[1][2][3];
+ Object o = new Object();
+ java.io.Serializable[] sera = new java.io.Serializable[1];
+ Cloneable[] cloa = new Cloneable[1];
+ StringBuffer[][] sbaa = new StringBuffer[1][1];
+ Foo[] fooa = new Foo[1];
+ FooChild[] fooca = new FooChild[1];
+
+ Class[] ifs = String[].class.getInterfaces();
+ assertEquals("String[] implements 2 interfaces", 2, ifs.length);
+ assertTrue("String[] implements Cloneable", ifs[0] == java.lang.Cloneable.class || ifs[1] == java.lang.Cloneable.class);
+ assertTrue("String[] implements Serializable", ifs[0] == java.io.Serializable.class || ifs[1] == java.io.Serializable.class);
+
+ assertEquals("String[] is public final abstract", 1041, String[].class.getModifiers());
+
+ assertEquals("classname ref", "[Ljava.lang.Object;", oa.getClass().getName());
+ assertEquals("classname primitive", "[I", ia.getClass().getName());
+ assertEquals("arraylength primitive", 5, ia.length);
+ assertEquals("arraylength ref", 2, oa.length);
+
+ assertEquals("arraylength of saa2", 2, saa2.length);
+ saa2[1] = new String[4];
+ assertEquals("arraylength of saa2[1]", 4, saa2[1].length);
+
+ assertEquals("arraylength of saaa", 1, saaa.length);
+ assertEquals("arraylength of saaa[0]", 2, saaa[0].length);
+ assertEquals("arraylength of saaa[0][1]", 3, saaa[0][1].length);
+
+ assertTrue("Object[].isArray", oa.getClass().isArray());
+ assertTrue("int[].isArray", ia.getClass().isArray());
+ assertFalse("!Object.isArray", o.getClass().isArray());
+ assertFalse("!Object.isPrimitive", o.getClass().isPrimitive());
+
+ assertEquals("component ref", "java.lang.Object", oa.getClass().getComponentType().getName());
+ assertFalse("component ref !isPrimitive", oa.getClass().getComponentType().isPrimitive());
+ assertEquals("component primitive", "int", ia.getClass().getComponentType().getName());
+ assertTrue("component primitive isPrimitive", ia.getClass().getComponentType().isPrimitive());
+
+ assertTrue("component of String[][] equals String[]", saa.getClass().getComponentType().equals(sa.getClass()));
+ assertFalse("component of String[][] !equals Object[]", saa.getClass().getComponentType().equals(oa.getClass()));
+
+ assertTrue("saa[0].getClass equals component of String[][]", saa[0].getClass().equals(saa.getClass().getComponentType()));
+
+ doStore(sa, new Object(), false, "!store Object in String[]");
+ doStore(sa, new String("test"), true, "store String in String[]");
+ doStore(oa, new Object(), true, "store Object in Object[]");
+ doStore(oa, new String("test"), true, "store String in Object[]");
+
+ doStore(oaa, sa, true, "store String[] in Object[][]");
+ doStore(saa, oa, false, "!store Object[] in String[][]");
+
+ doStore(sera, sa, true, "store String[] in java.io.Serializable[]");
+ doStore(cloa, sa, true, "store String[] in Cloneable[]");
+
+ doStore(sbaa, sa, false, "!store String[] in StringBuffer[][]");
+
+ doStore(fooa, new Foo(), true, "store Foo in Foo[]");
+ doStore(fooa, new FooChild(), true, "store FooChild in Foo[]");
+ doStore(fooca, new Foo(), false, "!store Foo in FooChild[]");
+ doStore(fooca, new FooChild(), true, "store FooChild in FooChild[]");
+
+ try {
+ Object[] oa2 = (Object[]) sa;
+ assertTrue("cast String[] to Object[]", true);
+ }
+ catch (ClassCastException x) {
+ fail("cast String[] to Object[]");
+ }
+
+ try {
+ String[] sa2 = (String[]) oa;
+ fail("!cast Object[] to String[]");
+ }
+ catch (ClassCastException x) {
+ assertTrue("!cast Object[] to String[]", true);
+ }
+
+ assertTrue("String[] instanceof String[]", sa instanceof String[]);
+ assertTrue("String[] instanceof Object[]", sa instanceof Object[]);
+ assertFalse("Object[] !instanceof String[]", oa instanceof String[]);
+ assertTrue("Object[] instanceof Object[]", oa instanceof Object[]);
+
+ assertTrue("Object[][] instanceof Object[]", oaa instanceof Object[]);
+ assertTrue("String[][] instanceof Object[]", saa instanceof Object[]);
+
+ assertTrue("String[] instanceof java.io.Serializable", sa instanceof java.io.Serializable);
+ assertTrue("String[] instanceof java.lang.Cloneable", sa instanceof java.lang.Cloneable);
+ assertTrue("String[] instanceof java.lang.Object", sa instanceof java.lang.Object);
+ assertTrue("saa[0] instanceof java.io.Serializable", saa[0] instanceof java.io.Serializable);
+ assertTrue("saa[0] instanceof java.lang.Cloneable", saa[0] instanceof java.lang.Cloneable);
+ assertTrue("saa[0] instanceof java.lang.Object", saa[0] instanceof java.lang.Object);
+ }
+}
projects / cacao.git / blobdiff