public void testAutomated()
{
Currency EUR = new EURCurrency(), GBP = new GBPCurrency(), USD = new USDCurrency();
Money m1 = 50000.0 * GBP;
Money m2 = 100000.0 * EUR;
Money m3 = 500000.0 * USD;
ExchangeRateManager.Instance.clear();
ExchangeRate eur_usd = new ExchangeRate(EUR, USD, 1.2042);
ExchangeRate eur_gbp = new ExchangeRate(EUR, GBP, 0.6612);
ExchangeRateManager.Instance.add(eur_usd);
ExchangeRateManager.Instance.add(eur_gbp);
Money.conversionType = Money.ConversionType.AutomatedConversion;
Money calculated = (m1*3.0 + 2.5*m2) - m3/5.0;
Rounding round = m1.currency.rounding;
double x = m1.value*3.0 + round.Round(2.5*m2.value*eur_gbp.rate)
- round.Round((m3.value/5.0)*eur_gbp.rate/eur_usd.rate);
Money expected = new Money(x, GBP);
Money.conversionType = Money.ConversionType.NoConversion;
if (calculated != expected)
{
Assert.Fail("Wrong result: " + "expected: " + expected + " calculated: " + calculated);
}
}
public void testDerived()
{
Currency EUR = new EURCurrency(), USD = new USDCurrency(), GBP = new GBPCurrency();
ExchangeRate eur_usd = new ExchangeRate(EUR, USD, 1.2042);
ExchangeRate eur_gbp = new ExchangeRate(EUR, GBP, 0.6612);
ExchangeRate derived = ExchangeRate.chain(eur_usd, eur_gbp);
Money m1 = 50000.0 * GBP;
Money m2 = 100000.0 * USD;
Money.conversionType = Money.ConversionType.NoConversion;
Money calculated = derived.exchange(m1);
Money expected = new Money(m1.value*eur_usd.rate/eur_gbp.rate, USD);
if (!Utils.close(calculated, expected))
{
Assert.Fail("Wrong result: expected: " + expected + " calculated: " + calculated);
}
calculated = derived.exchange(m2);
expected = new Money(m2.value*eur_gbp.rate/eur_usd.rate, GBP);
if (!Utils.close(calculated, expected))
{
Assert.Fail("Wrong result: expected: " + expected + " calculated: " + calculated);
}
}
public static bool close(Money m1, Money m2, int n) {
if (m1.currency == m2.currency) {
return close(m1.value, m2.value, n);
} else if (Money.conversionType == Money.ConversionType.BaseCurrencyConversion) {
Money tmp1 = m1;
Money.convertToBase(ref tmp1);
Money tmp2 = m2;
Money.convertToBase(ref tmp2);
return close(tmp1, tmp2, n);
} else if (Money.conversionType == Money.ConversionType.AutomatedConversion) {
Money tmp = m2;
Money.convertTo(ref tmp, m1.currency);
return close(m1, tmp, n);
} else {
throw new Exception("currency mismatch and no conversion specified");
}
}
public void testTriangulatedLookup()
{
ExchangeRateManager rateManager = ExchangeRateManager.Instance;
rateManager.clear();
Currency EUR = new EURCurrency(), USD = new USDCurrency(), ITL = new ITLCurrency();
ExchangeRate eur_usd1 = new ExchangeRate(EUR, USD, 1.1983);
ExchangeRate eur_usd2 = new ExchangeRate(EUR, USD, 1.2042);
rateManager.Add(eur_usd1, new Date(4,Month.August,2004));
rateManager.Add(eur_usd2, new Date(5,Month.August,2004));
Money m1 = 50000000.0 * ITL;
Money m2 = 100000.0 * USD;
Money.conversionType = Money.ConversionType.NoConversion;
ExchangeRate itl_usd = rateManager.lookup(ITL, USD,new Date(4,Month.August,2004));
Money calculated = itl_usd.exchange(m1);
Money expected = new Money(m1.value*eur_usd1.rate/1936.27, USD);
if (!Utils.close(calculated, expected))
{
Assert.Fail("Wrong result: expected: " + expected + " calculated: " + calculated);
}
itl_usd = rateManager.lookup(ITL, USD,new Date(5,Month.August,2004));
calculated = itl_usd.exchange(m1);
expected = new Money(m1.value*eur_usd2.rate/1936.27, USD);
if (!Utils.close(calculated, expected))
{
Assert.Fail("Wrong result: expected: " + expected + " calculated: " + calculated);
}
ExchangeRate usd_itl = rateManager.lookup(USD, ITL, new Date(4, Month.August, 2004));
calculated = usd_itl.exchange(m2);
expected = new Money(m2.value*1936.27/eur_usd1.rate, ITL);
if (!Utils.close(calculated, expected))
{
Assert.Fail("Wrong result: expected: " + expected + " calculated: " + calculated);
}
usd_itl = rateManager.lookup(USD, ITL, new Date(5, Month.August, 2004));
calculated = usd_itl.exchange(m2);
expected = new Money(m2.value*1936.27/eur_usd2.rate, ITL);
if (!Utils.close(calculated, expected))
{
Assert.Fail("Wrong result: expected: " + expected + " calculated: " + calculated);
}
}
public void testSmartLookup()
{
Currency EUR = new EURCurrency(), USD = new USDCurrency(), GBP = new GBPCurrency(),
CHF = new CHFCurrency(), SEK = new SEKCurrency(), JPY = new JPYCurrency();
ExchangeRateManager rateManager = ExchangeRateManager.Instance;
rateManager.clear();
ExchangeRate eur_usd1 = new ExchangeRate(EUR, USD, 1.1983);
ExchangeRate eur_usd2 = new ExchangeRate(USD, EUR, 1.0/1.2042);
rateManager.Add(eur_usd1, new Date(4,Month.August,2004));
rateManager.Add(eur_usd2, new Date(5,Month.August,2004));
ExchangeRate eur_gbp1 = new ExchangeRate(GBP, EUR, 1.0 / 0.6596);
ExchangeRate eur_gbp2 = new ExchangeRate(EUR, GBP, 0.6612);
rateManager.Add(eur_gbp1, new Date(4,Month.August,2004));
rateManager.Add(eur_gbp2, new Date(5,Month.August,2004));
ExchangeRate usd_chf1 = new ExchangeRate(USD, CHF, 1.2847);
ExchangeRate usd_chf2 = new ExchangeRate(CHF, USD, 1.0 / 1.2774);
rateManager.Add(usd_chf1, new Date(4,Month.August,2004));
rateManager.Add(usd_chf2, new Date(5,Month.August,2004));
ExchangeRate chf_sek1 = new ExchangeRate(SEK, CHF, 0.1674);
ExchangeRate chf_sek2 = new ExchangeRate(CHF, SEK, 1.0 / 0.1677);
rateManager.Add(chf_sek1, new Date(4,Month.August,2004));
rateManager.Add(chf_sek2, new Date(5,Month.August,2004));
ExchangeRate jpy_sek1 = new ExchangeRate(SEK, JPY, 14.5450);
ExchangeRate jpy_sek2 = new ExchangeRate(JPY, SEK, 1.0 / 14.6110);
rateManager.Add(jpy_sek1, new Date(4,Month.August,2004));
rateManager.Add(jpy_sek2, new Date(5,Month.August,2004));
Money m1 = 100000.0 * USD;
Money m2 = 100000.0 * EUR;
Money m3 = 100000.0 * GBP;
Money m4 = 100000.0 * CHF;
Money m5 = 100000.0 * SEK;
Money m6 = 100000.0 * JPY;
Money.conversionType = Money.ConversionType.NoConversion;
// two-rate chain
ExchangeRate usd_sek = rateManager.lookup(USD, SEK, new Date(4,Month.August,2004));
Money calculated = usd_sek.exchange(m1);
Money expected = new Money(m1.value*usd_chf1.rate/chf_sek1.rate, SEK);
if (!Utils.close(calculated, expected))
{
Assert.Fail("Wrong result: expected: " + expected + " calculated: " + calculated);
}
usd_sek = rateManager.lookup(SEK, USD, new Date(5,Month.August,2004));
calculated = usd_sek.exchange(m5);
expected = new Money(m5.value*usd_chf2.rate/chf_sek2.rate, USD);
if (!Utils.close(calculated, expected))
{
Assert.Fail("Wrong result: expected: " + expected + " calculated: " + calculated);
}
// three-rate chain
ExchangeRate eur_sek = rateManager.lookup(EUR, SEK,new Date(4,Month.August,2004));
calculated = eur_sek.exchange(m2);
expected = new Money(m2.value*eur_usd1.rate*usd_chf1.rate/chf_sek1.rate, SEK);
if (!Utils.close(calculated, expected))
{
Assert.Fail("Wrong result: expected: " + expected + " calculated: " + calculated);
}
eur_sek = rateManager.lookup(SEK, EUR, new Date(5,Month.August,2004));
calculated = eur_sek.exchange(m5);
expected = new Money(m5.value*eur_usd2.rate*usd_chf2.rate/chf_sek2.rate, EUR);
if (!Utils.close(calculated, expected))
{
Assert.Fail("Wrong result: expected: " + expected + " calculated: " + calculated);
}
// four-rate chain
ExchangeRate eur_jpy = rateManager.lookup(EUR, JPY,new Date(4,Month.August,2004));
calculated = eur_jpy.exchange(m2);
expected = new Money(m2.value*eur_usd1.rate*usd_chf1.rate*jpy_sek1.rate/chf_sek1.rate, JPY);
if (!Utils.close(calculated, expected))
{
Assert.Fail("Wrong result: expected: " + expected + " calculated: " + calculated);
}
eur_jpy = rateManager.lookup(JPY, EUR, new Date(5,Month.August,2004));
calculated = eur_jpy.exchange(m6);
expected = new Money(m6.value*jpy_sek2.rate*eur_usd2.rate*usd_chf2.rate/chf_sek2.rate, EUR);
if (!Utils.close(calculated, expected))
{
Assert.Fail("Wrong result: expected: " + expected + " calculated: " + calculated);
}
// five-rate chain
ExchangeRate gbp_jpy = rateManager.lookup(GBP, JPY,new Date(4,Month.August,2004));
calculated = gbp_jpy.exchange(m3);
expected = new Money(m3.value*eur_gbp1.rate*eur_usd1.rate*usd_chf1.rate*jpy_sek1.rate/chf_sek1.rate, JPY);
if (!Utils.close(calculated, expected))
{
Assert.Fail("Wrong result: expected: " + expected + " calculated: " + calculated);
}
gbp_jpy = rateManager.lookup(JPY, GBP, new Date(5,Month.August,2004));
calculated = gbp_jpy.exchange(m6);
expected = new Money(m6.value*jpy_sek2.rate*eur_usd2.rate*usd_chf2.rate*eur_gbp2.rate/chf_sek2.rate, GBP);
if (!Utils.close(calculated, expected))
{
Assert.Fail("Wrong result: expected: " + expected + " calculated: " + calculated);
}
}
public void testDirectLookup()
{
ExchangeRateManager rateManager = ExchangeRateManager.Instance;
rateManager.clear();
Currency EUR = new EURCurrency(), USD = new USDCurrency();
ExchangeRate eur_usd1 = new ExchangeRate(EUR, USD, 1.1983);
ExchangeRate eur_usd2 = new ExchangeRate(USD, EUR, 1.0/1.2042);
rateManager.Add(eur_usd1, new Date(4,Month.August,2004));
rateManager.Add(eur_usd2, new Date(5,Month.August,2004));
Money m1 = 50000.0 * EUR;
Money m2 = 100000.0 * USD;
Money.conversionType = Money.ConversionType.NoConversion;
ExchangeRate eur_usd = rateManager.lookup(EUR, USD,new Date(4,Month.August,2004),ExchangeRate.Type.Direct);
Money calculated = eur_usd.exchange(m1);
Money expected = new Money(m1.value*eur_usd1.rate, USD);
if (!Utils.close(calculated, expected))
{
Assert.Fail("Wrong result: expected: " + expected + " calculated: " + calculated);
}
eur_usd = rateManager.lookup(EUR, USD,new Date(5,Month.August,2004),ExchangeRate.Type.Direct);
calculated = eur_usd.exchange(m1);
expected = new Money(m1.value/eur_usd2.rate, USD);
if (!Utils.close(calculated, expected))
{
Assert.Fail("Wrong result: expected: " + expected + " calculated: " + calculated);
}
ExchangeRate usd_eur = rateManager.lookup(USD, EUR,new Date(4,Month.August,2004),ExchangeRate.Type.Direct);
calculated = usd_eur.exchange(m2);
expected = new Money(m2.value/eur_usd1.rate, EUR);
if (!Utils.close(calculated, expected))
{
Assert.Fail("Wrong result: expected: " + expected + " calculated: " + calculated);
}
usd_eur = rateManager.lookup(USD, EUR,new Date(5,Month.August,2004),ExchangeRate.Type.Direct);
calculated = usd_eur.exchange(m2);
expected = new Money(m2.value*eur_usd2.rate, EUR);
if (!Utils.close(calculated, expected))
{
Assert.Fail("Wrong result: expected: " + expected + " calculated: " + calculated);
}
}
/// <summary>
/// Utility methods
/// apply the exchange rate to a cash amount
/// </summary>
/// <param name="amount"></param>
/// <returns></returns>
public Money exchange(Money amount)
{
switch (type_)
{
case Type.Direct:
if (amount.currency == source_)
return new Money(amount.value * rate_.Value, target_);
else if (amount.currency == target_)
return new Money(amount.value / rate_.Value, source_);
else
throw new Exception ("exchange rate not applicable");
case Type.Derived:
if (amount.currency == rateChain_.Key.source || amount.currency == rateChain_.Key.target)
return rateChain_.Value.exchange(rateChain_.Key.exchange(amount));
else if (amount.currency == rateChain_.Value.source || amount.currency == rateChain_.Value.target)
return rateChain_.Key.exchange(rateChain_.Value.exchange(amount));
else
throw new Exception("exchange rate not applicable");
default:
throw new Exception("unknown exchange-rate type");
}
}
public static bool close(Money m1, Money m2)
{
return close(m1, m2, 42);
}
public bool Equals(Money other)
{
if (_currency == other._currency)
{
return _value == other._value;
}
if (conversionType == ConversionType.BaseCurrencyConversion)
{
Money tmp1 = (Money)MemberwiseClone();
convertToBase(ref tmp1);
Money tmp2 = (Money)other.MemberwiseClone();
convertToBase(ref tmp2);
// recursive...
return tmp1 == tmp2;
}
if (conversionType == ConversionType.AutomatedConversion)
{
Money tmp = (Money)other.MemberwiseClone();
convertTo(ref tmp, _currency);
return this == tmp;
}
throw new Exception("currency mismatch and no conversion specified"); // QA:[RG]::verified // TODO: message
}
public void testBaseCurrency()
{
Currency EUR = new EURCurrency(), GBP = new GBPCurrency(), USD = new USDCurrency();
Money m1 = 50000.0 * GBP;
Money m2 = 100000.0 * EUR;
Money m3 = 500000.0 * USD;
ExchangeRateManager.Instance.clear();
ExchangeRate eur_usd = new ExchangeRate(EUR, USD, 1.2042);
ExchangeRate eur_gbp = new ExchangeRate(EUR, GBP, 0.6612);
ExchangeRateManager.Instance.Add(eur_usd);
ExchangeRateManager.Instance.Add(eur_gbp);
Money.conversionType = Money.ConversionType.BaseCurrencyConversion;
Money.BaseCurrency = EUR;
Money calculated = m1 * 3.0 + 2.5 * m2 - m3 / 5.0;
Rounding round = Money.BaseCurrency.rounding;
double x = round.Round(m1.value * 3.0 / eur_gbp.rate) + 2.5 * m2.value
- round.Round(m3.value / (5.0 * eur_usd.rate));
Money expected = new Money(x, EUR);
Money.conversionType = Money.ConversionType.NoConversion;
if (calculated != expected)
{
Assert.Fail("Wrong result: expected: " + expected + "calculated: " + calculated);
}
}
public static void convertTo(ref Money m, Currency target)
{
if (m.currency != target)
{
ExchangeRate rate = ExchangeRateManager.Instance.lookup(m.currency, target);
m = rate.exchange(m).rounded();
}
}
public static Money operator -(Money m1, Money m2)
{
Money newInstance = new Money(m1.currency, m1.value);
if (newInstance._currency == m2._currency)
{
newInstance._value -= m2._value;
}
else if (conversionType == ConversionType.BaseCurrencyConversion)
{
convertToBase(ref newInstance);
Money tmp = (Money)m2.MemberwiseClone();
convertToBase(ref tmp);
newInstance -= tmp;
}
else if (conversionType == ConversionType.AutomatedConversion)
{
Money tmp = (Money)m2.MemberwiseClone();
convertTo(ref tmp, newInstance._currency);
newInstance -= tmp;
}
else
{
throw new Exception("currency mismatch and no conversion specified");
}
return newInstance;
}
public void testNone()
{
Currency EUR = new EURCurrency();
Money m1 = 50000.0 * EUR;
Money m2 = 100000.0 * EUR;
Money m3 = 500000.0 * EUR;
Money.conversionType = Money.ConversionType.NoConversion;
Money calculated = m1 * 3.0 + 2.5 * m2 - m3 / 5.0;
double x = m1.value * 3.0 + 2.5 * m2.value - m3.value / 5.0;
Money expected = new Money(x, EUR);
if (calculated != expected)
Assert.Fail("Wrong result: expected: " + expected + " calculated: " + calculated);
}
public static void convertToBase(ref Money m)
{
if (Money.baseCurrency.empty())
throw new Exception("no base currency set");
convertTo(ref m, Money.baseCurrency);
}
public static Money operator -(Money m1, Money m2)
{
Money m = new Money ( m1.currency ,m1.value );
if (m.currency_ == m2.currency_)
{
m.value_ -= m2.value_;
}
else if (Money.conversionType == Money.ConversionType.BaseCurrencyConversion)
{
convertToBase(ref m);
Money tmp = m2;
convertToBase(ref tmp);
m -= tmp;
}
else if (Money.conversionType == Money.ConversionType.AutomatedConversion)
{
Money tmp = m2;
convertTo(ref tmp, m.currency_);
m -= tmp;
}
else
{
throw new Exception ("currency mismatch and no conversion specified");
}
return m;
}
public void testDirect()
{
Currency EUR = new EURCurrency(), USD = new USDCurrency();
ExchangeRate eur_usd = new ExchangeRate(EUR, USD, 1.2042);
Money m1 = 50000.0 * EUR;
Money m2 = 100000.0 * USD;
Money.conversionType = Money.ConversionType.NoConversion;
Money calculated = eur_usd.exchange(m1);
Money expected = new Money(m1.value*eur_usd.rate, USD);
if (!Utils.close(calculated, expected))
{
Assert.Fail("Wrong result: expected: " + expected + " calculated: " + calculated);
}
calculated = eur_usd.exchange(m2);
expected = new Money(m2.value/eur_usd.rate, EUR);
if (!Utils.close(calculated, expected))
{
Assert.Fail("Wrong result: expected: " + expected + " calculated: " + calculated);
}
}
public static void convertToBase(ref Money m)
{
if (BaseCurrency.IsEmpty)
{
throw new Exception("no base currency set");
}
convertTo(ref m, BaseCurrency);
}
