jars/icu4j-4_2_1-src/src/com/ibm/icu/dev/test/serializable/SerializableTest.java

   1 //##header J2SE15
   2 /*
   3  *******************************************************************************
   4  * Copyright (C) 1996-2009, International Business Machines Corporation and    *
   5  * others. All Rights Reserved.                                                *
   6  *******************************************************************************
   7  *
   8  */
   9
  10 package com.ibm.icu.dev.test.serializable;
  11
  12 import java.util.Date;
  13 import java.util.HashMap;
  14 import java.util.Locale;
  15
  16 import com.ibm.icu.dev.test.TestFmwk;
  17 import com.ibm.icu.impl.JavaTimeZone;
  18 import com.ibm.icu.impl.OlsonTimeZone;
  19 import com.ibm.icu.impl.TimeZoneAdapter;
  20 import com.ibm.icu.math.BigDecimal;
  21 import com.ibm.icu.math.MathContext;
  22 import com.ibm.icu.util.AnnualTimeZoneRule;
  23 import com.ibm.icu.util.Calendar;
  24 import com.ibm.icu.util.Currency;
  25 import com.ibm.icu.util.DateInterval;
  26 import com.ibm.icu.util.DateTimeRule;
  27 import com.ibm.icu.util.GregorianCalendar;
  28 import com.ibm.icu.util.InitialTimeZoneRule;
  29 import com.ibm.icu.util.RuleBasedTimeZone;
  30 import com.ibm.icu.util.SimpleTimeZone;
  31 import com.ibm.icu.util.TimeArrayTimeZoneRule;
  32 import com.ibm.icu.util.TimeZone;
  33 import com.ibm.icu.util.TimeZoneRule;
  34 import com.ibm.icu.util.ULocale;
  35 import com.ibm.icu.util.VTimeZone;
  36
  37 /**
  38  * @author emader
  39  *
  40  * TODO To change the template for this generated type comment go to
  41  * Window - Preferences - Java - Code Style - Code Templates
  42  */
  43 public class SerializableTest extends TestFmwk.TestGroup
  44 {
  45     public interface Handler
  46     {
  47         public Object[] getTestObjects();
  48
  49         public boolean hasSameBehavior(Object a, Object b);
  50     }
  51
  52     public static Handler getHandler(String className)
  53     {
  54         return (Handler) map.get(className);
  55     }
  56
  57     private static class TimeZoneHandler implements Handler
  58     {
  59         String[] ZONES = { "GMT", "MET", "IST" };
  60
  61         public Object[] getTestObjects()
  62         {
  63             TimeZone zones[] = new TimeZone[ZONES.length];
  64
  65             for(int z = 0; z < ZONES.length; z += 1) {
  66                 zones[z] = TimeZone.getTimeZone(ZONES[z]);
  67             }
  68
  69             return zones;
  70         }
  71
  72         public boolean hasSameBehavior(Object a, Object b)
  73         {
  74             TimeZone zone_a = (TimeZone) a;
  75             TimeZone zone_b = (TimeZone) b;
  76
  77             if (!(zone_a.getDisplayName().equals(zone_b.getDisplayName()))) {
  78                 return false;
  79             }
  80
  81             int a_offsets[] = {0, 0};
  82             int b_offsets[] = {0, 0};
  83
  84             boolean bSame = true;
  85             for (int i = 0; i < sampleTimes.length; i++) {
  86                 zone_a.getOffset(sampleTimes[i], false, a_offsets);
  87                 zone_b.getOffset(sampleTimes[i], false, b_offsets);
  88                 if (a_offsets[0] != b_offsets[0] || a_offsets[1] != b_offsets[1]) {
  89                     bSame = false;
  90                     break;
  91                 }
  92             }
  93             return bSame;
  94         }
  95     }
  96
  97     private static Locale locales[] = {
  98         Locale.CANADA, Locale.CANADA_FRENCH, Locale.CHINA,
  99         Locale.CHINESE, Locale.ENGLISH, Locale.FRANCE, Locale.FRENCH,
 100         Locale.GERMAN, Locale.GERMANY, Locale.ITALIAN, Locale.ITALY,
 101         Locale.JAPAN, Locale.JAPANESE, Locale.KOREA, Locale.KOREAN,
 102         Locale.PRC, Locale.SIMPLIFIED_CHINESE, Locale.TAIWAN,
 103         Locale.TRADITIONAL_CHINESE, Locale.UK, Locale.US
 104     };
 105
 106     private static Locale places[] = {
 107         Locale.CANADA, Locale.CANADA_FRENCH, Locale.CHINA,
 108         Locale.FRANCE, Locale.GERMANY, Locale.ITALY,
 109         Locale.JAPAN, Locale.KOREA, Locale.PRC, Locale.TAIWAN,
 110         Locale.UK, Locale.US
 111     };
 112
 113     public static Locale[] getLocales()
 114     {
 115         return locales;
 116     }
 117
 118     public static boolean compareStrings(String a[], String b[])
 119     {
 120         if (a.length != b.length) {
 121             return false;
 122         }
 123
 124         for (int i = 0; i < a.length; i += 1) {
 125             if (! a[i].equals(b[i])) {
 126                 return false;
 127             }
 128         }
 129
 130         return true;
 131     }
 132
 133     public static boolean compareChars(char a[], char b[])
 134     {
 135         if (a.length != b.length) {
 136             return false;
 137         }
 138
 139         for (int i = 0; i < a.length; i += 1) {
 140             if (a[i] != b[i]) {
 141                 return false;
 142             }
 143         }
 144
 145         return true;
 146     }
 147
 148     private static class SimpleTimeZoneHandler extends TimeZoneHandler
 149     {
 150         public Object[] getTestObjects()
 151         {
 152             SimpleTimeZone simpleTimeZones[] = new SimpleTimeZone[6];
 153
 154             simpleTimeZones[0] = new SimpleTimeZone(32400000, "MyTimeZone");
 155
 156             simpleTimeZones[1] = new SimpleTimeZone(32400000, "Asia/Tokyo");
 157
 158             simpleTimeZones[2] = new SimpleTimeZone(32400000, "Asia/Tokyo");
 159             simpleTimeZones[2].setRawOffset(0);
 160
 161             simpleTimeZones[3] = new SimpleTimeZone(32400000, "Asia/Tokyo");
 162             simpleTimeZones[3].setStartYear(100);
 163
 164             simpleTimeZones[4] = new SimpleTimeZone(32400000, "Asia/Tokyo");
 165             simpleTimeZones[4].setStartYear(1000);
 166             simpleTimeZones[4].setDSTSavings(1800000);
 167             simpleTimeZones[4].setStartRule(3, 4, 180000);
 168             simpleTimeZones[4].setEndRule(6, 3, 4, 360000);
 169
 170             simpleTimeZones[5] = new SimpleTimeZone(32400000, "Asia/Tokyo");
 171             simpleTimeZones[5].setStartRule(2, 3, 4, 360000);
 172             simpleTimeZones[5].setEndRule(6, 3, 4, 360000);
 173
 174             return simpleTimeZones;
 175         }
 176     }
 177
 178     private static class VTimeZoneHandler extends TimeZoneHandler {
 179         public Object[] getTestObjects() {
 180             //TODO
 181             VTimeZone[] vtzs = new VTimeZone[1];
 182             vtzs[0] = VTimeZone.create("America/New_York");
 183             return vtzs;
 184         }
 185     }
 186
 187     private static final int HOUR = 60*60*1000;
 188     private static final AnnualTimeZoneRule[] TEST_US_EASTERN = {
 189         new AnnualTimeZoneRule("EST", -5*HOUR, 0,
 190                 new DateTimeRule(Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*HOUR, DateTimeRule.WALL_TIME),
 191                 1967, 2006),
 192
 193         new AnnualTimeZoneRule("EST", -5*HOUR, 0,
 194                 new DateTimeRule(Calendar.NOVEMBER, 1, Calendar.SUNDAY, true, 2*HOUR, DateTimeRule.WALL_TIME),
 195                 2007, AnnualTimeZoneRule.MAX_YEAR),
 196
 197         new AnnualTimeZoneRule("EDT", -5*HOUR, 1*HOUR,
 198                 new DateTimeRule(Calendar.APRIL, -1, Calendar.SUNDAY, 2*HOUR, DateTimeRule.WALL_TIME),
 199                 1967, 1973),
 200
 201         new AnnualTimeZoneRule("EDT", -5*HOUR, 1*HOUR,
 202                 new DateTimeRule(Calendar.JANUARY, 6, 2*HOUR, DateTimeRule.WALL_TIME),
 203                 1974, 1974),
 204
 205         new AnnualTimeZoneRule("EDT", -5*HOUR, 1*HOUR,
 206                 new DateTimeRule(Calendar.FEBRUARY, 23, 2*HOUR, DateTimeRule.WALL_TIME),
 207                 1975, 1975),
 208
 209         new AnnualTimeZoneRule("EDT", -5*HOUR, 1*HOUR,
 210                 new DateTimeRule(Calendar.APRIL, -1, Calendar.SUNDAY, 2*HOUR, DateTimeRule.WALL_TIME),
 211                 1976, 1986),
 212
 213         new AnnualTimeZoneRule("EDT", -5*HOUR, 1*HOUR,
 214                 new DateTimeRule(Calendar.APRIL, 1, Calendar.SUNDAY, true, 2*HOUR, DateTimeRule.WALL_TIME),
 215                 1987, 2006),
 216
 217         new AnnualTimeZoneRule("EDT", -5*HOUR, 1*HOUR,
 218                 new DateTimeRule(Calendar.MARCH, 8, Calendar.SUNDAY, true, 2*HOUR, DateTimeRule.WALL_TIME),
 219                 2007, AnnualTimeZoneRule.MAX_YEAR)
 220     };
 221
 222
 223
 224     private static class RuleBasedTimeZoneHandler extends TimeZoneHandler
 225     {
 226         public Object[] getTestObjects()
 227         {
 228             RuleBasedTimeZone ruleBasedTimeZones[] = new RuleBasedTimeZone[2];
 229
 230             InitialTimeZoneRule ir = new InitialTimeZoneRule("GMT-5", -5*HOUR, 0);
 231
 232             // GMT-5, no transition
 233             ruleBasedTimeZones[0] = new RuleBasedTimeZone("GMT-5", ir);
 234
 235
 236             // US Eastern since 1967
 237             ruleBasedTimeZones[1] = new RuleBasedTimeZone("US_East", ir);
 238             for (int i = 0; i < TEST_US_EASTERN.length; i++) {
 239                 ruleBasedTimeZones[1].addTransitionRule(TEST_US_EASTERN[i]);
 240             }
 241             return ruleBasedTimeZones;
 242         }
 243     }
 244
 245     private static class DateTimeRuleHandler implements Handler {
 246         public Object[] getTestObjects() {
 247             DateTimeRule[] rules = new DateTimeRule[4];
 248
 249             // DOM + UTC
 250             rules[0] = new DateTimeRule(Calendar.OCTOBER, 10, 13*HOUR, DateTimeRule.UTC_TIME);
 251
 252             // DOW + WALL
 253             rules[1] = new DateTimeRule(Calendar.MARCH, 2, Calendar.SUNDAY, 2*HOUR, DateTimeRule.WALL_TIME);
 254
 255             // DOW_GEQ_DOM + STD
 256             rules[2] = new DateTimeRule(Calendar.MAY, 1, Calendar.MONDAY, true, 0*HOUR, DateTimeRule.STANDARD_TIME);
 257
 258             // DOW_LEQ_DOM + WALL
 259             rules[3] = new DateTimeRule(Calendar.AUGUST, 31, Calendar.SATURDAY, false, 1*HOUR, DateTimeRule.WALL_TIME);
 260
 261             return rules;
 262         }
 263
 264         public boolean hasSameBehavior(Object a, Object b) {
 265             return hasSameRule((DateTimeRule)a, (DateTimeRule)b);
 266         }
 267
 268         static boolean hasSameRule(DateTimeRule dtra, DateTimeRule dtrb) {
 269             boolean bSame = false;
 270             if (dtra.getDateRuleType() == dtrb.getDateRuleType()
 271                     && dtra.getRuleMonth() == dtrb.getRuleMonth()
 272                     && dtra.getTimeRuleType() == dtrb.getTimeRuleType()
 273                     && dtra.getRuleMillisInDay() == dtrb.getRuleMillisInDay()) {
 274                 switch (dtra.getDateRuleType()) {
 275                 case DateTimeRule.DOM:
 276                     bSame = (dtra.getRuleDayOfMonth() == dtrb.getRuleDayOfMonth());
 277                     break;
 278                 case DateTimeRule.DOW:
 279                     bSame = (dtra.getRuleDayOfWeek() == dtrb.getRuleDayOfWeek() &&
 280                                 dtra.getRuleWeekInMonth() == dtrb.getRuleWeekInMonth());
 281                     break;
 282                 case DateTimeRule.DOW_GEQ_DOM:
 283                 case DateTimeRule.DOW_LEQ_DOM:
 284                     bSame = (dtra.getRuleDayOfMonth() == dtrb.getRuleDayOfMonth() &&
 285                                 dtra.getRuleDayOfWeek() == dtrb.getRuleDayOfWeek());
 286                     break;
 287                 }
 288             }
 289             return bSame;
 290         }
 291     }
 292
 293     private static boolean compareTimeZoneRules(TimeZoneRule ra, TimeZoneRule rb) {
 294         if (ra.getName().equals(rb.getName()) &&
 295                 ra.getRawOffset() == rb.getRawOffset() &&
 296                 ra.getDSTSavings() == rb.getDSTSavings()) {
 297             return true;
 298         }
 299         return false;
 300     }
 301
 302     private static class AnnualTimeZoneRuleHandler implements Handler {
 303         public Object[] getTestObjects() {
 304             return TEST_US_EASTERN;
 305         }
 306
 307         public boolean hasSameBehavior(Object a, Object b) {
 308             AnnualTimeZoneRule ra = (AnnualTimeZoneRule)a;
 309             AnnualTimeZoneRule rb = (AnnualTimeZoneRule)b;
 310             if (DateTimeRuleHandler.hasSameRule(ra.getRule(), rb.getRule()) &&
 311                     ra.getStartYear() == rb.getStartYear() &&
 312                     ra.getEndYear() == rb.getEndYear()) {
 313                 return compareTimeZoneRules(ra, rb);
 314             }
 315             return false;
 316         }
 317     }
 318
 319     private static class InitialTimeZoneRuleHandler implements Handler {
 320         public Object[] getTestObjects() {
 321             TimeZoneRule[] rules = new TimeZoneRule[2];
 322             rules[0] = new InitialTimeZoneRule("EST", -5*HOUR, 0);
 323             rules[1] = new InitialTimeZoneRule("PST", -8*HOUR, 0);
 324             return rules;
 325         }
 326
 327         public boolean hasSameBehavior(Object a, Object b) {
 328             return compareTimeZoneRules((TimeZoneRule)a, (TimeZoneRule)b);
 329         }
 330     }
 331
 332     private static class TimeArrayTimeZoneRuleHandler implements Handler {
 333         public Object[] getTestObjects() {
 334             TimeArrayTimeZoneRule[] rules = new TimeArrayTimeZoneRule[1];
 335             long[] ttime = new long[] {-631152000000L, 0L, 946684800000L}; /* {1950-1-1, 1970-1-1, 2000-1-1} */
 336             rules[0] = new TimeArrayTimeZoneRule("Foo", 1*HOUR, 1*HOUR, ttime, DateTimeRule.UTC_TIME);
 337
 338             return rules;
 339         }
 340         public boolean hasSameBehavior(Object a, Object b) {
 341             TimeArrayTimeZoneRule ra = (TimeArrayTimeZoneRule)a;
 342             TimeArrayTimeZoneRule rb = (TimeArrayTimeZoneRule)b;
 343
 344             Date da = ra.getFirstStart(0, 0);
 345             Date db = rb.getFirstStart(0, 0);
 346             long t = da.getTime();
 347             if (da.equals(db)) {
 348                 da = ra.getFinalStart(0, 0);
 349                 db = rb.getFinalStart(0, 0);
 350                 long end = da.getTime();
 351                 if (da.equals(db)) {
 352                     while (t < end) {
 353                         da = ra.getNextStart(t, 0, 0, false);
 354                         db = ra.getNextStart(t, 0, 0, false);
 355                         if (da == null || db == null || !da.equals(db)) {
 356                             break;
 357                         }
 358                         t = da.getTime();
 359                     }
 360                     return compareTimeZoneRules(ra, rb);
 361                 }
 362             }
 363             return false;
 364         }
 365     }
 366
 367     private static class ULocaleHandler implements Handler
 368     {
 369         public Object[] getTestObjects()
 370         {
 371             ULocale uLocales[] = new ULocale[locales.length];
 372
 373             for (int i = 0; i < locales.length; i += 1) {
 374                 uLocales[i] = ULocale.forLocale(locales[i]);
 375             }
 376
 377             return uLocales;
 378         }
 379
 380         public boolean hasSameBehavior(Object a, Object b)
 381         {
 382             ULocale uloc_a = (ULocale) a;
 383             ULocale uloc_b = (ULocale) b;
 384
 385             return uloc_a.getName().equals(uloc_b.getName());
 386         }
 387     }
 388
 389     public static class DateIntervalHandler implements Handler
 390     {
 391         private DateInterval dateInterval[] = {
 392                 new DateInterval(0L, 1164931200000L/*20061201T000000Z*/)
 393         };
 394         public Object[] getTestObjects()
 395         {
 396             return dateInterval;
 397         }
 398
 399         public boolean hasSameBehavior(Object a, Object b)
 400         {
 401             return a.equals(b);
 402         }
 403     }
 404
 405
 406     private static class CurrencyHandler implements Handler
 407     {
 408         public Object[] getTestObjects()
 409         {
 410             Currency currencies[] = new Currency[places.length];
 411
 412             for (int i = 0; i < places.length; i += 1) {
 413                 currencies[i] = Currency.getInstance(places[i]);
 414             }
 415
 416             return currencies;
 417         }
 418
 419         public boolean hasSameBehavior(Object a, Object b)
 420         {
 421             Currency curr_a = (Currency) a;
 422             Currency curr_b = (Currency) b;
 423
 424             return curr_a.getCurrencyCode().equals(curr_b.getCurrencyCode());
 425
 426         }
 427     }
 428
 429     private static String zoneIDs[] = {
 430         "Pacific/Honolulu", "America/Anchorage", "America/Los_Angeles", "America/Denver",
 431         "America/Chicago", "America/New_York", "Africa/Cairo", "Africa/Addis_Ababa", "Africa/Dar_es_Salaam",
 432         "Africa/Freetown", "Africa/Johannesburg", "Africa/Nairobi", "Asia/Bangkok", "Asia/Baghdad",
 433         "Asia/Calcutta", "Asia/Hong_Kong", "Asia/Jakarta", "Asia/Jerusalem", "Asia/Manila", "Asia/Tokyo",
 434         "Europe/Amsterdam", "Europe/Athens", "Europe/Berlin", "Europe/London", "Europe/Malta", "Europe/Moscow",
 435         "Europe/Paris", "Europe/Rome"
 436     };
 437
 438     private static long sampleTimes[] = {
 439         1136073600000L, // 20060101T000000Z
 440         1138752000000L, // 20060201T000000Z
 441         1141171200000L, // 20060301T000000Z
 442         1143849600000L, // 20060401T000000Z
 443         1146441600000L, // 20060501T000000Z
 444         1149120000000L, // 20060601T000000Z
 445         1151712000000L, // 20060701T000000Z
 446         1154390400000L, // 20060801T000000Z
 447         1157068800000L, // 20060901T000000Z
 448         1159660800000L, // 20061001T000000Z
 449         1162339200000L, // 20061101T000000Z
 450         1164931200000L, // 20061201T000000Z
 451     };
 452
 453     private static class OlsonTimeZoneHandler implements Handler
 454     {
 455         public Object[] getTestObjects()
 456         {
 457             OlsonTimeZone timeZones[] = new OlsonTimeZone[zoneIDs.length];
 458
 459             for (int i = 0; i < zoneIDs.length; i += 1) {
 460                 timeZones[i] = new OlsonTimeZone(zoneIDs[i]);
 461             }
 462
 463             return timeZones;
 464
 465         }
 466
 467         public boolean hasSameBehavior(Object a, Object b)
 468         {
 469             OlsonTimeZone otz_a = (OlsonTimeZone) a;
 470             OlsonTimeZone otz_b = (OlsonTimeZone) b;
 471             int a_offsets[] = {0, 0};
 472             int b_offsets[] = {0, 0};
 473
 474             boolean bSame = true;
 475             for (int i = 0; i < sampleTimes.length; i++) {
 476                 otz_a.getOffset(sampleTimes[i], false, a_offsets);
 477                 otz_b.getOffset(sampleTimes[i], false, b_offsets);
 478                 if (a_offsets[0] != b_offsets[0] || a_offsets[1] != b_offsets[1]) {
 479                     bSame = false;
 480                     break;
 481                 }
 482             }
 483             return bSame;
 484         }
 485     }
 486
 487     private static class TimeZoneAdapterHandler implements Handler
 488     {
 489         public Object[] getTestObjects()
 490         {
 491             TimeZoneAdapter timeZones[] = new TimeZoneAdapter[zoneIDs.length];
 492
 493             for (int i = 0; i < zoneIDs.length; i += 1) {
 494                 timeZones[i] = new TimeZoneAdapter(TimeZone.getTimeZone(zoneIDs[i]));
 495             }
 496
 497             return timeZones;
 498
 499         }
 500
 501         public boolean hasSameBehavior(Object a, Object b)
 502         {
 503             GregorianCalendar cal = new GregorianCalendar();
 504             TimeZoneAdapter tza_a = (TimeZoneAdapter) a;
 505             TimeZoneAdapter tza_b = (TimeZoneAdapter) b;
 506
 507             int a_offset, b_offset;
 508             boolean a_dst, b_dst;
 509             boolean bSame = true;
 510             for (int i = 0; i < sampleTimes.length; i++) {
 511                 cal.setTimeInMillis(sampleTimes[i]);
 512                 int era = cal.get(Calendar.ERA);
 513                 int year = cal.get(Calendar.YEAR);
 514                 int month = cal.get(Calendar.MONTH);
 515                 int day = cal.get(Calendar.DAY_OF_MONTH);
 516                 int dow = cal.get(Calendar.DAY_OF_WEEK);
 517                 int mid = cal.get(Calendar.MILLISECONDS_IN_DAY);
 518                 a_offset = tza_a.getOffset(era, year, month, day, dow, mid);
 519                 b_offset = tza_b.getOffset(era, year, month, day, dow, mid);
 520                 Date d = new Date(sampleTimes[i]);
 521                 a_dst = tza_a.inDaylightTime(d);
 522                 b_dst = tza_b.inDaylightTime(d);
 523                 if (a_offset != b_offset || a_dst != b_dst) {
 524                     bSame = false;
 525                     break;
 526                 }
 527             }
 528             return bSame;
 529         }
 530     }
 531
 532     private static class JavaTimeZoneHandler implements Handler {
 533         String[] ZONES = { "GMT", "America/New_York", "GMT+05:45" };
 534
 535         public Object[] getTestObjects() {
 536             JavaTimeZone zones[] = new JavaTimeZone[ZONES.length];
 537             for(int z = 0; z < ZONES.length; z += 1) {
 538                 zones[z] = new JavaTimeZone(ZONES[z]);
 539             }
 540             return zones;
 541         }
 542
 543         public boolean hasSameBehavior(Object a, Object b)
 544         {
 545             TimeZone zone_a = (TimeZone) a;
 546             TimeZone zone_b = (TimeZone) b;
 547
 548             if (!(TimeZone.getCanonicalID(zone_a.getID()).equals(TimeZone.getCanonicalID(zone_b.getID())))) {
 549                 return false;
 550             }
 551
 552             int a_offsets[] = {0, 0};
 553             int b_offsets[] = {0, 0};
 554
 555             boolean bSame = true;
 556             for (int i = 0; i < sampleTimes.length; i++) {
 557                 zone_a.getOffset(sampleTimes[i], false, a_offsets);
 558                 zone_b.getOffset(sampleTimes[i], false, b_offsets);
 559                 if (a_offsets[0] != b_offsets[0] || a_offsets[1] != b_offsets[1]) {
 560                     bSame = false;
 561                     break;
 562                 }
 563             }
 564             return bSame;
 565         }
 566     }
 567
 568     private static class BigDecimalHandler implements Handler
 569     {
 570         String values[] = {
 571             "1234567890.",
 572             "123456789.0",
 573             "12345678.90",
 574             "1234567.890",
 575             "123456.7890",
 576             "12345.67890",
 577             "1234.567890",
 578             "123.4567890",
 579             "12.34567890",
 580             "1.234567890",
 581             ".1234567890"};
 582
 583         public Object[] getTestObjects()
 584         {
 585             BigDecimal bds[] = new BigDecimal[values.length];
 586
 587             for (int i = 0; i < values.length; i += 1) {
 588                 bds[i] = new BigDecimal(values[i]);
 589             }
 590
 591             return bds;
 592         }
 593
 594         public boolean hasSameBehavior(Object a, Object b) {
 595             BigDecimal bda = (BigDecimal) a;
 596             BigDecimal bdb = (BigDecimal) b;
 597
 598             return bda.toString().equals(bdb.toString());
 599         }
 600     }
 601
 602     private static class MathContextHandler implements Handler
 603     {
 604         int forms[] = {MathContext.PLAIN, MathContext.ENGINEERING, MathContext.SCIENTIFIC};
 605         int rounds[] = {
 606             MathContext.ROUND_CEILING, MathContext.ROUND_DOWN, MathContext.ROUND_FLOOR,
 607             MathContext.ROUND_HALF_DOWN, MathContext.ROUND_HALF_EVEN, MathContext.ROUND_HALF_UP,
 608             MathContext.ROUND_UNNECESSARY, MathContext.ROUND_UP};
 609
 610         public Object[] getTestObjects()
 611         {
 612             int objectCount = forms.length * rounds.length;
 613             MathContext contexts[] = new MathContext[objectCount];
 614             int i = 0;
 615
 616             for (int f = 0; f < forms.length; f += 1) {
 617                 for (int r = 0; r < rounds.length; r += 1) {
 618                     int digits = f * r;
 619                     boolean lostDigits = (r & 1) != 0;
 620
 621                     contexts[i++] = new MathContext(digits, forms[f], lostDigits, rounds[r]);
 622                 }
 623             }
 624
 625             return contexts;
 626         }
 627
 628         public boolean hasSameBehavior(Object a, Object b)
 629         {
 630             MathContext mca = (MathContext) a;
 631             MathContext mcb = (MathContext) b;
 632
 633             return mca.toString().equals(mcb.toString());
 634         }
 635     }
 636
 637     private static HashMap map = new HashMap();
 638
 639     static {
 640         map.put("com.ibm.icu.util.TimeZone", new TimeZoneHandler());
 641         map.put("com.ibm.icu.util.SimpleTimeZone", new SimpleTimeZoneHandler());
 642         map.put("com.ibm.icu.util.RuleBasedTimeZone", new RuleBasedTimeZoneHandler());
 643         map.put("com.ibm.icu.util.VTimeZone", new VTimeZoneHandler());
 644         map.put("com.ibm.icu.util.DateTimeRule", new DateTimeRuleHandler());
 645         map.put("com.ibm.icu.util.AnnualTimeZoneRule", new AnnualTimeZoneRuleHandler());
 646         map.put("com.ibm.icu.util.InitialTimeZoneRule", new InitialTimeZoneRuleHandler());
 647         map.put("com.ibm.icu.util.TimeArrayTimeZoneRule", new TimeArrayTimeZoneRuleHandler());
 648         map.put("com.ibm.icu.util.ULocale", new ULocaleHandler());
 649         map.put("com.ibm.icu.util.Currency", new CurrencyHandler());
 650         map.put("com.ibm.icu.impl.JavaTimeZone", new JavaTimeZoneHandler());
 651         map.put("com.ibm.icu.impl.OlsonTimeZone", new OlsonTimeZoneHandler());
 652         map.put("com.ibm.icu.impl.TimeZoneAdapter", new TimeZoneAdapterHandler());
 653         map.put("com.ibm.icu.math.BigDecimal", new BigDecimalHandler());
 654         map.put("com.ibm.icu.math.MathContext", new MathContextHandler());
 655
 656         map.put("com.ibm.icu.text.NumberFormat", new FormatTests.NumberFormatHandler());
 657         map.put("com.ibm.icu.text.DecimalFormat", new FormatTests.DecimalFormatHandler());
 658         map.put("com.ibm.icu.text.RuleBasedNumberFormat", new FormatTests.RuleBasedNumberFormatHandler());
 659         map.put("com.ibm.icu.text.CurrencyPluralInfo", new FormatTests.CurrencyPluralInfoHandler());
 660         map.put("com.ibm.icu.text.DecimalFormatSymbols", new FormatTests.DecimalFormatSymbolsHandler());
 661         map.put("com.ibm.icu.text.MessageFormat", new FormatTests.MessageFormatHandler());
 662         map.put("com.ibm.icu.text.DateFormat", new FormatTests.DateFormatHandler());
 663         map.put("com.ibm.icu.text.DateFormatSymbols", new FormatTests.DateFormatSymbolsHandler());
 664         map.put("com.ibm.icu.util.DateInterval", new DateIntervalHandler());
 665         map.put("com.ibm.icu.text.DateIntervalFormat", new FormatTests.DateIntervalFormatHandler());
 666         map.put("com.ibm.icu.text.DateIntervalInfo", new FormatTests.DateIntervalInfoHandler());
 667         map.put("com.ibm.icu.text.DateIntervalInfo$PatternInfo", new FormatTests.PatternInfoHandler());
 668         map.put("com.ibm.icu.text.SimpleDateFormat", new FormatTests.SimpleDateFormatHandler());
 669         map.put("com.ibm.icu.text.ChineseDateFormat", new FormatTests.ChineseDateFormatHandler());
 670         map.put("com.ibm.icu.text.ChineseDateFormatSymbols", new FormatTests.ChineseDateFormatSymbolsHandler());
 671         map.put("com.ibm.icu.impl.DateNumberFormat", new FormatTests.DateNumberFormatHandler());
 672         map.put("com.ibm.icu.text.PluralFormat", new FormatTests.PluralFormatHandler());
 673         map.put("com.ibm.icu.text.PluralRules", new FormatTests.PluralRulesHandler());
 674         map.put("com.ibm.icu.text.TimeUnitFormat", new FormatTests.TimeUnitFormatHandler());
 675
 676         map.put("com.ibm.icu.util.Calendar", new CalendarTests.CalendarHandler());
 677         map.put("com.ibm.icu.util.BuddhistCalendar", new CalendarTests.BuddhistCalendarHandler());
 678         map.put("com.ibm.icu.util.ChineseCalendar", new CalendarTests.ChineseCalendarHandler());
 679         map.put("com.ibm.icu.util.CopticCalendar", new CalendarTests.CopticCalendarHandler());
 680         map.put("com.ibm.icu.util.EthiopicCalendar", new CalendarTests.EthiopicCalendarHandler());
 681         map.put("com.ibm.icu.util.GregorianCalendar", new CalendarTests.GregorianCalendarHandler());
 682         map.put("com.ibm.icu.util.HebrewCalendar", new CalendarTests.HebrewCalendarHandler());
 683         map.put("com.ibm.icu.util.IndianCalendar", new CalendarTests.IndianCalendarHandler());
 684         map.put("com.ibm.icu.util.IslamicCalendar", new CalendarTests.IslamicCalendarHandler());
 685         map.put("com.ibm.icu.util.JapaneseCalendar", new CalendarTests.JapaneseCalendarHandler());
 686         map.put("com.ibm.icu.util.TaiwanCalendar", new CalendarTests.TaiwanCalendarHandler());
 687
 688         map.put("com.ibm.icu.text.ArabicShapingException", new ExceptionTests.ArabicShapingExceptionHandler());
 689         map.put("com.ibm.icu.text.StringPrepParseException", new ExceptionTests.StringPrepParseExceptionHandler());
 690         map.put("com.ibm.icu.util.UResourceTypeMismatchException", new ExceptionTests.UResourceTypeMismatchExceptionHandler());
 691         map.put("com.ibm.icu.impl.InvalidFormatException", new ExceptionTests.InvalidFormatExceptionHandler());
 692
 693 //#if defined(FOUNDATION10) || defined(J2SE13)
 694 //#else
 695         map.put("com.ibm.icu.text.NumberFormat$Field", new FormatTests.NumberFormatFieldHandler());
 696         map.put("com.ibm.icu.text.DateFormat$Field", new FormatTests.DateFormatFieldHandler());
 697         map.put("com.ibm.icu.text.ChineseDateFormat$Field", new FormatTests.ChineseDateFormatFieldHandler());
 698         map.put("com.ibm.icu.text.MessageFormat$Field", new FormatTests.MessageFormatFieldHandler());
 699 //#endif
 700         map.put("com.ibm.icu.impl.duration.BasicDurationFormat", new FormatTests.BasicDurationFormatHandler());
 701         map.put("com.ibm.icu.impl.RelativeDateFormat", new FormatTests.RelativeDateFormatHandler());
 702         map.put("com.ibm.icu.util.IllformedLocaleException", new ExceptionTests.IllformedLocaleExceptionHandler());
 703         map.put("com.ibm.icu.impl.locale.LocaleSyntaxException", new ExceptionTests.LocaleSyntaxExceptionHandler());
 704         map.put("com.ibm.icu.impl.IllegalIcuArgumentException", new ExceptionTests.IllegalIcuArgumentExceptionHandler());
 705     }
 706
 707     public SerializableTest()
 708     {
 709         super(
 710             new String[] {
 711                 "com.ibm.icu.dev.test.serializable.CoverageTest",
 712                 "com.ibm.icu.dev.test.serializable.CompatibilityTest"},
 713             "All Serializable Tests"
 714         );
 715     }
 716
 717     public static final String CLASS_TARGET_NAME  = "Serializable";
 718
 719     public static void main(String[] args)
 720     {
 721         SerializableTest test = new SerializableTest();
 722
 723         test.run(args);
 724     }
 725 }
 726 //eof