internal static ResolvedFxSwap sut2()
{
ResolvedFxSingle nearLeg = ResolvedFxSingle.of(CurrencyAmount.of(GBP, 1_100), CurrencyAmount.of(USD, -1_650), DATE_2011_11_21);
ResolvedFxSingle farLeg = ResolvedFxSingle.of(CurrencyAmount.of(GBP, -1_100), CurrencyAmount.of(USD, 1_750), DATE_2011_12_21);
return(ResolvedFxSwap.of(nearLeg, farLeg));
}
public virtual void test_of_amounts_positiveNegative()
{
assertThrowsIllegalArg(() => ResolvedFxSingle.of(GBP_P1000, USD_P1600, DATE_2015_06_30));
assertThrowsIllegalArg(() => ResolvedFxSingle.of(GBP_M1000, USD_M1600, DATE_2015_06_30));
assertThrowsIllegalArg(() => ResolvedFxSingle.of(CurrencyAmount.zero(GBP), USD_M1600, DATE_2015_06_30));
assertThrowsIllegalArg(() => ResolvedFxSingle.of(CurrencyAmount.zero(GBP), USD_P1600, DATE_2015_06_30));
}
private ResolvedFxSingleTrade(TradeInfo info, ResolvedFxSingle product)
{
JodaBeanUtils.notNull(info, "info");
JodaBeanUtils.notNull(product, "product");
this.info = info;
this.product = product;
}
public virtual void test_of_wrongCounterCurrency()
{
ResolvedFxSingle nearLeg = ResolvedFxSingle.of(USD_P1550, EUR_P1590.negated(), DATE_2011_11_21);
ResolvedFxSingle farLeg = ResolvedFxSingle.of(GBP_M1000, EUR_P1590, DATE_2011_12_21);
assertThrowsIllegalArg(() => ResolvedFxSwap.of(nearLeg, farLeg));
}
public virtual void test_builder_switchOrder()
{
ResolvedFxSingle test = ResolvedFxSingle.meta().builder().set(ResolvedFxSingle.meta().baseCurrencyPayment(), PAYMENT_USD_M1600).set(ResolvedFxSingle.meta().counterCurrencyPayment(), PAYMENT_GBP_P1000).build();
assertEquals(test.BaseCurrencyPayment, PAYMENT_GBP_P1000);
assertEquals(test.CounterCurrencyPayment, PAYMENT_USD_M1600);
assertEquals(test.PaymentDate, DATE_2015_06_30);
}
private ResolvedFxSwap(ResolvedFxSingle nearLeg, ResolvedFxSingle farLeg)
{
JodaBeanUtils.notNull(nearLeg, "nearLeg");
JodaBeanUtils.notNull(farLeg, "farLeg");
this.nearLeg = nearLeg;
this.farLeg = farLeg;
validate();
}
//-------------------------------------------------------------------------
public virtual void test_resolve()
{
FxSingle fwd = sut();
ResolvedFxSingle test = fwd.resolve(REF_DATA);
assertEquals(test.BaseCurrencyPayment, Payment.of(GBP_P1000, DATE_2015_06_30));
assertEquals(test.CounterCurrencyPayment, Payment.of(USD_M1600, DATE_2015_06_30));
assertEquals(test.PaymentDate, DATE_2015_06_30);
}
public virtual void test_of_rate_bothZero()
{
ResolvedFxSingle test = ResolvedFxSingle.of(CurrencyAmount.zero(GBP), FxRate.of(USD, GBP, 1.6d), DATE_2015_06_30);
assertEquals(test.BaseCurrencyPayment.Value, CurrencyAmount.zero(GBP));
assertEquals(test.CounterCurrencyPayment.Value.Amount, CurrencyAmount.zero(USD).Amount, 1e-12);
assertEquals(test.PaymentDate, DATE_2015_06_30);
assertEquals(test.CurrencyPair, CurrencyPair.of(GBP, USD));
assertEquals(test.ReceiveCurrencyAmount, CurrencyAmount.of(USD, 0d));
}
//-------------------------------------------------------------------------
public virtual void test_of_rate_rightOrder()
{
ResolvedFxSingle test = ResolvedFxSingle.of(GBP_P1000, FxRate.of(GBP, USD, 1.6d), DATE_2015_06_30);
assertEquals(test.BaseCurrencyPayment, Payment.of(GBP_P1000, DATE_2015_06_30));
assertEquals(test.CounterCurrencyPayment, Payment.of(USD_M1600, DATE_2015_06_30));
assertEquals(test.PaymentDate, DATE_2015_06_30);
assertEquals(test.CurrencyPair, CurrencyPair.of(GBP, USD));
assertEquals(test.ReceiveCurrencyAmount, GBP_P1000);
}
public virtual void test_of_amounts_bothZero()
{
ResolvedFxSingle test = ResolvedFxSingle.of(CurrencyAmount.zero(GBP), CurrencyAmount.zero(USD), DATE_2015_06_30);
assertEquals(test.BaseCurrencyPayment, Payment.of(CurrencyAmount.zero(GBP), DATE_2015_06_30));
assertEquals(test.CounterCurrencyPayment, Payment.of(CurrencyAmount.zero(USD), DATE_2015_06_30));
assertEquals(test.PaymentDate, DATE_2015_06_30);
assertEquals(test.CurrencyPair, CurrencyPair.of(GBP, USD));
assertEquals(test.ReceiveCurrencyAmount, CurrencyAmount.zero(USD));
}
public virtual void test_of_amounts_switchOrder()
{
ResolvedFxSingle test = ResolvedFxSingle.of(USD_M1600, GBP_P1000, DATE_2015_06_30);
assertEquals(test.BaseCurrencyPayment, PAYMENT_GBP_P1000);
assertEquals(test.CounterCurrencyPayment, PAYMENT_USD_M1600);
assertEquals(test.PaymentDate, DATE_2015_06_30);
assertEquals(test.CurrencyPair, CurrencyPair.of(GBP, USD));
assertEquals(test.ReceiveCurrencyAmount, GBP_P1000);
}
/// <summary>
/// Creates an {@code ResolvedFxSingle} using a rate.
/// <para>
/// This create an FX specifying a value date, notional in one currency, the second currency
/// and the FX rate between the two.
/// The currencies of the payments must differ.
/// </para>
/// <para>
/// This factory identifies the currency pair of the exchange and assigns the payments
/// to match the base or counter currency of the standardized currency pair.
/// For example, a EUR/USD exchange always has EUR as the base payment and USD as the counter payment.
/// </para>
/// <para>
/// No payment date adjustments apply.
///
/// </para>
/// </summary>
/// <param name="amountCurrency1"> the amount of the near leg in the first currency </param>
/// <param name="fxRate"> the near FX rate </param>
/// <param name="paymentDate"> date that the FX settles </param>
/// <returns> the resolved foreign exchange transaction </returns>
public static ResolvedFxSingle of(CurrencyAmount amountCurrency1, FxRate fxRate, LocalDate paymentDate)
{
CurrencyPair pair = fxRate.Pair;
ArgChecker.isTrue(pair.contains(amountCurrency1.Currency));
Currency currency2 = pair.Base.Equals(amountCurrency1.Currency) ? pair.Counter : pair.Base;
CurrencyAmount amountCurrency2 = amountCurrency1.convertedTo(currency2, fxRate).negated();
return(ResolvedFxSingle.of(Payment.of(amountCurrency1, paymentDate), Payment.of(amountCurrency2, paymentDate)));
}
public virtual void test_ofForwardPoints()
{
double nearRate = 1.6;
double fwdPoint = 0.1;
ResolvedFxSwap test = ResolvedFxSwap.ofForwardPoints(GBP_P1000, USD, nearRate, fwdPoint, DATE_2011_11_21, DATE_2011_12_21);
ResolvedFxSingle nearLegExp = ResolvedFxSingle.of(GBP_P1000, CurrencyAmount.of(USD, -1000.0 * nearRate), DATE_2011_11_21);
ResolvedFxSingle farLegExp = ResolvedFxSingle.of(GBP_M1000, CurrencyAmount.of(USD, 1000.0 * (nearRate + fwdPoint)), DATE_2011_12_21);
assertEquals(test.NearLeg, nearLegExp);
assertEquals(test.FarLeg, farLegExp);
}
/// <summary>
/// Creates a {@code ResolvedFxSwap} using forward points.
/// <para>
/// The FX rate at the near date is specified as {@code fxRate}.
/// The FX rate at the far date is equal to {@code fxRate + forwardPoints}
/// </para>
/// <para>
/// The two currencies must not be equal.
/// The near date must be before the far date.
/// Conventions will be used to determine the base and counter currency.
///
/// </para>
/// </summary>
/// <param name="amountCurrency1"> the amount of the near leg in the first currency </param>
/// <param name="currency2"> the second currency </param>
/// <param name="nearFxRate"> the near FX rate, where {@code (1.0 * amountCurrency1 = fxRate * amountCurrency2)} </param>
/// <param name="forwardPoints"> the forward points, where the far FX rate is {@code (fxRate + forwardPoints)} </param>
/// <param name="nearDate"> the near value date </param>
/// <param name="farDate"> the far value date </param>
/// <returns> the resolved FX swap </returns>
public static ResolvedFxSwap ofForwardPoints(CurrencyAmount amountCurrency1, Currency currency2, double nearFxRate, double forwardPoints, LocalDate nearDate, LocalDate farDate)
{
Currency currency1 = amountCurrency1.Currency;
ArgChecker.isFalse(currency1.Equals(currency2), "Currencies must not be equal");
ArgChecker.notNegativeOrZero(nearFxRate, "fxRate");
double farFxRate = nearFxRate + forwardPoints;
ResolvedFxSingle nearLeg = ResolvedFxSingle.of(amountCurrency1, FxRate.of(currency1, currency2, nearFxRate), nearDate);
ResolvedFxSingle farLeg = ResolvedFxSingle.of(amountCurrency1.negated(), FxRate.of(currency1, currency2, farFxRate), farDate);
return(of(nearLeg, farLeg));
}
//-----------------------------------------------------------------------
public override bool Equals(object obj)
{
if (obj == this)
{
return(true);
}
if (obj != null && obj.GetType() == this.GetType())
{
ResolvedFxSingle other = (ResolvedFxSingle)obj;
return(JodaBeanUtils.equal(baseCurrencyPayment, other.baseCurrencyPayment) && JodaBeanUtils.equal(counterCurrencyPayment, other.counterCurrencyPayment));
}
return(false);
}
public override Builder set(string propertyName, object newValue)
{
switch (propertyName.GetHashCode())
{
case 1825755334: // nearLeg
this.nearLeg = (ResolvedFxSingle)newValue;
break;
case -1281739913: // farLeg
this.farLeg = (ResolvedFxSingle)newValue;
break;
default:
throw new NoSuchElementException("Unknown property: " + propertyName);
}
return(this);
}
public override Builder set(string propertyName, object newValue)
{
switch (propertyName.GetHashCode())
{
case 3237038: // info
this.info_Renamed = (TradeInfo)newValue;
break;
case -309474065: // product
this.product_Renamed = (ResolvedFxSingle)newValue;
break;
default:
throw new NoSuchElementException("Unknown property: " + propertyName);
}
return(this);
}
/// <summary>
/// Restricted copy constructor. </summary>
/// <param name="beanToCopy"> the bean to copy from, not null </param>
internal Builder(ResolvedFxSingleTrade beanToCopy)
{
this.info_Renamed = beanToCopy.Info;
this.product_Renamed = beanToCopy.Product;
}
public virtual void test_builder_sameCurrency()
{
assertThrowsIllegalArg(() => ResolvedFxSingle.meta().builder().set(ResolvedFxSingle.meta().baseCurrencyPayment(), PAYMENT_GBP_P1000).set(ResolvedFxSingle.meta().counterCurrencyPayment(), PAYMENT_GBP_M1000).build());
}
/// <summary>
/// Creates an {@code ResolvedFxSingle} from two amounts and the value date.
/// <para>
/// The amounts must be of the correct type, one pay and one receive.
/// The currencies of the payments must differ.
/// </para>
/// <para>
/// This factory identifies the currency pair of the exchange and assigns the payments
/// to match the base or counter currency of the standardized currency pair.
/// For example, a EUR/USD exchange always has EUR as the base payment and USD as the counter payment.
///
/// </para>
/// </summary>
/// <param name="amount1"> the amount in the first currency </param>
/// <param name="amount2"> the amount in the second currency </param>
/// <param name="valueDate"> the value date </param>
/// <returns> the resolved foreign exchange transaction </returns>
public static ResolvedFxSingle of(CurrencyAmount amount1, CurrencyAmount amount2, LocalDate valueDate)
{
return(ResolvedFxSingle.of(Payment.of(amount1, valueDate), Payment.of(amount2, valueDate)));
}
//-------------------------------------------------------------------------
/// <summary>
/// Obtains an instance of a resolved single FX trade.
/// </summary>
/// <param name="info"> the trade info </param>
/// <param name="product"> the product </param>
/// <returns> the resolved trade </returns>
public static ResolvedFxSingleTrade of(TradeInfo info, ResolvedFxSingle product)
{
return(new ResolvedFxSingleTrade(info, product));
}
//-------------------------------------------------------------------------
public virtual void test_inverse()
{
ResolvedFxSingle test = sut();
assertEquals(test.inverse(), ResolvedFxSingle.of(GBP_M1000, USD_P1600, DATE_2015_06_30));
}
public virtual void test_of_wrongBaseCurrency()
{
ResolvedFxSingle nearLeg = ResolvedFxSingle.of(EUR_P1590, USD_M1600, DATE_2011_11_21);
assertThrowsIllegalArg(() => ResolvedFxSwap.of(nearLeg, FAR_LEG));
}
//-------------------------------------------------------------------------
internal static ResolvedFxSingle sut()
{
return(ResolvedFxSingle.of(GBP_P1000, USD_M1600, DATE_2015_06_30));
}
internal static ResolvedFxSingle sut2()
{
return(ResolvedFxSingle.of(GBP_M1000, EUR_P1600, DATE_2015_06_29));
}
internal static ResolvedFxSingle sut3()
{
return(ResolvedFxSingle.of(USD_M1600, EUR_P1600, DATE_2015_06_30));
}
/// <summary>
/// Sets the resolved single FX product.
/// <para>
/// The product captures the contracted financial details of the trade.
/// </para>
/// </summary>
/// <param name="product"> the new value, not null </param>
/// <returns> this, for chaining, not null </returns>
public Builder product(ResolvedFxSingle product)
{
JodaBeanUtils.notNull(product, "product");
this.product_Renamed = product;
return(this);
}
public virtual void test_of_sameSign()
{
ResolvedFxSingle farLeg = ResolvedFxSingle.of(GBP_M1000.negated(), USD_P1550.negated(), DATE_2011_12_21);
assertThrowsIllegalArg(() => ResolvedFxSwap.of(NEAR_LEG, farLeg));
}
//-------------------------------------------------------------------------
/// <summary>
/// Creates a {@code ResolvedFxSwap} from two legs.
/// <para>
/// The transactions must be passed in with payment dates in the correct order.
/// The currency pair of each leg must match and have amounts flowing in opposite directions.
///
/// </para>
/// </summary>
/// <param name="nearLeg"> the earlier leg </param>
/// <param name="farLeg"> the later leg </param>
/// <returns> the resolved FX swap </returns>
public static ResolvedFxSwap of(ResolvedFxSingle nearLeg, ResolvedFxSingle farLeg)
{
return(new ResolvedFxSwap(nearLeg, farLeg));
}
public virtual void test_of_payments_sameCurrency()
{
assertThrowsIllegalArg(() => ResolvedFxSingle.of(PAYMENT_GBP_P1000, PAYMENT_GBP_M1000));
}