/* | |
* Copyright 2001-2013 Stephen Colebourne | |
* | |
* Licensed under the Apache License, Version 2.0 (the "License"); | |
* you may not use this file except in compliance with the License. | |
* You may obtain a copy of the License at | |
* | |
* http://www.apache.org/licenses/LICENSE-2.0 | |
* | |
* Unless required by applicable law or agreed to in writing, software | |
* distributed under the License is distributed on an "AS IS" BASIS, | |
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
* See the License for the specific language governing permissions and | |
* limitations under the License. | |
*/ | |
package org.joda.time; | |
import java.io.ByteArrayInputStream; | |
import java.io.ByteArrayOutputStream; | |
import java.io.ObjectInputStream; | |
import java.io.ObjectOutputStream; | |
import junit.framework.TestCase; | |
import junit.framework.TestSuite; | |
/** | |
* This class is a Junit unit test for Hours. | |
* | |
* @author Stephen Colebourne | |
*/ | |
public class TestHours extends TestCase { | |
// Test in 2002/03 as time zones are more well known | |
// (before the late 90's they were all over the place) | |
private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris"); | |
public static void main(String[] args) { | |
junit.textui.TestRunner.run(suite()); | |
} | |
public static TestSuite suite() { | |
return new TestSuite(TestHours.class); | |
} | |
public TestHours(String name) { | |
super(name); | |
} | |
protected void setUp() throws Exception { | |
} | |
protected void tearDown() throws Exception { | |
} | |
//----------------------------------------------------------------------- | |
public void testConstants() { | |
assertEquals(0, Hours.ZERO.getHours()); | |
assertEquals(1, Hours.ONE.getHours()); | |
assertEquals(2, Hours.TWO.getHours()); | |
assertEquals(3, Hours.THREE.getHours()); | |
assertEquals(4, Hours.FOUR.getHours()); | |
assertEquals(5, Hours.FIVE.getHours()); | |
assertEquals(6, Hours.SIX.getHours()); | |
assertEquals(7, Hours.SEVEN.getHours()); | |
assertEquals(8, Hours.EIGHT.getHours()); | |
assertEquals(Integer.MAX_VALUE, Hours.MAX_VALUE.getHours()); | |
assertEquals(Integer.MIN_VALUE, Hours.MIN_VALUE.getHours()); | |
} | |
//----------------------------------------------------------------------- | |
public void testFactory_hours_int() { | |
assertSame(Hours.ZERO, Hours.hours(0)); | |
assertSame(Hours.ONE, Hours.hours(1)); | |
assertSame(Hours.TWO, Hours.hours(2)); | |
assertSame(Hours.THREE, Hours.hours(3)); | |
assertSame(Hours.FOUR, Hours.hours(4)); | |
assertSame(Hours.FIVE, Hours.hours(5)); | |
assertSame(Hours.SIX, Hours.hours(6)); | |
assertSame(Hours.SEVEN, Hours.hours(7)); | |
assertSame(Hours.EIGHT, Hours.hours(8)); | |
assertSame(Hours.MAX_VALUE, Hours.hours(Integer.MAX_VALUE)); | |
assertSame(Hours.MIN_VALUE, Hours.hours(Integer.MIN_VALUE)); | |
assertEquals(-1, Hours.hours(-1).getHours()); | |
assertEquals(9, Hours.hours(9).getHours()); | |
} | |
//----------------------------------------------------------------------- | |
public void testFactory_hoursBetween_RInstant() { | |
DateTime start = new DateTime(2006, 6, 9, 12, 0, 0, 0, PARIS); | |
DateTime end1 = new DateTime(2006, 6, 9, 15, 0, 0, 0, PARIS); | |
DateTime end2 = new DateTime(2006, 6, 9, 18, 0, 0, 0, PARIS); | |
assertEquals(3, Hours.hoursBetween(start, end1).getHours()); | |
assertEquals(0, Hours.hoursBetween(start, start).getHours()); | |
assertEquals(0, Hours.hoursBetween(end1, end1).getHours()); | |
assertEquals(-3, Hours.hoursBetween(end1, start).getHours()); | |
assertEquals(6, Hours.hoursBetween(start, end2).getHours()); | |
} | |
public void testFactory_hoursBetween_RPartial() { | |
LocalTime start = new LocalTime(12, 0); | |
LocalTime end1 = new LocalTime(15, 0); | |
@SuppressWarnings("deprecation") | |
TimeOfDay end2 = new TimeOfDay(18, 0); | |
assertEquals(3, Hours.hoursBetween(start, end1).getHours()); | |
assertEquals(0, Hours.hoursBetween(start, start).getHours()); | |
assertEquals(0, Hours.hoursBetween(end1, end1).getHours()); | |
assertEquals(-3, Hours.hoursBetween(end1, start).getHours()); | |
assertEquals(6, Hours.hoursBetween(start, end2).getHours()); | |
} | |
public void testFactory_hoursIn_RInterval() { | |
DateTime start = new DateTime(2006, 6, 9, 12, 0, 0, 0, PARIS); | |
DateTime end1 = new DateTime(2006, 6, 9, 15, 0, 0, 0, PARIS); | |
DateTime end2 = new DateTime(2006, 6, 9, 18, 0, 0, 0, PARIS); | |
assertEquals(0, Hours.hoursIn((ReadableInterval) null).getHours()); | |
assertEquals(3, Hours.hoursIn(new Interval(start, end1)).getHours()); | |
assertEquals(0, Hours.hoursIn(new Interval(start, start)).getHours()); | |
assertEquals(0, Hours.hoursIn(new Interval(end1, end1)).getHours()); | |
assertEquals(6, Hours.hoursIn(new Interval(start, end2)).getHours()); | |
} | |
public void testFactory_standardHoursIn_RPeriod() { | |
assertEquals(0, Hours.standardHoursIn((ReadablePeriod) null).getHours()); | |
assertEquals(0, Hours.standardHoursIn(Period.ZERO).getHours()); | |
assertEquals(1, Hours.standardHoursIn(new Period(0, 0, 0, 0, 1, 0, 0, 0)).getHours()); | |
assertEquals(123, Hours.standardHoursIn(Period.hours(123)).getHours()); | |
assertEquals(-987, Hours.standardHoursIn(Period.hours(-987)).getHours()); | |
assertEquals(1, Hours.standardHoursIn(Period.minutes(119)).getHours()); | |
assertEquals(2, Hours.standardHoursIn(Period.minutes(120)).getHours()); | |
assertEquals(2, Hours.standardHoursIn(Period.minutes(121)).getHours()); | |
assertEquals(48, Hours.standardHoursIn(Period.days(2)).getHours()); | |
try { | |
Hours.standardHoursIn(Period.months(1)); | |
fail(); | |
} catch (IllegalArgumentException ex) { | |
// expeceted | |
} | |
} | |
public void testFactory_parseHours_String() { | |
assertEquals(0, Hours.parseHours((String) null).getHours()); | |
assertEquals(0, Hours.parseHours("PT0H").getHours()); | |
assertEquals(1, Hours.parseHours("PT1H").getHours()); | |
assertEquals(-3, Hours.parseHours("PT-3H").getHours()); | |
assertEquals(2, Hours.parseHours("P0Y0M0DT2H").getHours()); | |
assertEquals(2, Hours.parseHours("PT2H0M").getHours()); | |
try { | |
Hours.parseHours("P1Y1D"); | |
fail(); | |
} catch (IllegalArgumentException ex) { | |
// expeceted | |
} | |
try { | |
Hours.parseHours("P1DT1H"); | |
fail(); | |
} catch (IllegalArgumentException ex) { | |
// expeceted | |
} | |
} | |
//----------------------------------------------------------------------- | |
public void testGetMethods() { | |
Hours test = Hours.hours(20); | |
assertEquals(20, test.getHours()); | |
} | |
public void testGetFieldType() { | |
Hours test = Hours.hours(20); | |
assertEquals(DurationFieldType.hours(), test.getFieldType()); | |
} | |
public void testGetPeriodType() { | |
Hours test = Hours.hours(20); | |
assertEquals(PeriodType.hours(), test.getPeriodType()); | |
} | |
//----------------------------------------------------------------------- | |
public void testIsGreaterThan() { | |
assertEquals(true, Hours.THREE.isGreaterThan(Hours.TWO)); | |
assertEquals(false, Hours.THREE.isGreaterThan(Hours.THREE)); | |
assertEquals(false, Hours.TWO.isGreaterThan(Hours.THREE)); | |
assertEquals(true, Hours.ONE.isGreaterThan(null)); | |
assertEquals(false, Hours.hours(-1).isGreaterThan(null)); | |
} | |
public void testIsLessThan() { | |
assertEquals(false, Hours.THREE.isLessThan(Hours.TWO)); | |
assertEquals(false, Hours.THREE.isLessThan(Hours.THREE)); | |
assertEquals(true, Hours.TWO.isLessThan(Hours.THREE)); | |
assertEquals(false, Hours.ONE.isLessThan(null)); | |
assertEquals(true, Hours.hours(-1).isLessThan(null)); | |
} | |
//----------------------------------------------------------------------- | |
public void testToString() { | |
Hours test = Hours.hours(20); | |
assertEquals("PT20H", test.toString()); | |
test = Hours.hours(-20); | |
assertEquals("PT-20H", test.toString()); | |
} | |
//----------------------------------------------------------------------- | |
public void testSerialization() throws Exception { | |
Hours test = Hours.SEVEN; | |
ByteArrayOutputStream baos = new ByteArrayOutputStream(); | |
ObjectOutputStream oos = new ObjectOutputStream(baos); | |
oos.writeObject(test); | |
byte[] bytes = baos.toByteArray(); | |
oos.close(); | |
ByteArrayInputStream bais = new ByteArrayInputStream(bytes); | |
ObjectInputStream ois = new ObjectInputStream(bais); | |
Hours result = (Hours) ois.readObject(); | |
ois.close(); | |
assertSame(test, result); | |
} | |
//----------------------------------------------------------------------- | |
public void testToStandardWeeks() { | |
Hours test = Hours.hours(24 * 7 * 2); | |
Weeks expected = Weeks.weeks(2); | |
assertEquals(expected, test.toStandardWeeks()); | |
} | |
public void testToStandardDays() { | |
Hours test = Hours.hours(24 * 2); | |
Days expected = Days.days(2); | |
assertEquals(expected, test.toStandardDays()); | |
} | |
public void testToStandardMinutes() { | |
Hours test = Hours.hours(3); | |
Minutes expected = Minutes.minutes(3 * 60); | |
assertEquals(expected, test.toStandardMinutes()); | |
try { | |
Hours.MAX_VALUE.toStandardMinutes(); | |
fail(); | |
} catch (ArithmeticException ex) { | |
// expected | |
} | |
} | |
public void testToStandardSeconds() { | |
Hours test = Hours.hours(3); | |
Seconds expected = Seconds.seconds(3 * 60 * 60); | |
assertEquals(expected, test.toStandardSeconds()); | |
try { | |
Hours.MAX_VALUE.toStandardSeconds(); | |
fail(); | |
} catch (ArithmeticException ex) { | |
// expected | |
} | |
} | |
public void testToStandardDuration() { | |
Hours test = Hours.hours(20); | |
Duration expected = new Duration(20L * DateTimeConstants.MILLIS_PER_HOUR); | |
assertEquals(expected, test.toStandardDuration()); | |
expected = new Duration(((long) Integer.MAX_VALUE) * DateTimeConstants.MILLIS_PER_HOUR); | |
assertEquals(expected, Hours.MAX_VALUE.toStandardDuration()); | |
} | |
//----------------------------------------------------------------------- | |
public void testPlus_int() { | |
Hours test2 = Hours.hours(2); | |
Hours result = test2.plus(3); | |
assertEquals(2, test2.getHours()); | |
assertEquals(5, result.getHours()); | |
assertEquals(1, Hours.ONE.plus(0).getHours()); | |
try { | |
Hours.MAX_VALUE.plus(1); | |
fail(); | |
} catch (ArithmeticException ex) { | |
// expected | |
} | |
} | |
public void testPlus_Hours() { | |
Hours test2 = Hours.hours(2); | |
Hours test3 = Hours.hours(3); | |
Hours result = test2.plus(test3); | |
assertEquals(2, test2.getHours()); | |
assertEquals(3, test3.getHours()); | |
assertEquals(5, result.getHours()); | |
assertEquals(1, Hours.ONE.plus(Hours.ZERO).getHours()); | |
assertEquals(1, Hours.ONE.plus((Hours) null).getHours()); | |
try { | |
Hours.MAX_VALUE.plus(Hours.ONE); | |
fail(); | |
} catch (ArithmeticException ex) { | |
// expected | |
} | |
} | |
public void testMinus_int() { | |
Hours test2 = Hours.hours(2); | |
Hours result = test2.minus(3); | |
assertEquals(2, test2.getHours()); | |
assertEquals(-1, result.getHours()); | |
assertEquals(1, Hours.ONE.minus(0).getHours()); | |
try { | |
Hours.MIN_VALUE.minus(1); | |
fail(); | |
} catch (ArithmeticException ex) { | |
// expected | |
} | |
} | |
public void testMinus_Hours() { | |
Hours test2 = Hours.hours(2); | |
Hours test3 = Hours.hours(3); | |
Hours result = test2.minus(test3); | |
assertEquals(2, test2.getHours()); | |
assertEquals(3, test3.getHours()); | |
assertEquals(-1, result.getHours()); | |
assertEquals(1, Hours.ONE.minus(Hours.ZERO).getHours()); | |
assertEquals(1, Hours.ONE.minus((Hours) null).getHours()); | |
try { | |
Hours.MIN_VALUE.minus(Hours.ONE); | |
fail(); | |
} catch (ArithmeticException ex) { | |
// expected | |
} | |
} | |
public void testMultipliedBy_int() { | |
Hours test = Hours.hours(2); | |
assertEquals(6, test.multipliedBy(3).getHours()); | |
assertEquals(2, test.getHours()); | |
assertEquals(-6, test.multipliedBy(-3).getHours()); | |
assertSame(test, test.multipliedBy(1)); | |
Hours halfMax = Hours.hours(Integer.MAX_VALUE / 2 + 1); | |
try { | |
halfMax.multipliedBy(2); | |
fail(); | |
} catch (ArithmeticException ex) { | |
// expected | |
} | |
} | |
public void testDividedBy_int() { | |
Hours test = Hours.hours(12); | |
assertEquals(6, test.dividedBy(2).getHours()); | |
assertEquals(12, test.getHours()); | |
assertEquals(4, test.dividedBy(3).getHours()); | |
assertEquals(3, test.dividedBy(4).getHours()); | |
assertEquals(2, test.dividedBy(5).getHours()); | |
assertEquals(2, test.dividedBy(6).getHours()); | |
assertSame(test, test.dividedBy(1)); | |
try { | |
Hours.ONE.dividedBy(0); | |
fail(); | |
} catch (ArithmeticException ex) { | |
// expected | |
} | |
} | |
public void testNegated() { | |
Hours test = Hours.hours(12); | |
assertEquals(-12, test.negated().getHours()); | |
assertEquals(12, test.getHours()); | |
try { | |
Hours.MIN_VALUE.negated(); | |
fail(); | |
} catch (ArithmeticException ex) { | |
// expected | |
} | |
} | |
//----------------------------------------------------------------------- | |
public void testAddToLocalDate() { | |
Hours test = Hours.hours(26); | |
LocalDateTime date = new LocalDateTime(2006, 6, 1, 0, 0, 0, 0); | |
LocalDateTime expected = new LocalDateTime(2006, 6, 2, 2, 0, 0, 0); | |
assertEquals(expected, date.plus(test)); | |
} | |
} |