src/testcases/org/apache/poi/util/TestStringUtil.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 package org.apache.poi.util;
  20
  21 import junit.framework.*;
  22
  23 import java.text.NumberFormat;
  24
  25 /**
  26  * Unit test for StringUtil
  27  *
  28  * @author  Marc Johnson (mjohnson at apache dot org
  29  * @author  Glen Stampoultzis (glens at apache.org)
  30  * @author  Sergei Kozello (sergeikozello at mail.ru)
  31  */
  32 public class TestStringUtil
  33         extends TestCase
  34 {
  35     /**
  36      * Creates new TestStringUtil
  37      *
  38      * @param name
  39      */
  40     public TestStringUtil( String name )
  41     {
  42         super( name );
  43     }
  44
  45     /**
  46      * test simple form of getFromUnicode
  47      */
  48     public void testSimpleGetFromUnicode()
  49     {
  50         byte[] test_data = new byte[32];
  51         int index = 0;
  52
  53         for ( int k = 0; k < 16; k++ )
  54         {
  55             test_data[index++] = (byte) 0;
  56             test_data[index++] = (byte) ( 'a' + k );
  57         }
  58
  59         assertEquals( "abcdefghijklmnop",
  60                 StringUtil.getFromUnicodeBE( test_data ) );
  61     }
  62
  63     /**
  64      * test simple form of getFromUnicode with symbols with code below and more 127
  65      */
  66     public void testGetFromUnicodeSymbolsWithCodesMoreThan127()
  67     {
  68         byte[] test_data = new byte[]{0x04, 0x22,
  69                                       0x04, 0x35,
  70                                       0x04, 0x41,
  71                                       0x04, 0x42,
  72                                       0x00, 0x20,
  73                                       0x00, 0x74,
  74                                       0x00, 0x65,
  75                                       0x00, 0x73,
  76                                       0x00, 0x74,
  77         };
  78
  79         assertEquals( "\u0422\u0435\u0441\u0442 test",
  80                 StringUtil.getFromUnicodeBE( test_data ) );
  81     }
  82
  83     /**
  84      * test getFromUnicodeHigh for symbols with code below and more 127
  85      */
  86     public void testGetFromUnicodeHighSymbolsWithCodesMoreThan127()
  87     {
  88         byte[] test_data = new byte[]{0x22, 0x04,
  89                                       0x35, 0x04,
  90                                       0x41, 0x04,
  91                                       0x42, 0x04,
  92                                       0x20, 0x00,
  93                                       0x74, 0x00,
  94                                       0x65, 0x00,
  95                                       0x73, 0x00,
  96                                       0x74, 0x00,
  97         };
  98
  99
 100         assertEquals( "\u0422\u0435\u0441\u0442 test",
 101                 StringUtil.getFromUnicodeLE( test_data ) );
 102     }
 103
 104     /**
 105      * Test more complex form of getFromUnicode
 106      */
 107     public void testComplexGetFromUnicode()
 108     {
 109         byte[] test_data = new byte[32];
 110         int index = 0;
 111         for ( int k = 0; k < 16; k++ )
 112         {
 113             test_data[index++] = (byte) 0;
 114             test_data[index++] = (byte) ( 'a' + k );
 115         }
 116         assertEquals( "abcdefghijklmno",
 117                 StringUtil.getFromUnicodeBE( test_data, 0, 15 ) );
 118         assertEquals( "bcdefghijklmnop",
 119                 StringUtil.getFromUnicodeBE( test_data, 2, 15 ) );
 120         try
 121         {
 122             StringUtil.getFromUnicodeBE( test_data, -1, 16 );
 123             fail( "Should have caught ArrayIndexOutOfBoundsException" );
 124         }
 125         catch ( ArrayIndexOutOfBoundsException ignored )
 126         {
 127             // as expected
 128         }
 129
 130         try
 131         {
 132             StringUtil.getFromUnicodeBE( test_data, 32, 16 );
 133             fail( "Should have caught ArrayIndexOutOfBoundsException" );
 134         }
 135         catch ( ArrayIndexOutOfBoundsException ignored )
 136         {
 137             // as expected
 138         }
 139
 140         try
 141         {
 142             StringUtil.getFromUnicodeBE( test_data, 1, 16 );
 143             fail( "Should have caught IllegalArgumentException" );
 144         }
 145         catch ( IllegalArgumentException ignored )
 146         {
 147             // as expected
 148         }
 149
 150         try
 151         {
 152             StringUtil.getFromUnicodeBE( test_data, 1, -1 );
 153             fail( "Should have caught IllegalArgumentException" );
 154         }
 155         catch ( IllegalArgumentException ignored )
 156         {
 157             // as expected
 158         }
 159     }
 160
 161     /**
 162      * Test putCompressedUnicode
 163      */
 164     public void testPutCompressedUnicode() throws Exception
 165     {
 166         byte[] output = new byte[100];
 167         byte[] expected_output =
 168                 {
 169                     (byte) 'H', (byte) 'e', (byte) 'l', (byte) 'l',
 170                     (byte) 'o', (byte) ' ', (byte) 'W', (byte) 'o',
 171                     (byte) 'r', (byte) 'l', (byte) 'd', (byte) 0xAE
 172                 };
 173         String input = new String( expected_output, StringUtil.getPreferredEncoding() );
 174
 175         StringUtil.putCompressedUnicode( input, output, 0 );
 176         for ( int j = 0; j < expected_output.length; j++ )
 177         {
 178             assertEquals( "testing offset " + j, expected_output[j],
 179                     output[j] );
 180         }
 181         StringUtil.putCompressedUnicode( input, output,
 182                 100 - expected_output.length );
 183         for ( int j = 0; j < expected_output.length; j++ )
 184         {
 185             assertEquals( "testing offset " + j, expected_output[j],
 186                     output[100 + j - expected_output.length] );
 187         }
 188         try
 189         {
 190             StringUtil.putCompressedUnicode( input, output,
 191                     101 - expected_output.length );
 192             fail( "Should have caught ArrayIndexOutOfBoundsException" );
 193         }
 194         catch ( ArrayIndexOutOfBoundsException ignored )
 195         {
 196             // as expected
 197         }
 198     }
 199
 200     /**
 201      * Test putUncompressedUnicode
 202      */
 203     public void testPutUncompressedUnicode()
 204     {
 205         byte[] output = new byte[100];
 206         String input = "Hello World";
 207         byte[] expected_output =
 208                 {
 209                     (byte) 'H', (byte) 0, (byte) 'e', (byte) 0, (byte) 'l',
 210                     (byte) 0, (byte) 'l', (byte) 0, (byte) 'o', (byte) 0,
 211                     (byte) ' ', (byte) 0, (byte) 'W', (byte) 0, (byte) 'o',
 212                     (byte) 0, (byte) 'r', (byte) 0, (byte) 'l', (byte) 0,
 213                     (byte) 'd', (byte) 0
 214                 };
 215
 216         StringUtil.putUnicodeLE( input, output, 0 );
 217         for ( int j = 0; j < expected_output.length; j++ )
 218         {
 219             assertEquals( "testing offset " + j, expected_output[j],
 220                     output[j] );
 221         }
 222         StringUtil.putUnicodeLE( input, output,
 223                 100 - expected_output.length );
 224         for ( int j = 0; j < expected_output.length; j++ )
 225         {
 226             assertEquals( "testing offset " + j, expected_output[j],
 227                     output[100 + j - expected_output.length] );
 228         }
 229         try
 230         {
 231             StringUtil.putUnicodeLE( input, output,
 232                     101 - expected_output.length );
 233             fail( "Should have caught ArrayIndexOutOfBoundsException" );
 234         }
 235         catch ( ArrayIndexOutOfBoundsException ignored )
 236         {
 237             // as expected
 238         }
 239     }
 240
 241
 242     public void testFormat()
 243             throws Exception
 244     {
 245         assertEquals( "This is a test " + fmt( 1.2345, 2, 2 ),
 246                 StringUtil.format( "This is a test %2.2", new Object[]
 247                 {
 248                     new Double( 1.2345 )
 249                 } ) );
 250         assertEquals( "This is a test " + fmt( 1.2345, -1, 3 ),
 251                 StringUtil.format( "This is a test %.3", new Object[]
 252                 {
 253                     new Double( 1.2345 )
 254                 } ) );
 255         assertEquals( "This is a great test " + fmt( 1.2345, -1, 3 ),
 256                 StringUtil.format( "This is a % test %.3", new Object[]
 257                 {
 258                     "great", new Double( 1.2345 )
 259                 } ) );
 260         assertEquals( "This is a test 1",
 261                 StringUtil.format( "This is a test %", new Object[]
 262                 {
 263                     new Integer( 1 )
 264                 } ) );
 265         assertEquals( "This is a test 1",
 266                 StringUtil.format( "This is a test %", new Object[]
 267                 {
 268                     new Integer( 1 ), new Integer( 1 )
 269                 } ) );
 270         assertEquals( "This is a test 1.x",
 271                 StringUtil.format( "This is a test %1.x", new Object[]
 272                 {
 273                     new Integer( 1 )
 274                 } ) );
 275         assertEquals( "This is a test ?missing data?1.x",
 276                 StringUtil.format( "This is a test %1.x", new Object[]
 277                 {
 278                 } ) );
 279         assertEquals( "This is a test %1.x",
 280                 StringUtil.format( "This is a test \\%1.x", new Object[]
 281                 {
 282                 } ) );
 283     }
 284
 285
 286     private String fmt( double num, int minIntDigits, int maxFracDigitis )
 287     {
 288         NumberFormat nf = NumberFormat.getInstance();
 289
 290         if ( minIntDigits != -1 )
 291         {
 292             nf.setMinimumIntegerDigits( minIntDigits );
 293         }
 294         if ( maxFracDigitis != -1 )
 295         {
 296             nf.setMaximumFractionDigits( maxFracDigitis );
 297         }
 298
 299         return nf.format( num );
 300     }
 301
 302
 303     /**
 304      * main
 305      *
 306      * @param ignored_args
 307      */
 308     public static void main( String[] ignored_args )
 309     {
 310         System.out.println( "Testing util.StringUtil functionality" );
 311         junit.textui.TestRunner.run( TestStringUtil.class );
 312     }
 313
 314     /**
 315      * @see junit.framework.TestCase#setUp()
 316      */
 317     protected void setUp() throws Exception
 318     {
 319         super.setUp();
 320
 321         // System.setProperty()
 322     }
 323
 324 }
 325