//-------------------------------------------------------------------------
public virtual void test_yearFraction()
{
SchedulePeriod test = SchedulePeriod.of(JUN_16, JUL_18, JUN_16, JUL_17);
Schedule schedule = Schedule.ofTerm(test);
assertEquals(test.yearFraction(DayCounts.ACT_360, schedule), DayCounts.ACT_360.yearFraction(JUN_16, JUL_18, schedule), TOLERANCE);
}
//-------------------------------------------------------------------------
public virtual void test_isRegular()
{
assertEquals(SchedulePeriod.of(JUN_18, JUL_18).isRegular(P1M, DAY_18), true);
assertEquals(SchedulePeriod.of(JUN_18, JUL_05).isRegular(P1M, DAY_18), false);
assertEquals(SchedulePeriod.of(JUL_05, JUL_18).isRegular(P1M, DAY_18), false);
assertEquals(SchedulePeriod.of(JUN_18, JUL_05).isRegular(P2M, DAY_18), false);
}
//-------------------------------------------------------------------------
public virtual void test_contains()
{
assertEquals(SchedulePeriod.of(JUN_16, JUL_18, JUN_16, JUL_17).contains(JUN_15), false);
assertEquals(SchedulePeriod.of(JUN_16, JUL_18, JUN_16, JUL_17).contains(JUN_16), true);
assertEquals(SchedulePeriod.of(JUN_16, JUL_18, JUN_16, JUL_17).contains(JUL_05), true);
assertEquals(SchedulePeriod.of(JUN_16, JUL_18, JUN_16, JUL_17).contains(JUL_17), true);
assertEquals(SchedulePeriod.of(JUN_16, JUL_18, JUN_16, JUL_17).contains(JUL_18), false);
}
public virtual void test_isRegular_null()
{
SchedulePeriod test = SchedulePeriod.of(JUN_16, JUL_18);
assertThrowsIllegalArg(() => test.isRegular(null, DAY_18));
assertThrowsIllegalArg(() => test.isRegular(P1M, null));
assertThrowsIllegalArg(() => test.isRegular(null, null));
}
//-------------------------------------------------------------------------
public virtual void test_of_null()
{
assertThrowsIllegalArg(() => SchedulePeriod.of(null, JUL_18, JUL_04, JUL_17));
assertThrowsIllegalArg(() => SchedulePeriod.of(JUL_05, null, JUL_04, JUL_17));
assertThrowsIllegalArg(() => SchedulePeriod.of(JUL_05, JUL_18, null, JUL_17));
assertThrowsIllegalArg(() => SchedulePeriod.of(JUL_05, JUL_18, JUL_04, null));
assertThrowsIllegalArg(() => SchedulePeriod.of(null, null, null, null));
}
public virtual void test_subSchedule_3monthIn3Month()
{
SchedulePeriod test = SchedulePeriod.of(JUN_17, SEP_17);
Schedule schedule = test.subSchedule(P3M, RollConventions.DAY_17, StubConvention.NONE, BusinessDayAdjustment.NONE).createSchedule(REF_DATA);
assertEquals(schedule.size(), 1);
assertEquals(schedule.getPeriod(0), SchedulePeriod.of(JUN_17, SEP_17));
}
public virtual void test_of_noUnadjusted()
{
SchedulePeriod test = SchedulePeriod.of(JUL_05, JUL_18);
assertEquals(test.StartDate, JUL_05);
assertEquals(test.EndDate, JUL_18);
assertEquals(test.UnadjustedStartDate, JUL_05);
assertEquals(test.UnadjustedEndDate, JUL_18);
}
public virtual void test_yearFraction_null()
{
SchedulePeriod test = SchedulePeriod.of(JUN_16, JUL_18, JUN_16, JUL_17);
Schedule schedule = Schedule.ofTerm(test);
assertThrowsIllegalArg(() => test.yearFraction(null, schedule));
assertThrowsIllegalArg(() => test.yearFraction(DayCounts.ACT_360, null));
assertThrowsIllegalArg(() => test.yearFraction(null, null));
}
public virtual void test_builder_defaults()
{
SchedulePeriod test = SchedulePeriod.builder().startDate(JUL_05).endDate(JUL_18).build();
assertEquals(test.StartDate, JUL_05);
assertEquals(test.EndDate, JUL_18);
assertEquals(test.UnadjustedStartDate, JUL_05);
assertEquals(test.UnadjustedEndDate, JUL_18);
}
//-------------------------------------------------------------------------
public virtual void test_toAdjusted()
{
SchedulePeriod period1 = SchedulePeriod.of(JUN_15, SEP_17);
SchedulePeriod period2 = SchedulePeriod.of(SEP_17, SEP_30);
Schedule test = Schedule.builder().periods(period1, period2).frequency(P3M).rollConvention(DAY_17).build();
assertEquals(test.toAdjusted(date => date), test);
assertEquals(test.toAdjusted(date => date.Equals(JUN_15) ? JUN_16 : date), Schedule.builder().periods(SchedulePeriod.of(JUN_16, SEP_17, JUN_15, SEP_17), period2).frequency(P3M).rollConvention(DAY_17).build());
}
public virtual void test_toUnadjusted()
{
SchedulePeriod a = SchedulePeriod.of(JUL_17, OCT_17, JUL_16, OCT_15);
SchedulePeriod b = SchedulePeriod.of(JUL_16, OCT_15, JUL_16, OCT_15);
Schedule test = Schedule.builder().periods(ImmutableList.of(a)).frequency(P1M).rollConvention(DAY_17).build().toUnadjusted();
Schedule expected = Schedule.builder().periods(ImmutableList.of(b)).frequency(P1M).rollConvention(DAY_17).build();
assertEquals(test, expected);
}
/// <summary>
/// Merges this schedule to form a new schedule by combining the schedule periods.
/// <para>
/// This produces a schedule where some periods are merged together.
/// For example, this could be used to convert a 3 monthly schedule into a 6 monthly schedule.
/// </para>
/// <para>
/// The merging is controlled by the group size, which defines the number of periods
/// to merge together in the result. For example, to convert a 3 monthly schedule into
/// a 6 monthly schedule the group size would be 2 (6 divided by 3).
/// </para>
/// <para>
/// A group size of zero or less will throw an exception.
/// A group size of 1 will return this schedule providing that the specified start and end date match.
/// A larger group size will return a schedule where each group of regular periods are merged.
/// </para>
/// <para>
/// The specified dates must be one of the dates of this schedule (unadjusted or adjusted).
/// All periods of this schedule before the first regular start date, if any, will form a single period in the result.
/// All periods of this schedule after the last regular start date, if any, will form a single period in the result.
/// If this schedule has an initial or final stub, it may be merged with a regular period as part of the process.
/// </para>
/// <para>
/// For example, a schedule with an initial stub and 5 regular periods can be grouped by 2 if the
/// specified {@code firstRegularStartDate} equals the end of the first regular period.
///
/// </para>
/// </summary>
/// <param name="groupSize"> the group size </param>
/// <param name="firstRegularStartDate"> the unadjusted start date of the first regular payment period </param>
/// <param name="lastRegularEndDate"> the unadjusted end date of the last regular payment period </param>
/// <returns> the merged schedule </returns>
/// <exception cref="IllegalArgumentException"> if the group size is zero or less </exception>
/// <exception cref="ScheduleException"> if the merged schedule cannot be created because the dates don't
/// match this schedule or the regular periods don't match the grouping size </exception>
public Schedule merge(int groupSize, LocalDate firstRegularStartDate, LocalDate lastRegularEndDate)
{
ArgChecker.notNegativeOrZero(groupSize, "groupSize");
ArgChecker.inOrderOrEqual(firstRegularStartDate, lastRegularEndDate, "firstRegularStartDate", "lastRegularEndDate");
if (SinglePeriod || groupSize == 1)
{
return(this);
}
// determine stubs and regular
int startRegularIndex = -1;
int endRegularIndex = -1;
for (int i = 0; i < size(); i++)
{
SchedulePeriod period = periods.get(i);
if (period.UnadjustedStartDate.Equals(firstRegularStartDate) || period.StartDate.Equals(firstRegularStartDate))
{
startRegularIndex = i;
}
if (period.UnadjustedEndDate.Equals(lastRegularEndDate) || period.EndDate.Equals(lastRegularEndDate))
{
endRegularIndex = i + 1;
}
}
if (startRegularIndex < 0)
{
throw new ScheduleException("Unable to merge schedule, firstRegularStartDate {} does not match any date in the underlying schedule {}", firstRegularStartDate, UnadjustedDates);
}
if (endRegularIndex < 0)
{
throw new ScheduleException("Unable to merge schedule, lastRegularEndDate {} does not match any date in the underlying schedule {}", lastRegularEndDate, UnadjustedDates);
}
int numberRegular = endRegularIndex - startRegularIndex;
if ((numberRegular % groupSize) != 0)
{
Period newFrequency = frequency.Period.multipliedBy(groupSize);
throw new ScheduleException("Unable to merge schedule, firstRegularStartDate {} and lastRegularEndDate {} cannot be used to " + "create regular periods of frequency '{}'", firstRegularStartDate, lastRegularEndDate, newFrequency);
}
IList <SchedulePeriod> newSchedule = new List <SchedulePeriod>();
if (startRegularIndex > 0)
{
newSchedule.Add(createSchedulePeriod(periods.subList(0, startRegularIndex)));
}
for (int i = startRegularIndex; i < endRegularIndex; i += groupSize)
{
newSchedule.Add(createSchedulePeriod(periods.subList(i, i + groupSize)));
}
if (endRegularIndex < periods.size())
{
newSchedule.Add(createSchedulePeriod(periods.subList(endRegularIndex, periods.size())));
}
// build schedule
return(Schedule.builder().periods(newSchedule).frequency(Frequency.of(frequency.Period.multipliedBy(groupSize))).rollConvention(rollConvention).build());
}
//-------------------------------------------------------------------------
public virtual void test_toAdjusted()
{
SchedulePeriod test1 = SchedulePeriod.of(JUN_15, SEP_17);
assertEquals(test1.toAdjusted(date => date), test1);
assertEquals(test1.toAdjusted(date => date.Equals(JUN_15) ? JUN_16 : date), SchedulePeriod.of(JUN_16, SEP_17, JUN_15, SEP_17));
SchedulePeriod test2 = SchedulePeriod.of(JUN_16, AUG_17);
assertEquals(test2.toAdjusted(date => date.Equals(AUG_17) ? AUG_18 : date), SchedulePeriod.of(JUN_16, AUG_18, JUN_16, AUG_17));
}
public virtual void test_subSchedule_2monthIn3Month_shortFinal()
{
SchedulePeriod test = SchedulePeriod.of(JUN_17, SEP_17);
Schedule schedule = test.subSchedule(P2M, RollConventions.DAY_17, StubConvention.SHORT_FINAL, BusinessDayAdjustment.NONE).createSchedule(REF_DATA);
assertEquals(schedule.size(), 2);
assertEquals(schedule.getPeriod(0), SchedulePeriod.of(JUN_17, AUG_17));
assertEquals(schedule.getPeriod(1), SchedulePeriod.of(AUG_17, SEP_17));
assertEquals(schedule.Frequency, P2M);
assertEquals(schedule.RollConvention, RollConventions.DAY_17);
}
//-------------------------------------------------------------------------
/// <summary>
/// Merges this schedule to form a new schedule with a single 'Term' period.
/// <para>
/// The result will have one period of type 'Term', with dates matching this schedule.
///
/// </para>
/// </summary>
/// <returns> the merged 'Term' schedule </returns>
public Schedule mergeToTerm()
{
if (Term)
{
return(this);
}
SchedulePeriod first = FirstPeriod;
SchedulePeriod last = LastPeriod;
return(Schedule.ofTerm(SchedulePeriod.of(first.StartDate, last.EndDate, first.UnadjustedStartDate, last.UnadjustedEndDate)));
}
//-------------------------------------------------------------------------
public virtual void test_subSchedule_1monthIn3Month()
{
SchedulePeriod test = SchedulePeriod.of(JUN_17, SEP_17);
Schedule schedule = test.subSchedule(P1M, RollConventions.DAY_17, StubConvention.NONE, BusinessDayAdjustment.NONE).createSchedule(REF_DATA);
assertEquals(schedule.size(), 3);
assertEquals(schedule.getPeriod(0), SchedulePeriod.of(JUN_17, JUL_17));
assertEquals(schedule.getPeriod(1), SchedulePeriod.of(JUL_17, AUG_17));
assertEquals(schedule.getPeriod(2), SchedulePeriod.of(AUG_17, SEP_17));
assertEquals(schedule.Frequency, P1M);
assertEquals(schedule.RollConvention, RollConventions.DAY_17);
}
// creates a schedule period
private SchedulePeriod createSchedulePeriod(IList <SchedulePeriod> accruals)
{
SchedulePeriod first = accruals[0];
if (accruals.Count == 1)
{
return(first);
}
SchedulePeriod last = accruals[accruals.Count - 1];
return(SchedulePeriod.of(first.StartDate, last.EndDate, first.UnadjustedStartDate, last.UnadjustedEndDate));
}
//-------------------------------------------------------------------------
/// <summary>
/// Converts this schedule to a schedule where all the start and end dates are
/// adjusted using the specified adjuster.
/// <para>
/// The result will have the same number of periods, but each start date and
/// end date is replaced by the adjusted date as returned by the adjuster.
/// The unadjusted start date and unadjusted end date of each period will not be changed.
///
/// </para>
/// </summary>
/// <param name="adjuster"> the adjuster to use </param>
/// <returns> the adjusted schedule </returns>
public Schedule toAdjusted(DateAdjuster adjuster)
{
// implementation needs to return 'this' if unchanged to optimize downstream code
bool adjusted = false;
ImmutableList.Builder <SchedulePeriod> builder = ImmutableList.builder();
foreach (SchedulePeriod period in periods)
{
SchedulePeriod adjPeriod = period.toAdjusted(adjuster);
builder.add(adjPeriod);
adjusted |= (adjPeriod != period);
}
return(adjusted ? new Schedule(builder.build(), frequency, rollConvention) : this);
}
//-------------------------------------------------------------------------
public virtual void coverage_equals()
{
SchedulePeriod a1 = SchedulePeriod.of(JUL_05, JUL_18, JUL_04, JUL_17);
SchedulePeriod a2 = SchedulePeriod.of(JUL_05, JUL_18, JUL_04, JUL_17);
SchedulePeriod b = SchedulePeriod.of(JUL_04, JUL_18, JUL_04, JUL_17);
SchedulePeriod c = SchedulePeriod.of(JUL_05, JUL_17, JUL_04, JUL_17);
SchedulePeriod d = SchedulePeriod.of(JUL_05, JUL_18, JUL_05, JUL_17);
SchedulePeriod e = SchedulePeriod.of(JUL_05, JUL_18, JUL_04, JUL_18);
assertEquals(a1.Equals(a1), true);
assertEquals(a1.Equals(a2), true);
assertEquals(a1.Equals(b), false);
assertEquals(a1.Equals(c), false);
assertEquals(a1.Equals(d), false);
assertEquals(a1.Equals(e), false);
}
//-------------------------------------------------------------------------
public virtual void test_compareTo()
{
SchedulePeriod a = SchedulePeriod.of(JUL_05, JUL_18);
SchedulePeriod b = SchedulePeriod.of(JUL_04, JUL_18);
SchedulePeriod c = SchedulePeriod.of(JUL_05, JUL_17);
assertEquals(a.CompareTo(a) == 0, true);
assertEquals(a.CompareTo(b) > 0, true);
assertEquals(a.CompareTo(c) > 0, true);
assertEquals(b.CompareTo(a) < 0, true);
assertEquals(b.CompareTo(b) == 0, true);
assertEquals(b.CompareTo(c) < 0, true);
assertEquals(c.CompareTo(a) < 0, true);
assertEquals(c.CompareTo(b) > 0, true);
assertEquals(c.CompareTo(c) == 0, true);
}
//-------------------------------------------------------------------------
/// <summary>
/// Obtains a 'Term' instance based on a single period.
/// <para>
/// A 'Term' schedule has one period with a frequency of 'Term'.
///
/// </para>
/// </summary>
/// <param name="period"> the single period </param>
/// <returns> the merged 'Term' schedule </returns>
public static Schedule ofTerm(SchedulePeriod period)
{
ArgChecker.notNull(period, "period");
return(Schedule.builder().periods(ImmutableList.of(period)).frequency(Frequency.TERM).rollConvention(RollConventions.NONE).build());
}
//-------------------------------------------------------------------------
public virtual void test_length()
{
assertEquals(SchedulePeriod.of(JUN_16, JUN_18, JUN_16, JUN_18).length(), Period.between(JUN_16, JUN_18));
assertEquals(SchedulePeriod.of(JUN_16, JUL_18, JUN_16, JUL_17).length(), Period.between(JUN_16, JUL_18));
}
//-------------------------------------------------------------------------
public virtual void test_lengthInDays()
{
assertEquals(SchedulePeriod.of(JUN_16, JUN_18, JUN_16, JUN_18).lengthInDays(), 2);
assertEquals(SchedulePeriod.of(JUN_16, JUL_18, JUN_16, JUL_17).lengthInDays(), 32);
}
public virtual void test_serialization()
{
SchedulePeriod test = SchedulePeriod.of(JUL_05, JUL_18, JUL_04, JUL_17);
assertSerialization(test);
}
//-------------------------------------------------------------------------
public virtual void coverage()
{
SchedulePeriod test = SchedulePeriod.of(JUL_05, JUL_18, JUL_04, JUL_17);
coverImmutableBean(test);
}
//-------------------------------------------------------------------------
public virtual void coverage_builder()
{
SchedulePeriod.Builder builder = SchedulePeriod.builder();
builder.startDate(JUL_05).endDate(JUL_18).unadjustedStartDate(JUL_04).unadjustedEndDate(JUL_17).build();
}
public virtual void test_toUnadjusted()
{
assertEquals(SchedulePeriod.of(JUN_15, SEP_17).toUnadjusted(), SchedulePeriod.of(JUN_15, SEP_17));
assertEquals(SchedulePeriod.of(JUN_16, SEP_17, JUN_15, SEP_17).toUnadjusted(), SchedulePeriod.of(JUN_15, SEP_17));
assertEquals(SchedulePeriod.of(JUN_16, JUL_18, JUN_16, JUL_17).toUnadjusted(), SchedulePeriod.of(JUN_16, JUL_17));
}
public virtual void test_contains_null()
{
SchedulePeriod test = SchedulePeriod.of(JUN_16, JUL_18);
assertThrowsIllegalArg(() => test.contains(null));
}
