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 Months. 028 * 029 * @author Stephen Colebourne 030 */ 031 public class TestMonths 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(TestMonths.class); 042 } 043 044 public TestMonths(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, Months.ZERO.getMonths()); 057 assertEquals(1, Months.ONE.getMonths()); 058 assertEquals(2, Months.TWO.getMonths()); 059 assertEquals(3, Months.THREE.getMonths()); 060 assertEquals(4, Months.FOUR.getMonths()); 061 assertEquals(5, Months.FIVE.getMonths()); 062 assertEquals(6, Months.SIX.getMonths()); 063 assertEquals(7, Months.SEVEN.getMonths()); 064 assertEquals(8, Months.EIGHT.getMonths()); 065 assertEquals(9, Months.NINE.getMonths()); 066 assertEquals(10, Months.TEN.getMonths()); 067 assertEquals(11, Months.ELEVEN.getMonths()); 068 assertEquals(12, Months.TWELVE.getMonths()); 069 assertEquals(Integer.MAX_VALUE, Months.MAX_VALUE.getMonths()); 070 assertEquals(Integer.MIN_VALUE, Months.MIN_VALUE.getMonths()); 071 } 072 073 //----------------------------------------------------------------------- 074 public void testFactory_months_int() { 075 assertSame(Months.ZERO, Months.months(0)); 076 assertSame(Months.ONE, Months.months(1)); 077 assertSame(Months.TWO, Months.months(2)); 078 assertSame(Months.THREE, Months.months(3)); 079 assertSame(Months.FOUR, Months.months(4)); 080 assertSame(Months.FIVE, Months.months(5)); 081 assertSame(Months.SIX, Months.months(6)); 082 assertSame(Months.SEVEN, Months.months(7)); 083 assertSame(Months.EIGHT, Months.months(8)); 084 assertSame(Months.NINE, Months.months(9)); 085 assertSame(Months.TEN, Months.months(10)); 086 assertSame(Months.ELEVEN, Months.months(11)); 087 assertSame(Months.TWELVE, Months.months(12)); 088 assertSame(Months.MAX_VALUE, Months.months(Integer.MAX_VALUE)); 089 assertSame(Months.MIN_VALUE, Months.months(Integer.MIN_VALUE)); 090 assertEquals(-1, Months.months(-1).getMonths()); 091 assertEquals(13, Months.months(13).getMonths()); 092 } 093 094 //----------------------------------------------------------------------- 095 public void testFactory_monthsBetween_RInstant() { 096 DateTime start = new DateTime(2006, 6, 9, 12, 0, 0, 0, PARIS); 097 DateTime end1 = new DateTime(2006, 9, 9, 12, 0, 0, 0, PARIS); 098 DateTime end2 = new DateTime(2006, 12, 9, 12, 0, 0, 0, PARIS); 099 100 assertEquals(3, Months.monthsBetween(start, end1).getMonths()); 101 assertEquals(0, Months.monthsBetween(start, start).getMonths()); 102 assertEquals(0, Months.monthsBetween(end1, end1).getMonths()); 103 assertEquals(-3, Months.monthsBetween(end1, start).getMonths()); 104 assertEquals(6, Months.monthsBetween(start, end2).getMonths()); 105 } 106 107 public void testFactory_monthsBetween_RPartial() { 108 LocalDate start = new LocalDate(2006, 6, 9); 109 LocalDate end1 = new LocalDate(2006, 9, 9); 110 YearMonthDay end2 = new YearMonthDay(2006, 12, 9); 111 112 assertEquals(3, Months.monthsBetween(start, end1).getMonths()); 113 assertEquals(0, Months.monthsBetween(start, start).getMonths()); 114 assertEquals(0, Months.monthsBetween(end1, end1).getMonths()); 115 assertEquals(-3, Months.monthsBetween(end1, start).getMonths()); 116 assertEquals(6, Months.monthsBetween(start, end2).getMonths()); 117 } 118 119 public void testFactory_monthsIn_RInterval() { 120 DateTime start = new DateTime(2006, 6, 9, 12, 0, 0, 0, PARIS); 121 DateTime end1 = new DateTime(2006, 9, 9, 12, 0, 0, 0, PARIS); 122 DateTime end2 = new DateTime(2006, 12, 9, 12, 0, 0, 0, PARIS); 123 124 assertEquals(0, Months.monthsIn((ReadableInterval) null).getMonths()); 125 assertEquals(3, Months.monthsIn(new Interval(start, end1)).getMonths()); 126 assertEquals(0, Months.monthsIn(new Interval(start, start)).getMonths()); 127 assertEquals(0, Months.monthsIn(new Interval(end1, end1)).getMonths()); 128 assertEquals(6, Months.monthsIn(new Interval(start, end2)).getMonths()); 129 } 130 131 public void testFactory_parseMonths_String() { 132 assertEquals(0, Months.parseMonths((String) null).getMonths()); 133 assertEquals(0, Months.parseMonths("P0M").getMonths()); 134 assertEquals(1, Months.parseMonths("P1M").getMonths()); 135 assertEquals(-3, Months.parseMonths("P-3M").getMonths()); 136 assertEquals(2, Months.parseMonths("P0Y2M").getMonths()); 137 assertEquals(2, Months.parseMonths("P2MT0H0M").getMonths()); 138 try { 139 Months.parseMonths("P1Y1D"); 140 fail(); 141 } catch (IllegalArgumentException ex) { 142 // expeceted 143 } 144 try { 145 Months.parseMonths("P1MT1H"); 146 fail(); 147 } catch (IllegalArgumentException ex) { 148 // expeceted 149 } 150 } 151 152 //----------------------------------------------------------------------- 153 public void testGetMethods() { 154 Months test = Months.months(20); 155 assertEquals(20, test.getMonths()); 156 } 157 158 public void testGetFieldType() { 159 Months test = Months.months(20); 160 assertEquals(DurationFieldType.months(), test.getFieldType()); 161 } 162 163 public void testGetPeriodType() { 164 Months test = Months.months(20); 165 assertEquals(PeriodType.months(), test.getPeriodType()); 166 } 167 168 //----------------------------------------------------------------------- 169 public void testIsGreaterThan() { 170 assertEquals(true, Months.THREE.isGreaterThan(Months.TWO)); 171 assertEquals(false, Months.THREE.isGreaterThan(Months.THREE)); 172 assertEquals(false, Months.TWO.isGreaterThan(Months.THREE)); 173 assertEquals(true, Months.ONE.isGreaterThan(null)); 174 assertEquals(false, Months.months(-1).isGreaterThan(null)); 175 } 176 177 public void testIsLessThan() { 178 assertEquals(false, Months.THREE.isLessThan(Months.TWO)); 179 assertEquals(false, Months.THREE.isLessThan(Months.THREE)); 180 assertEquals(true, Months.TWO.isLessThan(Months.THREE)); 181 assertEquals(false, Months.ONE.isLessThan(null)); 182 assertEquals(true, Months.months(-1).isLessThan(null)); 183 } 184 185 //----------------------------------------------------------------------- 186 public void testToString() { 187 Months test = Months.months(20); 188 assertEquals("P20M", test.toString()); 189 190 test = Months.months(-20); 191 assertEquals("P-20M", test.toString()); 192 } 193 194 //----------------------------------------------------------------------- 195 public void testSerialization() throws Exception { 196 Months test = Months.THREE; 197 198 ByteArrayOutputStream baos = new ByteArrayOutputStream(); 199 ObjectOutputStream oos = new ObjectOutputStream(baos); 200 oos.writeObject(test); 201 byte[] bytes = baos.toByteArray(); 202 oos.close(); 203 204 ByteArrayInputStream bais = new ByteArrayInputStream(bytes); 205 ObjectInputStream ois = new ObjectInputStream(bais); 206 Months result = (Months) ois.readObject(); 207 ois.close(); 208 209 assertSame(test, result); 210 } 211 212 //----------------------------------------------------------------------- 213 public void testPlus_int() { 214 Months test2 = Months.months(2); 215 Months result = test2.plus(3); 216 assertEquals(2, test2.getMonths()); 217 assertEquals(5, result.getMonths()); 218 219 assertEquals(1, Months.ONE.plus(0).getMonths()); 220 221 try { 222 Months.MAX_VALUE.plus(1); 223 fail(); 224 } catch (ArithmeticException ex) { 225 // expected 226 } 227 } 228 229 public void testPlus_Months() { 230 Months test2 = Months.months(2); 231 Months test3 = Months.months(3); 232 Months result = test2.plus(test3); 233 assertEquals(2, test2.getMonths()); 234 assertEquals(3, test3.getMonths()); 235 assertEquals(5, result.getMonths()); 236 237 assertEquals(1, Months.ONE.plus(Months.ZERO).getMonths()); 238 assertEquals(1, Months.ONE.plus((Months) null).getMonths()); 239 240 try { 241 Months.MAX_VALUE.plus(Months.ONE); 242 fail(); 243 } catch (ArithmeticException ex) { 244 // expected 245 } 246 } 247 248 public void testMinus_int() { 249 Months test2 = Months.months(2); 250 Months result = test2.minus(3); 251 assertEquals(2, test2.getMonths()); 252 assertEquals(-1, result.getMonths()); 253 254 assertEquals(1, Months.ONE.minus(0).getMonths()); 255 256 try { 257 Months.MIN_VALUE.minus(1); 258 fail(); 259 } catch (ArithmeticException ex) { 260 // expected 261 } 262 } 263 264 public void testMinus_Months() { 265 Months test2 = Months.months(2); 266 Months test3 = Months.months(3); 267 Months result = test2.minus(test3); 268 assertEquals(2, test2.getMonths()); 269 assertEquals(3, test3.getMonths()); 270 assertEquals(-1, result.getMonths()); 271 272 assertEquals(1, Months.ONE.minus(Months.ZERO).getMonths()); 273 assertEquals(1, Months.ONE.minus((Months) null).getMonths()); 274 275 try { 276 Months.MIN_VALUE.minus(Months.ONE); 277 fail(); 278 } catch (ArithmeticException ex) { 279 // expected 280 } 281 } 282 283 public void testMultipliedBy_int() { 284 Months test = Months.months(2); 285 assertEquals(6, test.multipliedBy(3).getMonths()); 286 assertEquals(2, test.getMonths()); 287 assertEquals(-6, test.multipliedBy(-3).getMonths()); 288 assertSame(test, test.multipliedBy(1)); 289 290 Months halfMax = Months.months(Integer.MAX_VALUE / 2 + 1); 291 try { 292 halfMax.multipliedBy(2); 293 fail(); 294 } catch (ArithmeticException ex) { 295 // expected 296 } 297 } 298 299 public void testDividedBy_int() { 300 Months test = Months.months(12); 301 assertEquals(6, test.dividedBy(2).getMonths()); 302 assertEquals(12, test.getMonths()); 303 assertEquals(4, test.dividedBy(3).getMonths()); 304 assertEquals(3, test.dividedBy(4).getMonths()); 305 assertEquals(2, test.dividedBy(5).getMonths()); 306 assertEquals(2, test.dividedBy(6).getMonths()); 307 assertSame(test, test.dividedBy(1)); 308 309 try { 310 Months.ONE.dividedBy(0); 311 fail(); 312 } catch (ArithmeticException ex) { 313 // expected 314 } 315 } 316 317 public void testNegated() { 318 Months test = Months.months(12); 319 assertEquals(-12, test.negated().getMonths()); 320 assertEquals(12, test.getMonths()); 321 322 try { 323 Months.MIN_VALUE.negated(); 324 fail(); 325 } catch (ArithmeticException ex) { 326 // expected 327 } 328 } 329 330 //----------------------------------------------------------------------- 331 public void testAddToLocalDate() { 332 Months test = Months.months(3); 333 LocalDate date = new LocalDate(2006, 6, 1); 334 LocalDate expected = new LocalDate(2006, 9, 1); 335 assertEquals(expected, date.plus(test)); 336 } 337 338 }