src/testcases/org/apache/poi/util/TestLittleEndian.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.TestCase;
  23 import org.apache.poi.util.LittleEndian.BufferUnderrunException;
  24
  25 import java.io.ByteArrayInputStream;
  26 import java.io.IOException;
  27 import java.io.InputStream;
  28
  29 /**
  30  * Class to test LittleEndian functionality
  31  *
  32  * @author Marc Johnson
  33  */
  34
  35 public class TestLittleEndian
  36     extends TestCase
  37 {
  38
  39     /**
  40      * Constructor TestLittleEndian
  41      *
  42      * @param name
  43      */
  44     public TestLittleEndian(String name)
  45     {
  46         super(name);
  47     }
  48
  49     /**
  50      * test the getShort() method
  51      */
  52
  53     public void testGetShort()
  54     {
  55         byte[] testdata = new byte[ LittleEndian.SHORT_SIZE + 1 ];
  56
  57         testdata[ 0 ] = 0x01;
  58         testdata[ 1 ] = ( byte ) 0xFF;
  59         testdata[ 2 ] = 0x02;
  60         short expected[] = new short[ 2 ];
  61
  62         expected[ 0 ] = ( short ) 0xFF01;
  63         expected[ 1 ] = 0x02FF;
  64         assertEquals(expected[ 0 ], LittleEndian.getShort(testdata));
  65         assertEquals(expected[ 1 ], LittleEndian.getShort(testdata, 1));
  66     }
  67
  68     public void testGetUShort()
  69     {
  70         byte[] testdata = new byte[ LittleEndian.SHORT_SIZE + 1 ];
  71
  72         testdata[ 0 ] = 0x01;
  73         testdata[ 1 ] = ( byte ) 0xFF;
  74         testdata[ 2 ] = 0x02;
  75
  76         byte[] testdata2 = new byte[ LittleEndian.SHORT_SIZE + 1 ];
  77
  78         testdata2[ 0 ] = 0x0D;
  79         testdata2[ 1 ] = ( byte )0x93;
  80         testdata2[ 2 ] = ( byte )0xFF;
  81
  82         int expected[] = new int[ 4 ];
  83
  84         expected[ 0 ] = 0xFF01;
  85         expected[ 1 ] = 0x02FF;
  86         expected[ 2 ] = 0x930D;
  87         expected[ 3 ] = 0xFF93;
  88         assertEquals(expected[ 0 ], LittleEndian.getUShort(testdata));
  89         assertEquals(expected[ 1 ], LittleEndian.getUShort(testdata, 1));
  90         assertEquals(expected[ 2 ], LittleEndian.getUShort(testdata2));
  91         assertEquals(expected[ 3 ], LittleEndian.getUShort(testdata2, 1));
  92
  93         byte[] testdata3 = new byte[ LittleEndian.SHORT_SIZE + 1 ];
  94         LittleEndian.putShort(testdata3, 0, ( short ) expected[2] );
  95         LittleEndian.putShort(testdata3, 1, ( short ) expected[3] );
  96         assertEquals(testdata3[ 0 ], 0x0D);
  97         assertEquals(testdata3[ 1 ], (byte)0x93);
  98         assertEquals(testdata3[ 2 ], (byte)0xFF);
  99         assertEquals(expected[ 2 ], LittleEndian.getUShort(testdata3));
 100         assertEquals(expected[ 3 ], LittleEndian.getUShort(testdata3, 1));
 101         //System.out.println("TD[1][0]: "+LittleEndian.getUShort(testdata)+" expecting 65281");
 102         //System.out.println("TD[1][1]: "+LittleEndian.getUShort(testdata, 1)+" expecting 767");
 103         //System.out.println("TD[2][0]: "+LittleEndian.getUShort(testdata2)+" expecting 37645");
 104         //System.out.println("TD[2][1]: "+LittleEndian.getUShort(testdata2, 1)+" expecting 65427");
 105         //System.out.println("TD[3][0]: "+LittleEndian.getUShort(testdata3)+" expecting 37645");
 106         //System.out.println("TD[3][1]: "+LittleEndian.getUShort(testdata3, 1)+" expecting 65427");
 107
 108     }
 109
 110     private static final byte[]   _double_array =
 111     {
 112         56, 50, -113, -4, -63, -64, -13, 63, 76, -32, -42, -35, 60, -43, 3, 64
 113     };
 114     private static final byte[]   _nan_double_array =
 115     {
 116         (byte)0x00, (byte)0x00, (byte)0x3C, (byte)0x00, (byte)0x20, (byte)0x04, (byte)0xFF, (byte)0xFF
 117     };
 118     private static final double[] _doubles      =
 119     {
 120         1.23456, 2.47912, Double.NaN
 121     };
 122
 123     /**
 124      * test the getDouble() method
 125      */
 126
 127     public void testGetDouble()
 128     {
 129         assertEquals(_doubles[ 0 ], LittleEndian.getDouble(_double_array), 0.000001 );
 130         assertEquals(_doubles[ 1 ], LittleEndian.getDouble( _double_array, LittleEndian.DOUBLE_SIZE), 0.000001);
 131         assertTrue(Double.isNaN(LittleEndian.getDouble(_nan_double_array)));
 132
 133         double nan = LittleEndian.getDouble(_nan_double_array);
 134         byte[] data = new byte[8];
 135         LittleEndian.putDouble(data, nan);
 136         for ( int i = 0; i < data.length; i++ )
 137         {
 138             byte b = data[i];
 139             assertEquals(data[i], _nan_double_array[i]);
 140         }
 141     }
 142
 143     /**
 144      * test the getInt() method
 145      */
 146
 147     public void testGetInt()
 148     {
 149         byte[] testdata = new byte[ LittleEndian.INT_SIZE + 1 ];
 150
 151         testdata[ 0 ] = 0x01;
 152         testdata[ 1 ] = ( byte ) 0xFF;
 153         testdata[ 2 ] = ( byte ) 0xFF;
 154         testdata[ 3 ] = ( byte ) 0xFF;
 155         testdata[ 4 ] = 0x02;
 156         int expected[] = new int[ 2 ];
 157
 158         expected[ 0 ] = 0xFFFFFF01;
 159         expected[ 1 ] = 0x02FFFFFF;
 160         assertEquals(expected[ 0 ], LittleEndian.getInt(testdata));
 161         assertEquals(expected[ 1 ], LittleEndian.getInt(testdata, 1));
 162     }
 163
 164     /**
 165      * test the getLong method
 166      */
 167
 168     public void testGetLong()
 169     {
 170         byte[] testdata = new byte[ LittleEndian.LONG_SIZE + 1 ];
 171
 172         testdata[ 0 ] = 0x01;
 173         testdata[ 1 ] = ( byte ) 0xFF;
 174         testdata[ 2 ] = ( byte ) 0xFF;
 175         testdata[ 3 ] = ( byte ) 0xFF;
 176         testdata[ 4 ] = ( byte ) 0xFF;
 177         testdata[ 5 ] = ( byte ) 0xFF;
 178         testdata[ 6 ] = ( byte ) 0xFF;
 179         testdata[ 7 ] = ( byte ) 0xFF;
 180         testdata[ 8 ] = 0x02;
 181         long expected[] = new long[ 2 ];
 182
 183         expected[ 0 ] = 0xFFFFFFFFFFFFFF01L;
 184         expected[ 1 ] = 0x02FFFFFFFFFFFFFFL;
 185         assertEquals(expected[ 0 ], LittleEndian.getLong(testdata));
 186         assertEquals(expected[ 1 ], LittleEndian.getLong(testdata, 1));
 187     }
 188
 189     /**
 190      * test the PutShort method
 191      */
 192
 193     public void testPutShort()
 194     {
 195         byte[] expected = new byte[ LittleEndian.SHORT_SIZE + 1 ];
 196
 197         expected[ 0 ] = 0x01;
 198         expected[ 1 ] = ( byte ) 0xFF;
 199         expected[ 2 ] = 0x02;
 200         byte[] received   = new byte[ LittleEndian.SHORT_SIZE + 1 ];
 201         short  testdata[] = new short[ 2 ];
 202
 203         testdata[ 0 ] = ( short ) 0xFF01;
 204         testdata[ 1 ] = 0x02FF;
 205         LittleEndian.putShort(received, testdata[ 0 ]);
 206         assertTrue(ba_equivalent(received, expected, 0,
 207                                  LittleEndian.SHORT_SIZE));
 208         LittleEndian.putShort(received, 1, testdata[ 1 ]);
 209         assertTrue(ba_equivalent(received, expected, 1,
 210                                  LittleEndian.SHORT_SIZE));
 211     }
 212
 213     /**
 214      * test the putInt method
 215      */
 216
 217     public void testPutInt()
 218     {
 219         byte[] expected = new byte[ LittleEndian.INT_SIZE + 1 ];
 220
 221         expected[ 0 ] = 0x01;
 222         expected[ 1 ] = ( byte ) 0xFF;
 223         expected[ 2 ] = ( byte ) 0xFF;
 224         expected[ 3 ] = ( byte ) 0xFF;
 225         expected[ 4 ] = 0x02;
 226         byte[] received   = new byte[ LittleEndian.INT_SIZE + 1 ];
 227         int    testdata[] = new int[ 2 ];
 228
 229         testdata[ 0 ] = 0xFFFFFF01;
 230         testdata[ 1 ] = 0x02FFFFFF;
 231         LittleEndian.putInt(received, testdata[ 0 ]);
 232         assertTrue(ba_equivalent(received, expected, 0,
 233                                  LittleEndian.INT_SIZE));
 234         LittleEndian.putInt(received, 1, testdata[ 1 ]);
 235         assertTrue(ba_equivalent(received, expected, 1,
 236                                  LittleEndian.INT_SIZE));
 237     }
 238
 239     /**
 240      * test the putDouble methods
 241      */
 242
 243     public void testPutDouble()
 244     {
 245         byte[] received = new byte[ LittleEndian.DOUBLE_SIZE + 1 ];
 246
 247         LittleEndian.putDouble(received, _doubles[ 0 ]);
 248         assertTrue(ba_equivalent(received, _double_array, 0,
 249                                  LittleEndian.DOUBLE_SIZE));
 250         LittleEndian.putDouble(received, 1, _doubles[ 1 ]);
 251         byte[] expected = new byte[ LittleEndian.DOUBLE_SIZE + 1 ];
 252
 253         System.arraycopy(_double_array, LittleEndian.DOUBLE_SIZE, expected,
 254                          1, LittleEndian.DOUBLE_SIZE);
 255         assertTrue(ba_equivalent(received, expected, 1,
 256                                  LittleEndian.DOUBLE_SIZE));
 257     }
 258
 259     /**
 260      * test the putLong method
 261      */
 262
 263     public void testPutLong()
 264     {
 265         byte[] expected = new byte[ LittleEndian.LONG_SIZE + 1 ];
 266
 267         expected[ 0 ] = 0x01;
 268         expected[ 1 ] = ( byte ) 0xFF;
 269         expected[ 2 ] = ( byte ) 0xFF;
 270         expected[ 3 ] = ( byte ) 0xFF;
 271         expected[ 4 ] = ( byte ) 0xFF;
 272         expected[ 5 ] = ( byte ) 0xFF;
 273         expected[ 6 ] = ( byte ) 0xFF;
 274         expected[ 7 ] = ( byte ) 0xFF;
 275         expected[ 8 ] = 0x02;
 276         byte[] received   = new byte[ LittleEndian.LONG_SIZE + 1 ];
 277         long   testdata[] = new long[ 2 ];
 278
 279         testdata[ 0 ] = 0xFFFFFFFFFFFFFF01L;
 280         testdata[ 1 ] = 0x02FFFFFFFFFFFFFFL;
 281         LittleEndian.putLong(received, testdata[ 0 ]);
 282         assertTrue(ba_equivalent(received, expected, 0,
 283                                  LittleEndian.LONG_SIZE));
 284         LittleEndian.putLong(received, 1, testdata[ 1 ]);
 285         assertTrue(ba_equivalent(received, expected, 1,
 286                                  LittleEndian.LONG_SIZE));
 287     }
 288
 289     private static byte[] _good_array =
 290     {
 291         0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
 292         0x02, 0x01, 0x02, 0x01, 0x02
 293     };
 294     private static byte[] _bad_array  =
 295     {
 296         0x01
 297     };
 298
 299     /**
 300      * test the readShort method
 301      */
 302
 303     public void testReadShort()
 304         throws IOException
 305     {
 306         short       expected_value = 0x0201;
 307         InputStream stream         = new ByteArrayInputStream(_good_array);
 308         int         count          = 0;
 309
 310         while (true)
 311         {
 312             short value = LittleEndian.readShort(stream);
 313
 314             if (value == 0)
 315             {
 316                 break;
 317             }
 318             assertEquals(value, expected_value);
 319             count++;
 320         }
 321         assertEquals(count,
 322                      _good_array.length / LittleEndianConsts.SHORT_SIZE);
 323         stream = new ByteArrayInputStream(_bad_array);
 324         try
 325         {
 326             LittleEndian.readShort(stream);
 327             fail("Should have caught BufferUnderrunException");
 328         }
 329         catch (BufferUnderrunException ignored)
 330         {
 331
 332             // as expected
 333         }
 334     }
 335
 336     /**
 337      * test the readInt method
 338      */
 339
 340     public void testReadInt()
 341         throws IOException
 342     {
 343         int         expected_value = 0x02010201;
 344         InputStream stream         = new ByteArrayInputStream(_good_array);
 345         int         count          = 0;
 346
 347         while (true)
 348         {
 349             int value = LittleEndian.readInt(stream);
 350
 351             if (value == 0)
 352             {
 353                 break;
 354             }
 355             assertEquals(value, expected_value);
 356             count++;
 357         }
 358         assertEquals(count, _good_array.length / LittleEndianConsts.INT_SIZE);
 359         stream = new ByteArrayInputStream(_bad_array);
 360         try
 361         {
 362             LittleEndian.readInt(stream);
 363             fail("Should have caught BufferUnderrunException");
 364         }
 365         catch (BufferUnderrunException ignored)
 366         {
 367
 368             // as expected
 369         }
 370     }
 371
 372     /**
 373      * test the readLong method
 374      */
 375
 376     public void testReadLong()
 377         throws IOException
 378     {
 379         long        expected_value = 0x0201020102010201L;
 380         InputStream stream         = new ByteArrayInputStream(_good_array);
 381         int         count          = 0;
 382
 383         while (true)
 384         {
 385             long value = LittleEndian.readLong(stream);
 386
 387             if (value == 0)
 388             {
 389                 break;
 390             }
 391             assertEquals(value, expected_value);
 392             count++;
 393         }
 394         assertEquals(count,
 395                      _good_array.length / LittleEndianConsts.LONG_SIZE);
 396         stream = new ByteArrayInputStream(_bad_array);
 397         try
 398         {
 399             LittleEndian.readLong(stream);
 400             fail("Should have caught BufferUnderrunException");
 401         }
 402         catch (BufferUnderrunException ignored)
 403         {
 404
 405             // as expected
 406         }
 407     }
 408
 409     /**
 410      * test the readFromStream method
 411      */
 412
 413     public void testReadFromStream()
 414         throws IOException
 415     {
 416         InputStream stream = new ByteArrayInputStream(_good_array);
 417         byte[]      value  = LittleEndian.readFromStream(stream,
 418                                  _good_array.length);
 419
 420         assertTrue(ba_equivalent(value, _good_array, 0, _good_array.length));
 421         stream = new ByteArrayInputStream(_good_array);
 422         try
 423         {
 424             value = LittleEndian.readFromStream(stream,
 425                                                 _good_array.length + 1);
 426             fail("Should have caught BufferUnderrunException");
 427         }
 428         catch (BufferUnderrunException ignored)
 429         {
 430
 431             // as expected
 432         }
 433     }
 434
 435     public void testUnsignedByteToInt()
 436             throws Exception
 437     {
 438         assertEquals(255, LittleEndian.ubyteToInt((byte)255));
 439     }
 440
 441     private boolean ba_equivalent(byte [] received, byte [] expected,
 442                                   int offset, int size)
 443     {
 444         boolean result = true;
 445
 446         for (int j = offset; j < offset + size; j++)
 447         {
 448             if (received[ j ] != expected[ j ])
 449             {
 450                 System.out.println("difference at index " + j);
 451                 result = false;
 452                 break;
 453             }
 454         }
 455         return result;
 456     }
 457
 458     public void testUnsignedShort()
 459             throws Exception
 460     {
 461         assertEquals(0xffff, LittleEndian.getUShort(new byte[] { (byte)0xff, (byte)0xff }, 0));
 462     }
 463
 464     /**
 465      * main method to run the unit tests
 466      *
 467      * @param ignored_args
 468      */
 469
 470     public static void main(String [] ignored_args)
 471     {
 472         System.out.println("Testing util.LittleEndian functionality");
 473         junit.textui.TestRunner.run(TestLittleEndian.class);
 474     }
 475 }