jars/icu4j-4_2_1-src/src/com/ibm/icu/dev/test/util/UtilityTest.java

   1 //##header J2SE15
   2 /*
   3 **********************************************************************
   4 * Copyright (c) 2003-2009, International Business Machines
   5 * Corporation and others.  All Rights Reserved.
   6 **********************************************************************
   7 * Author: Alan Liu
   8 * Created: March 8 2003
   9 * Since: ICU 2.6
  10 **********************************************************************
  11 */
  12 package com.ibm.icu.dev.test.util;
  13 import java.util.Arrays;
  14 import java.util.HashSet;
  15 import java.util.List;
  16 import java.util.Set;
  17
  18 import com.ibm.icu.dev.test.TestFmwk;
  19 import com.ibm.icu.impl.Assert;
  20 import com.ibm.icu.impl.InvalidFormatException;
  21 import com.ibm.icu.impl.Utility;
  22 import com.ibm.icu.text.UnicodeSet;
  23 import com.ibm.icu.util.ByteArrayWrapper;
  24 import com.ibm.icu.util.CaseInsensitiveString;
  25
  26 /**
  27  * @test
  28  * @summary Test of internal Utility class
  29  */
  30 public class UtilityTest extends TestFmwk {
  31
  32     public static void main(String[] args) throws Exception {
  33         new UtilityTest().run(args);
  34     }
  35
  36     public void TestUnescape() {
  37         final String input =
  38             "Sch\\u00f6nes Auto: \\u20ac 11240.\\fPrivates Zeichen: \\U00102345\\e\\cC\\n \\x1b\\x{263a}";
  39
  40         final String expect =
  41             "Sch\u00F6nes Auto: \u20AC 11240.\u000CPrivates Zeichen: \uDBC8\uDF45\u001B\u0003\012 \u001B\u263A";
  42
  43         String result = Utility.unescape(input);
  44         if (!result.equals(expect)) {
  45             errln("FAIL: Utility.unescape() returned " + result + ", exp. " + expect);
  46         }
  47     }
  48
  49     public void TestFormat()
  50     {
  51         String data[] = {
  52             "the quick brown fox jumps over the lazy dog",
  53             // result of this conversion will exceed the original length and
  54             // cause a newline to be inserted
  55             "testing space , quotations \"",
  56             "testing weird supplementary characters \ud800\udc00",
  57             "testing control characters \u0001 and line breaking!! \n are we done yet?"
  58         };
  59         String result[] = {
  60             "        \"the quick brown fox jumps over the lazy dog\"",
  61             "        \"testing space , quotations \\042\"",
  62             "        \"testing weird supplementary characters \\uD800\\uDC00\"",
  63             "        \"testing control characters \\001 and line breaking!! \\n are we done ye\"+"
  64                      + Utility.LINE_SEPARATOR + "        \"t?\""
  65         };
  66         String result1[] = {
  67             "\"the quick brown fox jumps over the lazy dog\"",
  68             "\"testing space , quotations \\042\"",
  69             "\"testing weird supplementary characters \\uD800\\uDC00\"",
  70             "\"testing control characters \\001 and line breaking!! \\n are we done yet?\""
  71         };
  72
  73         for (int i = 0; i < data.length; i ++) {
  74             assertEquals("formatForSource(\"" + data[i] + "\")",
  75                          result[i], Utility.formatForSource(data[i]));
  76         }
  77         for (int i = 0; i < data.length; i ++) {
  78             assertEquals("format1ForSource(\"" + data[i] + "\")",
  79                          result1[i], Utility.format1ForSource(data[i]));
  80         }
  81     }
  82
  83     public void TestHighBit()
  84     {
  85         int data[] = {-1, -1276, 0, 0xFFFF, 0x1234};
  86         byte result[] = {-1, -1, -1, 15, 12};
  87         for (int i = 0; i < data.length; i ++) {
  88             if (Utility.highBit(data[i]) != result[i]) {
  89                 errln("Fail: Highest bit of \\u"
  90                       + Integer.toHexString(data[i]) + " should be "
  91                       + result[i]);
  92             }
  93         }
  94     }
  95
  96     public void TestCompareUnsigned()
  97     {
  98         int data[] = {0, 1, 0x8fffffff, -1, Integer.MAX_VALUE,
  99                       Integer.MIN_VALUE, 2342423, -2342423};
 100         for (int i = 0; i < data.length; i ++) {
 101             for (int j = 0; j < data.length; j ++) {
 102                 if (Utility.compareUnsigned(data[i], data[j])
 103                     != compareLongUnsigned(data[i], data[j])) {
 104                     errln("Fail: Unsigned comparison failed with " + data[i]
 105                           + " " + data[i + 1]);
 106                 }
 107             }
 108         }
 109     }
 110
 111     // This test indends to test the utility class ByteArrayWrapper
 112     // Seems that the class is somewhat incomplete, for example
 113     //      - getHashCode(Object) is weird
 114     //      - PatternMatch feature(search part of array within the whole one) lacks
 115     public void TestByteArrayWrapper()
 116     {
 117         byte[] ba = {0x00, 0x01, 0x02};
 118         byte[] bb = {0x00, 0x01, 0x02, -1};
 119 //#if defined(FOUNDATION10) || defined(J2SE13)
 120 //##        com.ibm.icu.impl.ByteBuffer buffer = com.ibm.icu.impl.ByteBuffer.wrap(ba);
 121 //#else
 122         java.nio.ByteBuffer buffer = java.nio.ByteBuffer.wrap(ba);
 123 //#endif
 124         ByteArrayWrapper x = new ByteArrayWrapper(buffer);
 125
 126         ByteArrayWrapper y = new ByteArrayWrapper(ba, 3);
 127         ByteArrayWrapper z = new ByteArrayWrapper(bb, 3);
 128
 129
 130         if (!y.toString().equals("00 01 02")){
 131             errln("FAIL: test toString : Failed!");
 132         }
 133
 134         // test equality
 135         if (!x.equals(y) || !x.equals(z))
 136             errln("FAIL: test (operator ==): Failed!");
 137         if (x.hashCode()!=y.hashCode())
 138             errln("FAIL: identical objects have different hash codes.");
 139
 140         // test non-equality
 141         y = new ByteArrayWrapper(bb, 4);
 142         if (x.equals(y))
 143             errln("FAIL: test (operator !=): Failed!");
 144
 145         // test sign of unequal comparison
 146         if ((x.compareTo(y) > 0) != (y.compareTo(x) < 0)) {
 147             errln("FAIL: comparisons not opposite sign");
 148         }
 149     }
 150
 151     private int compareLongUnsigned(int x, int y)
 152     {
 153         long x1 = x & 0xFFFFFFFFl;
 154         long y1 = y & 0xFFFFFFFFl;
 155         if (x1 < y1) {
 156             return -1;
 157         }
 158         else if (x1 > y1) {
 159             return 1;
 160         }
 161         return 0;
 162     }
 163     public void TestUnicodeSet(){
 164         String[] array = new String[]{"a", "b", "c", "{de}"};
 165         List list = Arrays.asList(array);
 166         Set aset = new HashSet(list);
 167         logln(" *** The source set's size is: " + aset.size());
 168     //The size reads 4
 169         UnicodeSet set = new UnicodeSet();
 170         set.clear();
 171         set.addAll(aset);
 172         logln(" *** After addAll, the UnicodeSet size is: " + set.size());
 173     //The size should also read 4, but 0 is seen instead
 174
 175     }
 176
 177     public void TestAssert(){
 178         try {
 179             Assert.assrt(false);
 180             errln("FAIL: Assert.assrt(false)");
 181         }
 182         catch (IllegalStateException e) {
 183             if (e.getMessage().equals("assert failed")) {
 184                 logln("Assert.assrt(false) works");
 185             }
 186             else {
 187                 errln("FAIL: Assert.assrt(false) returned " + e.getMessage());
 188             }
 189         }
 190         try {
 191             Assert.assrt("Assert message", false);
 192             errln("FAIL: Assert.assrt(false)");
 193         }
 194         catch (IllegalStateException e) {
 195             if (e.getMessage().equals("assert 'Assert message' failed")) {
 196                 logln("Assert.assrt(false) works");
 197             }
 198             else {
 199                 errln("FAIL: Assert.assrt(false) returned " + e.getMessage());
 200             }
 201         }
 202         try {
 203             Assert.fail("Assert message");
 204             errln("FAIL: Assert.fail");
 205         }
 206         catch (IllegalStateException e) {
 207             if (e.getMessage().equals("failure 'Assert message'")) {
 208                 logln("Assert.fail works");
 209             }
 210             else {
 211                 errln("FAIL: Assert.fail returned " + e.getMessage());
 212             }
 213         }
 214         try {
 215             Assert.fail(new InvalidFormatException());
 216             errln("FAIL: Assert.fail with an exception");
 217         }
 218         catch (IllegalStateException e) {
 219             logln("Assert.fail works");
 220         }
 221     }
 222
 223     public void TestCaseInsensitiveString() {
 224         CaseInsensitiveString str1 = new CaseInsensitiveString("ThIs is A tEst");
 225         CaseInsensitiveString str2 = new CaseInsensitiveString("This IS a test");
 226         if (!str1.equals(str2)
 227             || !str1.toString().equals(str1.getString())
 228             || str1.toString().equals(str2.toString()))
 229         {
 230             errln("FAIL: str1("+str1+") != str2("+str2+")");
 231         }
 232     }
 233 }