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