src/nom/tam/util/test/ArrayFuncsTest.java

   1 /*\r
   2  * ArrayFuncsTest.java\r
   3  * JUnit based test\r
   4  *\r
   5  * Created on December 2, 2007, 7:19 PM\r
   6  */\r
   7 package nom.tam.util.test;\r
   8 \r
   9 import junit.framework.*;\r
  10 import java.lang.reflect.*;\r
  11 import java.util.Arrays;\r
  12 import nom.tam.util.ArrayFuncs;\r
  13 \r
  14 /**\r
  15  *\r
  16  * @author Thomas McGlynn\r
  17  */\r
  18 public class ArrayFuncsTest extends TestCase {\r
  19 \r
  20     public ArrayFuncsTest(String testName) {\r
  21         super(testName);\r
  22     }\r
  23 \r
  24     protected void setUp() throws Exception {\r
  25     }\r
  26 \r
  27     protected void tearDown() throws Exception {\r
  28     }\r
  29 \r
  30     /**\r
  31      * Test of computeSize method, of class nom.tam.util.ArrayFuncs.\r
  32      */\r
  33     public void testComputeSize() {\r
  34         System.out.println("computeSize");\r
  35 \r
  36         Object o = null;\r
  37 \r
  38         int expResult = 0;\r
  39         int result = ArrayFuncs.computeSize(o);\r
  40         assertEquals(expResult, result);\r
  41         int[][] x = new int[2][3];\r
  42         assertEquals(ArrayFuncs.computeSize(x), 24);\r
  43         assertEquals(ArrayFuncs.computeSize(new double[3]), 24);\r
  44         assertEquals(ArrayFuncs.computeSize("1234"), 4);\r
  45         assertEquals(ArrayFuncs.computeSize(new Object()), 0);\r
  46         assertEquals(ArrayFuncs.computeSize(new Double[5]), 0);\r
  47         assertEquals(ArrayFuncs.computeSize(new Double[]{\r
  48                     new Double(0), new Double(1), new Double(2)}), 24);\r
  49         assertEquals(ArrayFuncs.computeLSize(x), 24);\r
  50         assertEquals(ArrayFuncs.computeLSize(new double[3]), 24);\r
  51         assertEquals(ArrayFuncs.computeLSize("1234"), 4);\r
  52         assertEquals(ArrayFuncs.computeLSize(new Object()), 0);\r
  53         assertEquals(ArrayFuncs.computeLSize(new Double[5]), 0);\r
  54         assertEquals(ArrayFuncs.computeLSize(new Double[]{\r
  55                     new Double(0), new Double(1), new Double(2)}), 24);\r
  56     }\r
  57 \r
  58     /**\r
  59      * Test of nElements method, of class nom.tam.util.ArrayFuncs.\r
  60      */\r
  61     public void testNElements() {\r
  62         System.out.println("nElements");\r
  63 \r
  64         Object o = null;\r
  65 \r
  66         assertEquals(ArrayFuncs.nElements(null), 0);\r
  67         assertEquals(ArrayFuncs.nElements(new int[2][2][3]), 12);\r
  68         assertEquals(ArrayFuncs.nLElements(null), 0);\r
  69         assertEquals(ArrayFuncs.nLElements(new int[2][2][3]), 12);\r
  70     }\r
  71 \r
  72     /**\r
  73      * Test of deepClone method, of class nom.tam.util.ArrayFuncs.\r
  74      */\r
  75     public void testDeepClone() {\r
  76         int[][] test = {{0, 1}, {2, 3}, {4, 5}};\r
  77         int[][] result = (int[][]) nom.tam.util.ArrayFuncs.deepClone(test);\r
  78 \r
  79         for (int i = 0; i < test.length; i += 1) {\r
  80             for (int j = 0; j < test[i].length; j += 1) {\r
  81                 assertEquals(test[i][j], result[i][j]);\r
  82             }\r
  83         }\r
  84     }\r
  85 \r
  86     public class CloneTest implements Cloneable {\r
  87 \r
  88         public int value = 2;\r
  89 \r
  90         public Object clone() {\r
  91             try {\r
  92                 return super.clone();\r
  93             } catch (Exception e) {\r
  94             }\r
  95             return null;\r
  96         }\r
  97 \r
  98         public boolean equals(Object x) {\r
  99             return (x instanceof CloneTest)\r
 100                     && (((CloneTest) x).value == this.value);\r
 101         }\r
 102     }\r
 103 \r
 104     /**\r
 105      * Test of genericClone method, of class nom.tam.util.ArrayFuncs.\r
 106      */\r
 107     public void testGenericClone() {\r
 108         System.out.println("genericClone");\r
 109 \r
 110         Object o = new int[]{1, 2, 3};\r
 111 \r
 112         Object result = nom.tam.util.ArrayFuncs.genericClone(o);\r
 113 \r
 114         int[] x = (int[]) o;\r
 115         int[] y = (int[]) result;\r
 116         for (int i = 0; i < x.length; i += 1) {\r
 117             assertEquals(x[i], y[i]);\r
 118         }\r
 119         CloneTest xa = new CloneTest();\r
 120         xa.value = 4;\r
 121         Object ya = ArrayFuncs.genericClone(xa);\r
 122         assertTrue(xa != ya);\r
 123         assertTrue(xa.equals(ya));\r
 124     }\r
 125 \r
 126     /**\r
 127      * Test of copyArray method, of class nom.tam.util.ArrayFuncs.\r
 128      */\r
 129     public void testCopyArray() {\r
 130         System.out.println("copyArray");\r
 131 \r
 132         double[] start = new double[]{1, 2, 3, 4, 5, 6};\r
 133         double[] finish = new double[6];\r
 134         ArrayFuncs.copyArray(start, finish);\r
 135         assertTrue(ArrayFuncs.arrayEquals(start, finish));\r
 136     }\r
 137 \r
 138     /**\r
 139      * Test of getDimensions method, of class nom.tam.util.ArrayFuncs.\r
 140      */\r
 141     public void testGetDimensions() {\r
 142         System.out.println("getDimensions");\r
 143 \r
 144         Object o = null;\r
 145         int[] expResult = null;\r
 146         int[] result = nom.tam.util.ArrayFuncs.getDimensions(o);\r
 147         assertEquals(expResult, result);\r
 148 \r
 149         assertEquals(ArrayFuncs.getDimensions(new Integer(0)).length, 0);\r
 150         int[][] test = new int[2][3];\r
 151         int[] dims = ArrayFuncs.getDimensions(test);\r
 152         assertEquals(dims.length, 2);\r
 153         assertEquals(dims[0], 2);\r
 154         assertEquals(dims[1], 3);\r
 155     }\r
 156 \r
 157     /**\r
 158      * Test of getBaseArray method, of class nom.tam.util.ArrayFuncs.\r
 159      */\r
 160     public void testGetBaseArray() {\r
 161 \r
 162         int[][][] test = new int[2][3][4];\r
 163         byte b = 0;\r
 164         ArrayFuncs.testPattern(test, b);\r
 165 \r
 166         assertEquals(ArrayFuncs.getBaseArray(test), test[0][0]);\r
 167     }\r
 168 \r
 169     /**\r
 170      * Test of getBaseClass method, of class nom.tam.util.ArrayFuncs.\r
 171      */\r
 172     public void testGetBaseClass() {\r
 173         System.out.println("getBaseClass");\r
 174 \r
 175         assertEquals(ArrayFuncs.getBaseClass(new int[2][3]), int.class);\r
 176         assertEquals(ArrayFuncs.getBaseClass(new String[3]), String.class);\r
 177     }\r
 178 \r
 179     /**\r
 180      * Test of getBaseLength method, of class nom.tam.util.ArrayFuncs.\r
 181      */\r
 182     public void testGetBaseLength() {\r
 183 \r
 184         assertEquals(ArrayFuncs.getBaseLength(new int[2][3]), 4);\r
 185         assertEquals(ArrayFuncs.getBaseLength(new double[2][3]), 8);\r
 186         assertEquals(ArrayFuncs.getBaseLength(new byte[2][3]), 1);\r
 187         assertEquals(ArrayFuncs.getBaseLength(new short[2][3]), 2);\r
 188         assertEquals(ArrayFuncs.getBaseLength(new int[2][3]), 4);\r
 189         assertEquals(ArrayFuncs.getBaseLength(new char[2][3]), 2);\r
 190         assertEquals(ArrayFuncs.getBaseLength(new float[2][3]), 4);\r
 191         assertEquals(ArrayFuncs.getBaseLength(new boolean[2][3]), 1);\r
 192         assertEquals(ArrayFuncs.getBaseLength(new Object[2][3]), -1);\r
 193     }\r
 194 \r
 195     /**\r
 196      * Test of generateArray method, of class nom.tam.util.ArrayFuncs.\r
 197      */\r
 198     public void testGenerateArray() {\r
 199         System.out.println("generateArray");\r
 200 \r
 201         Class baseType = int.class;\r
 202         int[] dims = {2, 3, 4};\r
 203 \r
 204         Object result = nom.tam.util.ArrayFuncs.generateArray(baseType, dims);\r
 205         assertEquals(result.getClass(), int[][][].class);\r
 206         int[][][] x = (int[][][]) result;\r
 207         assertEquals(x.length, 2);\r
 208         assertEquals(x[0].length, 3);\r
 209         assertEquals(x[0][0].length, 4);\r
 210 \r
 211     }\r
 212 \r
 213     /**\r
 214      * Test of testPattern method, of class nom.tam.util.ArrayFuncs.\r
 215      */\r
 216     public void testTestPattern() {\r
 217         System.out.println("testPattern");\r
 218 \r
 219         byte start = 2;\r
 220         int[] arr = new int[8];\r
 221 \r
 222         byte expResult = 0;\r
 223         byte result = nom.tam.util.ArrayFuncs.testPattern(arr, start);\r
 224         assertEquals(result, (byte) (start + arr.length));\r
 225         assertEquals(start, arr[0]);\r
 226         assertEquals(start + arr.length - 1, arr[arr.length - 1]);\r
 227     }\r
 228 \r
 229     /**\r
 230      * Test of flatten method, of class nom.tam.util.ArrayFuncs.\r
 231      */\r
 232     public void testFlatten() {\r
 233         System.out.println("flatten");\r
 234 \r
 235         int[][][] test = new int[2][3][4];\r
 236 \r
 237         int[] result = (int[]) ArrayFuncs.flatten(test);\r
 238         assertEquals(result.length, 24);\r
 239     }\r
 240 \r
 241     /**\r
 242      * Test of curl method, of class nom.tam.util.ArrayFuncs.\r
 243      */\r
 244     public void testCurl() {\r
 245         System.out.println("curl");\r
 246 \r
 247         int[] dimens = new int[]{2, 3, 4};\r
 248         int[] test = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23};\r
 249 \r
 250         int[][][] res = (int[][][]) nom.tam.util.ArrayFuncs.curl(test, dimens);\r
 251         assertEquals(res.length, 2);\r
 252         assertEquals(res[0].length, 3);\r
 253         assertEquals(res[0][0].length, 4);\r
 254         assertEquals(res[0][0][0], 0);\r
 255         assertEquals(res[0][0][3], 3);\r
 256         assertEquals(res[1][2][3], 23);\r
 257     }\r
 258 \r
 259     /**\r
 260      * Test of mimicArray method, of class nom.tam.util.ArrayFuncs.\r
 261      */\r
 262     public void testMimicArray() {\r
 263         System.out.println("mimicArray");\r
 264 \r
 265         int[][] array = new int[2][3];\r
 266         Class newType = double.class;\r
 267 \r
 268         double[][] result = (double[][]) nom.tam.util.ArrayFuncs.mimicArray(array, newType);\r
 269         assertEquals(result.length, array.length);\r
 270         assertEquals(result[0].length, array[0].length);\r
 271     }\r
 272 \r
 273     /**\r
 274      * Test of convertArray method, of class nom.tam.util.ArrayFuncs.\r
 275      */\r
 276     public void testConvertArray() {\r
 277         System.out.println("convertArray");\r
 278 \r
 279         int[][] array = {{1, 2, 3}, {4, 5, 6}};\r
 280         Class newType = double.class;\r
 281 \r
 282         boolean reuse = true;\r
 283         double[][] dres = (double[][]) ArrayFuncs.convertArray(array, newType, reuse);\r
 284         assertEquals(dres.length, array.length);\r
 285         assertEquals(dres[0].length, array[0].length);\r
 286 \r
 287         newType = int.class;\r
 288         int[][] ires = (int[][]) ArrayFuncs.convertArray(array, newType, true);\r
 289         assertEquals(array, ires);\r
 290 \r
 291         ires = (int[][]) ArrayFuncs.convertArray(array, newType, false);\r
 292         assertNotSame(array, ires);\r
 293         assertTrue(ArrayFuncs.arrayEquals(array, ires));\r
 294     }\r
 295 \r
 296     /**\r
 297      * Test of copyInto method, of class nom.tam.util.ArrayFuncs.\r
 298      */\r
 299     public void testCopyInto() {\r
 300         System.out.println("copyInto");\r
 301 \r
 302         int[][] x = {{2, 3, 4}, {5, 6, 7}};\r
 303         double[][] y = new double[2][3];\r
 304 \r
 305         ArrayFuncs.copyInto(x, y);\r
 306 \r
 307         assertEquals((double) x[0][0], y[0][0]);\r
 308         assertEquals((double) x[1][2], y[1][2]);\r
 309     }\r
 310 \r
 311     /**\r
 312      * Test of arrayEquals method, of class nom.tam.util.ArrayFuncs.\r
 313      */\r
 314     public void testArrayEquals() {\r
 315         System.out.println("arrayEquals");\r
 316 \r
 317         int[][] x = {{1, 2, 3}, {4, 5, 6}};\r
 318         int[][] y = {{1, 2, 3}, {4, 5, 6}};\r
 319         int[][] z = {{1, 2, 3}, {4, 5, 7}};\r
 320         int[][] t = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};\r
 321 \r
 322 \r
 323         assertTrue(ArrayFuncs.arrayEquals(null, null));\r
 324         assertFalse(ArrayFuncs.arrayEquals(null, new int[2]));\r
 325         assertTrue(ArrayFuncs.arrayEquals(x, y));\r
 326         assertFalse(ArrayFuncs.arrayEquals(x, z));\r
 327         assertFalse(ArrayFuncs.arrayEquals(x, t));\r
 328         assertTrue(ArrayFuncs.arrayEquals(x[0], z[0]));\r
 329     }\r
 330 \r
 331     /**\r
 332      * Test of doubleArrayEquals method, of class nom.tam.util.ArrayFuncs.\r
 333      */\r
 334     public void testDoubleArrayEquals() {\r
 335 \r
 336         double x[] = {1, 2, 3};\r
 337         double y[] = {1, 2, 3};\r
 338         System.out.println("doubleArrayEquals");\r
 339 \r
 340         double tol = 0.0;\r
 341 \r
 342         assertTrue(ArrayFuncs.doubleArrayEquals(x, y, tol));\r
 343         x[0] += 1.e-14;\r
 344         assertFalse(ArrayFuncs.doubleArrayEquals(x, y, tol));\r
 345         tol = 1.e-13;\r
 346         assertTrue(ArrayFuncs.doubleArrayEquals(x, y, tol));\r
 347     }\r
 348 \r
 349     /**\r
 350      * Test of floatArrayEquals method, of class nom.tam.util.ArrayFuncs.\r
 351      */\r
 352     public void testFloatArrayEquals() {\r
 353         float x[] = {1f, 2f, 3f};\r
 354         float y[] = {1f, 2f, 3f};\r
 355         System.out.println("floatArrayEquals");\r
 356 \r
 357         float tol = 0.0F;\r
 358         assertTrue(ArrayFuncs.floatArrayEquals(x, y, tol));\r
 359         x[0] += 1.e-6f;\r
 360         assertFalse(ArrayFuncs.floatArrayEquals(x, y, tol));\r
 361         tol = 1.e-5f;\r
 362         assertTrue(ArrayFuncs.floatArrayEquals(x, y, tol));\r
 363     }\r
 364 }\r