//------------------------------------------------------------------------- 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)); }