public void testWithFieldAdded_DurationFieldType_int_5() {
LocalTime test = new LocalTime(10, 20, 30, 40);
try {
test.withFieldAdded(DurationFieldType.days(), 6);
fail();
} catch (IllegalArgumentException ex) {
}
}
public void testIsSupported_DurationFieldType() {
LocalTime test = new LocalTime(10, 20, 30, 40);
assertEquals(true, test.isSupported(DurationFieldType.hours()));
assertEquals(true, test.isSupported(DurationFieldType.minutes()));
assertEquals(true, test.isSupported(DurationFieldType.seconds()));
assertEquals(true, test.isSupported(DurationFieldType.millis()));
assertEquals(true, test.isSupported(DurationFieldType.halfdays()));
assertEquals(false, test.isSupported(DurationFieldType.days()));
assertEquals(false, test.isSupported((DurationFieldType) null));
}
/**
* Gets a type that defines just the days field.
*
* @return the period type
*/
public static PeriodType days() {
PeriodType type = cDays;
if (type == null) {
type =
new PeriodType(
"Days",
new DurationFieldType[] {DurationFieldType.days()},
new int[] {
-1, -1, -1, 0, -1, -1, -1, -1,
});
cDays = type;
}
return type;
}
/**
* Gets a type that defines the year and day fields.
*
* <ul>
* <li>years
* <li>days
* </ul>
*
* @return the period type
* @since 1.1
*/
public static PeriodType yearDay() {
PeriodType type = cYD;
if (type == null) {
type =
new PeriodType(
"YearDay",
new DurationFieldType[] {
DurationFieldType.years(), DurationFieldType.days(),
},
new int[] {
0, -1, -1, 1, -1, -1, -1, -1,
});
cYD = type;
}
return type;
}
/**
* Gets a type that defines all standard fields except months and weeks.
*
* <ul>
* <li>years
* <li>days
* <li>hours
* <li>minutes
* <li>seconds
* <li>milliseconds
* </ul>
*
* @return the period type
*/
public static PeriodType yearDayTime() {
PeriodType type = cYDTime;
if (type == null) {
type =
new PeriodType(
"YearDayTime",
new DurationFieldType[] {
DurationFieldType.years(), DurationFieldType.days(),
DurationFieldType.hours(), DurationFieldType.minutes(),
DurationFieldType.seconds(), DurationFieldType.millis(),
},
new int[] {
0, -1, -1, 1, 2, 3, 4, 5,
});
cYDTime = type;
}
return type;
}
/**
* Gets a type that defines all standard fields.
*
* <ul>
* <li>years
* <li>months
* <li>weeks
* <li>days
* <li>hours
* <li>minutes
* <li>seconds
* <li>milliseconds
* </ul>
*
* @return the period type
*/
public static PeriodType standard() {
PeriodType type = cStandard;
if (type == null) {
type =
new PeriodType(
"Standard",
new DurationFieldType[] {
DurationFieldType.years(), DurationFieldType.months(),
DurationFieldType.weeks(), DurationFieldType.days(),
DurationFieldType.hours(), DurationFieldType.minutes(),
DurationFieldType.seconds(), DurationFieldType.millis(),
},
new int[] {
0, 1, 2, 3, 4, 5, 6, 7,
});
cStandard = type;
}
return type;
}
/**
* Gets a period type that contains the duration types of the array.
*
* <p>Only the 8 standard duration field types are supported.
*
* @param types the types to include in the array.
* @return the period type
* @since 1.1
*/
public static synchronized PeriodType forFields(DurationFieldType[] types) {
if (types == null || types.length == 0) {
throw new IllegalArgumentException("Types array must not be null or empty");
}
for (int i = 0; i < types.length; i++) {
if (types[i] == null) {
throw new IllegalArgumentException("Types array must not contain null");
}
}
Map<PeriodType, PeriodType> cache = cTypes;
if (cTypes.isEmpty()) {
cache.put(standard(), standard());
cache.put(yearMonthDayTime(), yearMonthDayTime());
cache.put(yearMonthDay(), yearMonthDay());
cache.put(yearWeekDayTime(), yearWeekDayTime());
cache.put(yearWeekDay(), yearWeekDay());
cache.put(yearDayTime(), yearDayTime());
cache.put(yearDay(), yearDay());
cache.put(dayTime(), dayTime());
cache.put(time(), time());
cache.put(years(), years());
cache.put(months(), months());
cache.put(weeks(), weeks());
cache.put(days(), days());
cache.put(hours(), hours());
cache.put(minutes(), minutes());
cache.put(seconds(), seconds());
cache.put(millis(), millis());
}
PeriodType inPartType = new PeriodType(null, types, null);
Object cached = cache.get(inPartType);
if (cached instanceof PeriodType) {
return (PeriodType) cached;
}
if (cached != null) {
throw new IllegalArgumentException("PeriodType does not support fields: " + cached);
}
PeriodType type = standard();
List<DurationFieldType> list = new ArrayList<DurationFieldType>(Arrays.asList(types));
if (list.remove(DurationFieldType.years()) == false) {
type = type.withYearsRemoved();
}
if (list.remove(DurationFieldType.months()) == false) {
type = type.withMonthsRemoved();
}
if (list.remove(DurationFieldType.weeks()) == false) {
type = type.withWeeksRemoved();
}
if (list.remove(DurationFieldType.days()) == false) {
type = type.withDaysRemoved();
}
if (list.remove(DurationFieldType.hours()) == false) {
type = type.withHoursRemoved();
}
if (list.remove(DurationFieldType.minutes()) == false) {
type = type.withMinutesRemoved();
}
if (list.remove(DurationFieldType.seconds()) == false) {
type = type.withSecondsRemoved();
}
if (list.remove(DurationFieldType.millis()) == false) {
type = type.withMillisRemoved();
}
if (list.size() > 0) {
// cache.put(inPartType, list);
throw new IllegalArgumentException("PeriodType does not support fields: " + list);
}
// recheck cache in case initial array order was wrong
PeriodType checkPartType = new PeriodType(null, type.iTypes, null);
PeriodType checkedType = (PeriodType) cache.get(checkPartType);
if (checkedType != null) {
cache.put(inPartType, checkedType);
return checkedType;
}
cache.put(inPartType, type);
return type;
}
