GregorianCalendarTest.java revision a61d31e2ee0ff49bf4d1fa7150f605bae836728b
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 dalvik.annotation.AndroidOnly; 21import dalvik.annotation.TestTargetNew; 22import dalvik.annotation.TestLevel; 23import dalvik.annotation.TestTargetClass; 24import dalvik.annotation.KnownFailure; 25 26import java.util.BitSet; 27import java.util.Calendar; 28import java.util.Date; 29import java.util.GregorianCalendar; 30import java.util.Locale; 31import java.util.SimpleTimeZone; 32import java.util.TimeZone; 33import java.util.Vector; 34 35 36@TestTargetClass(GregorianCalendar.class) 37public class GregorianCalendarTest extends junit.framework.TestCase { 38 39 /** 40 * @tests java.util.GregorianCalendar#GregorianCalendar() 41 */ 42 @TestTargetNew( 43 level = TestLevel.COMPLETE, 44 notes = "", 45 method = "GregorianCalendar", 46 args = {} 47 ) 48 public void test_Constructor() { 49 // Test for method java.util.GregorianCalendar() 50 assertTrue("Constructed incorrect calendar", (new GregorianCalendar() 51 .isLenient())); 52 } 53 54 /** 55 * @tests java.util.GregorianCalendar#GregorianCalendar(int, int, int) 56 */ 57 @TestTargetNew( 58 level = TestLevel.COMPLETE, 59 notes = "", 60 method = "GregorianCalendar", 61 args = {int.class, int.class, int.class} 62 ) 63 public void test_ConstructorIII() { 64 // Test for method java.util.GregorianCalendar(int, int, int) 65 GregorianCalendar gc = new GregorianCalendar(1972, Calendar.OCTOBER, 13); 66 assertEquals("Incorrect calendar constructed 1", 67 1972, gc.get(Calendar.YEAR)); 68 assertTrue("Incorrect calendar constructed 2", 69 gc.get(Calendar.MONTH) == Calendar.OCTOBER); 70 assertEquals("Incorrect calendar constructed 3", 13, gc 71 .get(Calendar.DAY_OF_MONTH)); 72 assertTrue("Incorrect calendar constructed 4", gc.getTimeZone().equals( 73 TimeZone.getDefault())); 74 } 75 76 /** 77 * @tests java.util.GregorianCalendar#GregorianCalendar(int, int, int, int, 78 * int) 79 */ 80 @TestTargetNew( 81 level = TestLevel.COMPLETE, 82 notes = "", 83 method = "GregorianCalendar", 84 args = {int.class, int.class, int.class, int.class, int.class} 85 ) 86 public void test_ConstructorIIIII() { 87 // Test for method java.util.GregorianCalendar(int, int, int, int, int) 88 GregorianCalendar gc = new GregorianCalendar(1972, Calendar.OCTOBER, 89 13, 19, 9); 90 assertEquals("Incorrect calendar constructed", 91 1972, gc.get(Calendar.YEAR)); 92 assertTrue("Incorrect calendar constructed", 93 gc.get(Calendar.MONTH) == Calendar.OCTOBER); 94 assertEquals("Incorrect calendar constructed", 13, gc 95 .get(Calendar.DAY_OF_MONTH)); 96 assertEquals("Incorrect calendar constructed", 7, gc.get(Calendar.HOUR)); 97 assertEquals("Incorrect calendar constructed", 98 1, gc.get(Calendar.AM_PM)); 99 assertEquals("Incorrect calendar constructed", 100 9, gc.get(Calendar.MINUTE)); 101 assertTrue("Incorrect calendar constructed", gc.getTimeZone().equals( 102 TimeZone.getDefault())); 103 104 //Regression for HARMONY-998 105 gc = new GregorianCalendar(1900, 0, 0, 0, Integer.MAX_VALUE); 106 assertEquals("Incorrect calendar constructed", 107 5983, gc.get(Calendar.YEAR)); 108 } 109 110 /** 111 * @tests java.util.GregorianCalendar#GregorianCalendar(int, int, int, int, 112 * int, int) 113 */ 114 @TestTargetNew( 115 level = TestLevel.COMPLETE, 116 notes = "", 117 method = "GregorianCalendar", 118 args = {int.class, int.class, int.class, int.class, int.class, int.class} 119 ) 120 public void test_ConstructorIIIIII() { 121 // Test for method java.util.GregorianCalendar(int, int, int, int, int, 122 // int) 123 GregorianCalendar gc = new GregorianCalendar(1972, Calendar.OCTOBER, 124 13, 19, 9, 59); 125 assertEquals("Incorrect calendar constructed", 126 1972, gc.get(Calendar.YEAR)); 127 assertTrue("Incorrect calendar constructed", 128 gc.get(Calendar.MONTH) == Calendar.OCTOBER); 129 assertEquals("Incorrect calendar constructed", 13, gc 130 .get(Calendar.DAY_OF_MONTH)); 131 assertEquals("Incorrect calendar constructed", 7, gc.get(Calendar.HOUR)); 132 assertEquals("Incorrect calendar constructed", 133 1, gc.get(Calendar.AM_PM)); 134 assertEquals("Incorrect calendar constructed", 135 9, gc.get(Calendar.MINUTE)); 136 assertEquals("Incorrect calendar constructed", 137 59, gc.get(Calendar.SECOND)); 138 assertTrue("Incorrect calendar constructed", gc.getTimeZone().equals( 139 TimeZone.getDefault())); 140 } 141 142 /** 143 * @tests java.util.GregorianCalendar#GregorianCalendar(java.util.Locale) 144 */ 145 @TestTargetNew( 146 level = TestLevel.COMPLETE, 147 notes = "", 148 method = "GregorianCalendar", 149 args = {java.util.Locale.class} 150 ) 151 public void test_ConstructorLjava_util_Locale() { 152 // Test for method java.util.GregorianCalendar(java.util.Locale) 153 Date date = new Date(); 154 GregorianCalendar gcUS = new GregorianCalendar(Locale.US); 155 gcUS.setTime(date); 156 GregorianCalendar gcUS2 = new GregorianCalendar(Locale.US); 157 gcUS2.setTime(date); 158 GregorianCalendar gcFrance = new GregorianCalendar(Locale.FRANCE); 159 gcFrance.setTime(date); 160 assertTrue("Locales not created correctly", gcUS.equals(gcUS2)); 161 assertFalse("Locales not created correctly", gcUS.equals(gcFrance)); 162 } 163 164 /** 165 * @tests java.util.GregorianCalendar#GregorianCalendar(java.util.TimeZone) 166 */ 167 @TestTargetNew( 168 level = TestLevel.COMPLETE, 169 notes = "", 170 method = "GregorianCalendar", 171 args = {java.util.TimeZone.class} 172 ) 173 public void test_ConstructorLjava_util_TimeZone() { 174 // Test for method java.util.GregorianCalendar(java.util.TimeZone) 175 Date date = new Date(); 176 TimeZone.getDefault(); 177 GregorianCalendar gc1 = new GregorianCalendar(TimeZone 178 .getTimeZone("EST")); 179 gc1.setTime(date); 180 GregorianCalendar gc2 = new GregorianCalendar(TimeZone 181 .getTimeZone("CST")); 182 gc2.setTime(date); 183 184 assertFalse(gc1.equals(gc2)); 185 186 gc1 = new GregorianCalendar(TimeZone 187 .getTimeZone("GMT+2")); 188 gc1.setTime(date); 189 gc2 = new GregorianCalendar(TimeZone 190 .getTimeZone("GMT+1")); 191 gc2.setTime(date); 192 assertTrue("Incorrect calendar returned", 193 gc1.get(Calendar.HOUR) == ((gc2.get(Calendar.HOUR) + 1) % 12)); 194 195 // Regression test for HARMONY-2961 196 SimpleTimeZone timezone = new SimpleTimeZone(-3600 * 24 * 1000 * 2, 197 "GMT"); 198 GregorianCalendar gc = new GregorianCalendar(timezone); 199 } 200 201 /** 202 * @tests java.util.GregorianCalendar#GregorianCalendar(java.util.TimeZone, 203 * java.util.Locale) 204 */ 205 @TestTargetNew( 206 level = TestLevel.COMPLETE, 207 notes = "", 208 method = "GregorianCalendar", 209 args = {java.util.TimeZone.class, java.util.Locale.class} 210 ) 211 public void test_ConstructorLjava_util_TimeZoneLjava_util_Locale() { 212 // Test for method java.util.GregorianCalendar(java.util.TimeZone, 213 // java.util.Locale) 214 Date date = new Date(); 215 TimeZone.getDefault(); 216 GregorianCalendar gc1 = new GregorianCalendar(TimeZone 217 .getTimeZone("EST"), Locale.US); 218 gc1.setTime(date); 219 GregorianCalendar gc2 = new GregorianCalendar(TimeZone 220 .getTimeZone("EST"), Locale.US); 221 gc2.setTime(date); 222 GregorianCalendar gc3 = new GregorianCalendar(TimeZone 223 .getTimeZone("CST"), Locale.FRANCE); 224 gc3.setTime(date); 225 assertTrue(gc1.equals(gc2)); 226 assertFalse(gc2.equals(gc3)); 227 assertFalse(gc3.equals(gc1)); 228 229 gc1 = new GregorianCalendar(TimeZone 230 .getTimeZone("GMT+2"), Locale.US); 231 gc1.setTime(date); 232 gc3 = new GregorianCalendar(TimeZone 233 .getTimeZone("GMT+1"), Locale.FRANCE); 234 gc3.setTime(date); 235 // CST is 1 hour before EST, add 1 to the CST time and convert to 0-12 236 // value 237 assertTrue("Incorrect calendar returned", 238 gc1.get(Calendar.HOUR) == ((gc3.get(Calendar.HOUR) + 1) % 12)); 239 } 240 241 /** 242 * @tests java.util.GregorianCalendar#add(int, int) 243 */ 244 @TestTargetNew( 245 level = TestLevel.COMPLETE, 246 notes = "", 247 method = "add", 248 args = {int.class, int.class} 249 ) 250 @AndroidOnly("This test fails on the RI with version 1.5 but succeeds" 251 + "on the RI with version 1.6") 252 public void test_addII() { 253 // Test for method void java.util.GregorianCalendar.add(int, int) 254 GregorianCalendar gc1 = new GregorianCalendar(1998, 11, 6); 255 gc1.add(GregorianCalendar.YEAR, 1); 256 assertEquals("Add failed to Increment", 257 1999, gc1.get(GregorianCalendar.YEAR)); 258 259 gc1 = new GregorianCalendar(1999, Calendar.JULY, 31); 260 gc1.add(Calendar.MONTH, 7); 261 assertEquals("Wrong result year 1", 2000, gc1.get(Calendar.YEAR)); 262 assertTrue("Wrong result month 1", 263 gc1.get(Calendar.MONTH) == Calendar.FEBRUARY); 264 assertEquals("Wrong result date 1", 29, gc1.get(Calendar.DATE)); 265 266 gc1.add(Calendar.YEAR, -1); 267 assertEquals("Wrong result year 2", 1999, gc1.get(Calendar.YEAR)); 268 assertTrue("Wrong result month 2", 269 gc1.get(Calendar.MONTH) == Calendar.FEBRUARY); 270 assertEquals("Wrong result date 2", 28, gc1.get(Calendar.DATE)); 271 272 gc1 = new GregorianCalendar(TimeZone.getTimeZone("EST")); 273 gc1.set(1999, Calendar.APRIL, 3, 16, 0); // day before DST change 274 gc1.add(Calendar.MILLISECOND, 24 * 60 * 60 * 1000); 275 276 assertEquals("Wrong time after MILLISECOND change", 16, gc1 277 .get(Calendar.HOUR_OF_DAY)); 278 gc1.set(1999, Calendar.APRIL, 3, 16, 0); // day before DST change 279 gc1.add(Calendar.SECOND, 24 * 60 * 60); 280 assertEquals("Wrong time after SECOND change", 16, gc1 281 .get(Calendar.HOUR_OF_DAY)); 282 gc1.set(1999, Calendar.APRIL, 3, 16, 0); // day before DST change 283 gc1.add(Calendar.MINUTE, 24 * 60); 284 assertEquals("Wrong time after MINUTE change", 16, gc1 285 .get(Calendar.HOUR_OF_DAY)); 286 gc1.set(1999, Calendar.APRIL, 3, 16, 0); // day before DST change 287 gc1.add(Calendar.HOUR, 24); 288 assertEquals("Wrong time after HOUR change", 16, gc1 289 .get(Calendar.HOUR_OF_DAY)); 290 gc1.set(1999, Calendar.APRIL, 3, 16, 0); // day before DST change 291 gc1.add(Calendar.HOUR_OF_DAY, 24); 292 assertEquals("Wrong time after HOUR_OF_DAY change", 16, gc1 293 .get(Calendar.HOUR_OF_DAY)); 294 295 gc1.set(1999, Calendar.APRIL, 3, 16, 0); // day before DST change 296 gc1.add(Calendar.AM_PM, 2); 297 assertEquals("Wrong time after AM_PM change", 16, gc1 298 .get(Calendar.HOUR_OF_DAY)); 299 gc1.set(1999, Calendar.APRIL, 3, 16, 0); // day before DST change 300 gc1.add(Calendar.DATE, 1); 301 assertEquals("Wrong time after DATE change", 16, gc1 302 .get(Calendar.HOUR_OF_DAY)); 303 gc1.set(1999, Calendar.APRIL, 3, 16, 0); // day before DST change 304 gc1.add(Calendar.DAY_OF_YEAR, 1); 305 assertEquals("Wrong time after DAY_OF_YEAR change", 16, gc1 306 .get(Calendar.HOUR_OF_DAY)); 307 gc1.set(1999, Calendar.APRIL, 3, 16, 0); // day before DST change 308 gc1.add(Calendar.DAY_OF_WEEK, 1); 309 assertEquals("Wrong time after DAY_OF_WEEK change", 16, gc1 310 .get(Calendar.HOUR_OF_DAY)); 311 gc1.set(1999, Calendar.APRIL, 3, 16, 0); // day before DST change 312 gc1.add(Calendar.WEEK_OF_YEAR, 1); 313 assertEquals("Wrong time after WEEK_OF_YEAR change", 16, gc1 314 .get(Calendar.HOUR_OF_DAY)); 315 gc1.set(1999, Calendar.APRIL, 3, 16, 0); // day before DST change 316 gc1.add(Calendar.WEEK_OF_MONTH, 1); 317 assertEquals("Wrong time after WEEK_OF_MONTH change", 16, gc1 318 .get(Calendar.HOUR_OF_DAY)); 319 gc1.set(1999, Calendar.APRIL, 3, 16, 0); // day before DST change 320 gc1.add(Calendar.DAY_OF_WEEK_IN_MONTH, 1); 321 assertEquals("Wrong time after DAY_OF_WEEK_IN_MONTH change", 16, gc1 322 .get(Calendar.HOUR_OF_DAY)); 323 324 gc1.clear(); 325 gc1.set(2000, Calendar.APRIL, 1, 23, 0); 326 gc1.add(Calendar.DATE, 1); 327 assertTrue("Wrong time after DATE change near DST boundary", gc1 328 .get(Calendar.MONTH) == Calendar.APRIL 329 && gc1.get(Calendar.DATE) == 2 330 && gc1.get(Calendar.HOUR_OF_DAY) == 23); 331 } 332 333 /** 334 * @tests java.util.GregorianCalendar#equals(java.lang.Object) 335 */ 336 @TestTargetNew( 337 level = TestLevel.COMPLETE, 338 notes = "", 339 method = "equals", 340 args = {java.lang.Object.class} 341 ) 342 public void test_equalsLjava_lang_Object() { 343 // Test for method boolean 344 // java.util.GregorianCalendar.equals(java.lang.Object) 345 GregorianCalendar gc1 = new GregorianCalendar(1998, 11, 6); 346 GregorianCalendar gc2 = new GregorianCalendar(2000, 11, 6); 347 GregorianCalendar gc3 = new GregorianCalendar(1998, 11, 6); 348 assertTrue("Equality check failed", gc1.equals(gc3)); 349 assertTrue("Equality check failed", !gc1.equals(gc2)); 350 gc3.setGregorianChange(new Date()); 351 assertTrue("Different gregorian change", !gc1.equals(gc3)); 352 } 353 354 /** 355 * @tests java.util.GregorianCalendar#getActualMaximum(int) 356 */ 357 @TestTargetNew( 358 level = TestLevel.COMPLETE, 359 notes = "", 360 method = "getActualMaximum", 361 args = {int.class} 362 ) 363 public void test_getActualMaximumI() { 364 // Test for method int java.util.GregorianCalendar.getActualMaximum(int) 365 GregorianCalendar gc1 = new GregorianCalendar(1900, 1, 1); 366 GregorianCalendar gc2 = new GregorianCalendar(1996, 1, 1); 367 GregorianCalendar gc3 = new GregorianCalendar(1997, 1, 1); 368 GregorianCalendar gc4 = new GregorianCalendar(2000, 1, 1); 369 GregorianCalendar gc5 = new GregorianCalendar(2000, 9, 9); 370 GregorianCalendar gc6 = new GregorianCalendar(2000, 3, 3); 371 assertEquals("Wrong actual maximum value for DAY_OF_MONTH for Feb 1900", 372 28, gc1.getActualMaximum(Calendar.DAY_OF_MONTH)); 373 assertEquals("Wrong actual maximum value for DAY_OF_MONTH for Feb 1996", 374 29, gc2.getActualMaximum(Calendar.DAY_OF_MONTH)); 375 assertEquals("Wrong actual maximum value for DAY_OF_MONTH for Feb 1998", 376 28, gc3.getActualMaximum(Calendar.DAY_OF_MONTH)); 377 assertEquals("Wrong actual maximum value for DAY_OF_MONTH for Feb 2000", 378 29, gc4.getActualMaximum(Calendar.DAY_OF_MONTH)); 379 assertEquals("Wrong actual maximum value for DAY_OF_MONTH for Oct 2000", 380 31, gc5.getActualMaximum(Calendar.DAY_OF_MONTH)); 381 assertEquals("Wrong actual maximum value for DAY_OF_MONTH for Apr 2000", 382 30, gc6.getActualMaximum(Calendar.DAY_OF_MONTH)); 383 assertTrue("Wrong actual maximum value for MONTH", gc1 384 .getActualMaximum(Calendar.MONTH) == Calendar.DECEMBER); 385 assertEquals("Wrong actual maximum value for HOUR_OF_DAY", 23, gc1 386 .getActualMaximum(Calendar.HOUR_OF_DAY)); 387 assertEquals("Wrong actual maximum value for HOUR", 11, gc1 388 .getActualMaximum(Calendar.HOUR)); 389 assertEquals("Wrong actual maximum value for DAY_OF_WEEK_IN_MONTH", 4, gc6 390 .getActualMaximum(Calendar.DAY_OF_WEEK_IN_MONTH)); 391 392 393 // Regression test for harmony 2954 394 Date date = new Date(Date.parse("Jan 15 00:00:01 GMT 2000")); 395 GregorianCalendar gc = new GregorianCalendar(); 396 gc.setTimeInMillis(Date.parse("Dec 15 00:00:01 GMT 1582")); 397 assertEquals(355, gc.getActualMaximum(Calendar.DAY_OF_YEAR)); 398 gc.setGregorianChange(date); 399 gc.setTimeInMillis(Date.parse("Jan 16 00:00:01 GMT 2000")); 400 assertEquals(353, gc.getActualMaximum(Calendar.DAY_OF_YEAR)); 401 402 //Regression test for HARMONY-3004 403 gc = new GregorianCalendar(1900, 7, 1); 404 String[] ids = TimeZone.getAvailableIDs(); 405 for (int i = 0; i < ids.length; i++) { 406 TimeZone tz = TimeZone.getTimeZone(ids[i]); 407 gc.setTimeZone(tz); 408 for (int j = 1900; j < 2000; j++) { 409 gc.set(Calendar.YEAR, j); 410 assertEquals(7200000, gc.getActualMaximum(Calendar.DST_OFFSET)); 411 } 412 } 413 } 414 415 /** 416 * @tests java.util.GregorianCalendar#getActualMinimum(int) 417 */ 418 @TestTargetNew( 419 level = TestLevel.COMPLETE, 420 notes = "", 421 method = "getActualMinimum", 422 args = {int.class} 423 ) 424 public void test_getActualMinimumI() { 425 // Test for method int java.util.GregorianCalendar.getActualMinimum(int) 426 GregorianCalendar gc1 = new GregorianCalendar(1900, 1, 1); 427 new GregorianCalendar(1996, 1, 1); 428 new GregorianCalendar(1997, 1, 1); 429 new GregorianCalendar(2000, 1, 1); 430 new GregorianCalendar(2000, 9, 9); 431 GregorianCalendar gc6 = new GregorianCalendar(2000, 3, 3); 432 assertEquals("Wrong actual minimum value for DAY_OF_MONTH for Feb 1900", 433 1, gc1.getActualMinimum(Calendar.DAY_OF_MONTH)); 434 assertTrue("Wrong actual minimum value for MONTH", gc1 435 .getActualMinimum(Calendar.MONTH) == Calendar.JANUARY); 436 assertEquals("Wrong actual minimum value for HOUR_OF_DAY", 0, gc1 437 .getActualMinimum(Calendar.HOUR_OF_DAY)); 438 assertEquals("Wrong actual minimum value for HOUR", 0, gc1 439 .getActualMinimum(Calendar.HOUR)); 440 assertEquals("Wrong actual minimum value for DAY_OF_WEEK_IN_MONTH", 1, gc6 441 .getActualMinimum(Calendar.DAY_OF_WEEK_IN_MONTH)); 442 } 443 444 /** 445 * @tests java.util.GregorianCalendar#getGreatestMinimum(int) 446 */ 447 @TestTargetNew( 448 level = TestLevel.COMPLETE, 449 notes = "", 450 method = "getGreatestMinimum", 451 args = {int.class} 452 ) 453 public void test_getGreatestMinimumI() { 454 // Test for method int 455 // java.util.GregorianCalendar.getGreatestMinimum(int) 456 GregorianCalendar gc = new GregorianCalendar(); 457 assertEquals("Wrong greatest minimum value for DAY_OF_MONTH", 1, gc 458 .getGreatestMinimum(Calendar.DAY_OF_MONTH)); 459 assertTrue("Wrong greatest minimum value for MONTH", gc 460 .getGreatestMinimum(Calendar.MONTH) == Calendar.JANUARY); 461 assertEquals("Wrong greatest minimum value for HOUR_OF_DAY", 0, gc 462 .getGreatestMinimum(Calendar.HOUR_OF_DAY)); 463 assertEquals("Wrong greatest minimum value for HOUR", 0, gc 464 .getGreatestMinimum(Calendar.HOUR)); 465 466 BitSet result = new BitSet(); 467 int[] min = { 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, -46800000, 468 0 }; 469 for (int i = 0; i < min.length; i++) { 470 if (gc.getGreatestMinimum(i) != min[i]) 471 result.set(i); 472 } 473 assertTrue("Wrong greatest min for " + result, result.length() == 0); 474 } 475 476 /** 477 * @tests java.util.GregorianCalendar#getGregorianChange() 478 */ 479 @TestTargetNew( 480 level = TestLevel.COMPLETE, 481 notes = "", 482 method = "getGregorianChange", 483 args = {} 484 ) 485 public void test_getGregorianChange() { 486 // Test for method java.util.Date 487 // java.util.GregorianCalendar.getGregorianChange() 488 GregorianCalendar gc = new GregorianCalendar(); 489 GregorianCalendar returnedChange = new GregorianCalendar(TimeZone 490 .getTimeZone("EST")); 491 returnedChange.setTime(gc.getGregorianChange()); 492 assertEquals("Returned incorrect year", 493 1582, returnedChange.get(Calendar.YEAR)); 494 assertTrue("Returned incorrect month", returnedChange 495 .get(Calendar.MONTH) == Calendar.OCTOBER); 496 assertEquals("Returned incorrect day of month", 4, returnedChange 497 .get(Calendar.DAY_OF_MONTH)); 498 } 499 500 /** 501 * @tests java.util.GregorianCalendar#getLeastMaximum(int) 502 */ 503 @TestTargetNew( 504 level = TestLevel.COMPLETE, 505 notes = "", 506 method = "getLeastMaximum", 507 args = {int.class} 508 ) 509 public void test_getLeastMaximumI() { 510 // Test for method int java.util.GregorianCalendar.getLeastMaximum(int) 511 GregorianCalendar gc = new GregorianCalendar(); 512 assertEquals("Wrong least maximum value for DAY_OF_MONTH", 28, gc 513 .getLeastMaximum(Calendar.DAY_OF_MONTH)); 514 assertTrue("Wrong least maximum value for MONTH", gc 515 .getLeastMaximum(Calendar.MONTH) == Calendar.DECEMBER); 516 assertEquals("Wrong least maximum value for HOUR_OF_DAY", 23, gc 517 .getLeastMaximum(Calendar.HOUR_OF_DAY)); 518 assertEquals("Wrong least maximum value for HOUR", 11, gc 519 .getLeastMaximum(Calendar.HOUR)); 520 521 BitSet result = new BitSet(); 522 Vector values = new Vector(); 523 int[] max = { 1, 292269054, 11, 50, 3, 28, 355, 7, 3, 1, 11, 23, 59, 524 59, 999, 50400000, 1200000 }; 525 for (int i = 0; i < max.length; i++) { 526 if (gc.getLeastMaximum(i) != max[i]) { 527 result.set(i); 528 values.add(new Integer(gc.getLeastMaximum(i))); 529 } 530 } 531 assertTrue("Wrong least max for " + result + " = " + values, result 532 .length() == 0); 533 534 // Regression test for harmony-2947 535 Date date = new Date(Date.parse("Jan 1 00:00:01 GMT 2000")); 536 gc = new GregorianCalendar(); 537 gc.setGregorianChange(date); 538 gc.setTime(date); 539 assertEquals(gc.getActualMaximum(Calendar.WEEK_OF_YEAR), gc 540 .getLeastMaximum(Calendar.WEEK_OF_YEAR)); 541 } 542 543 /** 544 * @tests java.util.GregorianCalendar#getMaximum(int) 545 */ 546 @TestTargetNew( 547 level = TestLevel.COMPLETE, 548 notes = "", 549 method = "getMaximum", 550 args = {int.class} 551 ) 552 public void test_getMaximumI() { 553 // Test for method int java.util.GregorianCalendar.getMaximum(int) 554 GregorianCalendar gc = new GregorianCalendar(); 555 assertEquals("Wrong maximum value for DAY_OF_MONTH", 31, gc 556 .getMaximum(Calendar.DAY_OF_MONTH)); 557 assertTrue("Wrong maximum value for MONTH", gc 558 .getMaximum(Calendar.MONTH) == Calendar.DECEMBER); 559 assertEquals("Wrong maximum value for HOUR_OF_DAY", 23, gc 560 .getMaximum(Calendar.HOUR_OF_DAY)); 561 assertEquals("Wrong maximum value for HOUR", 562 11, gc.getMaximum(Calendar.HOUR)); 563 564 BitSet result = new BitSet(); 565 Vector values = new Vector(); 566 int[] max = { 1, 292278994, 11, 53, 6, 31, 366, 7, 6, 1, 11, 23, 59, 567 59, 999, 50400000, 7200000 }; 568 for (int i = 0; i < max.length; i++) { 569 if (gc.getMaximum(i) != max[i]) { 570 result.set(i); 571 values.add(new Integer(gc.getMaximum(i))); 572 } 573 } 574 assertTrue("Wrong max for " + result + " = " + values, 575 result.length() == 0); 576 } 577 578 /** 579 * @tests java.util.GregorianCalendar#getMinimum(int) 580 */ 581 @TestTargetNew( 582 level = TestLevel.COMPLETE, 583 notes = "", 584 method = "getMinimum", 585 args = {int.class} 586 ) 587 public void test_getMinimumI() { 588 // Test for method int java.util.GregorianCalendar.getMinimum(int) 589 GregorianCalendar gc = new GregorianCalendar(); 590 assertEquals("Wrong minimum value for DAY_OF_MONTH", 1, gc 591 .getMinimum(Calendar.DAY_OF_MONTH)); 592 assertTrue("Wrong minimum value for MONTH", gc 593 .getMinimum(Calendar.MONTH) == Calendar.JANUARY); 594 assertEquals("Wrong minimum value for HOUR_OF_DAY", 0, gc 595 .getMinimum(Calendar.HOUR_OF_DAY)); 596 assertEquals("Wrong minimum value for HOUR", 597 0, gc.getMinimum(Calendar.HOUR)); 598 599 BitSet result = new BitSet(); 600 int[] min = { 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, -46800000, 601 0 }; 602 for (int i = 0; i < min.length; i++) { 603 if (gc.getMinimum(i) != min[i]) 604 result.set(i); 605 } 606 assertTrue("Wrong min for " + result, result.length() == 0); 607 } 608 609 /** 610 * @tests java.util.GregorianCalendar#isLeapYear(int) 611 */ 612 @TestTargetNew( 613 level = TestLevel.COMPLETE, 614 notes = "", 615 method = "isLeapYear", 616 args = {int.class} 617 ) 618 public void test_isLeapYearI() { 619 // Test for method boolean java.util.GregorianCalendar.isLeapYear(int) 620 GregorianCalendar gc = new GregorianCalendar(1998, 11, 6); 621 assertTrue("Returned incorrect value for leap year", !gc 622 .isLeapYear(1998)); 623 assertTrue("Returned incorrect value for leap year", gc 624 .isLeapYear(2000)); 625 626 } 627 628 /** 629 * @tests java.util.GregorianCalendar#roll(int, int) 630 */ 631 @TestTargetNew( 632 level = TestLevel.COMPLETE, 633 notes = "", 634 method = "roll", 635 args = {int.class, int.class} 636 ) 637 public void test_rollII() { 638 // Test for method void java.util.GregorianCalendar.roll(int, int) 639 GregorianCalendar gc = new GregorianCalendar(1972, Calendar.OCTOBER, 8, 640 2, 5, 0); 641 gc.roll(Calendar.DAY_OF_MONTH, -1); 642 assertTrue("Failed to roll DAY_OF_MONTH down by 1", gc 643 .equals(new GregorianCalendar(1972, Calendar.OCTOBER, 7, 2, 5, 644 0))); 645 gc = new GregorianCalendar(1972, Calendar.OCTOBER, 8, 2, 5, 0); 646 gc.roll(Calendar.DAY_OF_MONTH, 25); 647 assertTrue("Failed to roll DAY_OF_MONTH up by 25", gc 648 .equals(new GregorianCalendar(1972, Calendar.OCTOBER, 2, 2, 5, 649 0))); 650 gc = new GregorianCalendar(1972, Calendar.OCTOBER, 8, 2, 5, 0); 651 gc.roll(Calendar.DAY_OF_MONTH, -10); 652 assertTrue("Failed to roll DAY_OF_MONTH down by 10", gc 653 .equals(new GregorianCalendar(1972, Calendar.OCTOBER, 29, 2, 5, 654 0))); 655 } 656 657 /** 658 * @tests java.util.GregorianCalendar#roll(int, boolean) 659 */ 660 @TestTargetNew( 661 level = TestLevel.COMPLETE, 662 notes = "", 663 method = "roll", 664 args = {int.class, boolean.class} 665 ) 666 public void test_rollIZ() { 667 // Test for method void java.util.GregorianCalendar.roll(int, boolean) 668 GregorianCalendar gc = new GregorianCalendar(1972, Calendar.OCTOBER, 669 13, 19, 9, 59); 670 gc.roll(Calendar.DAY_OF_MONTH, false); 671 assertTrue("Failed to roll day_of_month down", gc 672 .equals(new GregorianCalendar(1972, Calendar.OCTOBER, 12, 19, 673 9, 59))); 674 gc = new GregorianCalendar(1972, Calendar.OCTOBER, 13, 19, 9, 59); 675 gc.roll(Calendar.DAY_OF_MONTH, true); 676 assertTrue("Failed to roll day_of_month up", gc 677 .equals(new GregorianCalendar(1972, Calendar.OCTOBER, 14, 19, 678 9, 59))); 679 gc = new GregorianCalendar(1972, Calendar.OCTOBER, 31, 19, 9, 59); 680 gc.roll(Calendar.DAY_OF_MONTH, true); 681 assertTrue("Failed to roll day_of_month up", gc 682 .equals(new GregorianCalendar(1972, Calendar.OCTOBER, 1, 19, 9, 683 59))); 684 685 GregorianCalendar cal = new GregorianCalendar(); 686 int result; 687 try { 688 cal.roll(Calendar.ZONE_OFFSET, true); 689 result = 0; 690 } catch (IllegalArgumentException e) { 691 result = 1; 692 } 693 assertEquals("ZONE_OFFSET roll", 1, result); 694 try { 695 cal.roll(Calendar.DST_OFFSET, true); 696 result = 0; 697 } catch (IllegalArgumentException e) { 698 result = 1; 699 } 700 assertEquals("ZONE_OFFSET roll", 1, result); 701 702 cal.set(2004, Calendar.DECEMBER, 31, 5, 0, 0); 703 cal.roll(Calendar.WEEK_OF_YEAR, true); 704 assertTrue("Wrong year: " + cal.getTime(), 705 cal.get(Calendar.YEAR) == 2004); 706 assertTrue("Wrong month: " + cal.getTime(), 707 cal.get(Calendar.MONTH) == Calendar.JANUARY); 708 assertTrue("Wrong date: " + cal.getTime(), cal.get(Calendar.DATE) == 9); 709 } 710 711 /** 712 * @tests java.util.GregorianCalendar#setGregorianChange(java.util.Date) 713 */ 714 @TestTargetNew( 715 level = TestLevel.COMPLETE, 716 notes = "", 717 method = "setGregorianChange", 718 args = {java.util.Date.class} 719 ) 720 public void test_setGregorianChangeLjava_util_Date() { 721 // Test for method void 722 // java.util.GregorianCalendar.setGregorianChange(java.util.Date) 723 GregorianCalendar gc1 = new GregorianCalendar(1582, Calendar.OCTOBER, 724 4, 0, 0); 725 GregorianCalendar gc2 = new GregorianCalendar(1972, Calendar.OCTOBER, 726 13, 0, 0); 727 gc1.setGregorianChange(gc2.getTime()); 728 assertTrue("Returned incorrect value", gc2.getTime().equals( 729 gc1.getGregorianChange())); 730 } 731 732 /** 733 * @tests java.util.GregorianCalendar#clone() 734 */ 735 @TestTargetNew( 736 level = TestLevel.COMPLETE, 737 notes = "", 738 method = "clone", 739 args = {} 740 ) 741 public void test_clone() { 742 743 // Regression for HARMONY-498 744 GregorianCalendar gCalend = new GregorianCalendar(); 745 746 gCalend.set(Calendar.MILLISECOND, 0); 747 int dayOfMonth = gCalend.get(Calendar.DAY_OF_MONTH); 748 749 // create clone object and change date 750 GregorianCalendar gCalendClone = (GregorianCalendar) gCalend.clone(); 751 gCalendClone.add(Calendar.DATE, 1); 752 753 assertEquals("Before", dayOfMonth, gCalend.get(Calendar.DAY_OF_MONTH)); 754 gCalend.set(Calendar.MILLISECOND, 0);//changes nothing 755 assertEquals("After", dayOfMonth, gCalend.get(Calendar.DAY_OF_MONTH)); 756 } 757 758 /** 759 * @tests java.util.GregorianCalendar#getMinimalDaysInFirstWeek() 760 */ 761 @TestTargetNew( 762 level = TestLevel.COMPLETE, 763 notes = "", 764 method = "getMinimalDaysInFirstWeek", 765 args = {} 766 ) 767 @KnownFailure("Some difference in timezones and/or locales data" 768 + "Who is right, the CLDR or the RI?") 769 public void test_getMinimalDaysInFirstWeek() { 770 // Regression for Harmony-1037 771 GregorianCalendar g = new GregorianCalendar(TimeZone 772 .getTimeZone("Paris/France"), new Locale("en", "GB")); 773 int minimalDaysInFirstWeek = g.getMinimalDaysInFirstWeek(); 774 assertEquals(4, minimalDaysInFirstWeek); 775 776 g = new GregorianCalendar(TimeZone.getTimeZone("Paris/France"), 777 new Locale("fr", "FR")); 778 minimalDaysInFirstWeek = g.getMinimalDaysInFirstWeek(); 779 assertEquals(4, minimalDaysInFirstWeek); 780 781 g = new GregorianCalendar(TimeZone.getTimeZone("Europe/London"), 782 new Locale("fr", "CA")); 783 minimalDaysInFirstWeek = g.getMinimalDaysInFirstWeek(); 784 assertEquals(1, minimalDaysInFirstWeek); 785 } 786 787 /** 788 * @tests java.util.GregorianCalendar#computeTime() 789 */ 790 @TestTargetNew( 791 level = TestLevel.COMPLETE, 792 notes = "Checks computeTime indirectly.", 793 method = "computeTime", 794 args = {} 795 ) 796 public void test_computeTime() { 797 798 // Regression for Harmony-493 799 GregorianCalendar g = new GregorianCalendar( 800 TimeZone.getTimeZone("Europe/London"), 801 new Locale("en", "GB") 802 ); 803 g.clear(); 804 g.set(2006, 02, 26, 01, 50, 00); 805 assertEquals(1143337800000L, g.getTimeInMillis()); 806 807 GregorianCalendar g1 = new GregorianCalendar( 808 TimeZone.getTimeZone("Europe/Moscow") 809 ); 810 g1.clear(); 811 g1.set(2006, 02, 26, 02, 20, 00); // in the DST transition interval 812 assertEquals(1143328800000L, g1.getTimeInMillis()); 813 assertEquals(3, g1.get(Calendar.HOUR_OF_DAY)); 814 g1.clear(); 815 g1.set(2006, 9, 29, 02, 50, 00); // transition from DST 816 assertEquals(1162079400000L, g1.getTimeInMillis()); 817 assertEquals(2, g1.get(Calendar.HOUR_OF_DAY)); 818 // End of regression test 819 820 g1.set(2006, -9, 29, 02, 50, 00); // transition from DST 821 g1.setLenient(false); 822 823 try { 824 g1.getTimeInMillis(); 825 fail("IllegalArgumentException expected"); 826 } catch (IllegalArgumentException e) { 827 //expected 828 } 829 } 830 831 @TestTargetNew( 832 level = TestLevel.COMPLETE, 833 notes = "Checks computeFields indirectly.", 834 method = "computeFields", 835 args = {} 836 ) 837 public void test_computeFields() { 838 GregorianCalendar g = new GregorianCalendar( 839 TimeZone.getTimeZone("Europe/London"), 840 new Locale("en", "GB") 841 ); 842 g.clear(); 843 g.setTimeInMillis(1222185600225L); 844 assertEquals(1, g.get(Calendar.ERA)); 845 assertEquals(2008, g.get(Calendar.YEAR)); 846 assertEquals(Calendar.SEPTEMBER, g.get(Calendar.MONTH)); 847 assertEquals(23, g.get(Calendar.DAY_OF_MONTH)); 848 assertEquals(17, g.get(Calendar.HOUR_OF_DAY)); 849 assertEquals(0, g.get(Calendar.MINUTE)); 850 } 851 852 /** 853 * @tests java.util.GregorianCalendar#get(int) 854 */ 855 @TestTargetNew( 856 level = TestLevel.PARTIAL_COMPLETE, 857 notes = "Doesn't verify ArrayIndexOutOfBoundsException.", 858 method = "get", 859 args = {int.class} 860 ) 861 @SuppressWarnings("deprecation") 862 public void test_getI() { 863 // Regression test for HARMONY-2959 864 Date date = new Date(Date.parse("Jan 15 00:00:01 GMT 2000")); 865 GregorianCalendar gc = new GregorianCalendar(TimeZone.getTimeZone("GMT")); 866 gc.setGregorianChange(date); 867 gc.setTimeInMillis(Date.parse("Dec 24 00:00:01 GMT 2000")); 868 assertEquals(346, gc.get(Calendar.DAY_OF_YEAR)); 869 870 // Regression test for HARMONY-3003 871 date = new Date(Date.parse("Feb 28 00:00:01 GMT 2000")); 872 gc = new GregorianCalendar(TimeZone.getTimeZone("GMT")); 873 gc.setGregorianChange(date); 874 gc.setTimeInMillis(Date.parse("Dec 1 00:00:01 GMT 2000")); 875 assertEquals(1, gc.get(Calendar.DAY_OF_MONTH)); 876 assertEquals(11, gc.get(Calendar.MONTH)); 877 } 878 879 @TestTargetNew( 880 level = TestLevel.COMPLETE, 881 notes = "", 882 method = "hashCode", 883 args = {} 884 ) 885 public void test_hashCode() { 886 GregorianCalendar g = new GregorianCalendar( 887 TimeZone.getTimeZone("Europe/London"), 888 new Locale("en", "GB") 889 ); 890 g.clear(); 891 g.setTimeInMillis(1222185600225L); 892 893 GregorianCalendar g1 = new GregorianCalendar( 894 TimeZone.getTimeZone("Europe/Moscow")); 895 g1.clear(); 896 g1.set(2008, Calendar.SEPTEMBER, 23, 18, 0, 0); 897 assertNotSame(g.hashCode(), g1.hashCode()); 898 } 899 900 @TestTargetNew( 901 level = TestLevel.COMPLETE, 902 notes = "", 903 method = "setFirstDayOfWeek", 904 args = {int.class} 905 ) 906 public void test_setFirstDayOfWeekI() { 907 GregorianCalendar g = new GregorianCalendar( 908 TimeZone.getTimeZone("Europe/London"), 909 new Locale("en", "GB")); 910 911 for (int i = 0; i < 10; i++) { 912 g.setFirstDayOfWeek(i); 913 assertEquals(i, g.getFirstDayOfWeek()); 914 } 915 g.setLenient(false); 916 g.setFirstDayOfWeek(10); 917 g.setFirstDayOfWeek(-10); 918 } 919 920 @TestTargetNew( 921 level = TestLevel.COMPLETE, 922 notes = "", 923 method = "setMinimalDaysInFirstWeek", 924 args = {int.class} 925 ) 926 public void test_setMinimalDaysInFirstWeekI() { 927 GregorianCalendar g = new GregorianCalendar( 928 TimeZone.getTimeZone("Europe/London"), 929 new Locale("en", "GB")); 930 931 for (int i = 0; i < 10; i++) { 932 g.setMinimalDaysInFirstWeek(i); 933 assertEquals(i, g.getMinimalDaysInFirstWeek()); 934 } 935 g.setLenient(false); 936 g.setMinimalDaysInFirstWeek(10); 937 g.setMinimalDaysInFirstWeek(-10); 938 } 939 940 /** 941 * Sets up the fixture, for example, open a network connection. This method 942 * is called before a test is executed. 943 */ 944 protected void setUp() { 945 Locale.setDefault(Locale.US); 946 } 947 948 /** 949 * Tears down the fixture, for example, close a network connection. This 950 * method is called after a test is executed. 951 */ 952 protected void tearDown() { 953 } 954} 955