예제 #1
0
        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);
            }
        }
예제 #2
0
        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);
            }
        }
예제 #3
0
        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);
             }
        }
예제 #4
0
파일: T_Money.cs 프로젝트: igitur/qlnet
        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)
            {
                QAssert.Fail("Wrong result: expected: " + expected + "calculated: " + calculated);
            }
        }
예제 #5
0
파일: MoneyTests.cs 프로젝트: vdt/QLNet
        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);
            }
        }
예제 #6
0
        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);
            }
        }
예제 #7
0
        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);
             }
        }
예제 #8
0
 internal static global::System.Runtime.InteropServices.HandleRef getCPtr(GBPCurrency obj)
 {
     return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
 }
예제 #9
0
파일: GBPCurrency.cs 프로젝트: minikie/test
 internal static global::System.Runtime.InteropServices.HandleRef getCPtr(GBPCurrency obj) {
   return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
 }