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 }