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