@DataProvider(name = "businessDayAdjustment") public static Object[][] data_businessDayAdjustment() { return new Object[][] { {CdsConventions.EUR_GB_STANDARD, BusinessDayAdjustment.of(FOLLOWING, GBLO_EUTA)}, {CdsConventions.EUR_STANDARD, BusinessDayAdjustment.of(FOLLOWING, EUTA)}, {CdsConventions.GBP_STANDARD, BusinessDayAdjustment.of(FOLLOWING, GBLO)}, {CdsConventions.GBP_US_STANDARD, BusinessDayAdjustment.of(FOLLOWING, GBLO_USNY)}, {CdsConventions.JPY_STANDARD, BusinessDayAdjustment.of(FOLLOWING, JPTO)}, {CdsConventions.JPY_US_GB_STANDARD, BusinessDayAdjustment.of(FOLLOWING, GBLO_USNY_JPTO)}, {CdsConventions.USD_STANDARD, BusinessDayAdjustment.of(FOLLOWING, USNY)} }; }
/** * Adjusts the date using the business day adjustment. * <p> * This returns the adjusted date, calculated by applying the business day * adjustment to the unadjusted date. * * @param refData the reference data to use * @return the adjusted date */ public LocalDate adjusted(ReferenceData refData) { return adjustment.adjust(unadjusted, refData); }
public void test_basics() { BusinessDayAdjustment test = BusinessDayAdjustment.of(MODIFIED_FOLLOWING, SAT_SUN); assertEquals(test.getConvention(), MODIFIED_FOLLOWING); assertEquals(test.getCalendar(), SAT_SUN); assertEquals(test.toString(), "ModifiedFollowing using calendar Sat/Sun"); }
/** * Restricted copy constructor. * @param beanToCopy the bean to copy from, not null */ private Builder(BusinessDayAdjustment beanToCopy) { this.convention = beanToCopy.getConvention(); this.calendar = beanToCopy.getCalendar(); }
public void test_noAdjust_constant() { BusinessDayAdjustment test = BusinessDayAdjustment.NONE; assertEquals(test.getConvention(), BusinessDayConventions.NO_ADJUST); assertEquals(test.getCalendar(), NO_HOLIDAYS); assertEquals(test.toString(), "NoAdjust"); }
@Test public void testImmutableReferenceDataWithMergedHolidays() { HolidayCalendar hc = HolidayCalendars.FRI_SAT.combinedWith(HolidayCalendars.SAT_SUN); ImmutableReferenceData referenceData = ImmutableReferenceData.of(hc.getId(), hc); LocalDate date = BusinessDayAdjustment.of(BusinessDayConventions.PRECEDING, hc.getId()).adjust(LocalDate.of(2016, 8, 20), referenceData); assertEquals(LocalDate.of(2016, 8, 18), date); }
@Test(dataProvider = "convention", dataProviderClass = BusinessDayConventionTest.class) public void test_adjustDate(BusinessDayConvention convention, LocalDate input, LocalDate expected) { BusinessDayAdjustment test = BusinessDayAdjustment.of(convention, SAT_SUN); assertEquals(test.adjust(input, REF_DATA), expected); assertEquals(test.resolve(REF_DATA).adjust(input), expected); }
resolvedDate = bda1.adjust(baseDate.plus(period), refData); } else { LocalDate datePlusBusDays = bda1.getCalendar().resolve(refData).shift(baseDate, period.getDays()); resolvedDate = bda1.adjust(datePlusBusDays, refData);
/** * Gets the holiday calendar that will be applied to the result. * <p> * This adjustment may contain more than one holiday calendar. * This method returns the calendar used last. * As such, the adjusted date will always be valid according to this calendar. * * @return the result holiday calendar */ public HolidayCalendarId getResultCalendar() { HolidayCalendarId cal = adjustment.getCalendar(); if (cal == HolidayCalendarIds.NO_HOLIDAYS) { cal = calendar; } return cal; }
public void coverage_builder() { BusinessDayAdjustment test = BusinessDayAdjustment.builder() .convention(MODIFIED_FOLLOWING) .calendar(SAT_SUN) .build(); assertEquals(test.getConvention(), MODIFIED_FOLLOWING); assertEquals(test.getCalendar(), SAT_SUN); }
@Test(dataProvider = "dayConvention") public void test_day_convention(OvernightIborSwapConvention convention, BusinessDayConvention dayConvention) { assertEquals(convention.getOvernightLeg().getAccrualBusinessDayAdjustment().getConvention(), dayConvention); }
/** * Returns a string describing the adjustment. * * @return the descriptive string */ @Override public String toString() { if (this.equals(NONE)) { return convention.toString(); } return convention + " using calendar " + calendar.getName(); }
/** * Converts this swap leg to the equivalent {@code ResolvedSwapLeg}. * <p> * An {@link ResolvedSwapLeg} represents the same data as this leg, but with * the schedules resolved to be {@link SwapPaymentPeriod} instances. * * @return the equivalent resolved swap leg * @throws ReferenceDataNotFoundException if an identifier cannot be resolved in the reference data * @throws RuntimeException if unable to resolve due to an invalid definition */ @Override public ResolvedSwapLeg resolve(ReferenceData refData) { DateAdjuster paymentDateAdjuster = paymentBusinessDayAdjustment.resolve(refData); ImmutableList<NotionalPaymentPeriod> adjusted = paymentPeriods.stream() .map(pp -> pp.adjustPaymentDate(paymentDateAdjuster)) .collect(toImmutableList()); ImmutableList<SwapPaymentEvent> payEvents = createEvents(adjusted, paymentDateAdjuster, refData); return new ResolvedSwapLeg(type, payReceive, adjusted, payEvents, currency); }
public void test_resolve() { BusinessDayAdjustment bussAdj = BusinessDayAdjustment.of(FOLLOWING, SAT_SUN); ResolvedCds test = PRODUCT_STD.resolve(REF_DATA); int nDates = 44; LocalDate start = i == 0 ? dates[i] : bussAdj.adjust(dates[i], REF_DATA); LocalDate end = bussAdj.adjust(dates[i + 1], REF_DATA); payments.add(CreditCouponPaymentPeriod.builder() .startDate(start) .build()); LocalDate start = bussAdj.adjust(dates[nDates - 2], REF_DATA); LocalDate end = dates[nDates - 1]; payments.add(CreditCouponPaymentPeriod.builder() .effectiveStartDate(start.minusDays(1)) .effectiveEndDate(end) .paymentDate(bussAdj.adjust(end, REF_DATA)) .currency(USD) .notional(NOTIONAL)
@Override protected Object propertyGet(Bean bean, String propertyName, boolean quiet) { switch (propertyName.hashCode()) { case 2039569265: // convention return ((BusinessDayAdjustment) bean).getConvention(); case -178324674: // calendar return ((BusinessDayAdjustment) bean).getCalendar(); } return super.propertyGet(bean, propertyName, quiet); }
@ImmutablePreBuild private static void preBuild(Builder builder) { if (builder.settlementDateOffset == null && builder.paymentSchedule != null) { builder.settlementDateOffset = DaysAdjustment.ofBusinessDays(3, builder.paymentSchedule.getBusinessDayAdjustment().getCalendar()); } }
@Test(dataProvider = "dayConvention") public void test_day_convention(FixedOvernightSwapConvention convention, BusinessDayConvention dayConvention) { assertEquals(convention.getFixedLeg().getAccrualBusinessDayAdjustment().getConvention(), dayConvention); }
/** * Returns a string describing the adjustment. * * @return the descriptive string */ @Override public String toString() { StringBuilder buf = new StringBuilder(64); buf.append(tenor); if (additionConvention != PeriodAdditionConventions.NONE) { buf.append(" with ").append(additionConvention); } if (adjustment.equals(BusinessDayAdjustment.NONE) == false) { buf.append(" then apply ").append(adjustment); } return buf.toString(); }
@Override public ResolvedFxSingle resolve(ReferenceData refData) { if (paymentDateAdjustment == null) { return ResolvedFxSingle.of(baseCurrencyPayment, counterCurrencyPayment); } DateAdjuster adjuster = paymentDateAdjustment.resolve(refData); return ResolvedFxSingle.of(baseCurrencyPayment.adjustDate(adjuster), counterCurrencyPayment.adjustDate(adjuster)); }
@DataProvider(name = "flatLegBda") public static Object[][] data_flat_leg_bda() { return new Object[][] { {XCcyIborIborSwapConventions.EUR_EURIBOR_3M_USD_LIBOR_3M, BusinessDayAdjustment.of(MODIFIED_FOLLOWING, EUTA_USNY)}, {XCcyIborIborSwapConventions.GBP_LIBOR_3M_USD_LIBOR_3M, BusinessDayAdjustment.of(MODIFIED_FOLLOWING, GBLO_USNY)}, {XCcyIborIborSwapConventions.GBP_LIBOR_3M_EUR_EURIBOR_3M, BusinessDayAdjustment.of(MODIFIED_FOLLOWING, EUTA_GBLO)}, {XCcyIborIborSwapConventions.GBP_LIBOR_3M_JPY_LIBOR_3M, BusinessDayAdjustment.of(MODIFIED_FOLLOWING, GBLO_JPTO)} }; }