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