//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test(dataProvider = "name") public void test_extendedEnum(FraConvention convention, String name) public virtual void test_extendedEnum(FraConvention convention, string name) { FraConvention.of(name); // ensures map is populated ImmutableMap <string, FraConvention> map = FraConvention.extendedEnum().lookupAll(); assertEquals(map.get(name), convention); }
/// <summary> /// Obtains a template based on the specified periods and convention. /// <para> /// The periods from the spot date to the start date and to the end date are specified. /// </para> /// <para> /// For example, a '2 x 5' FRA has a period to the start date of 2 months and /// a period to the end date of 5 months. /// /// </para> /// </summary> /// <param name="periodToStart"> the period between the spot date and the start date </param> /// <param name="periodToEnd"> the period between the spot date and the end date </param> /// <param name="convention"> the market convention </param> /// <returns> the template </returns> public static FraTemplate of(Period periodToStart, Period periodToEnd, FraConvention convention) { ArgChecker.notNull(periodToStart, "periodToStart"); ArgChecker.notNull(periodToEnd, "periodToEnd"); ArgChecker.notNull(convention, "convention"); return(FraTemplate.builder().periodToStart(periodToStart).periodToEnd(periodToEnd).convention(convention).build()); }
//------------------------------------------------------------------------- public virtual void test_createTrade_periods() { FraConvention @base = ImmutableFraConvention.builder().index(GBP_LIBOR_3M).spotDateOffset(NEXT_SAME_BUS_DAY).build(); LocalDate tradeDate = LocalDate.of(2015, 5, 5); FraTrade test = @base.createTrade(tradeDate, Period.ofMonths(3), Period.ofMonths(6), BUY, NOTIONAL_2M, 0.25d, REF_DATA); Fra expected = Fra.builder().buySell(BUY).notional(NOTIONAL_2M).startDate(date(2015, 8, 5)).endDate(date(2015, 11, 5)).fixedRate(0.25d).index(GBP_LIBOR_3M).build(); assertEquals(test.Info.TradeDate, tradeDate); assertEquals(test.Product, expected); }
public virtual void test_toTemplate_badDateOrder() { FraConvention @base = FraConvention.of(GBP_LIBOR_3M); LocalDate tradeDate = LocalDate.of(2015, 5, 5); LocalDate startDate = date(2015, 4, 5); LocalDate endDate = date(2015, 7, 5); LocalDate paymentDate = date(2015, 8, 7); assertThrowsIllegalArg(() => @base.toTrade(tradeDate, startDate, endDate, paymentDate, BUY, NOTIONAL_2M, 0.25d)); }
private FraTemplate(Period periodToStart, Period periodToEnd, FraConvention convention) { JodaBeanUtils.notNull(periodToStart, "periodToStart"); JodaBeanUtils.notNull(periodToEnd, "periodToEnd"); JodaBeanUtils.notNull(convention, "convention"); this.periodToStart = periodToStart; this.periodToEnd = periodToEnd; this.convention = convention; validate(); }
public virtual void test_createTrade_periods_adjust_payOffset() { FraConvention @base = ImmutableFraConvention.builder().index(GBP_LIBOR_3M).spotDateOffset(NEXT_SAME_BUS_DAY).paymentDateOffset(PLUS_TWO_DAYS).build(); LocalDate tradeDate = LocalDate.of(2016, 8, 11); FraTrade test = @base.createTrade(tradeDate, Period.ofMonths(1), Period.ofMonths(4), BUY, NOTIONAL_2M, 0.25d, REF_DATA); Fra expected = Fra.builder().buySell(BUY).notional(NOTIONAL_2M).startDate(date(2016, 9, 12)).endDate(date(2016, 12, 12)).paymentDate(AdjustableDate.of(date(2016, 9, 14), PLUS_TWO_DAYS.Adjustment)).fixedRate(0.25d).index(GBP_LIBOR_3M).build(); assertEquals(test.Info.TradeDate, tradeDate); assertEquals(test.Product, expected); }
public virtual void test_createTrade_paymentOffset() { FraConvention convention = ((ImmutableFraConvention)FRA_GBP_LIBOR_3M).toBuilder().paymentDateOffset(PLUS_TWO_DAYS).build(); FraTemplate @base = FraTemplate.of(Period.ofMonths(3), Period.ofMonths(6), convention); LocalDate tradeDate = LocalDate.of(2015, 5, 4); // trade date is a holiday! FraTrade test = @base.createTrade(tradeDate, BUY, NOTIONAL_2M, 0.25d, REF_DATA); Fra expected = Fra.builder().buySell(BUY).notional(NOTIONAL_2M).startDate(date(2015, 8, 5)).endDate(date(2015, 11, 5)).paymentDate(AdjustableDate.of(date(2015, 8, 7), PLUS_TWO_DAYS.Adjustment)).fixedRate(0.25d).index(GBP_LIBOR_3M).build(); assertEquals(test.Info.TradeDate, tradeDate); assertEquals(test.Product, expected); }
public virtual void test_toTrade_dates_paymentOffset() { FraConvention @base = ImmutableFraConvention.builder().index(GBP_LIBOR_3M).spotDateOffset(NEXT_SAME_BUS_DAY).paymentDateOffset(PLUS_TWO_DAYS).build(); LocalDate tradeDate = LocalDate.of(2015, 5, 5); LocalDate startDate = date(2015, 8, 5); LocalDate endDate = date(2015, 11, 5); LocalDate paymentDate = date(2015, 8, 7); FraTrade test = @base.toTrade(tradeDate, startDate, endDate, paymentDate, BUY, NOTIONAL_2M, 0.25d); Fra expected = Fra.builder().buySell(BUY).notional(NOTIONAL_2M).startDate(date(2015, 8, 5)).endDate(date(2015, 11, 5)).paymentDate(AdjustableDate.of(paymentDate, PLUS_TWO_DAYS.Adjustment)).fixedRate(0.25d).index(GBP_LIBOR_3M).build(); assertEquals(test.Info.TradeDate, tradeDate); assertEquals(test.Product, expected); }
private static CurveNode curveFraCurveNode(string conventionStr, string timeStr, string label, QuoteId quoteId, double spread, CurveNodeDate date, CurveNodeDateOrder order) { Matcher matcher = FRA_TIME_REGEX.matcher(timeStr.ToUpper(Locale.ENGLISH)); if (!matcher.matches()) { throw new System.ArgumentException(Messages.format("Invalid time format for FRA: {}", timeStr)); } Period periodToStart = Period.parse("P" + matcher.group(1) + "M"); Period periodToEnd = Period.parse("P" + matcher.group(2) + "M"); FraConvention convention = FraConvention.of(conventionStr); FraTemplate template = FraTemplate.of(periodToStart, periodToEnd, convention); return(FraCurveNode.builder().template(template).rateId(quoteId).additionalSpread(spread).label(label).date(date).dateOrder(order).build()); }
//------------------------------------------------------------------------- public virtual void test_of_index() { ImmutableFraConvention test = ImmutableFraConvention.of(GBP_LIBOR_3M); assertEquals(test.Index, GBP_LIBOR_3M); assertEquals(test.Name, GBP_LIBOR_3M.Name); assertEquals(test.Currency, GBP); assertEquals(test.SpotDateOffset, GBP_LIBOR_3M.EffectiveDateOffset); assertEquals(test.BusinessDayAdjustment, BDA_MOD_FOLLOW); assertEquals(test.PaymentDateOffset, DaysAdjustment.NONE); assertEquals(test.FixingDateOffset, GBP_LIBOR_3M.FixingDateOffset); assertEquals(test.DayCount, ACT_365F); assertEquals(test.Discounting, ISDA); // ensure other factories match assertEquals(FraConvention.of(GBP_LIBOR_3M), test); assertEquals(FraConventions.of(GBP_LIBOR_3M), test); }
public override Builder set(string propertyName, object newValue) { switch (propertyName.GetHashCode()) { case -574688858: // periodToStart this.periodToStart_Renamed = (Period)newValue; break; case -970442977: // periodToEnd this.periodToEnd_Renamed = (Period)newValue; break; case 2039569265: // convention this.convention_Renamed = (FraConvention)newValue; break; default: throw new NoSuchElementException("Unknown property: " + propertyName); } return(this); }
//------------------------------------------------------------------------- /// <summary> /// Obtains a template based on the specified period and index. /// <para> /// The period from the spot date to the start date is specified. /// The period from the spot date to the end date will be the period to start /// plus the tenor of the index. /// </para> /// <para> /// For example, a '2 x 5' FRA has a period to the start date of 2 months. /// The index will be a 3 month index, such as 'USD-LIBOR-3M'. /// The period to the end date will be the period to the start date plus the index tenor. /// /// </para> /// </summary> /// <param name="periodToStart"> the period between the spot date and the start date </param> /// <param name="index"> the index that defines the market convention </param> /// <returns> the template </returns> public static FraTemplate of(Period periodToStart, IborIndex index) { return(of(periodToStart, periodToStart.plus(index.Tenor.Period), FraConvention.of(index))); }
public virtual void test_of_lookup_null() { assertThrowsIllegalArg(() => FraConvention.of((string)null)); }
public virtual void test_of_lookup_notFound() { assertThrowsIllegalArg(() => FraConvention.of("Rubbish")); }
/// <summary> /// Restricted copy constructor. </summary> /// <param name="beanToCopy"> the bean to copy from, not null </param> internal Builder(FraTemplate beanToCopy) { this.periodToStart_Renamed = beanToCopy.PeriodToStart; this.periodToEnd_Renamed = beanToCopy.PeriodToEnd; this.convention_Renamed = beanToCopy.Convention; }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test(dataProvider = "name") public void test_of_lookup(FraConvention convention, String name) public virtual void test_of_lookup(FraConvention convention, string name) { assertEquals(FraConvention.of(name), convention); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test(dataProvider = "name") public void test_toString(FraConvention convention, String name) public virtual void test_toString(FraConvention convention, string name) { assertEquals(convention.ToString(), name); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test(dataProvider = "name") public void test_name(FraConvention convention, String name) public virtual void test_name(FraConvention convention, string name) { assertEquals(convention.Name, name); }
public virtual void test_unknownIndex() { assertThrowsIllegalArg(() => FraConvention.of("Rubbish")); }
/// <summary> /// Sets the underlying FRA convention. /// <para> /// This specifies the market convention of the FRA to be created. /// </para> /// </summary> /// <param name="convention"> the new value, not null </param> /// <returns> this, for chaining, not null </returns> public Builder convention(FraConvention convention) { JodaBeanUtils.notNull(convention, "convention"); this.convention_Renamed = convention; return(this); }
/// <summary> /// Obtains a convention based on the specified index. /// <para> /// This uses the index name to find the matching convention. /// By default, this will always return a convention, however configuration may be added /// to restrict the conventions that are registered. /// /// </para> /// </summary> /// <param name="index"> the index, from which the index name is used to find the matching convention </param> /// <returns> the convention </returns> /// <exception cref="IllegalArgumentException"> if no convention is registered for the index </exception> public static FraConvention of(IborIndex index) { return(FraConvention.of(index)); }
//------------------------------------------------------------------------- public virtual void coverage() { FraTemplate test = FraTemplate.of(Period.ofMonths(2), GBP_LIBOR_3M); coverImmutableBean(test); FraTemplate test2 = FraTemplate.of(Period.ofMonths(3), Period.ofMonths(6), FraConvention.of(USD_LIBOR_3M)); coverBeanEquals(test, test2); }