Home | History | Annotate | Download | only in src
      1 // Copyright 2008 The Android Open Source Project
      2 
      3 
      4 /**
      5  * Exercise arrays.
      6  */
      7 public class Array {
      8 
      9     /*
     10      * Verify array contents.
     11      */
     12     static void checkBytes(byte[] bytes) {
     13         assert(bytes[0] == 0);
     14         assert(bytes[1] == -1);
     15         assert(bytes[2] == -2);
     16         assert(bytes[3] == -3);
     17         assert(bytes[4] == -4);
     18     }
     19     static void checkShorts(short[] shorts) {
     20         assert(shorts[0] == 20);
     21         assert(shorts[1] == 10);
     22         assert(shorts[2] == 0);
     23         assert(shorts[3] == -10);
     24         assert(shorts[4] == -20);
     25     }
     26     static void checkChars(char[] chars) {
     27         assert(chars[0] == 40000);
     28         assert(chars[1] == 40001);
     29         assert(chars[2] == 40002);
     30         assert(chars[3] == 40003);
     31         assert(chars[4] == 40004);
     32     }
     33     static void checkInts(int[] ints) {
     34         assert(ints[0] == 70000);
     35         assert(ints[1] == 70001);
     36         assert(ints[2] == 70002);
     37         assert(ints[3] == 70003);
     38         assert(ints[4] == 70004);
     39     }
     40     static void checkBooleans(boolean[] booleans) {
     41         assert(booleans[0]);
     42         assert(booleans[1]);
     43         assert(!booleans[2]);
     44         assert(booleans[3]);
     45         assert(!booleans[4]);
     46     }
     47     static void checkFloats(float[] floats) {
     48         assert(floats[0] == -1.5);
     49         assert(floats[1] == -0.5);
     50         assert(floats[2] == 0.0);
     51         assert(floats[3] == 0.5);
     52         assert(floats[4] == 1.5);
     53     }
     54     static void checkLongs(long[] longs) {
     55         assert(longs[0] == 0x1122334455667788L);
     56         assert(longs[1] == 0x8877665544332211L);
     57         assert(longs[2] == 0L);
     58         assert(longs[3] == 1L);
     59         assert(longs[4] == -1L);
     60     }
     61     static void checkStrings(String[] strings) {
     62         assert(strings[0].equals("zero"));
     63         assert(strings[1].equals("one"));
     64         assert(strings[2].equals("two"));
     65         assert(strings[3].equals("three"));
     66         assert(strings[4].equals("four"));
     67     }
     68 
     69     /*
     70      * Try bad range values, 32 bit get/put.
     71      */
     72     static void checkRange32(int[] ints, int[] empty, int negVal1, int negVal2){
     73         System.out.println("Array.checkRange32");
     74         int i = 0;
     75 
     76         assert(ints.length == 5);
     77 
     78         try {
     79             i = ints[5];            // exact bound
     80             assert(false);
     81         } catch (ArrayIndexOutOfBoundsException aioobe) {
     82             // good
     83         }
     84         try {
     85             ints[5] = i;            // exact bound
     86             assert(false);
     87         } catch (ArrayIndexOutOfBoundsException aioobe) {
     88             // good
     89         }
     90         try {
     91             i = ints[6];            // one past
     92             assert(false);
     93         } catch (ArrayIndexOutOfBoundsException aioobe) {
     94             // good
     95         }
     96         try {
     97             i = ints[negVal1];      // -1
     98             assert(false);
     99         } catch (ArrayIndexOutOfBoundsException aioobe) {
    100             // good
    101         }
    102         try {
    103             ints[negVal1] = i;      // -1
    104             assert(false);
    105         } catch (ArrayIndexOutOfBoundsException aioobe) {
    106             // good
    107         }
    108         try {
    109             i = ints[negVal2];      // min int
    110             assert(false);
    111         } catch (ArrayIndexOutOfBoundsException aioobe) {
    112             // good
    113         }
    114 
    115 
    116         try {
    117             i = empty[1];
    118             assert(false);
    119         } catch (ArrayIndexOutOfBoundsException aioobe) {
    120             // good
    121         }
    122     }
    123 
    124     /*
    125      * Try bad range values, 64 bit get/put.
    126      */
    127     static void checkRange64(long[] longs, int negVal1, int negVal2) {
    128         System.out.println("Array.checkRange64");
    129         long l = 0L;
    130 
    131         assert(longs.length == 5);
    132 
    133         try {
    134             l = longs[5];            // exact bound
    135             assert(false);
    136         } catch (ArrayIndexOutOfBoundsException aioobe) {
    137             // good
    138         }
    139         try {
    140             longs[5] = l;            // exact bound
    141             assert(false);
    142         } catch (ArrayIndexOutOfBoundsException aioobe) {
    143             // good
    144         }
    145         try {
    146             l = longs[6];            // one past
    147             assert(false);
    148         } catch (ArrayIndexOutOfBoundsException aioobe) {
    149             // good
    150         }
    151         try {
    152             l = longs[negVal1];      // -1
    153             assert(false);
    154         } catch (ArrayIndexOutOfBoundsException aioobe) {
    155             // good
    156         }
    157         try {
    158             longs[negVal1] = l;      // -1
    159             assert(false);
    160         } catch (ArrayIndexOutOfBoundsException aioobe) {
    161             // good
    162         }
    163         try {
    164             l = longs[negVal2];      // min int
    165             assert(false);
    166         } catch (ArrayIndexOutOfBoundsException aioobe) {
    167             // good
    168         }
    169     }
    170 
    171     /*
    172      * Test negative allocations of object and primitive arrays.
    173      */
    174     static void checkNegAlloc(int count) {
    175         System.out.println("Array.checkNegAlloc");
    176         String[] strings;
    177         int[] ints;
    178 
    179         try {
    180             ints = new int[count];
    181             assert(false);
    182         } catch (NegativeArraySizeException nase) {
    183             // good
    184         }
    185 
    186         try {
    187             strings = new String[count];
    188             assert(false);
    189         } catch (NegativeArraySizeException nase) {
    190             // good
    191         }
    192     }
    193 
    194     public static void run() {
    195         System.out.println("Array check...");
    196 
    197         byte[] xBytes = new byte[] { 0, -1, -2, -3, -4 };
    198         short[] xShorts = new short[] { 20, 10, 0, -10, -20 };
    199         char[] xChars = new char[] { 40000, 40001, 40002, 40003, 40004 };
    200         int[] xInts = new int[] { 70000, 70001, 70002, 70003, 70004 };
    201         boolean[] xBooleans = new boolean[] { true, true, false, true, false };
    202         float[] xFloats = new float[] { -1.5f, -0.5f, 0.0f, 0.5f, 1.5f };
    203         long[] xLongs = new long[] {
    204             0x1122334455667788L, 0x8877665544332211L, 0L, 1L, -1l };
    205         String[] xStrings = new String[] {
    206             "zero", "one", "two", "three", "four" };
    207 
    208         int[] xEmpty = new int[0];
    209 
    210         checkBytes(xBytes);
    211         checkShorts(xShorts);
    212         checkChars(xChars);
    213         checkInts(xInts);
    214         checkBooleans(xBooleans);
    215         checkFloats(xFloats);
    216         checkLongs(xLongs);
    217         checkStrings(xStrings);
    218 
    219         checkRange32(xInts, xEmpty, -1, (int) 0x80000000);
    220         checkRange64(xLongs, -1, (int) 0x80000000);
    221 
    222         checkNegAlloc(-1);
    223     }
    224 }
    225