//-------------------------------------------------------------------------
public virtual void test_mapCurrencyAmounts()
{
MultiCurrencyAmount @base = MultiCurrencyAmount.of(CA1, CA2);
MultiCurrencyAmount test = @base.mapCurrencyAmounts(a => CurrencyAmount.of(CCY3, 1));
assertMCA(test, CurrencyAmount.of(CCY3, 2));
}
//-------------------------------------------------------------------------
public virtual void test_multipliedBy()
{
MultiCurrencyAmount @base = MultiCurrencyAmount.of(CA1, CA2);
MultiCurrencyAmount test = @base.multipliedBy(2.5);
assertMCA(test, CA1.multipliedBy(2.5), CA2.multipliedBy(2.5));
}
//-------------------------------------------------------------------------
public virtual void coverage()
{
coverImmutableBean(VALUES_ARRAY);
MultiCurrencyAmountArray test2 = MultiCurrencyAmountArray.of(MultiCurrencyAmount.of(CurrencyAmount.of(Currency.GBP, 21), CurrencyAmount.of(Currency.USD, 31), CurrencyAmount.of(Currency.EUR, 41)), MultiCurrencyAmount.of(CurrencyAmount.of(Currency.GBP, 22), CurrencyAmount.of(Currency.USD, 33), CurrencyAmount.of(Currency.EUR, 44)));
coverBeanEquals(VALUES_ARRAY, test2);
}
//-------------------------------------------------------------------------
public virtual void test_mapAmounts()
{
MultiCurrencyAmount @base = MultiCurrencyAmount.of(CA1, CA2);
MultiCurrencyAmount test = @base.mapAmounts(a => a * 2.5 + 1);
assertMCA(test, CA1.mapAmount(a => a * 2.5 + 1), CA2.mapAmount(a => a * 2.5 + 1));
}
public virtual void test_beanBuilder_invalid()
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.joda.beans.BeanBuilder<? extends MultiCurrencyAmount> test = MultiCurrencyAmount.meta().builder().set(MultiCurrencyAmount.meta().amounts(), com.google.common.collect.ImmutableSortedSet.of(CA1, CA2, CurrencyAmount.of(CA1.getCurrency(), AMT3)));
BeanBuilder <MultiCurrencyAmount> test = MultiCurrencyAmount.meta().builder().set(MultiCurrencyAmount.meta().amounts(), ImmutableSortedSet.of(CA1, CA2, CurrencyAmount.of(CA1.Currency, AMT3)));
assertThrowsIllegalArg(() => test.build());
}
//-------------------------------------------------------------------------
public virtual void test_stream()
{
MultiCurrencyAmount @base = MultiCurrencyAmount.of(CA1, CA2);
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
MultiCurrencyAmount test = @base.Select(ca => ca.mapAmount(a => a * 3)).collect(toMultiCurrencyAmount());
assertMCA(test, CA1.mapAmount(a => a * 3), CA2.mapAmount(a => a * 3));
}
public virtual void test_empty_amounts()
{
MultiCurrencyAmountArray array = MultiCurrencyAmountArray.of(MultiCurrencyAmount.empty(), MultiCurrencyAmount.empty());
assertThat(array.size()).isEqualTo(2);
assertThat(array.get(0)).isEqualTo(MultiCurrencyAmount.empty());
assertThat(array.get(1)).isEqualTo(MultiCurrencyAmount.empty());
}
public virtual void test_minusAmount()
{
MultiCurrencyAmountArray array = MultiCurrencyAmountArray.of(ImmutableMap.of(Currency.USD, DoubleArray.of(30, 32, 33), Currency.EUR, DoubleArray.of(40, 43, 44), Currency.CHF, DoubleArray.of(50, 54, 56)));
MultiCurrencyAmount amount = MultiCurrencyAmount.of(ImmutableMap.of(Currency.GBP, 21d, Currency.EUR, 143d, Currency.CHF, 254d));
MultiCurrencyAmountArray expected = MultiCurrencyAmountArray.of(ImmutableMap.of(Currency.GBP, DoubleArray.of(-21, -21, -21), Currency.USD, DoubleArray.of(30, 32, 33), Currency.EUR, DoubleArray.of(-103, -100, -99), Currency.CHF, DoubleArray.of(-204, -200, -198)));
assertThat(array.minus(amount)).isEqualTo(expected);
}
public virtual void test_plusAmount()
{
MultiCurrencyAmountArray array = MultiCurrencyAmountArray.of(ImmutableMap.of(Currency.USD, DoubleArray.of(30, 32, 33), Currency.EUR, DoubleArray.of(40, 43, 44), Currency.CHF, DoubleArray.of(50, 54, 56)));
MultiCurrencyAmount amount = MultiCurrencyAmount.of(ImmutableMap.of(Currency.GBP, 21d, Currency.EUR, 143d, Currency.CHF, 254d));
MultiCurrencyAmountArray expected = MultiCurrencyAmountArray.of(ImmutableMap.of(Currency.GBP, DoubleArray.of(21, 21, 21), Currency.USD, DoubleArray.of(30, 32, 33), Currency.EUR, DoubleArray.of(183, 186, 187), Currency.CHF, DoubleArray.of(304, 308, 310)));
assertThat(array.plus(amount)).isEqualTo(expected);
}
public virtual void test_get()
{
MultiCurrencyAmount expected = MultiCurrencyAmount.of(CurrencyAmount.of(Currency.GBP, 22), CurrencyAmount.of(Currency.USD, 33), CurrencyAmount.of(Currency.EUR, 44));
assertThat(VALUES_ARRAY.get(2)).isEqualTo(expected);
assertThrows(() => VALUES_ARRAY.get(3), typeof(System.IndexOutOfRangeException));
assertThrows(() => VALUES_ARRAY.get(-1), typeof(System.IndexOutOfRangeException));
}
//-------------------------------------------------------------------------
public virtual void test_plus_CurrencyDouble_merge()
{
CurrencyAmount ca = CurrencyAmount.of(Currency.AUD, 117);
CurrencyAmount cb = CurrencyAmount.of(Currency.USD, 12);
MultiCurrencyAmount mc1 = MultiCurrencyAmount.of(ca, cb);
MultiCurrencyAmount test = mc1.plus(Currency.AUD, 3);
assertMCA(test, cb, CurrencyAmount.of(Currency.AUD, 120));
}
public virtual void test_minus_CurrencyDouble_add()
{
CurrencyAmount ca = CurrencyAmount.of(Currency.AUD, 117);
CurrencyAmount cb = CurrencyAmount.of(Currency.USD, 12);
MultiCurrencyAmount mc1 = MultiCurrencyAmount.of(ca, cb);
MultiCurrencyAmount test = mc1.minus(Currency.NZD, 3);
assertMCA(test, ca, cb, CurrencyAmount.of(Currency.NZD, -3));
}
public virtual void test_collector_parallel()
{
IList <CurrencyAmount> amount = ImmutableList.of(CurrencyAmount.of(CCY1, 100), CurrencyAmount.of(CCY1, 150), CurrencyAmount.of(CCY2, 100));
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
MultiCurrencyAmount test = amount.collect(toMultiCurrencyAmount());
MultiCurrencyAmount expected = MultiCurrencyAmount.of(CurrencyAmount.of(CCY1, 250), CurrencyAmount.of(CCY2, 100));
assertEquals(test, expected);
}
//-------------------------------------------------------------------------
public virtual void test_negated()
{
MultiCurrencyAmount @base = MultiCurrencyAmount.of(CA1, CA2);
MultiCurrencyAmount test = @base.negated();
assertMCA(test, CA1.negated(), CA2.negated());
assertEquals(MultiCurrencyAmount.of(CurrencyAmount.zero(Currency.USD), CurrencyAmount.zero(Currency.EUR)).negated(), MultiCurrencyAmount.of(CurrencyAmount.zero(Currency.USD), CurrencyAmount.zero(Currency.EUR)));
assertEquals(MultiCurrencyAmount.of(CurrencyAmount.of(Currency.USD, -0d), CurrencyAmount.of(Currency.EUR, -0d)).negated(), MultiCurrencyAmount.of(CurrencyAmount.zero(Currency.USD), CurrencyAmount.zero(Currency.EUR)));
}
public virtual void test_minus_MultiCurrencyAmount_empty()
{
CurrencyAmount ca = CurrencyAmount.of(Currency.AUD, 117);
CurrencyAmount cb = CurrencyAmount.of(Currency.USD, 12);
MultiCurrencyAmount mc1 = MultiCurrencyAmount.of(ca, cb);
MultiCurrencyAmount mc2 = MultiCurrencyAmount.of();
MultiCurrencyAmount test = mc1.minus(mc2);
assertMCA(test, ca, cb);
}
//-------------------------------------------------------------------------
public virtual void test_convertedTo_rateProvider_noConversionSize1()
{
FxRateProvider provider = (ccy1, ccy2) =>
{
throw new System.ArgumentException();
};
MultiCurrencyAmount test = MultiCurrencyAmount.of(CA2);
assertEquals(test.convertedTo(CCY2, provider), CA2);
}
//-------------------------------------------------------------------------
public virtual void test_toMap()
{
ImmutableSortedMap <Currency, double> test = MultiCurrencyAmount.of(CA1, CA2).toMap();
assertEquals(test.size(), 2);
assertEquals(test.containsKey(CA1.Currency), true);
assertEquals(test.containsKey(CA2.Currency), true);
assertEquals(test.get(CA1.Currency), Convert.ToDouble(CA1.Amount));
assertEquals(test.get(CA2.Currency), Convert.ToDouble(CA2.Amount));
}
public virtual void test_minus_CurrencyAmount_add()
{
CurrencyAmount ca = CurrencyAmount.of(Currency.AUD, 117);
CurrencyAmount cb = CurrencyAmount.of(Currency.USD, 12);
CurrencyAmount cc = CurrencyAmount.of(Currency.NZD, 3);
MultiCurrencyAmount mc1 = MultiCurrencyAmount.of(ca, cb);
MultiCurrencyAmount test = mc1.minus(cc);
assertMCA(test, ca, cb, cc.negated());
}
// Test that the size is correctly restored after deserialization.
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void serializeSize() throws Exception
public virtual void serializeSize()
{
MultiCurrencyAmountArray deserialized = serializedDeserialize(VALUES_ARRAY);
assertThat(deserialized.size()).isEqualTo(3);
MultiCurrencyAmountArray empty = MultiCurrencyAmountArray.of(MultiCurrencyAmount.empty(), MultiCurrencyAmount.empty());
MultiCurrencyAmountArray deserializedEmpty = serializedDeserialize(empty);
assertThat(deserializedEmpty.size()).isEqualTo(2);
}
/// <summary>
/// Converts a {@code MultipleCurrencyAmount} into an amount in the
/// specified currency using the rates in this matrix.
/// </summary>
/// <param name="amount"> the {@code MultipleCurrencyAmount} to be converted </param>
/// <param name="targetCurrency"> the currency to convert all entries to </param>
/// <returns> the total amount in the requested currency </returns>
public CurrencyAmount convert(MultiCurrencyAmount amount, Currency targetCurrency)
{
ArgChecker.notNull(amount, "amount");
ArgChecker.notNull(targetCurrency, "targetCurrency");
// We could do this using the currency amounts but to
// avoid creating extra objects we'll use doubles
double total = amount.Amounts.Select(ca => convert(ca.Amount, ca.Currency, targetCurrency)).Sum();
return(CurrencyAmount.of(targetCurrency, total));
}
public virtual void convertMultipleCurrencyAmountWithSingleEntry()
{
FxMatrix matrix = FxMatrix.builder().addRate(GBP, EUR, 1.4).addRate(GBP, USD, 1.6).build();
MultiCurrencyAmount amount = MultiCurrencyAmount.of(CurrencyAmount.of(GBP, 1600));
assertThat(matrix.convert(amount, GBP)).hasCurrency(GBP).hasAmount(1600);
assertThat(matrix.convert(amount, USD)).hasCurrency(USD).hasAmount(2560);
assertThat(matrix.convert(amount, EUR)).hasCurrency(EUR).hasAmount(2240);
}
public virtual void convertMultipleCurrencyAmountWithMultipleEntries()
{
FxMatrix matrix = FxMatrix.builder().addRate(GBP, EUR, 1.4).addRate(GBP, USD, 1.6).build();
MultiCurrencyAmount amount = MultiCurrencyAmount.of(CurrencyAmount.of(GBP, 1600), CurrencyAmount.of(EUR, 1200), CurrencyAmount.of(USD, 1500));
assertThat(matrix.convert(amount, GBP)).hasCurrency(GBP).hasAmount(1600d + (1200 / 1.4) + (1500 / 1.6), TOL);
assertThat(matrix.convert(amount, USD)).hasCurrency(USD).hasAmount((1600d * 1.6) + ((1200 / 1.4) * 1.6) + 1500);
assertThat(matrix.convert(amount, EUR)).hasCurrency(EUR).hasAmount((1600d * 1.4) + 1200 + ((1500 / 1.6) * 1.4));
}
public virtual void convertMultipleCurrencyAmountWithNoEntries()
{
FxMatrix matrix = FxMatrix.builder().addRate(GBP, EUR, 1.4).addRate(GBP, USD, 1.6).build();
MultiCurrencyAmount amount = MultiCurrencyAmount.of();
assertThat(matrix.convert(amount, GBP)).hasCurrency(GBP).hasAmount(0);
assertThat(matrix.convert(amount, USD)).hasCurrency(USD).hasAmount(0);
assertThat(matrix.convert(amount, EUR)).hasCurrency(EUR).hasAmount(0);
}
//-------------------------------------------------------------------------
public virtual void test_minus_MultiCurrencyAmount_mergeAndAdd()
{
CurrencyAmount ca = CurrencyAmount.of(Currency.AUD, 117);
CurrencyAmount cb = CurrencyAmount.of(Currency.USD, 12);
CurrencyAmount cc = CurrencyAmount.of(Currency.AUD, 3);
CurrencyAmount cd = CurrencyAmount.of(Currency.NZD, 3);
MultiCurrencyAmount mc1 = MultiCurrencyAmount.of(ca, cb);
MultiCurrencyAmount mc2 = MultiCurrencyAmount.of(cc, cd);
MultiCurrencyAmount test = mc1.minus(mc2);
assertMCA(test, cb, cd.negated(), CurrencyAmount.of(Currency.AUD, 114));
}
public virtual void test_of_function()
{
MultiCurrencyAmount mca1 = MultiCurrencyAmount.of(CurrencyAmount.of(Currency.GBP, 10), CurrencyAmount.of(Currency.USD, 20));
MultiCurrencyAmount mca2 = MultiCurrencyAmount.of(CurrencyAmount.of(Currency.GBP, 10), CurrencyAmount.of(Currency.EUR, 30));
MultiCurrencyAmount mca3 = MultiCurrencyAmount.of(CurrencyAmount.of(Currency.USD, 40));
IList <MultiCurrencyAmount> amounts = ImmutableList.of(mca1, mca2, mca3);
MultiCurrencyAmountArray test = MultiCurrencyAmountArray.of(3, i => amounts[i]);
assertThat(test.get(0)).isEqualTo(mca1.plus(Currency.EUR, 0));
assertThat(test.get(1)).isEqualTo(mca2.plus(Currency.USD, 0));
assertThat(test.get(2)).isEqualTo(mca3.plus(Currency.GBP, 0).plus(Currency.EUR, 0));
}
//-----------------------------------------------------------------------
public override bool Equals(object obj)
{
if (obj == this)
{
return(true);
}
if (obj != null && obj.GetType() == this.GetType())
{
MultiCurrencyAmount other = (MultiCurrencyAmount)obj;
return(JodaBeanUtils.equal(amounts, other.amounts));
}
return(false);
}
public virtual void test_convertedTo_rateProvider_conversionSize1()
{
FxRateProvider provider = (ccy1, ccy2) =>
{
if (ccy1.Equals(CCY1) && ccy2.Equals(CCY2))
{
return(2.5d);
}
throw new System.ArgumentException();
};
MultiCurrencyAmount test = MultiCurrencyAmount.of(CA1);
assertEquals(test.convertedTo(CCY2, provider), CurrencyAmount.of(CCY2, AMT1 * 2.5d));
}
/// <summary>
/// Obtains an instance using a function to create the entries.
/// <para>
/// The function is passed the index and returns the {@code MultiCurrencyAmount} for that index.
///
/// </para>
/// </summary>
/// <param name="size"> the number of elements, at least size one </param>
/// <param name="valueFunction"> the function used to obtain each value </param>
/// <returns> an instance initialized using the function </returns>
/// <exception cref="IllegalArgumentException"> is size is zero or less </exception>
public static MultiCurrencyAmountArray of(int size, System.Func <int, MultiCurrencyAmount> valueFunction)
{
IDictionary <Currency, double[]> map = new Dictionary <Currency, double[]>();
for (int i = 0; i < size; i++)
{
MultiCurrencyAmount mca = valueFunction(i);
foreach (CurrencyAmount ca in mca.Amounts)
{
double[] array = map.computeIfAbsent(ca.Currency, c => new double[size]);
array[i] = ca.Amount;
}
}
return(new MultiCurrencyAmountArray(size, MapStream.of(map).mapValues(array => DoubleArray.ofUnsafe(array)).toMap()));
}
/// <summary>
/// Obtains an instance from the specified multi-currency amounts.
/// </summary>
/// <param name="amounts"> the amounts </param>
/// <returns> an instance with the specified amounts </returns>
public static MultiCurrencyAmountArray of(IList <MultiCurrencyAmount> amounts)
{
int size = amounts.Count;
Dictionary <Currency, double[]> valueMap = new Dictionary <Currency, double[]>();
for (int i = 0; i < size; i++)
{
MultiCurrencyAmount multiCurrencyAmount = amounts[i];
foreach (CurrencyAmount currencyAmount in multiCurrencyAmount.Amounts)
{
double[] currencyValues = valueMap.computeIfAbsent(currencyAmount.Currency, ccy => new double[size]);
currencyValues[i] = currencyAmount.Amount;
}
}
IDictionary <Currency, DoubleArray> doubleArrayMap = MapStream.of(valueMap).mapValues(v => DoubleArray.ofUnsafe(v)).toMap();
return(new MultiCurrencyAmountArray(size, doubleArrayMap));
}
/// <summary>
/// Returns a new array containing the values from this array with the values from the amount subtracted.
/// <para>
/// The amount is subtracted from each element in this array.
///
/// </para>
/// </summary>
/// <param name="amount"> the amount to subtract </param>
/// <returns> a new array containing the values from this array with the values from the amount subtracted </returns>
public MultiCurrencyAmountArray minus(MultiCurrencyAmount amount)
{
ImmutableMap.Builder <Currency, DoubleArray> builder = ImmutableMap.builder();
foreach (Currency currency in Sets.union(values.Keys, amount.Currencies))
{
DoubleArray array = values.get(currency);
if (array == null)
{
builder.put(currency, DoubleArray.filled(size_Renamed, -amount.getAmount(currency).Amount));
}
else if (!amount.contains(currency))
{
builder.put(currency, array);
}
else
{
builder.put(currency, array.minus(amount.getAmount(currency).Amount));
}
}
return(MultiCurrencyAmountArray.of(builder.build()));
}
