money-joshm1 5.1.2

data/spec/currency_spec.rb

@@ -0,0 +1,183 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Money::Currency do
+
+  FOO = '{ "priority": 1, "iso_code": "FOO", "iso_numeric": "840", "name": "United States Dollar", "symbol": "$", "subunit": "Cent", "subunit_to_unit": 450, "symbol_first": true, "html_entity": "$", "decimal_mark": ".", "thousands_separator": "," }'
+
+  describe ".find" do
+    it "returns currency matching given id" do
+      Money::Currency.register(JSON.parse(FOO, :symbolize_names => true))
+
+      expected = Money::Currency.new(:foo)
+      Money::Currency.find(:foo).should  == expected
+      Money::Currency.find(:FOO).should  == expected
+      Money::Currency.find("foo").should == expected
+      Money::Currency.find("FOO").should == expected
+    end
+
+    it "returns nil unless currency matching given id" do
+      Money::Currency.find("ZZZ").should be_nil
+    end
+  end
+
+  describe ".find_by_iso_numeric" do
+    it "returns currency matching given numeric code" do
+      Money::Currency.find_by_iso_numeric(978).should          == Money::Currency.new(:eur)
+      Money::Currency.find_by_iso_numeric(208).should_not      == Money::Currency.new(:eur)
+      Money::Currency.find_by_iso_numeric('840').should        == Money::Currency.new(:usd)
+
+      class Mock
+        def to_s
+          '208'
+        end
+      end
+      Money::Currency.find_by_iso_numeric(Mock.new).should     == Money::Currency.new(:dkk)
+      Money::Currency.find_by_iso_numeric(Mock.new).should_not == Money::Currency.new(:usd)
+    end
+
+    it "returns nil if no currency has the given numeric code" do
+      Money::Currency.find_by_iso_numeric('non iso 4217 numeric code').should == nil
+      Money::Currency.find_by_iso_numeric(0).should                           == nil
+    end
+  end
+
+  describe ".wrap" do
+    it "returns nil if object is nil" do
+      Money::Currency.wrap(nil).should == nil
+      Money::Currency.wrap(Money::Currency.new(:usd)).should == Money::Currency.new(:usd)
+      Money::Currency.wrap(:usd).should == Money::Currency.new(:usd)
+    end
+  end
+
+  describe ".all" do
+    it "returns an array of currencies" do
+      Money::Currency.all.should include Money::Currency.new(:usd)
+    end
+    it "includes registered currencies" do
+      Money::Currency.register(JSON.parse(FOO, :symbolize_names => true))
+      Money::Currency.all.should include Money::Currency.new(:foo)
+    end
+    it 'is sorted by priority' do
+      Money::Currency.all.first.priority.should == 1
+    end
+  end
+
+  describe "#initialize" do
+    it "lookups data from loaded config" do
+      currency = Money::Currency.new("USD")
+      currency.id.should                  == :usd
+      currency.priority.should            == 1
+      currency.iso_code.should            == "USD"
+      currency.iso_numeric.should         == "840"
+      currency.name.should                == "United States Dollar"
+      currency.decimal_mark.should        == "."
+      currency.separator.should           == "."
+      currency.thousands_separator.should == ","
+      currency.delimiter.should           == ","
+    end
+
+    it "raises UnknownMoney::Currency with unknown currency" do
+      expect { Money::Currency.new("xxx") }.to raise_error(Money::Currency::UnknownCurrency, /xxx/)
+    end
+  end
+
+  describe "#<=>" do
+    it "compares objects by priority" do
+      Money::Currency.new(:cad).should > Money::Currency.new(:usd)
+      Money::Currency.new(:usd).should < Money::Currency.new(:eur)
+    end
+  end
+
+  describe "#==" do
+    it "returns true if self === other" do
+      currency = Money::Currency.new(:eur)
+      currency.should == currency
+    end
+
+    it "returns true if the id is equal ignorning case" do
+      Money::Currency.new(:eur).should     == Money::Currency.new(:eur)
+      Money::Currency.new(:eur).should     == Money::Currency.new(:EUR)
+      Money::Currency.new(:eur).should_not == Money::Currency.new(:usd)
+    end
+    
+    it "allows direct comparison of currencies and symbols/strings" do
+      Money::Currency.new(:eur).should     == 'eur'
+      Money::Currency.new(:eur).should     == :EUR
+      Money::Currency.new(:eur).should_not == 'usd'
+    end
+  end
+
+  describe "#eql?" do
+    it "returns true if #== returns true" do
+      Money::Currency.new(:eur).eql?(Money::Currency.new(:eur)).should be true
+      Money::Currency.new(:eur).eql?(Money::Currency.new(:usd)).should be false
+    end
+  end
+
+  describe "#hash" do
+    it "returns the same value for equal objects" do
+      Money::Currency.new(:eur).hash.should == Money::Currency.new(:eur).hash
+      Money::Currency.new(:eur).hash.should_not == Money::Currency.new(:usd).hash
+    end
+
+    it "can be used to return the intersection of Currency object arrays" do
+      intersection = [Money::Currency.new(:eur), Money::Currency.new(:usd)] & [Money::Currency.new(:eur)]
+      intersection.should == [Money::Currency.new(:eur)]
+    end
+  end
+
+  describe "#inspect" do
+    it "works as documented" do
+      Money::Currency.new(:usd).inspect.should ==
+          %Q{#<Money::Currency id: usd, priority: 1, symbol_first: true, thousands_separator: ,, html_entity: $, decimal_mark: ., name: United States Dollar, symbol: $, subunit_to_unit: 100, exponent: 2.0, iso_code: USD, iso_numeric: 840, subunit: Cent>}
+    end
+  end
+
+  describe "#to_s" do
+    it "works as documented" do
+      Money::Currency.new(:usd).to_s.should == "USD"
+      Money::Currency.new(:eur).to_s.should == "EUR"
+    end
+  end
+
+  describe "#to_currency" do
+    it "works as documented" do
+      usd = Money::Currency.new(:usd)
+      usd.to_currency.should == usd
+    end
+
+    it "doesn't create new symbols indefinitely" do
+      expect { Money::Currency.new("bogus") }.to raise_exception(Money::Currency::UnknownCurrency)
+      Symbol.all_symbols.map{|s| s.to_s}.should_not include("bogus")
+    end
+  end
+
+  describe "#code" do
+    it "works as documented" do
+      Money::Currency.new(:usd).code.should == "$"
+      Money::Currency.new(:azn).code.should == "AZN"
+    end
+  end
+
+  describe "#exponent" do
+    it "conforms to iso 4217" do
+      Money::Currency.new(:jpy).exponent == 0
+      Money::Currency.new(:usd).exponent == 2
+      Money::Currency.new(:iqd).exponent == 3
+    end
+  end
+
+  describe "#decimal_places" do
+    it "proper places for known currency" do
+      Money::Currency.new(:mro).decimal_places == 1
+      Money::Currency.new(:usd).decimal_places == 2
+    end
+
+    it "proper places for custom currency" do
+      Money::Currency.register(JSON.parse(FOO, :symbolize_names => true))
+      Money::Currency.new(:foo).decimal_places == 3
+    end
+  end
+end

data/spec/money/arithmetic_spec.rb

@@ -0,0 +1,598 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Money do
+  describe "-@" do
+    it "changes the sign of a number" do
+      (- Money.new(0)).should == Money.new(0)
+      (- Money.new(1)).should == Money.new(-1)
+      (- Money.new(-1)).should == Money.new(1)
+    end
+  end
+
+  describe "#==" do
+    it "returns true if and only if their amount and currency are equal" do
+      Money.new(1_00, "USD").should == Money.new(1_00, "USD")
+      Money.new(1_00, "USD").should_not == Money.new(1_00, "EUR")
+      Money.new(1_00, "USD").should_not == Money.new(2_00, "USD")
+      Money.new(1_00, "USD").should_not == Money.new(99_00, "EUR")
+    end
+
+    it "returns false if used to compare with an object that doesn't respond to #to_money" do
+      Money.new(1_00, "USD").should_not == Object.new
+      Money.new(1_00, "USD").should_not == Class
+      Money.new(1_00, "USD").should_not == Kernel
+      Money.new(1_00, "USD").should_not == /foo/
+      Money.new(1_00, "USD").should_not == nil
+    end
+
+    it "can be used to compare with a String money value" do
+      Money.new(1_00, "USD").should == "1.00"
+      Money.new(1_00, "USD").should_not == "2.00"
+      Money.new(1_00, "GBP").should_not == "1.00"
+    end
+
+    it "can be used to compare with a Numeric money value" do
+      Money.new(1_00, "USD").should == 1
+      Money.new(1_57, "USD").should == 1.57
+      Money.new(1_00, "USD").should_not == 2
+      Money.new(1_00, "GBP").should_not == 1
+    end
+
+    it "can be used to compare with an object that responds to #to_money" do
+      klass = Class.new do
+        def initialize(money)
+          @money = money
+        end
+
+        def to_money
+          @money
+        end
+      end
+
+      Money.new(1_00, "USD").should == klass.new(Money.new(1_00, "USD"))
+      Money.new(2_50, "USD").should == klass.new(Money.new(2_50, "USD"))
+      Money.new(2_50, "USD").should_not == klass.new(Money.new(3_00, "USD"))
+      Money.new(1_00, "GBP").should_not == klass.new(Money.new(1_00, "USD"))
+    end
+  end
+
+  describe "#eql?" do
+    it "returns true if and only if their amount and currency are equal" do
+      Money.new(1_00, "USD").eql?(Money.new(1_00, "USD")).should be true
+      Money.new(1_00, "USD").eql?(Money.new(1_00, "EUR")).should be false
+      Money.new(1_00, "USD").eql?(Money.new(2_00, "USD")).should be false
+      Money.new(1_00, "USD").eql?(Money.new(99_00, "EUR")).should be false
+    end
+
+    it "returns false if used to compare with an object that doesn't respond to #to_money" do
+      Money.new(1_00, "USD").eql?(Object.new).should be false
+      Money.new(1_00, "USD").eql?(Class).should be false
+      Money.new(1_00, "USD").eql?(Kernel).should be false
+      Money.new(1_00, "USD").eql?(/foo/).should be false
+      Money.new(1_00, "USD").eql?(nil).should be false
+    end
+
+    it "can be used to compare with a String money value" do
+      Money.new(1_00, "USD").eql?("1.00").should be true
+      Money.new(1_00, "USD").eql?("2.00").should be false
+      Money.new(1_00, "GBP").eql?("1.00").should be false
+    end
+
+    it "can be used to compare with a Numeric money value" do
+      Money.new(1_00, "USD").eql?(1).should be true
+      Money.new(1_57, "USD").eql?(1.57).should be true
+      Money.new(1_00, "USD").eql?(2).should be false
+      Money.new(1_00, "GBP").eql?(1).should be false
+    end
+
+    it "can be used to compare with an object that responds to #to_money" do
+      klass = Class.new do
+        def initialize(money)
+          @money = money
+        end
+
+        def to_money
+          @money
+        end
+      end
+
+      Money.new(1_00, "USD").eql?(klass.new(Money.new(1_00, "USD"))).should be true
+      Money.new(2_50, "USD").eql?(klass.new(Money.new(2_50, "USD"))).should be true
+      Money.new(2_50, "USD").eql?(klass.new(Money.new(3_00, "USD"))).should be false
+      Money.new(1_00, "GBP").eql?(klass.new(Money.new(1_00, "USD"))).should be false
+    end
+  end
+
+  describe "#<=>" do
+    it "compares the two object amounts (same currency)" do
+      (Money.new(1_00, "USD") <=> Money.new(1_00, "USD")).should == 0
+      (Money.new(1_00, "USD") <=> Money.new(99, "USD")).should > 0
+      (Money.new(1_00, "USD") <=> Money.new(2_00, "USD")).should < 0
+    end
+
+    it "converts other object amount to current currency, then compares the two object amounts (different currency)" do
+      target = Money.new(200_00, "EUR")
+      target.should_receive(:exchange_to).with(Money::Currency.new("USD")).and_return(Money.new(300_00, "USD"))
+      (Money.new(100_00, "USD") <=> target).should < 0
+
+      target = Money.new(200_00, "EUR")
+      target.should_receive(:exchange_to).with(Money::Currency.new("USD")).and_return(Money.new(100_00, "USD"))
+      (Money.new(100_00, "USD") <=> target).should == 0
+
+      target = Money.new(200_00, "EUR")
+      target.should_receive(:exchange_to).with(Money::Currency.new("USD")).and_return(Money.new(99_00, "USD"))
+      (Money.new(100_00, "USD") <=> target).should > 0
+    end
+
+    it "cannot compare objects with different currencies when no rate exists, unless one of the amounts is zero" do
+      expect { Money.new(100_00, "EUR") <=> Money.new(100_00, "USD") }.to raise_error(Money::Bank::UnknownRate)
+
+      (Money.new(100_00, "EUR") <=> Money.new(0, "USD")).should > 0
+      (Money.new(0, "EUR") <=> Money.new(100_00, "USD")).should < 0
+      (Money.new(0, "EUR") <=> Money.new(0, "USD")).should == 0
+    end
+
+    it "can be used to compare with a String money value when Money object is in default currency" do
+      (Money.new(1_00) <=> "1.00").should == 0
+      (Money.new(1_00) <=> ".99").should > 0
+      (Money.new(1_00) <=> "2.00").should < 0
+    end
+
+    it "can be used to compare with a String money value when Money object is not in default currency if String evaluates to zero" do
+      expect { Money.new(1_00, "EUR") <=> "1.00" }.to raise_error(Money::Bank::UnknownRate)
+
+      (Money.new(1_00, "EUR") <=> "0.00").should > 0
+      (Money.new(0_00, "EUR") <=> "0.00").should == 0
+      (Money.new(-1_00, "EUR") <=> "0.00").should < 0
+    end
+
+    it "can be used to compare with a Numeric money value when Money object is in default currency" do
+      (Money.new(1_00) <=> 1).should == 0
+      (Money.new(1_00) <=> 0.99).should > 0
+      (Money.new(1_00) <=> 2.00).should < 0
+    end
+
+    it "can be used to compare with a Numeric money value when Money object is not in default currency if String evaluates to zero" do
+      expect { Money.new(1_00, "EUR") <=> 1 }.to raise_error(Money::Bank::UnknownRate)
+
+      (Money.new(1_00, "EUR") <=> 0).should > 0
+      (Money.new(0_00, "EUR") <=> 0).should == 0
+      (Money.new(-1_00, "EUR") <=> 0).should < 0
+    end
+
+    it "can be used to compare with an object that responds to #to_money" do
+      klass = Class.new do
+        def initialize(money)
+          @money = money
+        end
+
+        def to_money
+          @money
+        end
+      end
+
+      (Money.new(1_00) <=> klass.new(Money.new(1_00))).should == 0
+      (Money.new(1_00) <=> klass.new(Money.new(99))).should > 0
+      (Money.new(1_00) <=> klass.new(Money.new(2_00))).should < 0
+    end
+
+    it "raises ArgumentError when used to compare with an object that doesn't respond to #to_money" do
+      expected_message = /Comparison .+ failed/
+      expect{ Money.new(1_00) <=> Object.new  }.to raise_error(ArgumentError, expected_message)
+      expect{ Money.new(1_00) <=> Class       }.to raise_error(ArgumentError, expected_message)
+      expect{ Money.new(1_00) <=> Kernel      }.to raise_error(ArgumentError, expected_message)
+      expect{ Money.new(1_00) <=> /foo/       }.to raise_error(ArgumentError, expected_message)
+    end
+  end
+
+  describe "#positive?" do
+    it "returns true if the amount is greater than 0" do
+      Money.new(1).should be_positive
+    end
+
+    it "returns false if the amount is 0" do
+      Money.new(0).should_not be_positive
+    end
+
+    it "returns false if the amount is negative" do
+      Money.new(-1).should_not be_positive
+    end
+  end
+
+  describe "#negative?" do
+    it "returns true if the amount is less than 0" do
+      Money.new(-1).should be_negative
+    end
+
+    it "returns false if the amount is 0" do
+      Money.new(0).should_not be_negative
+    end
+
+    it "returns false if the amount is greater than 0" do
+      Money.new(1).should_not be_negative
+    end
+  end
+
+  describe "#+" do
+    it "adds other amount to current amount (same currency)" do
+      (Money.new(10_00, "USD") + Money.new(90, "USD")).should == Money.new(10_90, "USD")
+    end
+
+    it "converts other object amount to current currency and adds other amount to current amount (different currency)" do
+      other = Money.new(90, "EUR")
+      other.should_receive(:exchange_to).with(Money::Currency.new("USD")).and_return(Money.new(9_00, "USD"))
+      (Money.new(10_00, "USD") + other).should == Money.new(19_00, "USD")
+    end
+  end
+
+  describe "#-" do
+    it "subtracts other amount from current amount (same currency)" do
+      (Money.new(10_00, "USD") - Money.new(90, "USD")).should == Money.new(9_10, "USD")
+    end
+
+    it "converts other object amount to current currency and subtracts other amount from current amount (different currency)" do
+      other = Money.new(90, "EUR")
+      other.should_receive(:exchange_to).with(Money::Currency.new("USD")).and_return(Money.new(9_00, "USD"))
+      (Money.new(10_00, "USD") - other).should == Money.new(1_00, "USD")
+    end
+  end
+
+  describe "#*" do
+    it "multiplies Money by Fixnum and returns Money" do
+      ts = [
+        {:a => Money.new( 10, :USD), :b =>  4, :c => Money.new( 40, :USD)},
+        {:a => Money.new( 10, :USD), :b => -4, :c => Money.new(-40, :USD)},
+        {:a => Money.new(-10, :USD), :b =>  4, :c => Money.new(-40, :USD)},
+        {:a => Money.new(-10, :USD), :b => -4, :c => Money.new( 40, :USD)},
+      ]
+      ts.each do |t|
+        (t[:a] * t[:b]).should == t[:c]
+      end
+    end
+
+    it "does not multiply Money by Money (same currency)" do
+      expect { Money.new( 10, :USD) * Money.new( 4, :USD) }.to raise_error(ArgumentError)
+    end
+
+    it "does not multiply Money by Money (different currency)" do
+      expect { Money.new( 10, :USD) * Money.new( 4, :EUR) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#/" do
+    it "divides Money by Fixnum and returns Money" do
+      ts = [
+        {:a => Money.new( 13, :USD), :b =>  4, :c => Money.new( 3, :USD)},
+        {:a => Money.new( 13, :USD), :b => -4, :c => Money.new(-4, :USD)},
+        {:a => Money.new(-13, :USD), :b =>  4, :c => Money.new(-4, :USD)},
+        {:a => Money.new(-13, :USD), :b => -4, :c => Money.new( 3, :USD)},
+      ]
+      ts.each do |t|
+        (t[:a] / t[:b]).should == t[:c]
+      end
+    end
+
+    it "divides Money by Money (same currency) and returns Float" do
+      ts = [
+        {:a => Money.new( 13, :USD), :b => Money.new( 4, :USD), :c =>  3.25},
+        {:a => Money.new( 13, :USD), :b => Money.new(-4, :USD), :c => -3.25},
+        {:a => Money.new(-13, :USD), :b => Money.new( 4, :USD), :c => -3.25},
+        {:a => Money.new(-13, :USD), :b => Money.new(-4, :USD), :c =>  3.25},
+      ]
+      ts.each do |t|
+        (t[:a] / t[:b]).should == t[:c]
+      end
+    end
+
+    it "divides Money by Money (different currency) and returns Float" do
+      ts = [
+        {:a => Money.new( 13, :USD), :b => Money.new( 4, :EUR), :c =>  1.625},
+        {:a => Money.new( 13, :USD), :b => Money.new(-4, :EUR), :c => -1.625},
+        {:a => Money.new(-13, :USD), :b => Money.new( 4, :EUR), :c => -1.625},
+        {:a => Money.new(-13, :USD), :b => Money.new(-4, :EUR), :c =>  1.625},
+      ]
+      ts.each do |t|
+        t[:b].should_receive(:exchange_to).once.with(t[:a].currency).and_return(Money.new(t[:b].cents * 2, :USD))
+        (t[:a] / t[:b]).should == t[:c]
+      end
+    end
+
+    context "infinite_precision = true" do
+      before do
+        Money.infinite_precision = true
+      end
+
+      after do
+        Money.infinite_precision = false
+      end
+
+      it "uses BigDecimal division" do
+        ts = [
+          {:a => Money.new( 13, :USD), :b =>  4, :c => Money.new( 3.25, :USD)},
+          {:a => Money.new( 13, :USD), :b => -4, :c => Money.new(-3.25, :USD)},
+          {:a => Money.new(-13, :USD), :b =>  4, :c => Money.new(-3.25, :USD)},
+          {:a => Money.new(-13, :USD), :b => -4, :c => Money.new( 3.25, :USD)},
+        ]
+        ts.each do |t|
+          (t[:a] / t[:b]).should == t[:c]
+        end
+      end
+    end
+  end
+
+  describe "#div" do
+    it "divides Money by Fixnum and returns Money" do
+      ts = [
+          {:a => Money.new( 13, :USD), :b =>  4, :c => Money.new( 3, :USD)},
+          {:a => Money.new( 13, :USD), :b => -4, :c => Money.new(-4, :USD)},
+          {:a => Money.new(-13, :USD), :b =>  4, :c => Money.new(-4, :USD)},
+          {:a => Money.new(-13, :USD), :b => -4, :c => Money.new( 3, :USD)},
+      ]
+      ts.each do |t|
+        t[:a].div(t[:b]).should == t[:c]
+      end
+    end
+
+    it "divides Money by Money (same currency) and returns Float" do
+      ts = [
+          {:a => Money.new( 13, :USD), :b => Money.new( 4, :USD), :c =>  3.25},
+          {:a => Money.new( 13, :USD), :b => Money.new(-4, :USD), :c => -3.25},
+          {:a => Money.new(-13, :USD), :b => Money.new( 4, :USD), :c => -3.25},
+          {:a => Money.new(-13, :USD), :b => Money.new(-4, :USD), :c =>  3.25},
+      ]
+      ts.each do |t|
+        t[:a].div(t[:b]).should == t[:c]
+      end
+    end
+
+    it "divides Money by Money (different currency) and returns Float" do
+      ts = [
+          {:a => Money.new( 13, :USD), :b => Money.new( 4, :EUR), :c =>  1.625},
+          {:a => Money.new( 13, :USD), :b => Money.new(-4, :EUR), :c => -1.625},
+          {:a => Money.new(-13, :USD), :b => Money.new( 4, :EUR), :c => -1.625},
+          {:a => Money.new(-13, :USD), :b => Money.new(-4, :EUR), :c =>  1.625},
+      ]
+      ts.each do |t|
+        t[:b].should_receive(:exchange_to).once.with(t[:a].currency).and_return(Money.new(t[:b].cents * 2, :USD))
+        t[:a].div(t[:b]).should == t[:c]
+      end
+    end
+
+    context "infinite_precision = true" do
+      before do
+        Money.infinite_precision = true
+      end
+
+      after do
+        Money.infinite_precision = false
+      end
+
+      it "uses BigDecimal division" do
+        ts = [
+          {:a => Money.new( 13, :USD), :b =>  4, :c => Money.new( 3.25, :USD)},
+          {:a => Money.new( 13, :USD), :b => -4, :c => Money.new(-3.25, :USD)},
+          {:a => Money.new(-13, :USD), :b =>  4, :c => Money.new(-3.25, :USD)},
+          {:a => Money.new(-13, :USD), :b => -4, :c => Money.new( 3.25, :USD)},
+        ]
+        ts.each do |t|
+          t[:a].div(t[:b]).should == t[:c]
+        end
+      end
+    end
+  end
+
+  describe "#divmod" do
+    it "calculates division and modulo with Fixnum" do
+      ts = [
+          {:a => Money.new( 13, :USD), :b =>  4, :c => [Money.new( 3, :USD), Money.new( 1, :USD)]},
+          {:a => Money.new( 13, :USD), :b => -4, :c => [Money.new(-4, :USD), Money.new(-3, :USD)]},
+          {:a => Money.new(-13, :USD), :b =>  4, :c => [Money.new(-4, :USD), Money.new( 3, :USD)]},
+          {:a => Money.new(-13, :USD), :b => -4, :c => [Money.new( 3, :USD), Money.new(-1, :USD)]},
+      ]
+      ts.each do |t|
+        t[:a].divmod(t[:b]).should == t[:c]
+      end
+    end
+
+    it "calculates division and modulo with Money (same currency)" do
+      ts = [
+          {:a => Money.new( 13, :USD), :b => Money.new( 4, :USD), :c => [ 3, Money.new( 1, :USD)]},
+          {:a => Money.new( 13, :USD), :b => Money.new(-4, :USD), :c => [-4, Money.new(-3, :USD)]},
+          {:a => Money.new(-13, :USD), :b => Money.new( 4, :USD), :c => [-4, Money.new( 3, :USD)]},
+          {:a => Money.new(-13, :USD), :b => Money.new(-4, :USD), :c => [ 3, Money.new(-1, :USD)]},
+      ]
+      ts.each do |t|
+        t[:a].divmod(t[:b]).should == t[:c]
+      end
+    end
+
+    it "calculates division and modulo with Money (different currency)" do
+      ts = [
+          {:a => Money.new( 13, :USD), :b => Money.new( 4, :EUR), :c => [ 1, Money.new( 5, :USD)]},
+          {:a => Money.new( 13, :USD), :b => Money.new(-4, :EUR), :c => [-2, Money.new(-3, :USD)]},
+          {:a => Money.new(-13, :USD), :b => Money.new( 4, :EUR), :c => [-2, Money.new( 3, :USD)]},
+          {:a => Money.new(-13, :USD), :b => Money.new(-4, :EUR), :c => [ 1, Money.new(-5, :USD)]},
+      ]
+      ts.each do |t|
+        t[:b].should_receive(:exchange_to).once.with(t[:a].currency).and_return(Money.new(t[:b].cents * 2, :USD))
+        t[:a].divmod(t[:b]).should == t[:c]
+      end
+    end
+
+    context "infinite_precision = true" do
+      before do
+        Money.infinite_precision = true
+      end
+
+      after do
+        Money.infinite_precision = false
+      end
+
+      it "uses BigDecimal division" do
+        ts = [
+            {:a => Money.new( 13, :USD), :b =>  4, :c => [Money.new( 3, :USD), Money.new( 1, :USD)]},
+            {:a => Money.new( 13, :USD), :b => -4, :c => [Money.new(-4, :USD), Money.new(-3, :USD)]},
+            {:a => Money.new(-13, :USD), :b =>  4, :c => [Money.new(-4, :USD), Money.new( 3, :USD)]},
+            {:a => Money.new(-13, :USD), :b => -4, :c => [Money.new( 3, :USD), Money.new(-1, :USD)]},
+        ]
+        ts.each do |t|
+          t[:a].divmod(t[:b]).should == t[:c]
+        end
+      end
+    end
+  end
+
+  describe "#modulo" do
+    it "calculates modulo with Fixnum" do
+      ts = [
+          {:a => Money.new( 13, :USD), :b =>  4, :c => Money.new( 1, :USD)},
+          {:a => Money.new( 13, :USD), :b => -4, :c => Money.new(-3, :USD)},
+          {:a => Money.new(-13, :USD), :b =>  4, :c => Money.new( 3, :USD)},
+          {:a => Money.new(-13, :USD), :b => -4, :c => Money.new(-1, :USD)},
+      ]
+      ts.each do |t|
+        t[:a].modulo(t[:b]).should == t[:c]
+      end
+    end
+
+    it "calculates modulo with Money (same currency)" do
+      ts = [
+          {:a => Money.new( 13, :USD), :b => Money.new( 4, :USD), :c => Money.new( 1, :USD)},
+          {:a => Money.new( 13, :USD), :b => Money.new(-4, :USD), :c => Money.new(-3, :USD)},
+          {:a => Money.new(-13, :USD), :b => Money.new( 4, :USD), :c => Money.new( 3, :USD)},
+          {:a => Money.new(-13, :USD), :b => Money.new(-4, :USD), :c => Money.new(-1, :USD)},
+      ]
+      ts.each do |t|
+        t[:a].modulo(t[:b]).should == t[:c]
+      end
+    end
+
+    it "calculates modulo with Money (different currency)" do
+      ts = [
+          {:a => Money.new( 13, :USD), :b => Money.new( 4, :EUR), :c => Money.new( 5, :USD)},
+          {:a => Money.new( 13, :USD), :b => Money.new(-4, :EUR), :c => Money.new(-3, :USD)},
+          {:a => Money.new(-13, :USD), :b => Money.new( 4, :EUR), :c => Money.new( 3, :USD)},
+          {:a => Money.new(-13, :USD), :b => Money.new(-4, :EUR), :c => Money.new(-5, :USD)},
+      ]
+      ts.each do |t|
+        t[:b].should_receive(:exchange_to).once.with(t[:a].currency).and_return(Money.new(t[:b].cents * 2, :USD))
+        t[:a].modulo(t[:b]).should == t[:c]
+      end
+    end
+  end
+
+  describe "#%" do
+    it "calculates modulo with Fixnum" do
+      ts = [
+          {:a => Money.new( 13, :USD), :b =>  4, :c => Money.new( 1, :USD)},
+          {:a => Money.new( 13, :USD), :b => -4, :c => Money.new(-3, :USD)},
+          {:a => Money.new(-13, :USD), :b =>  4, :c => Money.new( 3, :USD)},
+          {:a => Money.new(-13, :USD), :b => -4, :c => Money.new(-1, :USD)},
+      ]
+      ts.each do |t|
+        (t[:a] % t[:b]).should == t[:c]
+      end
+    end
+
+    it "calculates modulo with Money (same currency)" do
+      ts = [
+          {:a => Money.new( 13, :USD), :b => Money.new( 4, :USD), :c => Money.new( 1, :USD)},
+          {:a => Money.new( 13, :USD), :b => Money.new(-4, :USD), :c => Money.new(-3, :USD)},
+          {:a => Money.new(-13, :USD), :b => Money.new( 4, :USD), :c => Money.new( 3, :USD)},
+          {:a => Money.new(-13, :USD), :b => Money.new(-4, :USD), :c => Money.new(-1, :USD)},
+      ]
+      ts.each do |t|
+        (t[:a] % t[:b]).should == t[:c]
+      end
+    end
+
+    it "calculates modulo with Money (different currency)" do
+      ts = [
+          {:a => Money.new( 13, :USD), :b => Money.new( 4, :EUR), :c => Money.new( 5, :USD)},
+          {:a => Money.new( 13, :USD), :b => Money.new(-4, :EUR), :c => Money.new(-3, :USD)},
+          {:a => Money.new(-13, :USD), :b => Money.new( 4, :EUR), :c => Money.new( 3, :USD)},
+          {:a => Money.new(-13, :USD), :b => Money.new(-4, :EUR), :c => Money.new(-5, :USD)},
+      ]
+      ts.each do |t|
+        t[:b].should_receive(:exchange_to).once.with(t[:a].currency).and_return(Money.new(t[:b].cents * 2, :USD))
+        (t[:a] % t[:b]).should == t[:c]
+      end
+    end
+  end
+
+  describe "#remainder" do
+    it "calculates remainder with Fixnum" do
+      ts = [
+          {:a => Money.new( 13, :USD), :b =>  4, :c => Money.new( 1, :USD)},
+          {:a => Money.new( 13, :USD), :b => -4, :c => Money.new( 1, :USD)},
+          {:a => Money.new(-13, :USD), :b =>  4, :c => Money.new(-1, :USD)},
+          {:a => Money.new(-13, :USD), :b => -4, :c => Money.new(-1, :USD)},
+      ]
+      ts.each do |t|
+        t[:a].remainder(t[:b]).should == t[:c]
+      end
+    end
+
+    it "calculates remainder with Money (same currency)" do
+      ts = [
+          {:a => Money.new( 13, :USD), :b => Money.new( 4, :USD), :c => Money.new( 1, :USD)},
+          {:a => Money.new( 13, :USD), :b => Money.new(-4, :USD), :c => Money.new( 1, :USD)},
+          {:a => Money.new(-13, :USD), :b => Money.new( 4, :USD), :c => Money.new(-1, :USD)},
+          {:a => Money.new(-13, :USD), :b => Money.new(-4, :USD), :c => Money.new(-1, :USD)},
+      ]
+      ts.each do |t|
+        t[:a].remainder(t[:b]).should == t[:c]
+      end
+    end
+
+    it "calculates remainder with Money (different currency)" do
+      ts = [
+          {:a => Money.new( 13, :USD), :b => Money.new( 4, :EUR), :c => Money.new( 5, :USD)},
+          {:a => Money.new( 13, :USD), :b => Money.new(-4, :EUR), :c => Money.new( 5, :USD)},
+          {:a => Money.new(-13, :USD), :b => Money.new( 4, :EUR), :c => Money.new(-5, :USD)},
+          {:a => Money.new(-13, :USD), :b => Money.new(-4, :EUR), :c => Money.new(-5, :USD)},
+      ]
+      ts.each do |t|
+        t[:b].should_receive(:exchange_to).once.with(t[:a].currency).and_return(Money.new(t[:b].cents * 2, :USD))
+        t[:a].remainder(t[:b]).should == t[:c]
+      end
+    end
+  end
+
+  describe "#abs" do
+    it "returns the absolute value as a new Money object" do
+      n = Money.new(-1, :USD)
+      n.abs.should == Money.new( 1, :USD)
+      n.should     == Money.new(-1, :USD)
+    end
+  end
+
+  describe "#zero?" do
+    it "returns whether the amount is 0" do
+      Money.new(0, "USD").should be_zero
+      Money.new(0, "EUR").should be_zero
+      Money.new(1, "USD").should_not be_zero
+      Money.new(10, "YEN").should_not be_zero
+      Money.new(-1, "EUR").should_not be_zero
+    end
+  end
+
+  describe "#nonzero?" do
+    it "returns whether the amount is not 0" do
+      Money.new(0, "USD").should_not be_nonzero
+      Money.new(0, "EUR").should_not be_nonzero
+      Money.new(1, "USD").should be_nonzero
+      Money.new(10, "YEN").should be_nonzero
+      Money.new(-1, "EUR").should be_nonzero
+    end
+
+    it "has the same return-value semantics as Numeric#nonzero?" do
+      Money.new(0, "USD").nonzero?.should be_nil
+
+      money = Money.new(1, "USD")
+      money.nonzero?.should be_equal(money)
+    end
+  end
+end