public virtual void test_inflation_fixed()
{
BusinessDayAdjustment bda = BusinessDayAdjustment.of(FOLLOWING, GBLO);
PeriodicSchedule accrualSchedule = PeriodicSchedule.builder().startDate(DATE_14_06_09).endDate(DATE_19_06_09).frequency(P12M).businessDayAdjustment(bda).build();
PaymentSchedule paymentSchedule = PaymentSchedule.builder().paymentFrequency(Frequency.ofYears(5)).paymentDateOffset(DaysAdjustment.ofBusinessDays(2, GBLO)).compoundingMethod(STRAIGHT).build();
FixedRateCalculation rateCalc = FixedRateCalculation.builder().rate(ValueSchedule.of(0.05)).dayCount(ONE_ONE).build();
NotionalSchedule notionalSchedule = NotionalSchedule.of(GBP, 1000d);
RateCalculationSwapLeg test = RateCalculationSwapLeg.builder().payReceive(RECEIVE).accrualSchedule(accrualSchedule).paymentSchedule(paymentSchedule).notionalSchedule(notionalSchedule).calculation(rateCalc).build();
assertEquals(test.StartDate, AdjustableDate.of(DATE_14_06_09, bda));
assertEquals(test.EndDate, AdjustableDate.of(DATE_19_06_09, bda));
assertEquals(test.Currency, GBP);
assertEquals(test.PayReceive, RECEIVE);
assertEquals(test.AccrualSchedule, accrualSchedule);
assertEquals(test.PaymentSchedule, paymentSchedule);
assertEquals(test.NotionalSchedule, notionalSchedule);
assertEquals(test.Calculation, rateCalc);
RateAccrualPeriod rap0 = RateAccrualPeriod.builder().startDate(bda.adjust(DATE_14_06_09, REF_DATA)).endDate(bda.adjust(DATE_14_06_09.plusYears(1), REF_DATA)).unadjustedStartDate(DATE_14_06_09).unadjustedEndDate(DATE_14_06_09.plusYears(1)).yearFraction(1.0).rateComputation(FixedRateComputation.of(0.05)).build();
RateAccrualPeriod rap1 = RateAccrualPeriod.builder().startDate(bda.adjust(DATE_14_06_09.plusYears(1), REF_DATA)).endDate(bda.adjust(DATE_14_06_09.plusYears(2), REF_DATA)).unadjustedStartDate(DATE_14_06_09.plusYears(1)).unadjustedEndDate(DATE_14_06_09.plusYears(2)).yearFraction(1.0).rateComputation(FixedRateComputation.of(0.05)).build();
RateAccrualPeriod rap2 = RateAccrualPeriod.builder().startDate(bda.adjust(DATE_14_06_09.plusYears(2), REF_DATA)).endDate(bda.adjust(DATE_14_06_09.plusYears(3), REF_DATA)).unadjustedStartDate(DATE_14_06_09.plusYears(2)).unadjustedEndDate(DATE_14_06_09.plusYears(3)).yearFraction(1.0).rateComputation(FixedRateComputation.of(0.05)).build();
RateAccrualPeriod rap3 = RateAccrualPeriod.builder().startDate(bda.adjust(DATE_14_06_09.plusYears(3), REF_DATA)).endDate(bda.adjust(DATE_14_06_09.plusYears(4), REF_DATA)).unadjustedStartDate(DATE_14_06_09.plusYears(3)).unadjustedEndDate(DATE_14_06_09.plusYears(4)).yearFraction(1.0).rateComputation(FixedRateComputation.of(0.05)).build();
RateAccrualPeriod rap4 = RateAccrualPeriod.builder().startDate(bda.adjust(DATE_14_06_09.plusYears(4), REF_DATA)).endDate(bda.adjust(DATE_19_06_09, REF_DATA)).unadjustedStartDate(DATE_14_06_09.plusYears(4)).unadjustedEndDate(DATE_19_06_09).yearFraction(1.0).rateComputation(FixedRateComputation.of(0.05)).build();
RatePaymentPeriod rpp = RatePaymentPeriod.builder().paymentDate(DaysAdjustment.ofBusinessDays(2, GBLO).adjust(bda.adjust(DATE_19_06_09, REF_DATA), REF_DATA)).accrualPeriods(rap0, rap1, rap2, rap3, rap4).compoundingMethod(STRAIGHT).dayCount(ONE_ONE).currency(GBP).notional(1000d).build();
ResolvedSwapLeg expected = ResolvedSwapLeg.builder().paymentPeriods(rpp).payReceive(RECEIVE).type(SwapLegType.FIXED).build();
ResolvedSwapLeg testExpand = test.resolve(REF_DATA);
assertEquals(testExpand, expected);
}
internal static FixedCouponBond sut2()
{
BusinessDayAdjustment adj = BusinessDayAdjustment.of(MODIFIED_FOLLOWING, SAT_SUN);
PeriodicSchedule sche = PeriodicSchedule.of(START_DATE, END_DATE, Frequency.P12M, adj, StubConvention.SHORT_INITIAL, true);
return(FixedCouponBond.builder().securityId(SECURITY_ID2).dayCount(DayCounts.ACT_360).fixedRate(0.005).legalEntityId(LegalEntityId.of("OG-Ticker", "BUN EUR 2")).currency(GBP).notional(1.0e6).accrualSchedule(sche).settlementDateOffset(DaysAdjustment.ofBusinessDays(2, SAT_SUN)).yieldConvention(FixedCouponBondYieldConvention.GB_BUMP_DMO).build());
}
public virtual void test_inflation_interpolated()
{
BusinessDayAdjustment bda = BusinessDayAdjustment.of(FOLLOWING, GBLO);
PeriodicSchedule accrualSchedule = PeriodicSchedule.builder().startDate(DATE_14_06_09).endDate(DATE_19_06_09).frequency(Frequency.ofYears(5)).businessDayAdjustment(bda).build();
PaymentSchedule paymentSchedule = PaymentSchedule.builder().paymentFrequency(Frequency.ofYears(5)).paymentDateOffset(DaysAdjustment.ofBusinessDays(2, GBLO)).build();
InflationRateCalculation rateCalc = InflationRateCalculation.builder().index(GB_RPI).indexCalculationMethod(INTERPOLATED).lag(Period.ofMonths(3)).build();
NotionalSchedule notionalSchedule = NotionalSchedule.of(GBP, 1000d);
RateCalculationSwapLeg test = RateCalculationSwapLeg.builder().payReceive(RECEIVE).accrualSchedule(accrualSchedule).paymentSchedule(paymentSchedule).notionalSchedule(notionalSchedule).calculation(rateCalc).build();
assertEquals(test.StartDate, AdjustableDate.of(DATE_14_06_09, bda));
assertEquals(test.EndDate, AdjustableDate.of(DATE_19_06_09, bda));
assertEquals(test.Currency, GBP);
assertEquals(test.PayReceive, RECEIVE);
assertEquals(test.AccrualSchedule, accrualSchedule);
assertEquals(test.PaymentSchedule, paymentSchedule);
assertEquals(test.NotionalSchedule, notionalSchedule);
assertEquals(test.Calculation, rateCalc);
double weight = 1.0 - 9.0 / 30.0;
RatePaymentPeriod rpp0 = RatePaymentPeriod.builder().paymentDate(DaysAdjustment.ofBusinessDays(2, GBLO).adjust(bda.adjust(DATE_19_06_09, REF_DATA), REF_DATA)).accrualPeriods(RateAccrualPeriod.builder().startDate(bda.adjust(DATE_14_06_09, REF_DATA)).endDate(bda.adjust(DATE_19_06_09, REF_DATA)).unadjustedStartDate(DATE_14_06_09).unadjustedEndDate(DATE_19_06_09).yearFraction(1.0).rateComputation(InflationInterpolatedRateComputation.of(GB_RPI, YearMonth.from(bda.adjust(DATE_14_06_09, REF_DATA)).minusMonths(3), YearMonth.from(bda.adjust(DATE_19_06_09, REF_DATA)).minusMonths(3), weight)).build()).dayCount(ONE_ONE).currency(GBP).notional(1000d).build();
ResolvedSwapLeg expected = ResolvedSwapLeg.builder().paymentPeriods(rpp0).payReceive(RECEIVE).type(SwapLegType.INFLATION).build();
ResolvedSwapLeg testExpand = test.resolve(REF_DATA);
assertEquals(testExpand, expected);
}
//-------------------------------------------------------------------------
public virtual void test_builder_ensureDefaults()
{
ResetSchedule test = ResetSchedule.builder().resetFrequency(P1M).businessDayAdjustment(BusinessDayAdjustment.of(FOLLOWING, GBLO)).build();
assertEquals(test.ResetFrequency, P1M);
assertEquals(test.BusinessDayAdjustment, BusinessDayAdjustment.of(FOLLOWING, GBLO));
assertEquals(test.ResetMethod, UNWEIGHTED);
}
//-------------------------------------------------------------------------
public virtual void test_of_nobda()
{
ImmutableFxSwapConvention test = ImmutableFxSwapConvention.of(EUR_USD, PLUS_TWO_DAYS);
assertEquals(test.Name, EUR_USD.ToString());
assertEquals(test.CurrencyPair, EUR_USD);
assertEquals(test.SpotDateOffset, PLUS_TWO_DAYS);
assertEquals(test.BusinessDayAdjustment, BusinessDayAdjustment.of(MODIFIED_FOLLOWING, EUTA_USNY));
}
// adjust trade based on additional fields specified
private static TermDepositTrade adjustTrade(TermDepositTrade trade, BusinessDayConvention dateCnv, Optional <HolidayCalendarId> dateCalOpt)
{
if (!dateCalOpt.Present)
{
return(trade);
}
TermDeposit.Builder builder = trade.Product.toBuilder();
dateCalOpt.ifPresent(cal => builder.businessDayAdjustment(BusinessDayAdjustment.of(dateCnv, cal)));
return(trade.toBuilder().product(builder.build()).build());
}
public virtual void test_of_indexOnly()
{
ImmutableIborFixingDepositConvention test = ImmutableIborFixingDepositConvention.of(GBP_LIBOR_6M);
assertEquals(test.BusinessDayAdjustment, BusinessDayAdjustment.of(MODIFIED_FOLLOWING, GBP_LIBOR_6M.FixingCalendar));
assertEquals(test.Currency, GBP_LIBOR_6M.Currency);
assertEquals(test.DayCount, GBP_LIBOR_6M.DayCount);
assertEquals(test.FixingDateOffset, GBP_LIBOR_6M.FixingDateOffset);
assertEquals(test.Index, GBP_LIBOR_6M);
assertEquals(test.SpotDateOffset, GBP_LIBOR_6M.EffectiveDateOffset);
}
//-------------------------------------------------------------------------
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @DataProvider(name = "businessDayAdjustment") public static Object[][] data_businessDayAdjustment()
public static object[][] data_businessDayAdjustment()
{
return(new object[][]
{
new object[] { CdsConventions.EUR_GB_STANDARD, BusinessDayAdjustment.of(FOLLOWING, GBLO_EUTA) },
new object[] { CdsConventions.EUR_STANDARD, BusinessDayAdjustment.of(FOLLOWING, EUTA) },
new object[] { CdsConventions.GBP_STANDARD, BusinessDayAdjustment.of(FOLLOWING, GBLO) },
new object[] { CdsConventions.GBP_US_STANDARD, BusinessDayAdjustment.of(FOLLOWING, GBLO_USNY) },
new object[] { CdsConventions.JPY_STANDARD, BusinessDayAdjustment.of(FOLLOWING, JPTO) },
new object[] { CdsConventions.JPY_US_GB_STANDARD, BusinessDayAdjustment.of(FOLLOWING, GBLO_USNY_JPTO) },
new object[] { CdsConventions.USD_STANDARD, BusinessDayAdjustment.of(FOLLOWING, USNY) }
});
}
//-------------------------------------------------------------------------
public virtual void test_createTrade()
{
FxSwapTemplate @base = FxSwapTemplate.of(NEAR_PERIOD, FAR_PERIOD, CONVENTION);
LocalDate tradeDate = LocalDate.of(2015, 10, 29);
FxSwapTrade test = @base.createTrade(tradeDate, BUY, NOTIONAL_EUR, FX_RATE_NEAR, FX_RATE_PTS, REF_DATA);
LocalDate spotDate = PLUS_TWO_DAYS.adjust(tradeDate, REF_DATA);
LocalDate nearDate = spotDate.plus(NEAR_PERIOD);
LocalDate farDate = spotDate.plus(FAR_PERIOD);
BusinessDayAdjustment bda = CONVENTION.BusinessDayAdjustment;
FxSwap expected = FxSwap.ofForwardPoints(CurrencyAmount.of(EUR, NOTIONAL_EUR), FxRate.of(EUR, USD, FX_RATE_NEAR), FX_RATE_PTS, nearDate, farDate, bda);
assertEquals(test.Info.TradeDate, tradeDate);
assertEquals(test.Product, expected);
}
public virtual void test_zar_jibar()
{
IborIndex test = IborIndex.of("ZAR-JIBAR-3M");
assertEquals(test.Currency, ZAR);
assertEquals(test.Name, "ZAR-JIBAR-3M");
assertEquals(test.Tenor, TENOR_3M);
assertEquals(test.FixingCalendar, ZAJO);
assertEquals(test.FixingDateOffset, DaysAdjustment.ofCalendarDays(0, BusinessDayAdjustment.of(PRECEDING, ZAJO)));
assertEquals(test.EffectiveDateOffset, DaysAdjustment.ofCalendarDays(0, BusinessDayAdjustment.of(FOLLOWING, ZAJO)));
assertEquals(test.MaturityDateOffset, TenorAdjustment.of(TENOR_3M, PeriodAdditionConventions.NONE, BusinessDayAdjustment.of(MODIFIED_FOLLOWING, ZAJO)));
assertEquals(test.DayCount, ACT_365F);
assertEquals(test.DefaultFixedLegDayCount, ACT_365F);
assertEquals(test.ToString(), "ZAR-JIBAR-3M");
}
public virtual void test_expiry_standard()
{
DaysAdjustment spotLag = DaysAdjustment.ofBusinessDays(2, LO_NY);
BusinessDayAdjustment bda = BusinessDayAdjustment.of(BusinessDayConventions.FOLLOWING, LO_NY);
FxOptionVolatilitiesNode[] nodes = new FxOptionVolatilitiesNode[] { FxOptionVolatilitiesNode.of(GBP_USD, spotLag, bda, ValueType.BLACK_VOLATILITY, QUOTE_ID, Tenor.TENOR_2M, STRIKE), FxOptionVolatilitiesNode.of(GBP_USD, spotLag, bda, ValueType.BLACK_VOLATILITY, QUOTE_ID, Tenor.TENOR_10M, STRIKE), FxOptionVolatilitiesNode.of(GBP_USD, spotLag, bda, ValueType.BLACK_VOLATILITY, QUOTE_ID, Tenor.TENOR_4M, STRIKE) };
ZonedDateTime[] valDates = new ZonedDateTime[] { LocalDate.of(2017, 10, 25).atStartOfDay(ZoneId.of("Europe/London")), LocalDate.of(2017, 10, 25).atStartOfDay(ZoneId.of("Europe/London")), LocalDate.of(2017, 10, 27).atStartOfDay(ZoneId.of("Europe/London")) };
LocalDate[] expDates = new LocalDate[] { LocalDate.of(2017, 12, 21), LocalDate.of(2018, 8, 23), LocalDate.of(2018, 2, 26) };
for (int i = 0; i < expDates.Length; ++i)
{
double computed = nodes[i].timeToExpiry(valDates[i], ACT_365F, REF_DATA);
double expected = ACT_365F.relativeYearFraction(valDates[i].toLocalDate(), expDates[i]);
assertEquals(computed, expected);
}
}
//-------------------------------------------------------------------------
public virtual void test_builder()
{
BusinessDayAdjustment bda = BusinessDayAdjustment.of(FOLLOWING, GBLO);
PeriodicSchedule accrualSchedule = PeriodicSchedule.builder().startDate(DATE_01_05).endDate(DATE_04_05).frequency(P1M).businessDayAdjustment(bda).build();
PaymentSchedule paymentSchedule = PaymentSchedule.builder().paymentFrequency(P1M).paymentDateOffset(DaysAdjustment.ofBusinessDays(2, GBLO)).build();
ValueSchedule amountSchedule = ValueSchedule.of(123d);
KnownAmountSwapLeg test = KnownAmountSwapLeg.builder().payReceive(PAY).accrualSchedule(accrualSchedule).paymentSchedule(paymentSchedule).amount(amountSchedule).currency(GBP).build();
assertEquals(test.PayReceive, PAY);
assertEquals(test.StartDate, AdjustableDate.of(DATE_01_05, bda));
assertEquals(test.EndDate, AdjustableDate.of(DATE_04_05, bda));
assertEquals(test.AccrualSchedule, accrualSchedule);
assertEquals(test.PaymentSchedule, paymentSchedule);
assertEquals(test.Amount, amountSchedule);
assertEquals(test.Currency, GBP);
assertEquals(test.allCurrencies(), ImmutableSet.of(GBP));
}
private static readonly HolidayCalendarId NZBD = HolidayCalendarId.of("NZBD"); // no constant for this
public virtual void test_gbpLibor3m()
{
IborIndex test = IborIndex.of("GBP-LIBOR-3M");
assertEquals(test.Name, "GBP-LIBOR-3M");
assertEquals(test.Currency, GBP);
assertEquals(test.Active, true);
assertEquals(test.Tenor, TENOR_3M);
assertEquals(test.FixingCalendar, GBLO);
assertEquals(test.FixingDateOffset, DaysAdjustment.ofCalendarDays(0, BusinessDayAdjustment.of(PRECEDING, GBLO)));
assertEquals(test.EffectiveDateOffset, DaysAdjustment.ofCalendarDays(0, BusinessDayAdjustment.of(FOLLOWING, GBLO)));
assertEquals(test.MaturityDateOffset, TenorAdjustment.ofLastBusinessDay(TENOR_3M, BusinessDayAdjustment.of(MODIFIED_FOLLOWING, GBLO)));
assertEquals(test.DayCount, ACT_365F);
assertEquals(test.DefaultFixedLegDayCount, ACT_365F);
assertEquals(test.FloatingRateName, FloatingRateName.of("GBP-LIBOR"));
assertEquals(test.ToString(), "GBP-LIBOR-3M");
}
//-------------------------------------------------------------------------
public virtual void test_builder()
{
BusinessDayAdjustment bda = BusinessDayAdjustment.of(FOLLOWING, GBLO);
PeriodicSchedule accrualSchedule = PeriodicSchedule.builder().startDate(DATE_01_05).endDate(DATE_04_05).frequency(P1M).businessDayAdjustment(bda).build();
PaymentSchedule paymentSchedule = PaymentSchedule.builder().paymentFrequency(P1M).paymentDateOffset(DaysAdjustment.ofBusinessDays(2, GBLO)).build();
FixedRateCalculation rateCalc = FixedRateCalculation.builder().dayCount(DayCounts.ACT_365F).rate(ValueSchedule.of(0.025d)).build();
NotionalSchedule notionalSchedule = NotionalSchedule.of(GBP, 1000d);
RateCalculationSwapLeg test = RateCalculationSwapLeg.builder().payReceive(PAY).accrualSchedule(accrualSchedule).paymentSchedule(paymentSchedule).notionalSchedule(notionalSchedule).calculation(rateCalc).build();
assertEquals(test.StartDate, AdjustableDate.of(DATE_01_05, bda));
assertEquals(test.EndDate, AdjustableDate.of(DATE_04_05, bda));
assertEquals(test.Currency, GBP);
assertEquals(test.PayReceive, PAY);
assertEquals(test.AccrualSchedule, accrualSchedule);
assertEquals(test.PaymentSchedule, paymentSchedule);
assertEquals(test.NotionalSchedule, notionalSchedule);
assertEquals(test.Calculation, rateCalc);
}
// parses the payment date adjustment, which consists of two linked optional fields
internal static Optional <BusinessDayAdjustment> parsePaymentDateAdjustment(CsvRow row)
{
Optional <BusinessDayAdjustment> paymentAdj = null;
Optional <string> paymentDateCnv = row.findValue(PAYMENT_DATE_CNV_FIELD); // Optional field with Business day adjustment
if (paymentDateCnv.Present)
{
BusinessDayConvention bdCnv = LoaderUtils.parseBusinessDayConvention(paymentDateCnv.get());
if (!bdCnv.Equals(BusinessDayConventions.NO_ADJUST))
{
Optional <string> paymentDateCalOpt = row.findValue(PAYMENT_DATE_CAL_FIELD);
if (paymentDateCalOpt.Present)
{
paymentAdj = BusinessDayAdjustment.of(LoaderUtils.parseBusinessDayConvention(paymentDateCnv.get()), HolidayCalendarId.of(paymentDateCalOpt.get()));
}
}
}
return(paymentAdj);
}
public virtual void test_krw_cd()
{
HolidayCalendarId KRSE = HolidayCalendarId.of("KRSE");
IborIndex test = IborIndex.of("KRW-CD-13W");
assertEquals(test.Currency, KRW);
assertEquals(test.Name, "KRW-CD-13W");
assertEquals(test.Tenor, TENOR_13W);
assertEquals(test.FixingCalendar, KRSE);
assertEquals(test.FixingDateOffset, DaysAdjustment.ofBusinessDays(-1, KRSE));
assertEquals(test.EffectiveDateOffset, DaysAdjustment.ofBusinessDays(1, KRSE));
assertEquals(test.MaturityDateOffset, TenorAdjustment.of(TENOR_13W, PeriodAdditionConventions.NONE, BusinessDayAdjustment.of(FOLLOWING, KRSE)));
assertEquals(test.DayCount, ACT_365F);
assertEquals(test.DefaultFixedLegDayCount, ACT_365F);
assertEquals(test.ToString(), "KRW-CD-13W");
IborIndex test2 = IborIndex.of("KRW-CD-3M");
assertEquals(test2.Name, "KRW-CD-13W");
}
public virtual void test_bbsw6m()
{
IborIndex test = IborIndex.of("AUD-BBSW-6M");
assertEquals(test.Currency, AUD);
assertEquals(test.Name, "AUD-BBSW-6M");
assertEquals(test.Tenor, TENOR_6M);
assertEquals(test.FixingCalendar, AUSY);
assertEquals(test.FixingDateOffset, DaysAdjustment.ofBusinessDays(-1, AUSY));
assertEquals(test.EffectiveDateOffset, DaysAdjustment.ofBusinessDays(1, AUSY));
assertEquals(test.MaturityDateOffset, TenorAdjustment.of(TENOR_6M, PeriodAdditionConventions.NONE, BusinessDayAdjustment.of(MODIFIED_FOLLOWING_BI_MONTHLY, AUSY)));
assertEquals(test.DayCount, ACT_365F);
assertEquals(test.ToString(), "AUD-BBSW-6M");
}
public virtual void test_tibor_euroyen3m()
{
IborIndex test = IborIndex.of("JPY-TIBOR-EUROYEN-3M");
assertEquals(test.Currency, JPY);
assertEquals(test.Name, "JPY-TIBOR-EUROYEN-3M");
assertEquals(test.Tenor, TENOR_3M);
assertEquals(test.FixingCalendar, JPTO);
assertEquals(test.FixingDateOffset, DaysAdjustment.ofBusinessDays(-2, JPTO));
assertEquals(test.EffectiveDateOffset, DaysAdjustment.ofBusinessDays(2, JPTO));
assertEquals(test.MaturityDateOffset, TenorAdjustment.ofLastBusinessDay(TENOR_3M, BusinessDayAdjustment.of(MODIFIED_FOLLOWING, JPTO)));
assertEquals(test.DayCount, ACT_360);
assertEquals(test.DefaultFixedLegDayCount, ACT_365F);
assertEquals(test.FloatingRateName, FloatingRateName.of("JPY-TIBOR-EUROYEN"));
assertEquals(test.ToString(), "JPY-TIBOR-EUROYEN-3M");
}
public virtual void test_euribor3m()
{
IborIndex test = IborIndex.of("EUR-EURIBOR-3M");
assertEquals(test.Currency, EUR);
assertEquals(test.Name, "EUR-EURIBOR-3M");
assertEquals(test.Tenor, TENOR_3M);
assertEquals(test.FixingCalendar, EUTA);
assertEquals(test.FixingDateOffset, DaysAdjustment.ofBusinessDays(-2, EUTA));
assertEquals(test.EffectiveDateOffset, DaysAdjustment.ofBusinessDays(2, EUTA));
assertEquals(test.MaturityDateOffset, TenorAdjustment.ofLastBusinessDay(TENOR_3M, BusinessDayAdjustment.of(MODIFIED_FOLLOWING, EUTA)));
assertEquals(test.DayCount, ACT_360);
assertEquals(test.DefaultFixedLegDayCount, THIRTY_U_360);
assertEquals(test.FloatingRateName, FloatingRateName.of("EUR-EURIBOR"));
assertEquals(test.ToString(), "EUR-EURIBOR-3M");
}
//-------------------------------------------------------------------------
public virtual void test_usdLibor3m()
{
IborIndex test = IborIndex.of("USD-LIBOR-3M");
assertEquals(test.Currency, USD);
assertEquals(test.Name, "USD-LIBOR-3M");
assertEquals(test.Tenor, TENOR_3M);
assertEquals(test.FixingCalendar, GBLO);
assertEquals(test.FixingDateOffset, DaysAdjustment.ofBusinessDays(-2, GBLO));
assertEquals(test.EffectiveDateOffset, DaysAdjustment.ofBusinessDays(2, GBLO, BusinessDayAdjustment.of(FOLLOWING, GBLO.combinedWith(USNY))));
assertEquals(test.MaturityDateOffset, TenorAdjustment.ofLastBusinessDay(TENOR_3M, BusinessDayAdjustment.of(MODIFIED_FOLLOWING, GBLO.combinedWith(USNY))));
assertEquals(test.DayCount, ACT_360);
assertEquals(test.DefaultFixedLegDayCount, ACT_360);
assertEquals(test.FloatingRateName, FloatingRateName.of("USD-LIBOR"));
assertEquals(test.ToString(), "USD-LIBOR-3M");
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(dataProvider = "businessDayAdjustment") public void test_businessDayAdjustment(ImmutableCdsConvention convention, com.opengamma.strata.basics.date.BusinessDayAdjustment adj)
public virtual void test_businessDayAdjustment(ImmutableCdsConvention convention, BusinessDayAdjustment adj)
{
assertEquals(convention.BusinessDayAdjustment, adj);
assertEquals(convention.StartDateBusinessDayAdjustment, adj);
assertEquals(convention.EndDateBusinessDayAdjustment, BusinessDayAdjustment.NONE);
}
public virtual void formatForCsv()
{
AdjustableDate date = AdjustableDate.of(date(2016, 6, 30), BusinessDayAdjustment.of(MODIFIED_FOLLOWING, SAT_SUN));
assertThat(AdjustableDateValueFormatter.INSTANCE.formatForCsv(date)).isEqualTo("2016-06-30");
}
public virtual void test_mxn_tiie()
{
IborIndex test = IborIndex.of("MXN-TIIE-4W");
assertEquals(test.Currency, MXN);
assertEquals(test.Name, "MXN-TIIE-4W");
assertEquals(test.Tenor, TENOR_4W);
assertEquals(test.FixingCalendar, MXMC);
assertEquals(test.FixingDateOffset, DaysAdjustment.ofBusinessDays(-1, MXMC));
assertEquals(test.EffectiveDateOffset, DaysAdjustment.ofBusinessDays(1, MXMC));
assertEquals(test.MaturityDateOffset, TenorAdjustment.of(TENOR_4W, PeriodAdditionConventions.NONE, BusinessDayAdjustment.of(FOLLOWING, MXMC)));
assertEquals(test.DayCount, ACT_360);
assertEquals(test.DefaultFixedLegDayCount, ACT_360);
assertEquals(test.ToString(), "MXN-TIIE-4W");
}
public virtual void test_sek_stibor()
{
IborIndex test = IborIndex.of("SEK-STIBOR-3M");
assertEquals(test.Currency, SEK);
assertEquals(test.Name, "SEK-STIBOR-3M");
assertEquals(test.Tenor, TENOR_3M);
assertEquals(test.FixingCalendar, SEST);
assertEquals(test.FixingDateOffset, DaysAdjustment.ofBusinessDays(-2, SEST));
assertEquals(test.EffectiveDateOffset, DaysAdjustment.ofBusinessDays(2, SEST));
assertEquals(test.MaturityDateOffset, TenorAdjustment.of(TENOR_3M, PeriodAdditionConventions.NONE, BusinessDayAdjustment.of(MODIFIED_FOLLOWING, SEST)));
assertEquals(test.DayCount, ACT_360);
assertEquals(test.DefaultFixedLegDayCount, THIRTY_U_360);
assertEquals(test.ToString(), "SEK-STIBOR-3M");
}
public virtual void test_pln_wibor()
{
IborIndex test = IborIndex.of("PLN-WIBOR-3M");
assertEquals(test.Currency, PLN);
assertEquals(test.Name, "PLN-WIBOR-3M");
assertEquals(test.Tenor, TENOR_3M);
assertEquals(test.FixingCalendar, PLWA);
assertEquals(test.FixingDateOffset, DaysAdjustment.ofBusinessDays(-2, PLWA));
assertEquals(test.EffectiveDateOffset, DaysAdjustment.ofBusinessDays(2, PLWA));
assertEquals(test.MaturityDateOffset, TenorAdjustment.of(TENOR_3M, PeriodAdditionConventions.NONE, BusinessDayAdjustment.of(MODIFIED_FOLLOWING, PLWA)));
assertEquals(test.DayCount, ACT_365F);
assertEquals(test.DefaultFixedLegDayCount, ACT_ACT_ISDA);
assertEquals(test.ToString(), "PLN-WIBOR-3M");
}
public virtual void test_serialization()
{
ResetSchedule test = ResetSchedule.builder().resetFrequency(P1M).businessDayAdjustment(BusinessDayAdjustment.of(FOLLOWING, GBLO)).build();
assertSerialization(test);
}
public virtual void test_sgd_sibor()
{
HolidayCalendarId SGSI = HolidayCalendarId.of("SGSI");
IborIndex test = IborIndex.of("SGD-SIBOR-3M");
assertEquals(test.Currency, SGD);
assertEquals(test.Name, "SGD-SIBOR-3M");
assertEquals(test.Tenor, TENOR_3M);
assertEquals(test.FixingCalendar, SGSI);
assertEquals(test.FixingDateOffset, DaysAdjustment.ofBusinessDays(-2, SGSI));
assertEquals(test.EffectiveDateOffset, DaysAdjustment.ofBusinessDays(2, SGSI));
assertEquals(test.MaturityDateOffset, TenorAdjustment.of(TENOR_3M, PeriodAdditionConventions.NONE, BusinessDayAdjustment.of(MODIFIED_FOLLOWING, SGSI)));
assertEquals(test.DayCount, ACT_365F);
assertEquals(test.DefaultFixedLegDayCount, ACT_365F);
assertEquals(test.ToString(), "SGD-SIBOR-3M");
}
//-------------------------------------------------------------------------
public virtual void test_resolve()
{
ResetSchedule test = ResetSchedule.builder().resetFrequency(P1M).businessDayAdjustment(BusinessDayAdjustment.of(FOLLOWING, GBLO)).build();
SchedulePeriod accrualPeriod = SchedulePeriod.of(DATE_01_06, DATE_04_07, DATE_01_05, DATE_04_05);
Schedule schedule = test.createSchedule(DAY_5, REF_DATA).apply(accrualPeriod);
Schedule expected = Schedule.builder().periods(SchedulePeriod.of(DATE_01_06, DATE_02_05, DATE_01_05, DATE_02_05), SchedulePeriod.of(DATE_02_05, DATE_03_05, DATE_02_05, DATE_03_05), SchedulePeriod.of(DATE_03_05, DATE_04_07, DATE_03_05, DATE_04_05)).frequency(P1M).rollConvention(DAY_5).build();
assertEquals(schedule, expected);
}
// Create a zero-coupon fixed leg convention
private static FixedRateSwapLegConvention fixedLegZcConvention(Currency ccy, HolidayCalendarId cal)
{
return(FixedRateSwapLegConvention.builder().paymentFrequency(Frequency.TERM).accrualFrequency(Frequency.P12M).accrualBusinessDayAdjustment(BusinessDayAdjustment.of(MODIFIED_FOLLOWING, cal)).startDateBusinessDayAdjustment(BusinessDayAdjustment.of(MODIFIED_FOLLOWING, cal)).endDateBusinessDayAdjustment(BusinessDayAdjustment.of(MODIFIED_FOLLOWING, cal)).compoundingMethod(CompoundingMethod.STRAIGHT).dayCount(ONE_ONE).currency(ccy).build());
}
//-------------------------------------------------------------------------
public virtual void coverage()
{
ResetSchedule test = ResetSchedule.builder().resetFrequency(P1M).businessDayAdjustment(BusinessDayAdjustment.of(FOLLOWING, GBLO)).build();
coverImmutableBean(test);
ResetSchedule test2 = ResetSchedule.builder().resetFrequency(P3M).businessDayAdjustment(BusinessDayAdjustment.of(MODIFIED_FOLLOWING, GBLO)).resetMethod(WEIGHTED).build();
coverBeanEquals(test, test2);
}