//-------------------------------------------------------------------------
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_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 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_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 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_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_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_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_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_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_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_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());
}
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 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 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 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 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));
}
public virtual void test_of_Iterable_duplicate()
{
IEnumerable <CurrencyAmount> iterable = Arrays.asList(CA1, CurrencyAmount.of(CCY1, AMT2));
assertThrowsIllegalArg(() => MultiCurrencyAmount.of(iterable));
}
//-------------------------------------------------------------------------
public virtual void test_of_Iterable()
{
IEnumerable <CurrencyAmount> iterable = Arrays.asList(CA1, CA3);
assertMCA(MultiCurrencyAmount.of(iterable), CA1, CA3);
}
public virtual void test_of_VarArgs_null()
{
CurrencyAmount[] array = null;
assertThrowsIllegalArg(() => MultiCurrencyAmount.of(array));
}
public virtual void test_of_VarArgs_duplicate()
{
assertThrowsIllegalArg(() => MultiCurrencyAmount.of(CA1, CurrencyAmount.of(CCY1, AMT2)));
}
public virtual void test_of_VarArgs()
{
assertMCA(MultiCurrencyAmount.of(CA1, CA3), CA1, CA3);
}
//-------------------------------------------------------------------------
public virtual void test_of_VarArgs_empty()
{
assertMCA(MultiCurrencyAmount.of());
}
/// <summary>
/// Gets the amount at the specified index.
/// </summary>
/// <param name="index"> the zero-based index to retrieve </param>
/// <returns> the amount at the specified index </returns>
public MultiCurrencyAmount get(int index)
{
IList <CurrencyAmount> currencyAmounts = values.Keys.Select(ccy => CurrencyAmount.of(ccy, values.get(ccy).get(index))).ToList();
return(MultiCurrencyAmount.of(currencyAmounts));
}
public virtual void test_of_CurrencyDouble_null()
{
assertThrowsIllegalArg(() => MultiCurrencyAmount.of(null, AMT1));
}
