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

   1 /*
   2  *******************************************************************************
   3  * Copyright (C) 2004-2010, International Business Machines Corporation and    *
   4  * others. All Rights Reserved.                                                *
   5  *******************************************************************************
   6  *
   7  */
   8
   9 package com.ibm.icu.dev.test.timescale;
  10
  11 import java.util.Date;
  12 import java.util.Locale;
  13
  14 import com.ibm.icu.dev.test.TestFmwk;
  15 import com.ibm.icu.util.GregorianCalendar;
  16 import com.ibm.icu.util.SimpleTimeZone;
  17 import com.ibm.icu.util.TimeZone;
  18 import com.ibm.icu.util.UniversalTimeScale;
  19
  20 /**
  21  * @author Owner
  22  *
  23  * TODO To change the template for this generated type comment go to
  24  * Window - Preferences - Java - Code Style - Code Templates
  25  */
  26 public class TimeScaleDataTest extends TestFmwk
  27 {
  28
  29     /**
  30      * Default contstructor.
  31      */
  32     public TimeScaleDataTest()
  33     {
  34     }
  35
  36     private void roundTripTest(long value, int scale)
  37     {
  38         long rt = UniversalTimeScale.toLong(UniversalTimeScale.from(value, scale), scale);
  39
  40         if (rt != value) {
  41             errln("Round-trip error: time scale = " + scale + ", value = " + value + ", round-trip = " + rt);
  42         }
  43     }
  44
  45     private void toLimitTest(long toLimit, long fromLimit, int scale)
  46     {
  47         long result = UniversalTimeScale.toLong(toLimit, scale);
  48
  49         if (result != fromLimit) {
  50             errln("toLimit failure: scale = " + scale + ", toLimit = " + toLimit +
  51                   ", toLong(toLimit, scale) = " + result + ", fromLimit = " + fromLimit);
  52         }
  53     }
  54
  55     private void epochOffsetTest(long epochOffset, long units, int scale)
  56     {
  57         long universalEpoch = epochOffset * units;
  58         long local = UniversalTimeScale.toLong(universalEpoch, scale);
  59
  60         if (local != 0) {
  61             errln("toLong(epochOffset, scale): scale = " + scale + ", epochOffset = " + universalEpoch +
  62                   ", result = " + local);
  63         }
  64
  65         local = UniversalTimeScale.toLong(0, scale);
  66
  67         if (local != -epochOffset) {
  68             errln("toLong(0, scale): scale = " + scale + ", result = " + local);
  69         }
  70
  71         long universal = UniversalTimeScale.from(-epochOffset, scale);
  72
  73         if (universal != 0) {
  74             errln("from(-epochOffest, scale): scale = " + scale + ", epochOffset = " + epochOffset +
  75                   ", result = " + universal);
  76         }
  77
  78         universal = UniversalTimeScale.from(0, scale);
  79
  80         if (universal != universalEpoch) {
  81             errln("from(0, scale): scale = " + scale + ", result = " + universal);
  82         }
  83     }
  84
  85     public void TestEpochOffsets()
  86     {
  87         for (int scale = 0; scale < UniversalTimeScale.MAX_SCALE; scale += 1) {
  88             long units       = UniversalTimeScale.getTimeScaleValue(scale, UniversalTimeScale.UNITS_VALUE);
  89             long epochOffset = UniversalTimeScale.getTimeScaleValue(scale, UniversalTimeScale.EPOCH_OFFSET_VALUE);
  90
  91             epochOffsetTest(epochOffset, units, scale);
  92         }
  93     }
  94
  95     public void TestFromLimits()
  96     {
  97         for (int scale = 0; scale < UniversalTimeScale.MAX_SCALE; scale += 1) {
  98             long fromMin = UniversalTimeScale.getTimeScaleValue(scale, UniversalTimeScale.FROM_MIN_VALUE);
  99             long fromMax = UniversalTimeScale.getTimeScaleValue(scale, UniversalTimeScale.FROM_MAX_VALUE);
 100
 101             roundTripTest(fromMin, scale);
 102             roundTripTest(fromMax, scale);
 103         }
 104     }
 105
 106     public void TestToLimits()
 107     {
 108         for (int scale = 0; scale < UniversalTimeScale.MAX_SCALE; scale += 1) {
 109             long fromMin = UniversalTimeScale.getTimeScaleValue(scale, UniversalTimeScale.FROM_MIN_VALUE);
 110             long fromMax = UniversalTimeScale.getTimeScaleValue(scale, UniversalTimeScale.FROM_MAX_VALUE);
 111             long toMin   = UniversalTimeScale.getTimeScaleValue(scale, UniversalTimeScale.TO_MIN_VALUE);
 112             long toMax   = UniversalTimeScale.getTimeScaleValue(scale, UniversalTimeScale.TO_MAX_VALUE);
 113
 114             toLimitTest(toMin, fromMin, scale);
 115             toLimitTest(toMax, fromMax, scale);
 116        }
 117     }
 118
 119     // Test with data from .Net System.DateTime ---------------------------- ***
 120
 121     /*
 122      * This data was generated by C++.Net code like
 123      * Console::WriteLine(L"    {{ {0}, 1, 1, INT64_C({1}) }},", year, DateTime(year, 1, 1).Ticks);
 124      * with the DateTime constructor taking int values for year, month, and date.
 125      */
 126     static private final long dotNetDateTimeTicks[] = {
 127         /* year, month, day, ticks */
 128         100, 1, 1, 31241376000000000L,
 129         100, 3, 1, 31292352000000000L,
 130         200, 1, 1, 62798112000000000L,
 131         200, 3, 1, 62849088000000000L,
 132         300, 1, 1, 94354848000000000L,
 133         300, 3, 1, 94405824000000000L,
 134         400, 1, 1, 125911584000000000L,
 135         400, 3, 1, 125963424000000000L,
 136         500, 1, 1, 157469184000000000L,
 137         500, 3, 1, 157520160000000000L,
 138         600, 1, 1, 189025920000000000L,
 139         600, 3, 1, 189076896000000000L,
 140         700, 1, 1, 220582656000000000L,
 141         700, 3, 1, 220633632000000000L,
 142         800, 1, 1, 252139392000000000L,
 143         800, 3, 1, 252191232000000000L,
 144         900, 1, 1, 283696992000000000L,
 145         900, 3, 1, 283747968000000000L,
 146         1000, 1, 1, 315253728000000000L,
 147         1000, 3, 1, 315304704000000000L,
 148         1100, 1, 1, 346810464000000000L,
 149         1100, 3, 1, 346861440000000000L,
 150         1200, 1, 1, 378367200000000000L,
 151         1200, 3, 1, 378419040000000000L,
 152         1300, 1, 1, 409924800000000000L,
 153         1300, 3, 1, 409975776000000000L,
 154         1400, 1, 1, 441481536000000000L,
 155         1400, 3, 1, 441532512000000000L,
 156         1500, 1, 1, 473038272000000000L,
 157         1500, 3, 1, 473089248000000000L,
 158         1600, 1, 1, 504595008000000000L,
 159         1600, 3, 1, 504646848000000000L,
 160         1700, 1, 1, 536152608000000000L,
 161         1700, 3, 1, 536203584000000000L,
 162         1800, 1, 1, 567709344000000000L,
 163         1800, 3, 1, 567760320000000000L,
 164         1900, 1, 1, 599266080000000000L,
 165         1900, 3, 1, 599317056000000000L,
 166         2000, 1, 1, 630822816000000000L,
 167         2000, 3, 1, 630874656000000000L,
 168         2100, 1, 1, 662380416000000000L,
 169         2100, 3, 1, 662431392000000000L,
 170         2200, 1, 1, 693937152000000000L,
 171         2200, 3, 1, 693988128000000000L,
 172         2300, 1, 1, 725493888000000000L,
 173         2300, 3, 1, 725544864000000000L,
 174         2400, 1, 1, 757050624000000000L,
 175         2400, 3, 1, 757102464000000000L,
 176         2500, 1, 1, 788608224000000000L,
 177         2500, 3, 1, 788659200000000000L,
 178         2600, 1, 1, 820164960000000000L,
 179         2600, 3, 1, 820215936000000000L,
 180         2700, 1, 1, 851721696000000000L,
 181         2700, 3, 1, 851772672000000000L,
 182         2800, 1, 1, 883278432000000000L,
 183         2800, 3, 1, 883330272000000000L,
 184         2900, 1, 1, 914836032000000000L,
 185         2900, 3, 1, 914887008000000000L,
 186         3000, 1, 1, 946392768000000000L,
 187         3000, 3, 1, 946443744000000000L,
 188         1, 1, 1, 0L,
 189         1601, 1, 1, 504911232000000000L,
 190         1899, 12, 31, 599265216000000000L,
 191         1904, 1, 1, 600527520000000000L,
 192         1970, 1, 1, 621355968000000000L,
 193         2001, 1, 1, 631139040000000000L,
 194         9900, 3, 1, 3123873216000000000L,
 195         9999, 12, 31, 3155378112000000000L
 196     };
 197
 198     /*
 199      * ICU's Universal Time Scale is designed to be tick-for-tick compatible with
 200      * .Net System.DateTime. Verify that this is so for the
 201      * .Net-supported date range (years 1-9999 AD).
 202      * This requires a proleptic Gregorian calendar because that's what .Net uses.
 203      * Proleptic: No Julian/Gregorian switchover, or a switchover before
 204      * any date that we test, that is, before 0001 AD.
 205      */
 206     public void TestDotNet() {
 207         TimeZone utc;
 208         final long dayMillis = 86400 * 1000L;    /* 1 day = 86400 seconds */
 209         final long dayTicks = 86400 * 10000000L;
 210         final int kYear = 0;  // offset for dotNetDateTimeTicks[] field
 211         final int kMonth = 1;
 212         final int kDay = 2;
 213         final int kTicks = 3;
 214         final int kIncrement = 4;
 215         GregorianCalendar cal;
 216         long icuDate;
 217         long ticks, millis;
 218         int i;
 219
 220         /* Open a proleptic Gregorian calendar. */
 221         long before0001AD = -1000000 * dayMillis;
 222         utc = new SimpleTimeZone(0, "UTC");
 223         cal = new GregorianCalendar(utc, Locale.ENGLISH);
 224         cal.setGregorianChange(new Date(before0001AD));
 225         for(i = 0; i < dotNetDateTimeTicks.length; i += kIncrement) {
 226             /* Test conversion from .Net/Universal time to ICU time. */
 227             millis = UniversalTimeScale.toLong(dotNetDateTimeTicks[i + kTicks], UniversalTimeScale.ICU4C_TIME);
 228             cal.clear();
 229             cal.set((int)dotNetDateTimeTicks[i + kYear],
 230                     (int)dotNetDateTimeTicks[i + kMonth] - 1, /* Java & ICU use January = month 0. */
 231                     (int)dotNetDateTimeTicks[i + kDay]);
 232             icuDate = cal.getTimeInMillis();
 233             if(millis != icuDate) {
 234                 /* Print days not millis. */
 235                 errln("UniversalTimeScale.toLong(ticks[" + i + "], ICU4C)=" +
 236                       (millis/dayMillis) + " != " + (icuDate/dayMillis) +
 237                       "=ucal_getMillis(" + dotNetDateTimeTicks[i + kYear] +
 238                       "-" + dotNetDateTimeTicks[i + kMonth] +
 239                       "-" + dotNetDateTimeTicks[i + kDay] + ")");
 240             }
 241
 242             /* Test conversion from ICU time to .Net/Universal time. */
 243             ticks = UniversalTimeScale.from(icuDate, UniversalTimeScale.ICU4C_TIME);
 244             if(ticks != dotNetDateTimeTicks[i + kTicks]) {
 245                 /* Print days not ticks. */
 246                 errln("UniversalTimeScale.from(date[" + i + "], ICU4C)=" +
 247                       (ticks/dayTicks) + " != " + dotNetDateTimeTicks[i + kTicks]/dayTicks +
 248                       "=.Net System.DateTime(" + dotNetDateTimeTicks[i + kYear] +
 249                       "-" + dotNetDateTimeTicks[i + kMonth] +
 250                       "-" + dotNetDateTimeTicks[i + kDay] + ").Ticks");
 251             }
 252         }
 253     }
 254
 255     public static void main(String[] args)
 256     {
 257         new TimeScaleDataTest().run(args);
 258     }
 259 }