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