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