//------------------------------------------------------------------------- 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_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_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_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_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_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_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_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_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); }
//------------------------------------------------------------------------- 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))); }
// 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)); }
//------------------------------------------------------------------------- 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); }
//------------------------------------------------------------------------- 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); }
//------------------------------------------------------------------------- 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_contains_null() { SchedulePeriod test = SchedulePeriod.of(JUN_16, JUL_18); assertThrowsIllegalArg(() => test.contains(null)); }
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 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)); }