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

   1 package nom.tam.util.test;
   2
   3 import org.junit.Test;
   4 import static org.junit.Assert.assertEquals;
   5 import junit.framework.JUnit4TestAdapter;
   6 import nom.tam.util.ArrayFuncs;
   7
   8 public class ArrayFuncs2Test {
   9
  10     /** Test and demonstrate the ArrayFuncs methods.
  11      */
  12     @Test
  13     public void test() {
  14
  15         int[][][] test1 = new int[10][9][8];
  16         boolean[][] test2 = new boolean[4][];
  17         test2[0] = new boolean[5];
  18         test2[1] = new boolean[4];
  19         test2[2] = new boolean[3];
  20         test2[3] = new boolean[2];
  21
  22         double[][] test3 = new double[10][20];
  23         StringBuffer[][] test4 = new StringBuffer[3][2];
  24
  25         assertEquals("getBaseClass()", int.class, ArrayFuncs.getBaseClass(test1));
  26         assertEquals("getBaseLength()", 4, ArrayFuncs.getBaseLength(test1));
  27         assertEquals("computeSize()", 4 * 8 * 9 * 10, ArrayFuncs.computeSize(test1));
  28         assertEquals("computeLSize()", 4 * 8 * 9 * 10L, ArrayFuncs.computeLSize(test1));
  29
  30         assertEquals("getBaseClass(boolean)", boolean.class, ArrayFuncs.getBaseClass(test2));
  31         assertEquals("getBaseLength(boolean)", 1, ArrayFuncs.getBaseLength(test2));
  32         assertEquals("computeSize() not rect", 1 * (2 + 3 + 4 + 5), ArrayFuncs.computeSize(test2));
  33         assertEquals("computeLSize() not rect", 1L * (2 + 3 + 4 + 5), ArrayFuncs.computeLSize(test2));
  34
  35         assertEquals("getBaseClass(double)", double.class, ArrayFuncs.getBaseClass(test3));
  36         assertEquals("getBaseLength(double)", 8, ArrayFuncs.getBaseLength(test3));
  37         assertEquals("computeSize(double)", 8 * 10 * 20, ArrayFuncs.computeSize(test3));
  38         assertEquals("computeLSize(double)", 8 * 10 * 20L, ArrayFuncs.computeLSize(test3));
  39
  40         assertEquals("getBaseClass(StrBuf)", StringBuffer.class, ArrayFuncs.getBaseClass(test4));
  41         assertEquals("getBaseLength(StrBuf)", -1, ArrayFuncs.getBaseLength(test4));
  42         assertEquals("computeSize(StrBuf)", 0, ArrayFuncs.computeSize(test4));
  43         assertEquals("computeLSize(StrBuf)", 0L, ArrayFuncs.computeLSize(test4));
  44
  45         Object[] agg = new Object[4];
  46         agg[0] = test1;
  47         agg[1] = test2;
  48         agg[2] = test3;
  49         agg[3] = test4;
  50
  51         assertEquals("getBaseClass(Object[])", Object.class, ArrayFuncs.getBaseClass(agg));
  52         assertEquals("getBaseLength(Object[])", -1, ArrayFuncs.getBaseLength(agg));
  53
  54         // Add up all the primitive arrays and ignore the objects.
  55         assertEquals("computeSize(Object[])", 2880 + 14 + 1600 + 0, ArrayFuncs.computeSize(agg));
  56         assertEquals("computeLSize(Object[])", 2880L + 14 + 1600 + 0, ArrayFuncs.computeLSize(agg));
  57
  58         // Try allocating a very large array.  This is likely to fail
  59         // in the allocation step, so don't consider that to be a failure.
  60         try {
  61             float[][] data = new float[10000][30000];
  62             long expect = 10000L * 30000 * 4;
  63             assertEquals("computLSize(big)", ArrayFuncs.computeLSize(data), expect);
  64
  65         } catch (Error e) {
  66             System.out.println("Unable to allocate large array. Test skipped");
  67         }
  68
  69
  70         for (int i = 0; i < test1.length; i += 1) {
  71             for (int j = 0; j < test1[i].length; j += 1) {
  72                 for (int k = 0; k < test1[i][j].length; k += 1) {
  73                     test1[i][j][k] = i + j + k;
  74                 }
  75             }
  76         }
  77         int[][][] test5 = (int[][][]) ArrayFuncs.deepClone(test1);
  78
  79         assertEquals("deepClone()", true, ArrayFuncs.arrayEquals(test1, test5));
  80         test5[1][1][1] = -3;
  81         assertEquals("arrayEquals()", false, ArrayFuncs.arrayEquals(test1, test5));
  82
  83         int[] dimsOrig = ArrayFuncs.getDimensions(test1);
  84         int[] test6 = (int[]) ArrayFuncs.flatten(test1);
  85
  86         int[] dims = ArrayFuncs.getDimensions(test6);
  87
  88         assertEquals("getDimensions()", 3, dimsOrig.length);
  89         assertEquals("getDimensions()", 10, dimsOrig[0]);
  90         assertEquals("getDimensions()", 9, dimsOrig[1]);
  91         assertEquals("getDimensions()", 8, dimsOrig[2]);
  92         assertEquals("flatten()", 1, dims.length);
  93
  94         int[] newdims = {8, 9, 10};
  95
  96         int[][][] test7 = (int[][][]) ArrayFuncs.curl(test6, newdims);
  97
  98         int[] dimsAfter = ArrayFuncs.getDimensions(test7);
  99
 100         assertEquals("curl()", 3, dimsAfter.length);
 101         assertEquals("getDimensions()", 8, dimsAfter[0]);
 102         assertEquals("getDimensions()", 9, dimsAfter[1]);
 103         assertEquals("getDimensions()", 10, dimsAfter[2]);
 104
 105         byte[][][] xtest1 = (byte[][][]) ArrayFuncs.convertArray(test1, byte.class);
 106
 107         assertEquals("convertArray(toByte)", byte.class, ArrayFuncs.getBaseClass(xtest1));
 108         assertEquals("convertArray(tobyte)", test1[3][3][3], (int) xtest1[3][3][3]);
 109
 110         double[][][] xtest2 = (double[][][]) ArrayFuncs.convertArray(test1, double.class);
 111         assertEquals("convertArray(toByte)", double.class, ArrayFuncs.getBaseClass(xtest2));
 112         assertEquals("convertArray(tobyte)", test1[3][3][3], (int) xtest2[3][3][3]);
 113
 114         int[] xtest3 = (int[]) ArrayFuncs.newInstance(int.class, 20);
 115         int[] xtd = ArrayFuncs.getDimensions(xtest3);
 116         assertEquals("newInstance(vector)", 1, xtd.length);
 117         assertEquals("newInstance(vector)", 20, xtd[0]);
 118         double[][][][] xtest4 = (double[][][][]) ArrayFuncs.newInstance(double.class, new int[]{5, 4, 3, 2});
 119         xtd = ArrayFuncs.getDimensions(xtest4);
 120         assertEquals("newInstance(tensor)", 4, xtd.length);
 121         assertEquals("newInstance(tensor)", 5, xtd[0]);
 122         assertEquals("newInstance(tensor)", 4, xtd[1]);
 123         assertEquals("newInstance(tensor)", 3, xtd[2]);
 124         assertEquals("newInstance(tensor)", 2, xtd[3]);
 125         assertEquals("nElements()", 120, ArrayFuncs.nElements(xtest4));
 126         assertEquals("nLElements()", 120L, ArrayFuncs.nLElements(xtest4));
 127
 128         ArrayFuncs.testPattern(xtest4, (byte) -1);
 129
 130         assertEquals("testPattern()", (double) -1, xtest4[0][0][0][0], 0);
 131         assertEquals("testPattern()", (double) 118, xtest4[4][3][2][1], 0);
 132         double[] xtest4x = (double[]) ArrayFuncs.getBaseArray(xtest4);
 133
 134         assertEquals("getBaseArray()", 2, xtest4x.length);
 135
 136         double[] x = {1, 2, 3, 4, 5};
 137         double[] y = new double[x.length];
 138         for (int i = 0; i < y.length; i += 1) {
 139             y[i] = x[i] + 1.E-10;
 140         }
 141
 142         assertEquals("eqTest", false, ArrayFuncs.arrayEquals(x, y));
 143         assertEquals("eqTest2", true, ArrayFuncs.arrayEquals(x, y, 0., 1.e-9));
 144         assertEquals("eqTest3", true, ArrayFuncs.arrayEquals(x, y, 1.E-5, 1.e-9));
 145         assertEquals("eqTest4", false, ArrayFuncs.arrayEquals(x, y, 0., 1.e-11));
 146         assertEquals("eqTest5", false, ArrayFuncs.arrayEquals(x, y, 1.E-5, 0.));
 147
 148         float[] fx = {1, 2, 3, 4, 5};
 149         float[] fy = new float[fx.length];
 150         for (int i = 0; i < fy.length; i += 1) {
 151             fy[i] = fx[i] + 1.E-5F;
 152         }
 153
 154         assertEquals("eqTest6", false, ArrayFuncs.arrayEquals(fx, fy));
 155         assertEquals("eqTest7", true, ArrayFuncs.arrayEquals(fx, fy, 1.E-4, 0.));
 156         assertEquals("eqTest8", false, ArrayFuncs.arrayEquals(fx, fy, 1.E-6, 0.));
 157         assertEquals("eqTest9", false, ArrayFuncs.arrayEquals(fx, fy, 0., 0.));
 158         assertEquals("eqTest10", false, ArrayFuncs.arrayEquals(fx, fy, 0., 1.E-4));
 159
 160     }
 161 }