jars/icu4j-52_1/main/tests/core/src/com/ibm/icu/dev/test/serializable/SerializableTest.java

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