src/testcases/org/apache/poi/util/TestShortField.java

   1
   2 /* ====================================================================
   3    Licensed to the Apache Software Foundation (ASF) under one or more
   4    contributor license agreements.  See the NOTICE file distributed with
   5    this work for additional information regarding copyright ownership.
   6    The ASF licenses this file to You under the Apache License, Version 2.0
   7    (the "License"); you may not use this file except in compliance with
   8    the License.  You may obtain a copy of the License at
   9
  10        http://www.apache.org/licenses/LICENSE-2.0
  11
  12    Unless required by applicable law or agreed to in writing, software
  13    distributed under the License is distributed on an "AS IS" BASIS,
  14    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15    See the License for the specific language governing permissions and
  16    limitations under the License.
  17 ==================================================================== */
  18
  19
  20 package org.apache.poi.util;
  21
  22 import junit.framework.*;
  23
  24 import java.io.*;
  25
  26 /**
  27  * Test ShortField code
  28  *
  29  * @author  Marc Johnson (mjohnson at apache dot org)
  30  */
  31
  32 public class TestShortField
  33     extends TestCase
  34 {
  35
  36     /**
  37      * Constructor
  38      *
  39      * @param name
  40      */
  41
  42     public TestShortField(String name)
  43     {
  44         super(name);
  45     }
  46
  47     static private final short[] _test_array =
  48     {
  49         Short.MIN_VALUE, ( short ) -1, ( short ) 0, ( short ) 1,
  50         Short.MAX_VALUE
  51     };
  52
  53     /**
  54      * Test constructors.
  55      */
  56
  57     public void testConstructors()
  58     {
  59         try
  60         {
  61             new ShortField(-1);
  62             fail("Should have caught ArrayIndexOutOfBoundsException");
  63         }
  64         catch (ArrayIndexOutOfBoundsException ignored_e)
  65         {
  66
  67             // as expected
  68         }
  69         ShortField field = new ShortField(2);
  70
  71         assertEquals(0, field.get());
  72         try
  73         {
  74             new ShortField(-1, ( short ) 1);
  75             fail("Should have caught ArrayIndexOutOfBoundsException");
  76         }
  77         catch (ArrayIndexOutOfBoundsException ignored_e)
  78         {
  79
  80             // as expected
  81         }
  82         field = new ShortField(2, ( short ) 0x1234);
  83         assertEquals(0x1234, field.get());
  84         byte[] array = new byte[ 4 ];
  85
  86         try
  87         {
  88             new ShortField(-1, ( short ) 1, array);
  89             fail("Should have caught ArrayIndexOutOfBoundsException");
  90         }
  91         catch (ArrayIndexOutOfBoundsException ignored_e)
  92         {
  93
  94             // as expected
  95         }
  96         field = new ShortField(2, ( short ) 0x1234, array);
  97         assertEquals(( short ) 0x1234, field.get());
  98         assertEquals(( byte ) 0x34, array[ 2 ]);
  99         assertEquals(( byte ) 0x12, array[ 3 ]);
 100         array = new byte[ 3 ];
 101         try
 102         {
 103             new ShortField(2, ( short ) 5, array);
 104             fail("should have gotten ArrayIndexOutOfBoundsException");
 105         }
 106         catch (ArrayIndexOutOfBoundsException ignored_e)
 107         {
 108
 109             // as expected
 110         }
 111         for (int j = 0; j < _test_array.length; j++)
 112         {
 113             array = new byte[ 2 ];
 114             new ShortField(0, _test_array[ j ], array);
 115             assertEquals(_test_array[ j ], new ShortField(0, array).get());
 116         }
 117     }
 118
 119     /**
 120      * Test set() methods
 121      */
 122
 123     public void testSet()
 124     {
 125         ShortField field = new ShortField(0);
 126         byte[]     array = new byte[ 2 ];
 127
 128         for (int j = 0; j < _test_array.length; j++)
 129         {
 130             field.set(_test_array[ j ]);
 131             assertEquals("testing _1 " + j, _test_array[ j ], field.get());
 132             field = new ShortField(0);
 133             field.set(_test_array[ j ], array);
 134             assertEquals("testing _2 ", _test_array[ j ], field.get());
 135             assertEquals("testing _3.0 " + _test_array[ j ],
 136                          ( byte ) (_test_array[ j ] % 256), array[ 0 ]);
 137             assertEquals("testing _3.1 " + _test_array[ j ],
 138                          ( byte ) ((_test_array[ j ] >> 8) % 256),
 139                          array[ 1 ]);
 140         }
 141     }
 142
 143     /**
 144      * Test readFromBytes
 145      */
 146
 147     public void testReadFromBytes()
 148     {
 149         ShortField field = new ShortField(1);
 150         byte[]     array = new byte[ 2 ];
 151
 152         try
 153         {
 154             field.readFromBytes(array);
 155             fail("should have caught ArrayIndexOutOfBoundsException");
 156         }
 157         catch (ArrayIndexOutOfBoundsException ignored_e)
 158         {
 159
 160             // as expected
 161         }
 162         field = new ShortField(0);
 163         for (int j = 0; j < _test_array.length; j++)
 164         {
 165             array[ 0 ] = ( byte ) (_test_array[ j ] % 256);
 166             array[ 1 ] = ( byte ) ((_test_array[ j ] >> 8) % 256);
 167             field.readFromBytes(array);
 168             assertEquals("testing " + j, _test_array[ j ], field.get());
 169         }
 170     }
 171
 172     /**
 173      * Test readFromStream
 174      *
 175      * @exception IOException
 176      */
 177
 178     public void testReadFromStream()
 179         throws IOException
 180     {
 181         ShortField field  = new ShortField(0);
 182         byte[]     buffer = new byte[ _test_array.length * 2 ];
 183
 184         for (int j = 0; j < _test_array.length; j++)
 185         {
 186             buffer[ (j * 2) + 0 ] = ( byte ) (_test_array[ j ] % 256);
 187             buffer[ (j * 2) + 1 ] = ( byte ) ((_test_array[ j ] >> 8) % 256);
 188         }
 189         ByteArrayInputStream stream = new ByteArrayInputStream(buffer);
 190
 191         for (int j = 0; j < buffer.length / 2; j++)
 192         {
 193             field.readFromStream(stream);
 194             assertEquals("Testing " + j, _test_array[ j ], field.get());
 195         }
 196     }
 197
 198     /**
 199      * test writeToBytes
 200      */
 201
 202     public void testWriteToBytes()
 203     {
 204         ShortField field = new ShortField(0);
 205         byte[]     array = new byte[ 2 ];
 206
 207         for (int j = 0; j < _test_array.length; j++)
 208         {
 209             field.set(_test_array[ j ]);
 210             field.writeToBytes(array);
 211             short val = ( short ) (array[ 1 ] << 8);
 212
 213             val &= ( short ) 0xFF00;
 214             val += ( short ) (array[ 0 ] & 0x00FF);
 215             assertEquals("testing ", _test_array[ j ], val);
 216         }
 217     }
 218
 219     /**
 220      * Main
 221      *
 222      * @param args
 223      */
 224
 225     public static void main(String [] args)
 226     {
 227         System.out.println("Testing util.ShortField functionality");
 228         junit.textui.TestRunner.run(TestShortField.class);
 229     }
 230 }