GregorianCalendarTest.java revision 2ad60cfc28e14ee8f0bb038720836a4696c478ad
1/* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18package tests.api.java.util; 19 20import java.util.BitSet; 21import java.util.Calendar; 22import java.util.Date; 23import java.util.GregorianCalendar; 24import java.util.Locale; 25import java.util.SimpleTimeZone; 26import java.util.TimeZone; 27import java.util.Vector; 28 29public class GregorianCalendarTest extends junit.framework.TestCase { 30 31 /** 32 * @tests java.util.GregorianCalendar#GregorianCalendar() 33 */ 34 public void test_Constructor() { 35 // Test for method java.util.GregorianCalendar() 36 assertTrue("Constructed incorrect calendar", (new GregorianCalendar() 37 .isLenient())); 38 } 39 40 /** 41 * @tests java.util.GregorianCalendar#GregorianCalendar(int, int, int) 42 */ 43 public void test_ConstructorIII() { 44 // Test for method java.util.GregorianCalendar(int, int, int) 45 GregorianCalendar gc = new GregorianCalendar(1972, Calendar.OCTOBER, 13); 46 assertEquals("Incorrect calendar constructed 1", 47 1972, gc.get(Calendar.YEAR)); 48 assertTrue("Incorrect calendar constructed 2", 49 gc.get(Calendar.MONTH) == Calendar.OCTOBER); 50 assertEquals("Incorrect calendar constructed 3", 13, gc 51 .get(Calendar.DAY_OF_MONTH)); 52 assertTrue("Incorrect calendar constructed 4", gc.getTimeZone().equals( 53 TimeZone.getDefault())); 54 } 55 56 /** 57 * @tests java.util.GregorianCalendar#GregorianCalendar(int, int, int, int, 58 * int) 59 */ 60 public void test_ConstructorIIIII() { 61 // Test for method java.util.GregorianCalendar(int, int, int, int, int) 62 GregorianCalendar gc = new GregorianCalendar(1972, Calendar.OCTOBER, 63 13, 19, 9); 64 assertEquals("Incorrect calendar constructed", 65 1972, gc.get(Calendar.YEAR)); 66 assertTrue("Incorrect calendar constructed", 67 gc.get(Calendar.MONTH) == Calendar.OCTOBER); 68 assertEquals("Incorrect calendar constructed", 13, gc 69 .get(Calendar.DAY_OF_MONTH)); 70 assertEquals("Incorrect calendar constructed", 7, gc.get(Calendar.HOUR)); 71 assertEquals("Incorrect calendar constructed", 72 1, gc.get(Calendar.AM_PM)); 73 assertEquals("Incorrect calendar constructed", 74 9, gc.get(Calendar.MINUTE)); 75 assertTrue("Incorrect calendar constructed", gc.getTimeZone().equals( 76 TimeZone.getDefault())); 77 78 //Regression for HARMONY-998 79 gc = new GregorianCalendar(1900, 0, 0, 0, Integer.MAX_VALUE); 80 assertEquals("Incorrect calendar constructed", 81 5983, gc.get(Calendar.YEAR)); 82 } 83 84 /** 85 * @tests java.util.GregorianCalendar#GregorianCalendar(int, int, int, int, 86 * int, int) 87 */ 88 public void test_ConstructorIIIIII() { 89 // Test for method java.util.GregorianCalendar(int, int, int, int, int, 90 // int) 91 GregorianCalendar gc = new GregorianCalendar(1972, Calendar.OCTOBER, 92 13, 19, 9, 59); 93 assertEquals("Incorrect calendar constructed", 94 1972, gc.get(Calendar.YEAR)); 95 assertTrue("Incorrect calendar constructed", 96 gc.get(Calendar.MONTH) == Calendar.OCTOBER); 97 assertEquals("Incorrect calendar constructed", 13, gc 98 .get(Calendar.DAY_OF_MONTH)); 99 assertEquals("Incorrect calendar constructed", 7, gc.get(Calendar.HOUR)); 100 assertEquals("Incorrect calendar constructed", 101 1, gc.get(Calendar.AM_PM)); 102 assertEquals("Incorrect calendar constructed", 103 9, gc.get(Calendar.MINUTE)); 104 assertEquals("Incorrect calendar constructed", 105 59, gc.get(Calendar.SECOND)); 106 assertTrue("Incorrect calendar constructed", gc.getTimeZone().equals( 107 TimeZone.getDefault())); 108 } 109 110 /** 111 * @tests java.util.GregorianCalendar#GregorianCalendar(java.util.Locale) 112 */ 113 public void test_ConstructorLjava_util_Locale() { 114 // Test for method java.util.GregorianCalendar(java.util.Locale) 115 Date date = new Date(); 116 GregorianCalendar gcJapan = new GregorianCalendar(Locale.JAPAN); 117 gcJapan.setTime(date); 118 GregorianCalendar gcJapan2 = new GregorianCalendar(Locale.JAPAN); 119 gcJapan2.setTime(date); 120 GregorianCalendar gcItaly = new GregorianCalendar(Locale.ITALY); 121 gcItaly.setTime(date); 122 assertTrue("Locales not created correctly", gcJapan.equals(gcJapan2) 123 && !gcJapan.equals(gcItaly)); 124 } 125 126 /** 127 * @tests java.util.GregorianCalendar#GregorianCalendar(java.util.TimeZone) 128 */ 129 public void test_ConstructorLjava_util_TimeZone() { 130 // Test for method java.util.GregorianCalendar(java.util.TimeZone) 131 Date date = new Date(); 132 TimeZone.getDefault(); 133 GregorianCalendar gc1 = new GregorianCalendar(TimeZone 134 .getTimeZone("EST")); 135 gc1.setTime(date); 136 GregorianCalendar gc2 = new GregorianCalendar(TimeZone 137 .getTimeZone("CST")); 138 gc2.setTime(date); 139 // CST is 1 hour before EST, add 1 to the CST time and convert to 0-12 140 // value 141 assertTrue("Incorrect calendar returned", 142 gc1.get(Calendar.HOUR) == ((gc2.get(Calendar.HOUR) + 1) % 12)); 143 144 // Regression test for HARMONY-2961 145 SimpleTimeZone timezone = new SimpleTimeZone(-3600 * 24 * 1000 * 2, 146 "GMT"); 147 GregorianCalendar gc = new GregorianCalendar(timezone); 148 } 149 150 /** 151 * @tests java.util.GregorianCalendar#GregorianCalendar(java.util.TimeZone, 152 * java.util.Locale) 153 */ 154 public void test_ConstructorLjava_util_TimeZoneLjava_util_Locale() { 155 // Test for method java.util.GregorianCalendar(java.util.TimeZone, 156 // java.util.Locale) 157 Date date = new Date(); 158 TimeZone.getDefault(); 159 GregorianCalendar gc1 = new GregorianCalendar(TimeZone 160 .getTimeZone("EST"), Locale.JAPAN); 161 gc1.setTime(date); 162 GregorianCalendar gc2 = new GregorianCalendar(TimeZone 163 .getTimeZone("EST"), Locale.JAPAN); 164 gc2.setTime(date); 165 GregorianCalendar gc3 = new GregorianCalendar(TimeZone 166 .getTimeZone("CST"), Locale.ITALY); 167 gc3.setTime(date); 168 // CST is 1 hour before EST, add 1 to the CST time and convert to 0-12 169 // value 170 assertTrue("Incorrect calendar returned", 171 gc1.get(Calendar.HOUR) == ((gc3.get(Calendar.HOUR) + 1) % 12)); 172 assertTrue("Locales not created correctly", gc1.equals(gc2) 173 && !gc1.equals(gc3)); 174 } 175 176 /** 177 * @tests java.util.GregorianCalendar#add(int, int) 178 */ 179 public void test_addII() { 180 // Test for method void java.util.GregorianCalendar.add(int, int) 181 GregorianCalendar gc1 = new GregorianCalendar(1998, 11, 6); 182 gc1.add(GregorianCalendar.YEAR, 1); 183 assertEquals("Add failed to Increment", 184 1999, gc1.get(GregorianCalendar.YEAR)); 185 186 gc1 = new GregorianCalendar(1999, Calendar.JULY, 31); 187 gc1.add(Calendar.MONTH, 7); 188 assertEquals("Wrong result year 1", 2000, gc1.get(Calendar.YEAR)); 189 assertTrue("Wrong result month 1", 190 gc1.get(Calendar.MONTH) == Calendar.FEBRUARY); 191 assertEquals("Wrong result date 1", 29, gc1.get(Calendar.DATE)); 192 193 gc1.add(Calendar.YEAR, -1); 194 assertEquals("Wrong result year 2", 1999, gc1.get(Calendar.YEAR)); 195 assertTrue("Wrong result month 2", 196 gc1.get(Calendar.MONTH) == Calendar.FEBRUARY); 197 assertEquals("Wrong result date 2", 28, gc1.get(Calendar.DATE)); 198 199 gc1 = new GregorianCalendar(TimeZone.getTimeZone("EST")); 200 gc1.set(1999, Calendar.APRIL, 3, 16, 0); // day before DST change 201 gc1.add(Calendar.MILLISECOND, 24 * 60 * 60 * 1000); 202 assertEquals("Wrong time after MILLISECOND change", 17, gc1 203 .get(Calendar.HOUR_OF_DAY)); 204 gc1.set(1999, Calendar.APRIL, 3, 16, 0); // day before DST change 205 gc1.add(Calendar.SECOND, 24 * 60 * 60); 206 assertEquals("Wrong time after SECOND change", 17, gc1 207 .get(Calendar.HOUR_OF_DAY)); 208 gc1.set(1999, Calendar.APRIL, 3, 16, 0); // day before DST change 209 gc1.add(Calendar.MINUTE, 24 * 60); 210 assertEquals("Wrong time after MINUTE change", 17, gc1 211 .get(Calendar.HOUR_OF_DAY)); 212 gc1.set(1999, Calendar.APRIL, 3, 16, 0); // day before DST change 213 gc1.add(Calendar.HOUR, 24); 214 assertEquals("Wrong time after HOUR change", 17, gc1 215 .get(Calendar.HOUR_OF_DAY)); 216 gc1.set(1999, Calendar.APRIL, 3, 16, 0); // day before DST change 217 gc1.add(Calendar.HOUR_OF_DAY, 24); 218 assertEquals("Wrong time after HOUR_OF_DAY change", 17, gc1 219 .get(Calendar.HOUR_OF_DAY)); 220 221 gc1.set(1999, Calendar.APRIL, 3, 16, 0); // day before DST change 222 gc1.add(Calendar.AM_PM, 2); 223 assertEquals("Wrong time after AM_PM change", 16, gc1 224 .get(Calendar.HOUR_OF_DAY)); 225 gc1.set(1999, Calendar.APRIL, 3, 16, 0); // day before DST change 226 gc1.add(Calendar.DATE, 1); 227 assertEquals("Wrong time after DATE change", 16, gc1 228 .get(Calendar.HOUR_OF_DAY)); 229 gc1.set(1999, Calendar.APRIL, 3, 16, 0); // day before DST change 230 gc1.add(Calendar.DAY_OF_YEAR, 1); 231 assertEquals("Wrong time after DAY_OF_YEAR change", 16, gc1 232 .get(Calendar.HOUR_OF_DAY)); 233 gc1.set(1999, Calendar.APRIL, 3, 16, 0); // day before DST change 234 gc1.add(Calendar.DAY_OF_WEEK, 1); 235 assertEquals("Wrong time after DAY_OF_WEEK change", 16, gc1 236 .get(Calendar.HOUR_OF_DAY)); 237 gc1.set(1999, Calendar.APRIL, 3, 16, 0); // day before DST change 238 gc1.add(Calendar.WEEK_OF_YEAR, 1); 239 assertEquals("Wrong time after WEEK_OF_YEAR change", 16, gc1 240 .get(Calendar.HOUR_OF_DAY)); 241 gc1.set(1999, Calendar.APRIL, 3, 16, 0); // day before DST change 242 gc1.add(Calendar.WEEK_OF_MONTH, 1); 243 assertEquals("Wrong time after WEEK_OF_MONTH change", 16, gc1 244 .get(Calendar.HOUR_OF_DAY)); 245 gc1.set(1999, Calendar.APRIL, 3, 16, 0); // day before DST change 246 gc1.add(Calendar.DAY_OF_WEEK_IN_MONTH, 1); 247 assertEquals("Wrong time after DAY_OF_WEEK_IN_MONTH change", 16, gc1 248 .get(Calendar.HOUR_OF_DAY)); 249 250 gc1.clear(); 251 gc1.set(2000, Calendar.APRIL, 1, 23, 0); 252 gc1.add(Calendar.DATE, 1); 253 assertTrue("Wrong time after DATE change near DST boundary", gc1 254 .get(Calendar.MONTH) == Calendar.APRIL 255 && gc1.get(Calendar.DATE) == 2 256 && gc1.get(Calendar.HOUR_OF_DAY) == 23); 257 } 258 259 /** 260 * @tests java.util.GregorianCalendar#equals(java.lang.Object) 261 */ 262 public void test_equalsLjava_lang_Object() { 263 // Test for method boolean 264 // java.util.GregorianCalendar.equals(java.lang.Object) 265 GregorianCalendar gc1 = new GregorianCalendar(1998, 11, 6); 266 GregorianCalendar gc2 = new GregorianCalendar(2000, 11, 6); 267 GregorianCalendar gc3 = new GregorianCalendar(1998, 11, 6); 268 assertTrue("Equality check failed", gc1.equals(gc3)); 269 assertTrue("Equality check failed", !gc1.equals(gc2)); 270 gc3.setGregorianChange(new Date()); 271 assertTrue("Different gregorian change", !gc1.equals(gc3)); 272 } 273 274 /** 275 * @tests java.util.GregorianCalendar#getActualMaximum(int) 276 */ 277 public void test_getActualMaximumI() { 278 // Test for method int java.util.GregorianCalendar.getActualMaximum(int) 279 GregorianCalendar gc1 = new GregorianCalendar(1900, 1, 1); 280 GregorianCalendar gc2 = new GregorianCalendar(1996, 1, 1); 281 GregorianCalendar gc3 = new GregorianCalendar(1997, 1, 1); 282 GregorianCalendar gc4 = new GregorianCalendar(2000, 1, 1); 283 GregorianCalendar gc5 = new GregorianCalendar(2000, 9, 9); 284 GregorianCalendar gc6 = new GregorianCalendar(2000, 3, 3); 285 assertEquals("Wrong actual maximum value for DAY_OF_MONTH for Feb 1900", 286 28, gc1.getActualMaximum(Calendar.DAY_OF_MONTH)); 287 assertEquals("Wrong actual maximum value for DAY_OF_MONTH for Feb 1996", 288 29, gc2.getActualMaximum(Calendar.DAY_OF_MONTH)); 289 assertEquals("Wrong actual maximum value for DAY_OF_MONTH for Feb 1998", 290 28, gc3.getActualMaximum(Calendar.DAY_OF_MONTH)); 291 assertEquals("Wrong actual maximum value for DAY_OF_MONTH for Feb 2000", 292 29, gc4.getActualMaximum(Calendar.DAY_OF_MONTH)); 293 assertEquals("Wrong actual maximum value for DAY_OF_MONTH for Oct 2000", 294 31, gc5.getActualMaximum(Calendar.DAY_OF_MONTH)); 295 assertEquals("Wrong actual maximum value for DAY_OF_MONTH for Apr 2000", 296 30, gc6.getActualMaximum(Calendar.DAY_OF_MONTH)); 297 assertTrue("Wrong actual maximum value for MONTH", gc1 298 .getActualMaximum(Calendar.MONTH) == Calendar.DECEMBER); 299 assertEquals("Wrong actual maximum value for HOUR_OF_DAY", 23, gc1 300 .getActualMaximum(Calendar.HOUR_OF_DAY)); 301 assertEquals("Wrong actual maximum value for HOUR", 11, gc1 302 .getActualMaximum(Calendar.HOUR)); 303 assertEquals("Wrong actual maximum value for DAY_OF_WEEK_IN_MONTH", 4, gc6 304 .getActualMaximum(Calendar.DAY_OF_WEEK_IN_MONTH)); 305 306 307 // Regression test for harmony 2954 308 Date date = new Date(Date.parse("Jan 15 00:00:01 GMT 2000")); 309 GregorianCalendar gc = new GregorianCalendar(); 310 gc.setTimeInMillis(Date.parse("Dec 15 00:00:01 GMT 1582")); 311 assertEquals(355, gc.getActualMaximum(Calendar.DAY_OF_YEAR)); 312 gc.setGregorianChange(date); 313 gc.setTimeInMillis(Date.parse("Jan 16 00:00:01 GMT 2000")); 314 assertEquals(353, gc.getActualMaximum(Calendar.DAY_OF_YEAR)); 315 316 //Regression test for HARMONY-3004 317 gc = new GregorianCalendar(1900, 7, 1); 318 String[] ids = TimeZone.getAvailableIDs(); 319 for (int i = 0; i < ids.length; i++) { 320 TimeZone tz = TimeZone.getTimeZone(ids[i]); 321 gc.setTimeZone(tz); 322 for (int j = 1900; j < 2000; j++) { 323 gc.set(Calendar.YEAR, j); 324 assertEquals(7200000, gc.getActualMaximum(Calendar.DST_OFFSET)); 325 } 326 } 327 } 328 329 /** 330 * @tests java.util.GregorianCalendar#getActualMinimum(int) 331 */ 332 public void test_getActualMinimumI() { 333 // Test for method int java.util.GregorianCalendar.getActualMinimum(int) 334 GregorianCalendar gc1 = new GregorianCalendar(1900, 1, 1); 335 new GregorianCalendar(1996, 1, 1); 336 new GregorianCalendar(1997, 1, 1); 337 new GregorianCalendar(2000, 1, 1); 338 new GregorianCalendar(2000, 9, 9); 339 GregorianCalendar gc6 = new GregorianCalendar(2000, 3, 3); 340 assertEquals("Wrong actual minimum value for DAY_OF_MONTH for Feb 1900", 341 1, gc1.getActualMinimum(Calendar.DAY_OF_MONTH)); 342 assertTrue("Wrong actual minimum value for MONTH", gc1 343 .getActualMinimum(Calendar.MONTH) == Calendar.JANUARY); 344 assertEquals("Wrong actual minimum value for HOUR_OF_DAY", 0, gc1 345 .getActualMinimum(Calendar.HOUR_OF_DAY)); 346 assertEquals("Wrong actual minimum value for HOUR", 0, gc1 347 .getActualMinimum(Calendar.HOUR)); 348 assertEquals("Wrong actual minimum value for DAY_OF_WEEK_IN_MONTH", 1, gc6 349 .getActualMinimum(Calendar.DAY_OF_WEEK_IN_MONTH)); 350 } 351 352 /** 353 * @tests java.util.GregorianCalendar#getGreatestMinimum(int) 354 */ 355 public void test_getGreatestMinimumI() { 356 // Test for method int 357 // java.util.GregorianCalendar.getGreatestMinimum(int) 358 GregorianCalendar gc = new GregorianCalendar(); 359 assertEquals("Wrong greatest minimum value for DAY_OF_MONTH", 1, gc 360 .getGreatestMinimum(Calendar.DAY_OF_MONTH)); 361 assertTrue("Wrong greatest minimum value for MONTH", gc 362 .getGreatestMinimum(Calendar.MONTH) == Calendar.JANUARY); 363 assertEquals("Wrong greatest minimum value for HOUR_OF_DAY", 0, gc 364 .getGreatestMinimum(Calendar.HOUR_OF_DAY)); 365 assertEquals("Wrong greatest minimum value for HOUR", 0, gc 366 .getGreatestMinimum(Calendar.HOUR)); 367 368 BitSet result = new BitSet(); 369 int[] min = { 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, -46800000, 370 0 }; 371 for (int i = 0; i < min.length; i++) { 372 if (gc.getGreatestMinimum(i) != min[i]) 373 result.set(i); 374 } 375 assertTrue("Wrong greatest min for " + result, result.length() == 0); 376 } 377 378 /** 379 * @tests java.util.GregorianCalendar#getGregorianChange() 380 */ 381 public void test_getGregorianChange() { 382 // Test for method java.util.Date 383 // java.util.GregorianCalendar.getGregorianChange() 384 GregorianCalendar gc = new GregorianCalendar(); 385 GregorianCalendar returnedChange = new GregorianCalendar(TimeZone 386 .getTimeZone("EST")); 387 returnedChange.setTime(gc.getGregorianChange()); 388 assertEquals("Returned incorrect year", 389 1582, returnedChange.get(Calendar.YEAR)); 390 assertTrue("Returned incorrect month", returnedChange 391 .get(Calendar.MONTH) == Calendar.OCTOBER); 392 assertEquals("Returned incorrect day of month", 4, returnedChange 393 .get(Calendar.DAY_OF_MONTH)); 394 } 395 396 /** 397 * @tests java.util.GregorianCalendar#getLeastMaximum(int) 398 */ 399 public void test_getLeastMaximumI() { 400 // Test for method int java.util.GregorianCalendar.getLeastMaximum(int) 401 GregorianCalendar gc = new GregorianCalendar(); 402 assertEquals("Wrong least maximum value for DAY_OF_MONTH", 28, gc 403 .getLeastMaximum(Calendar.DAY_OF_MONTH)); 404 assertTrue("Wrong least maximum value for MONTH", gc 405 .getLeastMaximum(Calendar.MONTH) == Calendar.DECEMBER); 406 assertEquals("Wrong least maximum value for HOUR_OF_DAY", 23, gc 407 .getLeastMaximum(Calendar.HOUR_OF_DAY)); 408 assertEquals("Wrong least maximum value for HOUR", 11, gc 409 .getLeastMaximum(Calendar.HOUR)); 410 411 BitSet result = new BitSet(); 412 Vector values = new Vector(); 413 int[] max = { 1, 292269054, 11, 50, 3, 28, 355, 7, 3, 1, 11, 23, 59, 414 59, 999, 50400000, 1200000 }; 415 for (int i = 0; i < max.length; i++) { 416 if (gc.getLeastMaximum(i) != max[i]) { 417 result.set(i); 418 values.add(new Integer(gc.getLeastMaximum(i))); 419 } 420 } 421 assertTrue("Wrong least max for " + result + " = " + values, result 422 .length() == 0); 423 424 // Regression test for harmony-2947 425 Date date = new Date(Date.parse("Jan 1 00:00:01 GMT 2000")); 426 gc = new GregorianCalendar(); 427 gc.setGregorianChange(date); 428 gc.setTime(date); 429 assertEquals(gc.getActualMaximum(Calendar.WEEK_OF_YEAR), gc 430 .getLeastMaximum(Calendar.WEEK_OF_YEAR)); 431 } 432 433 /** 434 * @tests java.util.GregorianCalendar#getMaximum(int) 435 */ 436 public void test_getMaximumI() { 437 // Test for method int java.util.GregorianCalendar.getMaximum(int) 438 GregorianCalendar gc = new GregorianCalendar(); 439 assertEquals("Wrong maximum value for DAY_OF_MONTH", 31, gc 440 .getMaximum(Calendar.DAY_OF_MONTH)); 441 assertTrue("Wrong maximum value for MONTH", gc 442 .getMaximum(Calendar.MONTH) == Calendar.DECEMBER); 443 assertEquals("Wrong maximum value for HOUR_OF_DAY", 23, gc 444 .getMaximum(Calendar.HOUR_OF_DAY)); 445 assertEquals("Wrong maximum value for HOUR", 446 11, gc.getMaximum(Calendar.HOUR)); 447 448 BitSet result = new BitSet(); 449 Vector values = new Vector(); 450 int[] max = { 1, 292278994, 11, 53, 6, 31, 366, 7, 6, 1, 11, 23, 59, 451 59, 999, 50400000, 7200000 }; 452 for (int i = 0; i < max.length; i++) { 453 if (gc.getMaximum(i) != max[i]) { 454 result.set(i); 455 values.add(new Integer(gc.getMaximum(i))); 456 } 457 } 458 assertTrue("Wrong max for " + result + " = " + values, 459 result.length() == 0); 460 } 461 462 /** 463 * @tests java.util.GregorianCalendar#getMinimum(int) 464 */ 465 public void test_getMinimumI() { 466 // Test for method int java.util.GregorianCalendar.getMinimum(int) 467 GregorianCalendar gc = new GregorianCalendar(); 468 assertEquals("Wrong minimum value for DAY_OF_MONTH", 1, gc 469 .getMinimum(Calendar.DAY_OF_MONTH)); 470 assertTrue("Wrong minimum value for MONTH", gc 471 .getMinimum(Calendar.MONTH) == Calendar.JANUARY); 472 assertEquals("Wrong minimum value for HOUR_OF_DAY", 0, gc 473 .getMinimum(Calendar.HOUR_OF_DAY)); 474 assertEquals("Wrong minimum value for HOUR", 475 0, gc.getMinimum(Calendar.HOUR)); 476 477 BitSet result = new BitSet(); 478 int[] min = { 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, -46800000, 479 0 }; 480 for (int i = 0; i < min.length; i++) { 481 if (gc.getMinimum(i) != min[i]) 482 result.set(i); 483 } 484 assertTrue("Wrong min for " + result, result.length() == 0); 485 } 486 487 /** 488 * @tests java.util.GregorianCalendar#isLeapYear(int) 489 */ 490 public void test_isLeapYearI() { 491 // Test for method boolean java.util.GregorianCalendar.isLeapYear(int) 492 GregorianCalendar gc = new GregorianCalendar(1998, 11, 6); 493 assertTrue("Returned incorrect value for leap year", !gc 494 .isLeapYear(1998)); 495 assertTrue("Returned incorrect value for leap year", gc 496 .isLeapYear(2000)); 497 498 } 499 500 /** 501 * @tests java.util.GregorianCalendar#roll(int, int) 502 */ 503 public void test_rollII() { 504 // Test for method void java.util.GregorianCalendar.roll(int, int) 505 GregorianCalendar gc = new GregorianCalendar(1972, Calendar.OCTOBER, 8, 506 2, 5, 0); 507 gc.roll(Calendar.DAY_OF_MONTH, -1); 508 assertTrue("Failed to roll DAY_OF_MONTH down by 1", gc 509 .equals(new GregorianCalendar(1972, Calendar.OCTOBER, 7, 2, 5, 510 0))); 511 gc = new GregorianCalendar(1972, Calendar.OCTOBER, 8, 2, 5, 0); 512 gc.roll(Calendar.DAY_OF_MONTH, 25); 513 assertTrue("Failed to roll DAY_OF_MONTH up by 25", gc 514 .equals(new GregorianCalendar(1972, Calendar.OCTOBER, 2, 2, 5, 515 0))); 516 gc = new GregorianCalendar(1972, Calendar.OCTOBER, 8, 2, 5, 0); 517 gc.roll(Calendar.DAY_OF_MONTH, -10); 518 assertTrue("Failed to roll DAY_OF_MONTH down by 10", gc 519 .equals(new GregorianCalendar(1972, Calendar.OCTOBER, 29, 2, 5, 520 0))); 521 } 522 523 /** 524 * @tests java.util.GregorianCalendar#roll(int, boolean) 525 */ 526 public void test_rollIZ() { 527 // Test for method void java.util.GregorianCalendar.roll(int, boolean) 528 GregorianCalendar gc = new GregorianCalendar(1972, Calendar.OCTOBER, 529 13, 19, 9, 59); 530 gc.roll(Calendar.DAY_OF_MONTH, false); 531 assertTrue("Failed to roll day_of_month down", gc 532 .equals(new GregorianCalendar(1972, Calendar.OCTOBER, 12, 19, 533 9, 59))); 534 gc = new GregorianCalendar(1972, Calendar.OCTOBER, 13, 19, 9, 59); 535 gc.roll(Calendar.DAY_OF_MONTH, true); 536 assertTrue("Failed to roll day_of_month up", gc 537 .equals(new GregorianCalendar(1972, Calendar.OCTOBER, 14, 19, 538 9, 59))); 539 gc = new GregorianCalendar(1972, Calendar.OCTOBER, 31, 19, 9, 59); 540 gc.roll(Calendar.DAY_OF_MONTH, true); 541 assertTrue("Failed to roll day_of_month up", gc 542 .equals(new GregorianCalendar(1972, Calendar.OCTOBER, 1, 19, 9, 543 59))); 544 545 GregorianCalendar cal = new GregorianCalendar(); 546 int result; 547 try { 548 cal.roll(Calendar.ZONE_OFFSET, true); 549 result = 0; 550 } catch (IllegalArgumentException e) { 551 result = 1; 552 } 553 assertEquals("ZONE_OFFSET roll", 1, result); 554 try { 555 cal.roll(Calendar.DST_OFFSET, true); 556 result = 0; 557 } catch (IllegalArgumentException e) { 558 result = 1; 559 } 560 assertEquals("ZONE_OFFSET roll", 1, result); 561 562 cal.set(2004, Calendar.DECEMBER, 31, 5, 0, 0); 563 cal.roll(Calendar.WEEK_OF_YEAR, true); 564 assertTrue("Wrong year: " + cal.getTime(), 565 cal.get(Calendar.YEAR) == 2004); 566 assertTrue("Wrong month: " + cal.getTime(), 567 cal.get(Calendar.MONTH) == Calendar.JANUARY); 568 assertTrue("Wrong date: " + cal.getTime(), cal.get(Calendar.DATE) == 9); 569 } 570 571 /** 572 * @tests java.util.GregorianCalendar#setGregorianChange(java.util.Date) 573 */ 574 public void test_setGregorianChangeLjava_util_Date() { 575 // Test for method void 576 // java.util.GregorianCalendar.setGregorianChange(java.util.Date) 577 GregorianCalendar gc1 = new GregorianCalendar(1582, Calendar.OCTOBER, 578 4, 0, 0); 579 GregorianCalendar gc2 = new GregorianCalendar(1972, Calendar.OCTOBER, 580 13, 0, 0); 581 gc1.setGregorianChange(gc2.getTime()); 582 assertTrue("Returned incorrect value", gc2.getTime().equals( 583 gc1.getGregorianChange())); 584 } 585 586 /** 587 * @tests java.util.GregorianCalendar#clone() 588 */ 589 public void test_clone() { 590 591 // Regression for HARMONY-498 592 GregorianCalendar gCalend = new GregorianCalendar(); 593 594 gCalend.set(Calendar.MILLISECOND, 0); 595 int dayOfMonth = gCalend.get(Calendar.DAY_OF_MONTH); 596 597 // create clone object and change date 598 GregorianCalendar gCalendClone = (GregorianCalendar) gCalend.clone(); 599 gCalendClone.add(Calendar.DATE, 1); 600 601 assertEquals("Before", dayOfMonth, gCalend.get(Calendar.DAY_OF_MONTH)); 602 gCalend.set(Calendar.MILLISECOND, 0);//changes nothing 603 assertEquals("After", dayOfMonth, gCalend.get(Calendar.DAY_OF_MONTH)); 604 } 605 606 /** 607 * @tests java.util.GregorianCalendar#getMinimalDaysInFirstWeek() 608 */ 609 public void test_getMinimalDaysInFirstWeek() { 610 // Regression for Harmony-1037 611 GregorianCalendar g = new GregorianCalendar(TimeZone 612 .getTimeZone("Europe/London"), new Locale("en", "GB")); 613 int minimalDaysInFirstWeek = g.getMinimalDaysInFirstWeek(); 614 assertEquals(4, minimalDaysInFirstWeek); 615 616 g = new GregorianCalendar(TimeZone.getTimeZone("Europe/London"), 617 new Locale("fr")); 618 minimalDaysInFirstWeek = g.getMinimalDaysInFirstWeek(); 619 assertEquals(4, minimalDaysInFirstWeek); 620 621 g = new GregorianCalendar(TimeZone.getTimeZone("Europe/London"), 622 new Locale("fr", "CA")); 623 minimalDaysInFirstWeek = g.getMinimalDaysInFirstWeek(); 624 assertEquals(1, minimalDaysInFirstWeek); 625 626 } 627 628 /** 629 * @tests java.util.GregorianCalendar#computeTime() 630 */ 631 public void test_computeTime() { 632 // Regression for Harmony-493 633 GregorianCalendar g = new GregorianCalendar( 634 TimeZone.getTimeZone("Europe/London"), 635 new Locale("en", "GB") 636 ); 637 g.clear(); 638 g.set(2006, 02, 26, 01, 50, 00); 639 assertEquals(1143337800000L, g.getTimeInMillis()); 640 641 GregorianCalendar g1 = new GregorianCalendar( 642 TimeZone.getTimeZone("Europe/Moscow") 643 ); 644 g1.clear(); 645 g1.set(2006, 02, 26, 02, 20, 00); // in the DST transition interval 646 assertEquals(1143328800000L, g1.getTimeInMillis()); 647 assertEquals(3, g1.get(Calendar.HOUR_OF_DAY)); 648 g1.clear(); 649 g1.set(2006, 9, 29, 02, 50, 00); // transition from DST 650 assertEquals(1162079400000L, g1.getTimeInMillis()); 651 assertEquals(2, g1.get(Calendar.HOUR_OF_DAY)); 652 // End of regression test 653 } 654 655 /** 656 * @tests java.util.GregorianCalendar#get(int) 657 */ 658 @SuppressWarnings("deprecation") 659 public void test_getI() { 660 // Regression test for HARMONY-2959 661 Date date = new Date(Date.parse("Jan 15 00:00:01 GMT 2000")); 662 GregorianCalendar gc = new GregorianCalendar(TimeZone.getTimeZone("GMT")); 663 gc.setGregorianChange(date); 664 gc.setTimeInMillis(Date.parse("Dec 24 00:00:01 GMT 2000")); 665 assertEquals(346, gc.get(Calendar.DAY_OF_YEAR)); 666 667 // Regression test for HARMONY-3003 668 date = new Date(Date.parse("Feb 28 00:00:01 GMT 2000")); 669 gc = new GregorianCalendar(TimeZone.getTimeZone("GMT")); 670 gc.setGregorianChange(date); 671 gc.setTimeInMillis(Date.parse("Dec 1 00:00:01 GMT 2000")); 672 assertEquals(1, gc.get(Calendar.DAY_OF_MONTH)); 673 assertEquals(11, gc.get(Calendar.MONTH)); 674 } 675 676 /** 677 * Sets up the fixture, for example, open a network connection. This method 678 * is called before a test is executed. 679 */ 680 protected void setUp() { 681 } 682 683 /** 684 * Tears down the fixture, for example, close a network connection. This 685 * method is called after a test is executed. 686 */ 687 protected void tearDown() { 688 } 689} 690