001 /* 002 * Copyright 2001-2005 Stephen Colebourne 003 * 004 * Licensed under the Apache License, Version 2.0 (the "License"); 005 * you may not use this file except in compliance with the License. 006 * You may obtain a copy of the License at 007 * 008 * http://www.apache.org/licenses/LICENSE-2.0 009 * 010 * Unless required by applicable law or agreed to in writing, software 011 * distributed under the License is distributed on an "AS IS" BASIS, 012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 013 * See the License for the specific language governing permissions and 014 * limitations under the License. 015 */ 016 package org.joda.time; 017 018 import java.io.ByteArrayInputStream; 019 import java.io.ByteArrayOutputStream; 020 import java.io.ObjectInputStream; 021 import java.io.ObjectOutputStream; 022 import java.lang.reflect.Modifier; 023 import java.util.ArrayList; 024 import java.util.Calendar; 025 import java.util.Collections; 026 import java.util.Comparator; 027 import java.util.Date; 028 import java.util.List; 029 030 import junit.framework.TestCase; 031 import junit.framework.TestSuite; 032 033 import org.joda.time.chrono.ISOChronology; 034 /** 035 * This class is a Junit unit test for the 036 * org.joda.time.DateTimeComparator class. 037 * 038 * @author Guy Allard 039 */ 040 public class TestDateTimeComparator extends TestCase { 041 042 private static final Chronology ISO = ISOChronology.getInstance(); 043 044 public static void main(String[] args) { 045 junit.textui.TestRunner.run(suite()); 046 } 047 048 public static TestSuite suite() { 049 return new TestSuite(TestDateTimeComparator.class); 050 } 051 052 public TestDateTimeComparator(String name) { 053 super(name); 054 } 055 056 /** 057 * A reference to a DateTime object. 058 */ 059 DateTime aDateTime = null; 060 /** 061 * A reference to a DateTime object. 062 */ 063 DateTime bDateTime = null; 064 /** 065 * A reference to a DateTimeComparator object 066 * (a Comparator) for millis of seconds. 067 */ 068 Comparator cMillis = null; 069 /** 070 * A reference to a DateTimeComparator object 071 * (a Comparator) for seconds. 072 */ 073 Comparator cSecond = null; 074 /** 075 * A reference to a DateTimeComparator object 076 * (a Comparator) for minutes. 077 */ 078 Comparator cMinute = null; 079 /** 080 * A reference to a DateTimeComparator object 081 * (a Comparator) for hours. 082 */ 083 Comparator cHour = null; 084 /** 085 * A reference to a DateTimeComparator object 086 * (a Comparator) for day of the week. 087 */ 088 Comparator cDayOfWeek = null; 089 /** 090 * A reference to a DateTimeComparator object 091 * (a Comparator) for day of the month. 092 */ 093 Comparator cDayOfMonth = null; 094 /** 095 * A reference to a DateTimeComparator object 096 * (a Comparator) for day of the year. 097 */ 098 Comparator cDayOfYear = null; 099 /** 100 * A reference to a DateTimeComparator object 101 * (a Comparator) for week of the weekyear. 102 */ 103 Comparator cWeekOfWeekyear = null; 104 /** 105 * A reference to a DateTimeComparator object 106 * (a Comparator) for year given a week of the year. 107 */ 108 Comparator cWeekyear = null; 109 /** 110 * A reference to a DateTimeComparator object 111 * (a Comparator) for months. 112 */ 113 Comparator cMonth = null; 114 /** 115 * A reference to a DateTimeComparator object 116 * (a Comparator) for year. 117 */ 118 Comparator cYear = null; 119 /** 120 * A reference to a DateTimeComparator object 121 * (a Comparator) for the date portion of an 122 * object. 123 */ 124 Comparator cDate = null; 125 /** 126 * A reference to a DateTimeComparator object 127 * (a Comparator) for the time portion of an 128 * object. 129 */ 130 Comparator cTime = null; 131 /** 132 * Junit <code>setUp()</code> method. 133 */ 134 public void setUp() /* throws Exception */ { 135 Chronology chrono = ISOChronology.getInstanceUTC(); 136 137 // super.setUp(); 138 // Obtain comparator's 139 cMillis = DateTimeComparator.getInstance(null, DateTimeFieldType.secondOfMinute()); 140 cSecond = DateTimeComparator.getInstance(DateTimeFieldType.secondOfMinute(), DateTimeFieldType.minuteOfHour()); 141 cMinute = DateTimeComparator.getInstance(DateTimeFieldType.minuteOfHour(), DateTimeFieldType.hourOfDay()); 142 cHour = DateTimeComparator.getInstance(DateTimeFieldType.hourOfDay(), DateTimeFieldType.dayOfYear()); 143 cDayOfWeek = DateTimeComparator.getInstance(DateTimeFieldType.dayOfWeek(), DateTimeFieldType.weekOfWeekyear()); 144 cDayOfMonth = DateTimeComparator.getInstance(DateTimeFieldType.dayOfMonth(), DateTimeFieldType.monthOfYear()); 145 cDayOfYear = DateTimeComparator.getInstance(DateTimeFieldType.dayOfYear(), DateTimeFieldType.year()); 146 cWeekOfWeekyear = DateTimeComparator.getInstance(DateTimeFieldType.weekOfWeekyear(), DateTimeFieldType.weekyear()); 147 cWeekyear = DateTimeComparator.getInstance(DateTimeFieldType.weekyear()); 148 cMonth = DateTimeComparator.getInstance(DateTimeFieldType.monthOfYear(), DateTimeFieldType.year()); 149 cYear = DateTimeComparator.getInstance(DateTimeFieldType.year()); 150 cDate = DateTimeComparator.getDateOnlyInstance(); 151 cTime = DateTimeComparator.getTimeOnlyInstance(); 152 } 153 154 /** 155 * Junit <code>tearDown()</code> method. 156 */ 157 protected void tearDown() /* throws Exception */ { 158 // super.tearDown(); 159 aDateTime = null; 160 bDateTime = null; 161 // 162 cMillis = null; 163 cSecond = null; 164 cMinute = null; 165 cHour = null; 166 cDayOfWeek = null; 167 cDayOfMonth = null; 168 cDayOfYear = null; 169 cWeekOfWeekyear = null; 170 cWeekyear = null; 171 cMonth = null; 172 cYear = null; 173 cDate = null; 174 cTime = null; 175 } 176 177 //----------------------------------------------------------------------- 178 public void testClass() { 179 assertEquals(true, Modifier.isPublic(DateTimeComparator.class.getModifiers())); 180 assertEquals(false, Modifier.isFinal(DateTimeComparator.class.getModifiers())); 181 assertEquals(1, DateTimeComparator.class.getDeclaredConstructors().length); 182 assertEquals(true, Modifier.isProtected(DateTimeComparator.class.getDeclaredConstructors()[0].getModifiers())); 183 } 184 185 //----------------------------------------------------------------------- 186 public void testStaticGetInstance() { 187 DateTimeComparator c = DateTimeComparator.getInstance(); 188 assertEquals(null, c.getLowerLimit()); 189 assertEquals(null, c.getUpperLimit()); 190 assertEquals("DateTimeComparator[]", c.toString()); 191 } 192 public void testStaticGetDateOnlyInstance() { 193 DateTimeComparator c = DateTimeComparator.getDateOnlyInstance(); 194 assertEquals(DateTimeFieldType.dayOfYear(), c.getLowerLimit()); 195 assertEquals(null, c.getUpperLimit()); 196 assertEquals("DateTimeComparator[dayOfYear-]", c.toString()); 197 198 assertSame(DateTimeComparator.getDateOnlyInstance(), DateTimeComparator.getDateOnlyInstance()); 199 } 200 public void testStaticGetTimeOnlyInstance() { 201 DateTimeComparator c = DateTimeComparator.getTimeOnlyInstance(); 202 assertEquals(null, c.getLowerLimit()); 203 assertEquals(DateTimeFieldType.dayOfYear(), c.getUpperLimit()); 204 assertEquals("DateTimeComparator[-dayOfYear]", c.toString()); 205 206 assertSame(DateTimeComparator.getTimeOnlyInstance(), DateTimeComparator.getTimeOnlyInstance()); 207 } 208 public void testStaticGetInstanceLower() { 209 DateTimeComparator c = DateTimeComparator.getInstance(DateTimeFieldType.hourOfDay()); 210 assertEquals(DateTimeFieldType.hourOfDay(), c.getLowerLimit()); 211 assertEquals(null, c.getUpperLimit()); 212 assertEquals("DateTimeComparator[hourOfDay-]", c.toString()); 213 214 c = DateTimeComparator.getInstance(null); 215 assertSame(DateTimeComparator.getInstance(), c); 216 } 217 public void testStaticGetInstanceLowerUpper() { 218 DateTimeComparator c = DateTimeComparator.getInstance(DateTimeFieldType.hourOfDay(), DateTimeFieldType.dayOfYear()); 219 assertEquals(DateTimeFieldType.hourOfDay(), c.getLowerLimit()); 220 assertEquals(DateTimeFieldType.dayOfYear(), c.getUpperLimit()); 221 assertEquals("DateTimeComparator[hourOfDay-dayOfYear]", c.toString()); 222 223 c = DateTimeComparator.getInstance(DateTimeFieldType.hourOfDay(), DateTimeFieldType.hourOfDay()); 224 assertEquals(DateTimeFieldType.hourOfDay(), c.getLowerLimit()); 225 assertEquals(DateTimeFieldType.hourOfDay(), c.getUpperLimit()); 226 assertEquals("DateTimeComparator[hourOfDay]", c.toString()); 227 228 c = DateTimeComparator.getInstance(null, null); 229 assertSame(DateTimeComparator.getInstance(), c); 230 231 c = DateTimeComparator.getInstance(DateTimeFieldType.dayOfYear(), null); 232 assertSame(DateTimeComparator.getDateOnlyInstance(), c); 233 234 c = DateTimeComparator.getInstance(null, DateTimeFieldType.dayOfYear()); 235 assertSame(DateTimeComparator.getTimeOnlyInstance(), c); 236 } 237 238 //----------------------------------------------------------------------- 239 public void testEqualsHashCode() { 240 DateTimeComparator c1 = DateTimeComparator.getInstance(); 241 assertEquals(true, c1.equals(c1)); 242 assertEquals(false, c1.equals(null)); 243 assertEquals(true, c1.hashCode() == c1.hashCode()); 244 245 DateTimeComparator c2 = DateTimeComparator.getTimeOnlyInstance(); 246 assertEquals(true, c2.equals(c2)); 247 assertEquals(false, c2.equals(c1)); 248 assertEquals(false, c1.equals(c2)); 249 assertEquals(false, c2.equals(null)); 250 assertEquals(false, c1.hashCode() == c2.hashCode()); 251 252 DateTimeComparator c3 = DateTimeComparator.getTimeOnlyInstance(); 253 assertEquals(true, c3.equals(c3)); 254 assertEquals(false, c3.equals(c1)); 255 assertEquals(true, c3.equals(c2)); 256 assertEquals(false, c1.equals(c3)); 257 assertEquals(true, c2.equals(c3)); 258 assertEquals(false, c1.hashCode() == c3.hashCode()); 259 assertEquals(true, c2.hashCode() == c3.hashCode()); 260 261 DateTimeComparator c4 = DateTimeComparator.getDateOnlyInstance(); 262 assertEquals(false, c4.hashCode() == c3.hashCode()); 263 } 264 265 //----------------------------------------------------------------------- 266 public void testSerialization1() throws Exception { 267 DateTimeField f = ISO.dayOfYear(); 268 f.toString(); 269 DateTimeComparator c = DateTimeComparator.getInstance(DateTimeFieldType.hourOfDay(), DateTimeFieldType.dayOfYear()); 270 271 ByteArrayOutputStream baos = new ByteArrayOutputStream(); 272 ObjectOutputStream oos = new ObjectOutputStream(baos); 273 oos.writeObject(c); 274 byte[] bytes = baos.toByteArray(); 275 oos.close(); 276 277 ByteArrayInputStream bais = new ByteArrayInputStream(bytes); 278 ObjectInputStream ois = new ObjectInputStream(bais); 279 DateTimeComparator result = (DateTimeComparator) ois.readObject(); 280 ois.close(); 281 282 assertEquals(c, result); 283 } 284 285 //----------------------------------------------------------------------- 286 public void testSerialization2() throws Exception { 287 DateTimeComparator c = DateTimeComparator.getInstance(); 288 289 ByteArrayOutputStream baos = new ByteArrayOutputStream(); 290 ObjectOutputStream oos = new ObjectOutputStream(baos); 291 oos.writeObject(c); 292 byte[] bytes = baos.toByteArray(); 293 oos.close(); 294 295 ByteArrayInputStream bais = new ByteArrayInputStream(bytes); 296 ObjectInputStream ois = new ObjectInputStream(bais); 297 DateTimeComparator result = (DateTimeComparator) ois.readObject(); 298 ois.close(); 299 300 assertSame(c, result); 301 } 302 303 //----------------------------------------------------------------------- 304 /** 305 * Test all basic comparator operation with DateTime objects. 306 */ 307 public void testBasicComps1() { 308 aDateTime = new DateTime( System.currentTimeMillis(), DateTimeZone.UTC ); 309 bDateTime = new DateTime( aDateTime.getMillis(), DateTimeZone.UTC ); 310 assertEquals( "getMillis", aDateTime.getMillis(), 311 bDateTime.getMillis() ); 312 assertEquals( "MILLIS", 0, cMillis.compare( aDateTime, bDateTime ) ); 313 assertEquals( "SECOND", 0, cSecond.compare( aDateTime, bDateTime ) ); 314 assertEquals( "MINUTE", 0, cMinute.compare( aDateTime, bDateTime ) ); 315 assertEquals( "HOUR", 0, cHour.compare( aDateTime, bDateTime ) ); 316 assertEquals( "DOW", 0, cDayOfWeek.compare( aDateTime, bDateTime ) ); 317 assertEquals( "DOM", 0, cDayOfMonth.compare( aDateTime, bDateTime ) ); 318 assertEquals( "DOY", 0, cDayOfYear.compare( aDateTime, bDateTime ) ); 319 assertEquals( "WOW", 0, cWeekOfWeekyear.compare( aDateTime, bDateTime ) ); 320 assertEquals( "WY", 0, cWeekyear.compare( aDateTime, bDateTime ) ); 321 assertEquals( "MONTH", 0, cMonth.compare( aDateTime, bDateTime ) ); 322 assertEquals( "YEAR", 0, cYear.compare( aDateTime, bDateTime ) ); 323 assertEquals( "DATE", 0, cDate.compare( aDateTime, bDateTime ) ); 324 assertEquals( "TIME", 0, cTime.compare( aDateTime, bDateTime ) ); 325 } // end of testBasicComps 326 327 328 /** 329 * Test all basic comparator operation with ReadableInstant objects. 330 */ 331 public void testBasicComps2() { 332 ReadableInstant aDateTime = new DateTime( System.currentTimeMillis(), DateTimeZone.UTC ); 333 ReadableInstant bDateTime = new DateTime( aDateTime.getMillis(), DateTimeZone.UTC ); 334 assertEquals( "getMillis", aDateTime.getMillis(), 335 bDateTime.getMillis() ); 336 assertEquals( "MILLIS", 0, cMillis.compare( aDateTime, bDateTime ) ); 337 assertEquals( "SECOND", 0, cSecond.compare( aDateTime, bDateTime ) ); 338 assertEquals( "MINUTE", 0, cMinute.compare( aDateTime, bDateTime ) ); 339 assertEquals( "HOUR", 0, cHour.compare( aDateTime, bDateTime ) ); 340 assertEquals( "DOW", 0, cDayOfWeek.compare( aDateTime, bDateTime ) ); 341 assertEquals( "DOM", 0, cDayOfMonth.compare( aDateTime, bDateTime ) ); 342 assertEquals( "DOY", 0, cDayOfYear.compare( aDateTime, bDateTime ) ); 343 assertEquals( "WOW", 0, cWeekOfWeekyear.compare( aDateTime, bDateTime ) ); 344 assertEquals( "WY", 0, cWeekyear.compare( aDateTime, bDateTime ) ); 345 assertEquals( "MONTH", 0, cMonth.compare( aDateTime, bDateTime ) ); 346 assertEquals( "YEAR", 0, cYear.compare( aDateTime, bDateTime ) ); 347 assertEquals( "DATE", 0, cDate.compare( aDateTime, bDateTime ) ); 348 assertEquals( "TIME", 0, cTime.compare( aDateTime, bDateTime ) ); 349 } // end of testBasicComps 350 351 /** 352 * Test all basic comparator operation with java Date objects. 353 */ 354 public void testBasicComps3() { 355 Date aDateTime 356 = new Date( System.currentTimeMillis() ); 357 Date bDateTime 358 = new Date( aDateTime.getTime() ); 359 assertEquals( "MILLIS", 0, cMillis.compare( aDateTime, bDateTime ) ); 360 assertEquals( "SECOND", 0, cSecond.compare( aDateTime, bDateTime ) ); 361 assertEquals( "MINUTE", 0, cMinute.compare( aDateTime, bDateTime ) ); 362 assertEquals( "HOUR", 0, cHour.compare( aDateTime, bDateTime ) ); 363 assertEquals( "DOW", 0, cDayOfWeek.compare( aDateTime, bDateTime ) ); 364 assertEquals( "DOM", 0, cDayOfMonth.compare( aDateTime, bDateTime ) ); 365 assertEquals( "DOY", 0, cDayOfYear.compare( aDateTime, bDateTime ) ); 366 assertEquals( "WOW", 0, cWeekOfWeekyear.compare( aDateTime, bDateTime ) ); 367 assertEquals( "WY", 0, cWeekyear.compare( aDateTime, bDateTime ) ); 368 assertEquals( "MONTH", 0, cMonth.compare( aDateTime, bDateTime ) ); 369 assertEquals( "YEAR", 0, cYear.compare( aDateTime, bDateTime ) ); 370 assertEquals( "DATE", 0, cDate.compare( aDateTime, bDateTime ) ); 371 assertEquals( "TIME", 0, cTime.compare( aDateTime, bDateTime ) ); 372 } // end of testBasicComps 373 374 /** 375 * Test all basic comparator operation with Long objects. 376 */ 377 public void testBasicComps4() { 378 Long aDateTime 379 = new Long( System.currentTimeMillis() ); 380 Long bDateTime 381 = new Long( aDateTime.longValue() ); 382 assertEquals( "MILLIS", 0, cMillis.compare( aDateTime, bDateTime ) ); 383 assertEquals( "SECOND", 0, cSecond.compare( aDateTime, bDateTime ) ); 384 assertEquals( "MINUTE", 0, cMinute.compare( aDateTime, bDateTime ) ); 385 assertEquals( "HOUR", 0, cHour.compare( aDateTime, bDateTime ) ); 386 assertEquals( "DOW", 0, cDayOfWeek.compare( aDateTime, bDateTime ) ); 387 assertEquals( "DOM", 0, cDayOfMonth.compare( aDateTime, bDateTime ) ); 388 assertEquals( "DOY", 0, cDayOfYear.compare( aDateTime, bDateTime ) ); 389 assertEquals( "WOW", 0, cWeekOfWeekyear.compare( aDateTime, bDateTime ) ); 390 assertEquals( "WY", 0, cWeekyear.compare( aDateTime, bDateTime ) ); 391 assertEquals( "MONTH", 0, cMonth.compare( aDateTime, bDateTime ) ); 392 assertEquals( "YEAR", 0, cYear.compare( aDateTime, bDateTime ) ); 393 assertEquals( "DATE", 0, cDate.compare( aDateTime, bDateTime ) ); 394 assertEquals( "TIME", 0, cTime.compare( aDateTime, bDateTime ) ); 395 } // end of testBasicComps 396 397 /** 398 * Test all basic comparator operation with Calendar objects. 399 */ 400 public void testBasicComps5() { 401 Calendar aDateTime 402 = Calendar.getInstance(); // right now 403 Calendar bDateTime = aDateTime; 404 assertEquals( "MILLIS", 0, cMillis.compare( aDateTime, bDateTime ) ); 405 assertEquals( "SECOND", 0, cSecond.compare( aDateTime, bDateTime ) ); 406 assertEquals( "MINUTE", 0, cMinute.compare( aDateTime, bDateTime ) ); 407 assertEquals( "HOUR", 0, cHour.compare( aDateTime, bDateTime ) ); 408 assertEquals( "DOW", 0, cDayOfWeek.compare( aDateTime, bDateTime ) ); 409 assertEquals( "DOM", 0, cDayOfMonth.compare( aDateTime, bDateTime ) ); 410 assertEquals( "DOY", 0, cDayOfYear.compare( aDateTime, bDateTime ) ); 411 assertEquals( "WOW", 0, cWeekOfWeekyear.compare( aDateTime, bDateTime ) ); 412 assertEquals( "WY", 0, cWeekyear.compare( aDateTime, bDateTime ) ); 413 assertEquals( "MONTH", 0, cMonth.compare( aDateTime, bDateTime ) ); 414 assertEquals( "YEAR", 0, cYear.compare( aDateTime, bDateTime ) ); 415 assertEquals( "DATE", 0, cDate.compare( aDateTime, bDateTime ) ); 416 assertEquals( "TIME", 0, cTime.compare( aDateTime, bDateTime ) ); 417 } // end of testBasicComps 418 419 420 /** 421 * Test unequal comparisons with millis of second comparators. 422 */ 423 public void testMillis() { 424 aDateTime = new DateTime( System.currentTimeMillis(), DateTimeZone.UTC ); 425 bDateTime = new DateTime( aDateTime.getMillis() + 1, DateTimeZone.UTC ); 426 assertEquals( "MillisM1", -1, cMillis.compare( aDateTime, bDateTime ) ); 427 assertEquals( "MillisP1", 1, cMillis.compare( bDateTime, aDateTime ) ); 428 } // end of testMillis 429 430 /** 431 * Test unequal comparisons with second comparators. 432 */ 433 public void testSecond() { 434 aDateTime = getADate( "1969-12-31T23:59:58" ); 435 bDateTime = getADate( "1969-12-31T23:50:59" ); 436 assertEquals( "SecondM1a", -1, cSecond.compare( aDateTime, bDateTime ) ); 437 assertEquals( "SecondP1a", 1, cSecond.compare( bDateTime, aDateTime ) ); 438 aDateTime = getADate( "1970-01-01T00:00:00" ); 439 bDateTime = getADate( "1970-01-01T00:00:01" ); 440 assertEquals( "SecondM1b", -1, cSecond.compare( aDateTime, bDateTime ) ); 441 assertEquals( "SecondP1b", 1, cSecond.compare( bDateTime, aDateTime ) ); 442 } // end of testSecond 443 444 /** 445 * Test unequal comparisons with minute comparators. 446 */ 447 public void testMinute() { 448 aDateTime = getADate( "1969-12-31T23:58:00" ); 449 bDateTime = getADate( "1969-12-31T23:59:00" ); 450 assertEquals( "MinuteM1a", -1, cMinute.compare( aDateTime, bDateTime ) ); 451 assertEquals( "MinuteP1a", 1, cMinute.compare( bDateTime, aDateTime ) ); 452 aDateTime = getADate( "1970-01-01T00:00:00" ); 453 bDateTime = getADate( "1970-01-01T00:01:00" ); 454 assertEquals( "MinuteM1b", -1, cMinute.compare( aDateTime, bDateTime ) ); 455 assertEquals( "MinuteP1b", 1, cMinute.compare( bDateTime, aDateTime ) ); 456 } // end of testMinute 457 458 /** 459 * Test unequal comparisons with hour comparators. 460 */ 461 public void testHour() { 462 aDateTime = getADate( "1969-12-31T22:00:00" ); 463 bDateTime = getADate( "1969-12-31T23:00:00" ); 464 assertEquals( "HourM1a", -1, cHour.compare( aDateTime, bDateTime ) ); 465 assertEquals( "HourP1a", 1, cHour.compare( bDateTime, aDateTime ) ); 466 aDateTime = getADate( "1970-01-01T00:00:00" ); 467 bDateTime = getADate( "1970-01-01T01:00:00" ); 468 assertEquals( "HourM1b", -1, cHour.compare( aDateTime, bDateTime ) ); 469 assertEquals( "HourP1b", 1, cHour.compare( bDateTime, aDateTime ) ); 470 aDateTime = getADate( "1969-12-31T23:59:59" ); 471 bDateTime = getADate( "1970-01-01T00:00:00" ); 472 assertEquals( "HourP1c", 1, cHour.compare( aDateTime, bDateTime ) ); 473 assertEquals( "HourM1c", -1, cHour.compare( bDateTime, aDateTime ) ); 474 } // end of testHour 475 476 /** 477 * Test unequal comparisons with day of week comparators. 478 */ 479 public void testDOW() { 480 /* 481 * Dates chosen when I wrote the code, so I know what day of 482 * the week it is. 483 */ 484 aDateTime = getADate( "2002-04-12T00:00:00" ); 485 bDateTime = getADate( "2002-04-13T00:00:00" ); 486 assertEquals( "DOWM1a", -1, cDayOfWeek.compare( aDateTime, bDateTime ) ); 487 assertEquals( "DOWP1a", 1, cDayOfWeek.compare( bDateTime, aDateTime ) ); 488 } // end of testDOW 489 490 /** 491 * Test unequal comparisons with day of month comparators. 492 */ 493 public void testDOM() { 494 aDateTime = getADate( "2002-04-12T00:00:00" ); 495 bDateTime = getADate( "2002-04-13T00:00:00" ); 496 assertEquals( "DOMM1a", -1, cDayOfMonth.compare( aDateTime, bDateTime ) ); 497 assertEquals( "DOMP1a", 1, cDayOfMonth.compare( bDateTime, aDateTime ) ); 498 aDateTime = getADate( "2000-12-01T00:00:00" ); 499 bDateTime = getADate( "1814-04-30T00:00:00" ); 500 assertEquals( "DOMM1b", -1, cDayOfMonth.compare( aDateTime, bDateTime ) ); 501 assertEquals( "DOMP1b", 1, cDayOfMonth.compare( bDateTime, aDateTime ) ); 502 } // end of testDOM 503 504 /** 505 * Test unequal comparisons with day of year comparators. 506 */ 507 public void testDOY() { 508 aDateTime = getADate( "2002-04-12T00:00:00" ); 509 bDateTime = getADate( "2002-04-13T00:00:00" ); 510 assertEquals( "DOYM1a", -1, cDayOfYear.compare( aDateTime, bDateTime ) ); 511 assertEquals( "DOYP1a", 1, cDayOfYear.compare( bDateTime, aDateTime ) ); 512 aDateTime = getADate( "2000-02-29T00:00:00" ); 513 bDateTime = getADate( "1814-11-30T00:00:00" ); 514 assertEquals( "DOYM1b", -1, cDayOfYear.compare( aDateTime, bDateTime ) ); 515 assertEquals( "DOYP1b", 1, cDayOfYear.compare( bDateTime, aDateTime ) ); 516 } // end of testDOY 517 518 /** 519 * Test unequal comparisons with week of weekyear comparators. 520 */ 521 public void testWOW() { 522 // 1st week of year contains Jan 04. 523 aDateTime = getADate( "2000-01-04T00:00:00" ); 524 bDateTime = getADate( "2000-01-11T00:00:00" ); 525 assertEquals( "WOWM1a", -1, 526 cWeekOfWeekyear.compare( aDateTime, bDateTime ) ); 527 assertEquals( "WOWP1a", 1, 528 cWeekOfWeekyear.compare( bDateTime, aDateTime ) ); 529 aDateTime = getADate( "2000-01-04T00:00:00" ); 530 bDateTime = getADate( "1999-12-31T00:00:00" ); 531 assertEquals( "WOWM1b", -1, 532 cWeekOfWeekyear.compare( aDateTime, bDateTime ) ); 533 assertEquals( "WOWP1b", 1, 534 cWeekOfWeekyear.compare( bDateTime, aDateTime ) ); 535 } // end of testMillis 536 537 /** 538 * Test unequal comparisons with year given the week comparators. 539 */ 540 public void testWOYY() { 541 // How do I test the end conditions of this? 542 // Don't understand ...... 543 aDateTime = getADate( "1998-12-31T23:59:59" ); 544 bDateTime = getADate( "1999-01-01T00:00:00" ); 545 assertEquals( "YOYYZ", 0, cWeekyear.compare( aDateTime, bDateTime ) ); 546 bDateTime = getADate( "1999-01-04T00:00:00" ); 547 assertEquals( "YOYYM1", -1, cWeekyear.compare( aDateTime, bDateTime ) ); 548 assertEquals( "YOYYP1", 1, cWeekyear.compare( bDateTime, aDateTime ) ); 549 } // end of testWOYY 550 551 /** 552 * Test unequal comparisons with month comparators. 553 */ 554 public void testMonth() { 555 aDateTime = getADate( "2002-04-30T00:00:00" ); 556 bDateTime = getADate( "2002-05-01T00:00:00" ); 557 assertEquals( "MONTHM1a", -1, cMonth.compare( aDateTime, bDateTime ) ); 558 assertEquals( "MONTHP1a", 1, cMonth.compare( bDateTime, aDateTime ) ); 559 aDateTime = getADate( "1900-01-01T00:00:00" ); 560 bDateTime = getADate( "1899-12-31T00:00:00" ); 561 assertEquals( "MONTHM1b", -1, cMonth.compare( aDateTime, bDateTime ) ); 562 assertEquals( "MONTHP1b", 1, cMonth.compare( bDateTime, aDateTime ) ); 563 } // end of testMonth 564 565 /** 566 * Test unequal comparisons with year comparators. 567 */ 568 public void testYear() { 569 aDateTime = getADate( "2000-01-01T00:00:00" ); 570 bDateTime = getADate( "2001-01-01T00:00:00" ); 571 assertEquals( "YEARM1a", -1, cYear.compare( aDateTime, bDateTime ) ); 572 assertEquals( "YEARP1a", 1, cYear.compare( bDateTime, aDateTime ) ); 573 aDateTime = getADate( "1968-12-31T23:59:59" ); 574 bDateTime = getADate( "1970-01-01T00:00:00" ); 575 assertEquals( "YEARM1b", -1, cYear.compare( aDateTime, bDateTime ) ); 576 assertEquals( "YEARP1b", 1, cYear.compare( bDateTime, aDateTime ) ); 577 aDateTime = getADate( "1969-12-31T23:59:59" ); 578 bDateTime = getADate( "1970-01-01T00:00:00" ); 579 assertEquals( "YEARM1c", -1, cYear.compare( aDateTime, bDateTime ) ); 580 assertEquals( "YEARP1c", 1, cYear.compare( bDateTime, aDateTime ) ); 581 } // end of testYear 582 583 /* 584 * 'List' processing tests follow. 585 */ 586 587 /** 588 * Test sorting with full default comparator. 589 */ 590 public void testListBasic() { 591 String[] dtStrs = { 592 "1999-02-01T00:00:00", 593 "1998-01-20T00:00:00" 594 }; 595 // 596 List sl = loadAList( dtStrs ); 597 boolean isSorted1 = isListSorted( sl ); 598 Collections.sort( sl ); 599 boolean isSorted2 = isListSorted( sl ); 600 assertEquals("ListBasic", !isSorted1, isSorted2); 601 } // end of testListBasic 602 603 /** 604 * Test sorting with millis of second comparator. 605 */ 606 public void testListMillis() { 607 // 608 List sl = new ArrayList(); 609 long base = 12345L * 1000L; 610 sl.add( new DateTime( base + 999L, DateTimeZone.UTC ) ); 611 sl.add( new DateTime( base + 222L, DateTimeZone.UTC ) ); 612 sl.add( new DateTime( base + 456L, DateTimeZone.UTC ) ); 613 sl.add( new DateTime( base + 888L, DateTimeZone.UTC ) ); 614 sl.add( new DateTime( base + 123L, DateTimeZone.UTC ) ); 615 sl.add( new DateTime( base + 000L, DateTimeZone.UTC ) ); 616 // 617 boolean isSorted1 = isListSorted( sl ); 618 Collections.sort( sl, cMillis ); 619 boolean isSorted2 = isListSorted( sl ); 620 assertEquals("ListLillis", !isSorted1, isSorted2); 621 } // end of testListSecond 622 623 624 /** 625 * Test sorting with second comparator. 626 */ 627 public void testListSecond() { 628 String[] dtStrs = { 629 "1999-02-01T00:00:10", 630 "1999-02-01T00:00:30", 631 "1999-02-01T00:00:25", 632 "1999-02-01T00:00:18", 633 "1999-02-01T00:00:01", 634 "1999-02-01T00:00:59", 635 "1999-02-01T00:00:22" 636 }; 637 // 638 List sl = loadAList( dtStrs ); 639 boolean isSorted1 = isListSorted( sl ); 640 Collections.sort( sl, cSecond ); 641 boolean isSorted2 = isListSorted( sl ); 642 assertEquals("ListSecond", !isSorted1, isSorted2); 643 } // end of testListSecond 644 645 /** 646 * Test sorting with minute comparator. 647 */ 648 public void testListMinute() { 649 String[] dtStrs = { 650 "1999-02-01T00:10:00", 651 "1999-02-01T00:30:00", 652 "1999-02-01T00:25:00", 653 "1999-02-01T00:18:00", 654 "1999-02-01T00:01:00", 655 "1999-02-01T00:59:00", 656 "1999-02-01T00:22:00" 657 }; 658 // 659 List sl = loadAList( dtStrs ); 660 boolean isSorted1 = isListSorted( sl ); 661 Collections.sort( sl, cMinute ); 662 boolean isSorted2 = isListSorted( sl ); 663 assertEquals("ListMinute", !isSorted1, isSorted2); 664 } // end of testListMinute 665 666 /** 667 * Test sorting with hour comparator. 668 */ 669 public void testListHour() { 670 String[] dtStrs = { 671 "1999-02-01T10:00:00", 672 "1999-02-01T23:00:00", 673 "1999-02-01T01:00:00", 674 "1999-02-01T15:00:00", 675 "1999-02-01T05:00:00", 676 "1999-02-01T20:00:00", 677 "1999-02-01T17:00:00" 678 }; 679 // 680 List sl = loadAList( dtStrs ); 681 boolean isSorted1 = isListSorted( sl ); 682 Collections.sort( sl, cHour ); 683 boolean isSorted2 = isListSorted( sl ); 684 assertEquals("ListHour", !isSorted1, isSorted2); 685 } // end of testListHour 686 687 688 /** 689 * Test sorting with day of week comparator. 690 */ 691 public void testListDOW() { 692 String[] dtStrs = { 693 /* 2002-04-15 = Monday */ 694 "2002-04-21T10:00:00", 695 "2002-04-16T10:00:00", 696 "2002-04-15T10:00:00", 697 "2002-04-17T10:00:00", 698 "2002-04-19T10:00:00", 699 "2002-04-18T10:00:00", 700 "2002-04-20T10:00:00" 701 }; 702 // 703 List sl = loadAList( dtStrs ); 704 boolean isSorted1 = isListSorted( sl ); 705 Collections.sort( sl, cDayOfWeek ); 706 boolean isSorted2 = isListSorted( sl ); 707 assertEquals("ListDOW", !isSorted1, isSorted2); 708 } // end of testListDOW 709 710 /** 711 * Test sorting with day of month comparator. 712 */ 713 public void testListDOM() { 714 String[] dtStrs = { 715 /* 2002-04-14 = Sunday */ 716 "2002-04-20T10:00:00", 717 "2002-04-16T10:00:00", 718 "2002-04-15T10:00:00", 719 "2002-04-17T10:00:00", 720 "2002-04-19T10:00:00", 721 "2002-04-18T10:00:00", 722 "2002-04-14T10:00:00" 723 }; 724 // 725 List sl = loadAList( dtStrs ); 726 boolean isSorted1 = isListSorted( sl ); 727 Collections.sort( sl, cDayOfMonth ); 728 boolean isSorted2 = isListSorted( sl ); 729 assertEquals("ListDOM", !isSorted1, isSorted2); 730 } // end of testListDOM 731 732 /** 733 * Test sorting with day of year comparator. 734 */ 735 public void testListDOY() { 736 String[] dtStrs = { 737 "2002-04-20T10:00:00", 738 "2002-01-16T10:00:00", 739 "2002-12-31T10:00:00", 740 "2002-09-14T10:00:00", 741 "2002-09-19T10:00:00", 742 "2002-02-14T10:00:00", 743 "2002-10-30T10:00:00" 744 }; 745 // 746 List sl = loadAList( dtStrs ); 747 boolean isSorted1 = isListSorted( sl ); 748 Collections.sort( sl, cDayOfYear ); 749 boolean isSorted2 = isListSorted( sl ); 750 assertEquals("ListDOY", !isSorted1, isSorted2); 751 } // end of testListDOY 752 753 /** 754 * Test sorting with week of weekyear comparator. 755 */ 756 public void testListWOW() { 757 String[] dtStrs = { 758 "2002-04-01T10:00:00", 759 "2002-01-01T10:00:00", 760 "2002-12-01T10:00:00", 761 "2002-09-01T10:00:00", 762 "2002-09-01T10:00:00", 763 "2002-02-01T10:00:00", 764 "2002-10-01T10:00:00" 765 }; 766 // 767 List sl = loadAList( dtStrs ); 768 boolean isSorted1 = isListSorted( sl ); 769 Collections.sort( sl, cWeekOfWeekyear ); 770 boolean isSorted2 = isListSorted( sl ); 771 assertEquals("ListWOW", !isSorted1, isSorted2); 772 } // end of testListWOW 773 774 /** 775 * Test sorting with year (given week) comparator. 776 */ 777 public void testListYOYY() { 778 // ?? How to catch end conditions ?? 779 String[] dtStrs = { 780 "2010-04-01T10:00:00", 781 "2002-01-01T10:00:00" 782 }; 783 // 784 List sl = loadAList( dtStrs ); 785 boolean isSorted1 = isListSorted( sl ); 786 Collections.sort( sl, cWeekyear ); 787 boolean isSorted2 = isListSorted( sl ); 788 assertEquals("ListYOYY", !isSorted1, isSorted2); 789 } // end of testListYOYY 790 791 792 /** 793 * Test sorting with month comparator. 794 */ 795 public void testListMonth() { 796 String[] dtStrs = { 797 "2002-04-01T10:00:00", 798 "2002-01-01T10:00:00", 799 "2002-12-01T10:00:00", 800 "2002-09-01T10:00:00", 801 "2002-09-01T10:00:00", 802 "2002-02-01T10:00:00", 803 "2002-10-01T10:00:00" 804 }; 805 // 806 List sl = loadAList( dtStrs ); 807 boolean isSorted1 = isListSorted( sl ); 808 Collections.sort( sl, cMonth ); 809 boolean isSorted2 = isListSorted( sl ); 810 assertEquals("ListMonth", !isSorted1, isSorted2); 811 } // end of testListMonth 812 813 /** 814 * Test sorting with year comparator. 815 */ 816 public void testListYear() { 817 String[] dtStrs = { 818 "1999-02-01T00:00:00", 819 "1998-02-01T00:00:00", 820 "2525-02-01T00:00:00", 821 "1776-02-01T00:00:00", 822 "1863-02-01T00:00:00", 823 "1066-02-01T00:00:00", 824 "2100-02-01T00:00:00" 825 }; 826 // 827 List sl = loadAList( dtStrs ); 828 boolean isSorted1 = isListSorted( sl ); 829 Collections.sort( sl, cYear ); 830 boolean isSorted2 = isListSorted( sl ); 831 assertEquals("ListYear", !isSorted1, isSorted2); 832 } // end of testListYear 833 834 /** 835 * Test sorting with date only comparator. 836 */ 837 public void testListDate() { 838 String[] dtStrs = { 839 "1999-02-01T00:00:00", 840 "1998-10-03T00:00:00", 841 "2525-05-20T00:00:00", 842 "1776-12-25T00:00:00", 843 "1863-01-31T00:00:00", 844 "1066-09-22T00:00:00", 845 "2100-07-04T00:00:00" 846 }; 847 // 848 List sl = loadAList( dtStrs ); 849 boolean isSorted1 = isListSorted( sl ); 850 Collections.sort( sl, cDate ); 851 boolean isSorted2 = isListSorted( sl ); 852 assertEquals("ListDate", !isSorted1, isSorted2); 853 } // end of testListDate 854 855 /** 856 * Test sorting with time only comparator. 857 */ 858 public void testListTime() { 859 String[] dtStrs = { 860 "1999-02-01T01:02:05", 861 "1999-02-01T22:22:22", 862 "1999-02-01T05:30:45", 863 "1999-02-01T09:17:59", 864 "1999-02-01T09:17:58", 865 "1999-02-01T15:30:00", 866 "1999-02-01T17:00:44" 867 }; 868 // 869 List sl = loadAList( dtStrs ); 870 boolean isSorted1 = isListSorted( sl ); 871 Collections.sort( sl, cTime ); 872 boolean isSorted2 = isListSorted( sl ); 873 assertEquals("ListTime", !isSorted1, isSorted2); 874 } // end of testListTime 875 876 877 /** 878 * Test comparator operation with null object(s). 879 */ 880 public void testNullDT() { 881 // null means now 882 aDateTime = getADate("2000-01-01T00:00:00"); 883 assertTrue(cYear.compare(null, aDateTime) > 0); 884 assertTrue(cYear.compare(aDateTime, null) < 0); 885 } 886 887 /** 888 * Test comparator operation with an invalid object type. 889 */ 890 public void testInvalidObj() { 891 aDateTime = getADate("2000-01-01T00:00:00"); 892 try { 893 cYear.compare("FreeBird", aDateTime); 894 fail("Invalid object failed"); 895 } catch (IllegalArgumentException cce) {} 896 } 897 898 // private convenience methods 899 //----------------------------------------------------------------------- 900 /** 901 * Creates a date to test with. 902 */ 903 private DateTime getADate(String s) { 904 DateTime retDT = null; 905 try { 906 retDT = new DateTime(s, DateTimeZone.UTC); 907 } catch (IllegalArgumentException pe) { 908 pe.printStackTrace(); 909 } 910 return retDT; 911 } 912 913 /** 914 * Load a string array. 915 */ 916 private List loadAList(String[] someStrs) { 917 List newList = new ArrayList(); 918 try { 919 for (int i = 0; i < someStrs.length; ++i) { 920 newList.add(new DateTime(someStrs[i], DateTimeZone.UTC)); 921 } // end of the for 922 } catch (IllegalArgumentException pe) { 923 pe.printStackTrace(); 924 } 925 return newList; 926 } 927 928 /** 929 * Check if the list is sorted. 930 */ 931 private boolean isListSorted(List tl) { 932 // tl must be populated with DateTime objects. 933 DateTime lhDT = (DateTime)tl.get(0); 934 DateTime rhDT = null; 935 Long lhVal = new Long( lhDT.getMillis() ); 936 Long rhVal = null; 937 for (int i = 1; i < tl.size(); ++i) { 938 rhDT = (DateTime)tl.get(i); 939 rhVal = new Long( rhDT.getMillis() ); 940 if ( lhVal.compareTo( rhVal) > 0 ) return false; 941 // 942 lhVal = rhVal; // swap for next iteration 943 lhDT = rhDT; // swap for next iteration 944 } 945 return true; 946 } 947 948 }