jars/icu4j-4_4_2-src/main/tests/core/src/com/ibm/icu/dev/test/timescale/TimeScaleAPITest.java

   1 /*\r
   2  *******************************************************************************\r
   3  * Copyright (C) 1996-2010, International Business Machines Corporation and    *\r
   4  * others. All Rights Reserved.                                                *\r
   5  *******************************************************************************\r
   6  *\r
   7  */\r
   8 \r
   9 package com.ibm.icu.dev.test.timescale;\r
  10 \r
  11 import com.ibm.icu.dev.test.TestFmwk;\r
  12 import com.ibm.icu.math.BigDecimal;\r
  13 import com.ibm.icu.util.UniversalTimeScale;\r
  14 \r
  15 /**\r
  16  * Test UniversalTimeScale API\r
  17  */\r
  18 public class TimeScaleAPITest extends TestFmwk\r
  19 {\r
  20 \r
  21     /**\r
  22      * \r
  23      */\r
  24     public TimeScaleAPITest()\r
  25     {\r
  26     }\r
  27     \r
  28     public void TestBigDecimalFromBigDecimal()\r
  29     {\r
  30         BigDecimal bigZero = new BigDecimal(0);\r
  31         \r
  32         try {\r
  33             UniversalTimeScale.bigDecimalFrom(bigZero, -1);\r
  34             errln("bigDecimalFrom(bigZero, -1) did not throw IllegalArgumentException.");\r
  35         } catch (IllegalArgumentException iae) {\r
  36             logln("PASS: UniversalTimeScale.bigDecimalFrom failed as expected");\r
  37         }\r
  38         \r
  39         for (int scale = 0; scale < UniversalTimeScale.MAX_SCALE; scale += 1) {\r
  40             try {\r
  41                 UniversalTimeScale.bigDecimalFrom(bigZero, scale);\r
  42             } catch (IllegalArgumentException iae) {\r
  43                 errln("bigDecimalFrom(bigZero, " + scale + ") threw IllegalArgumentException.");\r
  44             }\r
  45         }\r
  46         \r
  47         try {\r
  48             UniversalTimeScale.bigDecimalFrom(bigZero, UniversalTimeScale.MAX_SCALE);\r
  49             errln("from(bigZero, MAX_SCALE) did not throw IllegalArgumetException.");\r
  50         } catch (IllegalArgumentException iae) {\r
  51             logln("PASS: UniversalTimeScale.bigDecimalFrom failed as expected");\r
  52         }\r
  53     }\r
  54     \r
  55     public void TestBigDecimalFromDouble()\r
  56     {\r
  57         try {\r
  58             UniversalTimeScale.bigDecimalFrom(0.0, -1);\r
  59             errln("bigDecimalFrom(0.0, -1) did not throw IllegalArgumentException.");\r
  60         } catch (IllegalArgumentException iae) {\r
  61             logln("PASS: UniversalTimeScale.bigDecimalFrom failed as expected");\r
  62         }\r
  63         \r
  64         for (int scale = 0; scale < UniversalTimeScale.MAX_SCALE; scale += 1) {\r
  65             try {\r
  66                 UniversalTimeScale.bigDecimalFrom(0.0, scale);\r
  67             } catch (IllegalArgumentException iae) {\r
  68                 errln("bigDecimalFrom(0.0, " + scale + ") threw IllegalArgumentException.");\r
  69             }\r
  70        }\r
  71         \r
  72         try {\r
  73             UniversalTimeScale.bigDecimalFrom(0.0, UniversalTimeScale.MAX_SCALE);\r
  74             errln("from(0.0, MAX_SCALE) did not throw IllegalArgumetException.");\r
  75         } catch (IllegalArgumentException iae) {\r
  76             logln("PASS: UniversalTimeScale.bigDecimalFrom failed as expected");\r
  77         }\r
  78     }\r
  79     \r
  80     public void TestBigDecimalFromLong()\r
  81     {\r
  82         try {\r
  83             UniversalTimeScale.bigDecimalFrom(0L, -1);\r
  84             errln("bigDecimalFrom(0L, -1) did not throw IllegalArgumentException.");\r
  85         } catch (IllegalArgumentException iae) {\r
  86             logln("PASS: UniversalTimeScale.bigDecimalFrom failed as expected");\r
  87         }\r
  88         \r
  89         for (int scale = 0; scale < UniversalTimeScale.MAX_SCALE; scale += 1) {\r
  90             try {\r
  91                 UniversalTimeScale.bigDecimalFrom(0L, scale);\r
  92             } catch (IllegalArgumentException iae) {\r
  93                 errln("bigDecimalFrom(0L, " + scale + ") threw IllegalArgumentException.");\r
  94             }\r
  95        }\r
  96         \r
  97         try {\r
  98             UniversalTimeScale.bigDecimalFrom(0L, UniversalTimeScale.MAX_SCALE);\r
  99             errln("from(0L, MAX_SCALE) did not throw IllegalArgumetException.");\r
 100         } catch (IllegalArgumentException iae) {\r
 101             logln("PASS: UniversalTimeScale.bigDecimalFrom failed as expected");\r
 102         }\r
 103     }\r
 104     \r
 105     public void TestFromLong()\r
 106     {\r
 107         long result;\r
 108         \r
 109         try {\r
 110             result = UniversalTimeScale.from(0L, -1);\r
 111             errln("from(0L, -1) did not throw IllegalArgumentException.");\r
 112         } catch (IllegalArgumentException iae) {\r
 113             logln("PASS: UniversalTimeScale.from failed as expected");\r
 114         }\r
 115 \r
 116         for (int scale = 0; scale < UniversalTimeScale.MAX_SCALE; scale += 1) {\r
 117             long fromMin = UniversalTimeScale.getTimeScaleValue(scale, UniversalTimeScale.FROM_MIN_VALUE);\r
 118             long fromMax = UniversalTimeScale.getTimeScaleValue(scale, UniversalTimeScale.FROM_MAX_VALUE);\r
 119             \r
 120             try {\r
 121                 result = UniversalTimeScale.from(0L, scale);\r
 122                 logln("from(0L, " + scale + ") returned " + result);\r
 123             } catch (IllegalArgumentException iae) {\r
 124                 errln("from(0L, " + scale + ") threw IllegalArgumentException.");\r
 125             }\r
 126 \r
 127             try {\r
 128                 result = UniversalTimeScale.from(fromMin, scale);\r
 129                 logln("from(fromMin, " + scale + ") returned " + result);\r
 130             } catch (IllegalArgumentException iae) {\r
 131                 errln("from(fromMin, " + scale + ") threw IllegalArgumentException.");\r
 132             }\r
 133              \r
 134             if (fromMin > Long.MIN_VALUE) {\r
 135                 try {\r
 136                     result = UniversalTimeScale.from(fromMin - 1, scale);\r
 137                     errln("from(fromMin - 1, " + scale + ") did not throw IllegalArgumentException.");\r
 138                 } catch (IllegalArgumentException iae) {\r
 139                     logln("PASS: UniversalTimeScale.from failed as expected");\r
 140                 }\r
 141             }\r
 142              \r
 143             try {\r
 144                 result = UniversalTimeScale.from(fromMax, scale);\r
 145                 logln("from(fromMax, " + scale + ") returned " + result);\r
 146             } catch (IllegalArgumentException iae) {\r
 147                 errln("from(fromMax, " + scale + ") threw IllegalArgumentException.");\r
 148             }\r
 149               \r
 150             if (fromMax < Long.MAX_VALUE) {\r
 151                 try {\r
 152                     result = UniversalTimeScale.from(fromMax + 1, scale);\r
 153                     errln("from(fromMax + 1, " + scale + ") did not throw IllegalArgumentException.");\r
 154                } catch (IllegalArgumentException iae) {\r
 155                 logln("PASS: UniversalTimeScale.from failed as expected");\r
 156                }\r
 157             }\r
 158        }\r
 159         \r
 160         try {\r
 161             result = UniversalTimeScale.from(0L, UniversalTimeScale.MAX_SCALE);\r
 162             errln("from(0L, MAX_SCALE) did not throw IllegalArgumetException.");\r
 163         } catch (IllegalArgumentException iae) {\r
 164             logln("PASS: UniversalTimeScale.from failed as expected");\r
 165         }\r
 166     }\r
 167     \r
 168     public void TestGetTimeScale()\r
 169     {\r
 170         long value;\r
 171         \r
 172         try {\r
 173             value = UniversalTimeScale.getTimeScaleValue(-1, 0);\r
 174             errln("getTimeScaleValue(-1, 0) did not throw IllegalArgumentException.");\r
 175         } catch (IllegalArgumentException iae) {\r
 176             logln("PASS: UniversalTimeScale.getTimeScaleValue failed as expected");\r
 177         }\r
 178         \r
 179         try {\r
 180             value = UniversalTimeScale.getTimeScaleValue(0, -1);\r
 181             errln("getTimeScaleValue(0, -1) did not throw IllegalArgumentException.");\r
 182         } catch (IllegalArgumentException iae) {\r
 183             logln("PASS: UniversalTimeScale.getTimeScaleValue failed as expected");\r
 184         }\r
 185         \r
 186         for (int scale = 0; scale < UniversalTimeScale.MAX_SCALE; scale += 1) {\r
 187             try {\r
 188                 value = UniversalTimeScale.getTimeScaleValue(scale, 0);\r
 189                 logln("getTimeScaleValue(" + scale + ", 0) returned " + value);\r
 190             } catch (IllegalArgumentException iae) {\r
 191                 errln("getTimeScaleValue(" + scale + ", 0) threw IllegalArgumentException.");\r
 192             }\r
 193         }\r
 194         \r
 195         try {\r
 196             value = UniversalTimeScale.getTimeScaleValue(UniversalTimeScale.MAX_SCALE, 0);\r
 197             errln("getTimeScaleValue(MAX_SCALE, 0) did not throw IllegalArgumentException");\r
 198         } catch (IllegalArgumentException iae) {\r
 199             logln("PASS: UniversalTimeScale.getTimeScaleValue failed as expected");\r
 200         }\r
 201         \r
 202         try {\r
 203             value = UniversalTimeScale.getTimeScaleValue(0, UniversalTimeScale.MAX_SCALE_VALUE);\r
 204             errln("getTimeScaleValue(0, MAX_SCALE_VALUE) did not throw IllegalArgumentException");\r
 205         } catch (IllegalArgumentException iae) {\r
 206             logln("PASS: UniversalTimeScale.getTimeScaleValue failed as expected");\r
 207         }\r
 208     }\r
 209     \r
 210     public void TestToBigDecimalFromBigDecimal()\r
 211     {\r
 212         BigDecimal bigZero = new BigDecimal(0);\r
 213         \r
 214         try {\r
 215             UniversalTimeScale.toBigDecimal(bigZero, -1);\r
 216             errln("toBigDecimal(bigZero, -1) did not throw IllegalArgumentException.");\r
 217         } catch (IllegalArgumentException iae) {\r
 218             logln("PASS: UniversalTimeScale.toBigDecimal failed as expected");\r
 219         }\r
 220         \r
 221         for (int scale = 0; scale < UniversalTimeScale.MAX_SCALE; scale += 1) {\r
 222             try {\r
 223                 UniversalTimeScale.toBigDecimal(bigZero, scale);\r
 224             } catch (IllegalArgumentException iae) {\r
 225                 errln("toBigDecimal(bigZero, " + scale + ") threw IllegalArgumentException.");\r
 226             }\r
 227         }\r
 228         \r
 229         try {\r
 230             UniversalTimeScale.toBigDecimal(bigZero, UniversalTimeScale.MAX_SCALE);\r
 231             errln("toBigDecimal(bigZero, MAX_SCALE) did not throw IllegalArgumetException.");\r
 232         } catch (IllegalArgumentException iae) {\r
 233             logln("PASS: UniversalTimeScale.toBigDecimal failed as expected");\r
 234         }\r
 235     }\r
 236 \r
 237     public void TestToBigDecimalTrunc()\r
 238     {\r
 239         BigDecimal bigZero = new BigDecimal(0);\r
 240         \r
 241         try {\r
 242             UniversalTimeScale.toBigDecimalTrunc(bigZero, -1);\r
 243             errln("toBigDecimalTrunc(bigZero, -1) did not throw IllegalArgumentException.");\r
 244         } catch (IllegalArgumentException iae) {\r
 245             logln("PASS: UniversalTimeScale.toBigDecimalTrunc failed as expected");\r
 246         }\r
 247         \r
 248         for (int scale = 0; scale < UniversalTimeScale.MAX_SCALE; scale += 1) {\r
 249             try {\r
 250                 UniversalTimeScale.toBigDecimalTrunc(bigZero, scale);\r
 251             } catch (IllegalArgumentException iae) {\r
 252                 errln("toBigDecimalTrunc(bigZero, " + scale + ") threw IllegalArgumentException.");\r
 253             }\r
 254         }\r
 255         \r
 256         try {\r
 257             UniversalTimeScale.toBigDecimalTrunc(bigZero, UniversalTimeScale.MAX_SCALE);\r
 258             errln("toBigDecimalTrunc(bigZero, MAX_SCALE) did not throw IllegalArgumetException.");\r
 259         } catch (IllegalArgumentException iae) {\r
 260             logln("PASS: UniversalTimeScale.toBigDecimalTrunc failed as expected");\r
 261         }\r
 262     }\r
 263     \r
 264     public void TestToBigDecimalFromLong()\r
 265     {\r
 266         try {\r
 267             UniversalTimeScale.toBigDecimal(0L, -1);\r
 268             errln("toBigDecimal(0L, -1) did not throw IllegalArgumentException.");\r
 269         } catch (IllegalArgumentException iae) {\r
 270             logln("PASS: UniversalTimeScale.toBigDecimal failed as expected");\r
 271         }\r
 272         \r
 273         for (int scale = 0; scale < UniversalTimeScale.MAX_SCALE; scale += 1) {\r
 274             try {\r
 275                 UniversalTimeScale.toBigDecimal(0L, scale);\r
 276             } catch (IllegalArgumentException iae) {\r
 277                 errln("toBigDecimal(0L, " + scale + ") threw IllegalArgumentException.");\r
 278             }\r
 279         }\r
 280         \r
 281         try {\r
 282             UniversalTimeScale.toBigDecimal(0L, UniversalTimeScale.MAX_SCALE);\r
 283             errln("toBigDecimal(0L, MAX_SCALE) did not throw IllegalArgumetException.");\r
 284         } catch (IllegalArgumentException iae) {\r
 285             logln("PASS: UniversalTimeScale.toBigDecimal failed as expected");\r
 286         }\r
 287     }\r
 288     \r
 289     public void TestToLong()\r
 290     {\r
 291         long result;\r
 292         \r
 293         try {\r
 294             result = UniversalTimeScale.toLong(0L, -1);\r
 295             errln("toLong(0L, -1) did not throw IllegalArgumentException.");\r
 296         } catch (IllegalArgumentException iae) {\r
 297             logln("PASS: UniversalTimeScale.toLong failed as expected");\r
 298         }\r
 299         \r
 300         for (int scale = 0; scale < UniversalTimeScale.MAX_SCALE; scale += 1) {\r
 301             long toMin = UniversalTimeScale.getTimeScaleValue(scale, UniversalTimeScale.TO_MIN_VALUE);\r
 302             long toMax = UniversalTimeScale.getTimeScaleValue(scale, UniversalTimeScale.TO_MAX_VALUE);\r
 303             \r
 304             try {\r
 305                 result = UniversalTimeScale.toLong(0L, scale);\r
 306                 logln("toLong(0L, " + scale + ") returned " + result);\r
 307             } catch (IllegalArgumentException iae) {\r
 308                 errln("toLong(0L, " + scale + ") threw IllegalArgumentException.");\r
 309             }\r
 310             \r
 311             try {\r
 312                 result = UniversalTimeScale.toLong(toMin, scale);\r
 313                 logln("toLong(toMin, " + scale + ") returned " + result);\r
 314             } catch (IllegalArgumentException iae) {\r
 315                 errln("toLong(toMin, " + scale + ") threw IllegalArgumentException.");\r
 316             }\r
 317              \r
 318             if (toMin > Long.MIN_VALUE) {\r
 319                 try {\r
 320                     result = UniversalTimeScale.toLong(toMin - 1, scale);\r
 321                     errln("toLong(toMin - 1, " + scale + ") did not throw IllegalArgumentException.");\r
 322                 } catch (IllegalArgumentException iae) {\r
 323                     logln("PASS: UniversalTimeScale.toLong failed as expected");\r
 324                 }\r
 325             }\r
 326              \r
 327             try {\r
 328                 result = UniversalTimeScale.toLong(toMax, scale);\r
 329                 logln("toLong(toMax, " + scale + ") returned " + result);\r
 330             } catch (IllegalArgumentException iae) {\r
 331                 errln("toLong(toMax, " + scale + ") threw IllegalArgumentException.");\r
 332             }\r
 333               \r
 334             if (toMax < Long.MAX_VALUE) {\r
 335                 try {\r
 336                     result = UniversalTimeScale.toLong(toMax + 1, scale);\r
 337                     errln("toLong(toMax + 1, " + scale + ") did not throw IllegalArgumentException.");\r
 338                } catch (IllegalArgumentException iae) {\r
 339                 logln("PASS: UniversalTimeScale.toLong failed as expected");\r
 340                }\r
 341             }\r
 342        }\r
 343         \r
 344         try {\r
 345             result = UniversalTimeScale.toLong(0L, UniversalTimeScale.MAX_SCALE);\r
 346             errln("toLong(0L, MAX_SCALE) did not throw IllegalArgumetException.");\r
 347         } catch (IllegalArgumentException iae) {\r
 348             logln("PASS: UniversalTimeScale.toLong failed as expected");\r
 349         }\r
 350     }\r
 351     \r
 352     public static void main(String[] args)\r
 353     {\r
 354         new TimeScaleAPITest().run(args);\r
 355     }\r
 356 }\r