001 /* 002 * Copyright 2001-2006 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 023 import junit.framework.TestCase; 024 import junit.framework.TestSuite; 025 026 /** 027 * This class is a Junit unit test for Weeks. 028 * 029 * @author Stephen Colebourne 030 */ 031 public class TestWeeks extends TestCase { 032 // Test in 2002/03 as time zones are more well known 033 // (before the late 90's they were all over the place) 034 private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris"); 035 036 public static void main(String[] args) { 037 junit.textui.TestRunner.run(suite()); 038 } 039 040 public static TestSuite suite() { 041 return new TestSuite(TestWeeks.class); 042 } 043 044 public TestWeeks(String name) { 045 super(name); 046 } 047 048 protected void setUp() throws Exception { 049 } 050 051 protected void tearDown() throws Exception { 052 } 053 054 //----------------------------------------------------------------------- 055 public void testConstants() { 056 assertEquals(0, Weeks.ZERO.getWeeks()); 057 assertEquals(1, Weeks.ONE.getWeeks()); 058 assertEquals(2, Weeks.TWO.getWeeks()); 059 assertEquals(3, Weeks.THREE.getWeeks()); 060 assertEquals(Integer.MAX_VALUE, Weeks.MAX_VALUE.getWeeks()); 061 assertEquals(Integer.MIN_VALUE, Weeks.MIN_VALUE.getWeeks()); 062 } 063 064 //----------------------------------------------------------------------- 065 public void testFactory_weeks_int() { 066 assertSame(Weeks.ZERO, Weeks.weeks(0)); 067 assertSame(Weeks.ONE, Weeks.weeks(1)); 068 assertSame(Weeks.TWO, Weeks.weeks(2)); 069 assertSame(Weeks.THREE, Weeks.weeks(3)); 070 assertSame(Weeks.MAX_VALUE, Weeks.weeks(Integer.MAX_VALUE)); 071 assertSame(Weeks.MIN_VALUE, Weeks.weeks(Integer.MIN_VALUE)); 072 assertEquals(-1, Weeks.weeks(-1).getWeeks()); 073 assertEquals(4, Weeks.weeks(4).getWeeks()); 074 } 075 076 //----------------------------------------------------------------------- 077 public void testFactory_weeksBetween_RInstant() { 078 DateTime start = new DateTime(2006, 6, 9, 12, 0, 0, 0, PARIS); 079 DateTime end1 = new DateTime(2006, 6, 30, 12, 0, 0, 0, PARIS); 080 DateTime end2 = new DateTime(2006, 7, 21, 12, 0, 0, 0, PARIS); 081 082 assertEquals(3, Weeks.weeksBetween(start, end1).getWeeks()); 083 assertEquals(0, Weeks.weeksBetween(start, start).getWeeks()); 084 assertEquals(0, Weeks.weeksBetween(end1, end1).getWeeks()); 085 assertEquals(-3, Weeks.weeksBetween(end1, start).getWeeks()); 086 assertEquals(6, Weeks.weeksBetween(start, end2).getWeeks()); 087 } 088 089 public void testFactory_weeksBetween_RPartial() { 090 LocalDate start = new LocalDate(2006, 6, 9); 091 LocalDate end1 = new LocalDate(2006, 6, 30); 092 YearMonthDay end2 = new YearMonthDay(2006, 7, 21); 093 094 assertEquals(3, Weeks.weeksBetween(start, end1).getWeeks()); 095 assertEquals(0, Weeks.weeksBetween(start, start).getWeeks()); 096 assertEquals(0, Weeks.weeksBetween(end1, end1).getWeeks()); 097 assertEquals(-3, Weeks.weeksBetween(end1, start).getWeeks()); 098 assertEquals(6, Weeks.weeksBetween(start, end2).getWeeks()); 099 } 100 101 public void testFactory_weeksIn_RInterval() { 102 DateTime start = new DateTime(2006, 6, 9, 12, 0, 0, 0, PARIS); 103 DateTime end1 = new DateTime(2006, 6, 30, 12, 0, 0, 0, PARIS); 104 DateTime end2 = new DateTime(2006, 7, 21, 12, 0, 0, 0, PARIS); 105 106 assertEquals(0, Weeks.weeksIn((ReadableInterval) null).getWeeks()); 107 assertEquals(3, Weeks.weeksIn(new Interval(start, end1)).getWeeks()); 108 assertEquals(0, Weeks.weeksIn(new Interval(start, start)).getWeeks()); 109 assertEquals(0, Weeks.weeksIn(new Interval(end1, end1)).getWeeks()); 110 assertEquals(6, Weeks.weeksIn(new Interval(start, end2)).getWeeks()); 111 } 112 113 public void testFactory_standardWeeksIn_RPeriod() { 114 assertEquals(0, Weeks.standardWeeksIn((ReadablePeriod) null).getWeeks()); 115 assertEquals(0, Weeks.standardWeeksIn(Period.ZERO).getWeeks()); 116 assertEquals(1, Weeks.standardWeeksIn(new Period(0, 0, 1, 0, 0, 0, 0, 0)).getWeeks()); 117 assertEquals(123, Weeks.standardWeeksIn(Period.weeks(123)).getWeeks()); 118 assertEquals(-987, Weeks.standardWeeksIn(Period.weeks(-987)).getWeeks()); 119 assertEquals(1, Weeks.standardWeeksIn(Period.days(13)).getWeeks()); 120 assertEquals(2, Weeks.standardWeeksIn(Period.days(14)).getWeeks()); 121 assertEquals(2, Weeks.standardWeeksIn(Period.days(15)).getWeeks()); 122 try { 123 Weeks.standardWeeksIn(Period.months(1)); 124 fail(); 125 } catch (IllegalArgumentException ex) { 126 // expeceted 127 } 128 } 129 130 public void testFactory_parseWeeks_String() { 131 assertEquals(0, Weeks.parseWeeks((String) null).getWeeks()); 132 assertEquals(0, Weeks.parseWeeks("P0W").getWeeks()); 133 assertEquals(1, Weeks.parseWeeks("P1W").getWeeks()); 134 assertEquals(-3, Weeks.parseWeeks("P-3W").getWeeks()); 135 assertEquals(2, Weeks.parseWeeks("P0Y0M2W").getWeeks()); 136 assertEquals(2, Weeks.parseWeeks("P2WT0H0M").getWeeks()); 137 try { 138 Weeks.parseWeeks("P1Y1D"); 139 fail(); 140 } catch (IllegalArgumentException ex) { 141 // expeceted 142 } 143 try { 144 Weeks.parseWeeks("P1WT1H"); 145 fail(); 146 } catch (IllegalArgumentException ex) { 147 // expeceted 148 } 149 } 150 151 //----------------------------------------------------------------------- 152 public void testGetMethods() { 153 Weeks test = Weeks.weeks(20); 154 assertEquals(20, test.getWeeks()); 155 } 156 157 public void testGetFieldType() { 158 Weeks test = Weeks.weeks(20); 159 assertEquals(DurationFieldType.weeks(), test.getFieldType()); 160 } 161 162 public void testGetPeriodType() { 163 Weeks test = Weeks.weeks(20); 164 assertEquals(PeriodType.weeks(), test.getPeriodType()); 165 } 166 167 //----------------------------------------------------------------------- 168 public void testIsGreaterThan() { 169 assertEquals(true, Weeks.THREE.isGreaterThan(Weeks.TWO)); 170 assertEquals(false, Weeks.THREE.isGreaterThan(Weeks.THREE)); 171 assertEquals(false, Weeks.TWO.isGreaterThan(Weeks.THREE)); 172 assertEquals(true, Weeks.ONE.isGreaterThan(null)); 173 assertEquals(false, Weeks.weeks(-1).isGreaterThan(null)); 174 } 175 176 public void testIsLessThan() { 177 assertEquals(false, Weeks.THREE.isLessThan(Weeks.TWO)); 178 assertEquals(false, Weeks.THREE.isLessThan(Weeks.THREE)); 179 assertEquals(true, Weeks.TWO.isLessThan(Weeks.THREE)); 180 assertEquals(false, Weeks.ONE.isLessThan(null)); 181 assertEquals(true, Weeks.weeks(-1).isLessThan(null)); 182 } 183 184 //----------------------------------------------------------------------- 185 public void testToString() { 186 Weeks test = Weeks.weeks(20); 187 assertEquals("P20W", test.toString()); 188 189 test = Weeks.weeks(-20); 190 assertEquals("P-20W", test.toString()); 191 } 192 193 //----------------------------------------------------------------------- 194 public void testSerialization() throws Exception { 195 Weeks test = Weeks.THREE; 196 197 ByteArrayOutputStream baos = new ByteArrayOutputStream(); 198 ObjectOutputStream oos = new ObjectOutputStream(baos); 199 oos.writeObject(test); 200 byte[] bytes = baos.toByteArray(); 201 oos.close(); 202 203 ByteArrayInputStream bais = new ByteArrayInputStream(bytes); 204 ObjectInputStream ois = new ObjectInputStream(bais); 205 Weeks result = (Weeks) ois.readObject(); 206 ois.close(); 207 208 assertSame(test, result); 209 } 210 211 //----------------------------------------------------------------------- 212 public void testToStandardDays() { 213 Weeks test = Weeks.weeks(2); 214 Days expected = Days.days(14); 215 assertEquals(expected, test.toStandardDays()); 216 217 try { 218 Weeks.MAX_VALUE.toStandardDays(); 219 fail(); 220 } catch (ArithmeticException ex) { 221 // expected 222 } 223 } 224 225 public void testToStandardHours() { 226 Weeks test = Weeks.weeks(2); 227 Hours expected = Hours.hours(2 * 7 * 24); 228 assertEquals(expected, test.toStandardHours()); 229 230 try { 231 Weeks.MAX_VALUE.toStandardHours(); 232 fail(); 233 } catch (ArithmeticException ex) { 234 // expected 235 } 236 } 237 238 public void testToStandardMinutes() { 239 Weeks test = Weeks.weeks(2); 240 Minutes expected = Minutes.minutes(2 * 7 * 24 * 60); 241 assertEquals(expected, test.toStandardMinutes()); 242 243 try { 244 Weeks.MAX_VALUE.toStandardMinutes(); 245 fail(); 246 } catch (ArithmeticException ex) { 247 // expected 248 } 249 } 250 251 public void testToStandardSeconds() { 252 Weeks test = Weeks.weeks(2); 253 Seconds expected = Seconds.seconds(2 * 7 * 24 * 60 * 60); 254 assertEquals(expected, test.toStandardSeconds()); 255 256 try { 257 Weeks.MAX_VALUE.toStandardSeconds(); 258 fail(); 259 } catch (ArithmeticException ex) { 260 // expected 261 } 262 } 263 264 public void testToStandardDuration() { 265 Weeks test = Weeks.weeks(20); 266 Duration expected = new Duration(20L * DateTimeConstants.MILLIS_PER_WEEK); 267 assertEquals(expected, test.toStandardDuration()); 268 269 expected = new Duration(((long) Integer.MAX_VALUE) * DateTimeConstants.MILLIS_PER_WEEK); 270 assertEquals(expected, Weeks.MAX_VALUE.toStandardDuration()); 271 } 272 273 //----------------------------------------------------------------------- 274 public void testPlus_int() { 275 Weeks test2 = Weeks.weeks(2); 276 Weeks result = test2.plus(3); 277 assertEquals(2, test2.getWeeks()); 278 assertEquals(5, result.getWeeks()); 279 280 assertEquals(1, Weeks.ONE.plus(0).getWeeks()); 281 282 try { 283 Weeks.MAX_VALUE.plus(1); 284 fail(); 285 } catch (ArithmeticException ex) { 286 // expected 287 } 288 } 289 290 public void testPlus_Weeks() { 291 Weeks test2 = Weeks.weeks(2); 292 Weeks test3 = Weeks.weeks(3); 293 Weeks result = test2.plus(test3); 294 assertEquals(2, test2.getWeeks()); 295 assertEquals(3, test3.getWeeks()); 296 assertEquals(5, result.getWeeks()); 297 298 assertEquals(1, Weeks.ONE.plus(Weeks.ZERO).getWeeks()); 299 assertEquals(1, Weeks.ONE.plus((Weeks) null).getWeeks()); 300 301 try { 302 Weeks.MAX_VALUE.plus(Weeks.ONE); 303 fail(); 304 } catch (ArithmeticException ex) { 305 // expected 306 } 307 } 308 309 public void testMinus_int() { 310 Weeks test2 = Weeks.weeks(2); 311 Weeks result = test2.minus(3); 312 assertEquals(2, test2.getWeeks()); 313 assertEquals(-1, result.getWeeks()); 314 315 assertEquals(1, Weeks.ONE.minus(0).getWeeks()); 316 317 try { 318 Weeks.MIN_VALUE.minus(1); 319 fail(); 320 } catch (ArithmeticException ex) { 321 // expected 322 } 323 } 324 325 public void testMinus_Weeks() { 326 Weeks test2 = Weeks.weeks(2); 327 Weeks test3 = Weeks.weeks(3); 328 Weeks result = test2.minus(test3); 329 assertEquals(2, test2.getWeeks()); 330 assertEquals(3, test3.getWeeks()); 331 assertEquals(-1, result.getWeeks()); 332 333 assertEquals(1, Weeks.ONE.minus(Weeks.ZERO).getWeeks()); 334 assertEquals(1, Weeks.ONE.minus((Weeks) null).getWeeks()); 335 336 try { 337 Weeks.MIN_VALUE.minus(Weeks.ONE); 338 fail(); 339 } catch (ArithmeticException ex) { 340 // expected 341 } 342 } 343 344 public void testMultipliedBy_int() { 345 Weeks test = Weeks.weeks(2); 346 assertEquals(6, test.multipliedBy(3).getWeeks()); 347 assertEquals(2, test.getWeeks()); 348 assertEquals(-6, test.multipliedBy(-3).getWeeks()); 349 assertSame(test, test.multipliedBy(1)); 350 351 Weeks halfMax = Weeks.weeks(Integer.MAX_VALUE / 2 + 1); 352 try { 353 halfMax.multipliedBy(2); 354 fail(); 355 } catch (ArithmeticException ex) { 356 // expected 357 } 358 } 359 360 public void testDividedBy_int() { 361 Weeks test = Weeks.weeks(12); 362 assertEquals(6, test.dividedBy(2).getWeeks()); 363 assertEquals(12, test.getWeeks()); 364 assertEquals(4, test.dividedBy(3).getWeeks()); 365 assertEquals(3, test.dividedBy(4).getWeeks()); 366 assertEquals(2, test.dividedBy(5).getWeeks()); 367 assertEquals(2, test.dividedBy(6).getWeeks()); 368 assertSame(test, test.dividedBy(1)); 369 370 try { 371 Weeks.ONE.dividedBy(0); 372 fail(); 373 } catch (ArithmeticException ex) { 374 // expected 375 } 376 } 377 378 public void testNegated() { 379 Weeks test = Weeks.weeks(12); 380 assertEquals(-12, test.negated().getWeeks()); 381 assertEquals(12, test.getWeeks()); 382 383 try { 384 Weeks.MIN_VALUE.negated(); 385 fail(); 386 } catch (ArithmeticException ex) { 387 // expected 388 } 389 } 390 391 //----------------------------------------------------------------------- 392 public void testAddToLocalDate() { 393 Weeks test = Weeks.weeks(3); 394 LocalDate date = new LocalDate(2006, 6, 1); 395 LocalDate expected = new LocalDate(2006, 6, 22); 396 assertEquals(expected, date.plus(test)); 397 } 398 399 }