money 6.9.0 → 6.16.0

data/spec/money/arithmetic_spec.rb

@@ -1,693 +0,0 @@
-# encoding: utf-8
-
-describe Money do
-  describe "-@" do
-    it "changes the sign of a number" do
-      expect((- Money.new(0))).to  eq Money.new(0)
-      expect((- Money.new(1))).to  eq Money.new(-1)
-      expect((- Money.new(-1))).to eq Money.new(1)
-    end
-
-    it "preserves the class in the result when using a subclass of Money" do
-      special_money_class = Class.new(Money)
-      expect(- special_money_class.new(10_00)).to be_a special_money_class
-    end
-  end
-
-  describe "#==" do
-    it "returns true if both the amounts and currencies are equal" do
-      expect(Money.new(1_00, "USD")).to     eq Money.new(1_00, "USD")
-      expect(Money.new(1_00, "USD")).not_to eq Money.new(1_00, "EUR")
-      expect(Money.new(1_00, "USD")).not_to eq Money.new(2_00, "USD")
-      expect(Money.new(1_00, "USD")).not_to eq Money.new(99_00, "EUR")
-    end
-
-    it "returns true if both amounts are zero, even if currency differs" do
-      allow_any_instance_of(Money).to receive(:exchange_to) { Money.usd(0) }
-      expect(Money.new(0, "USD")).to eq Money.new(0, "USD")
-      expect(Money.new(0, "USD")).to eq Money.new(0, "EUR")
-      expect(Money.new(0, "USD")).to eq Money.new(0, "AUD")
-      expect(Money.new(0, "USD")).to eq Money.new(0, "JPY")
-    end
-
-    it "returns false if used to compare with an object that doesn't inherit from Money" do
-      expect(Money.new(1_00, "USD")).not_to eq Object.new
-      expect(Money.new(1_00, "USD")).not_to eq Class
-      expect(Money.new(1_00, "USD")).not_to eq Kernel
-      expect(Money.new(1_00, "USD")).not_to eq(/foo/)
-      expect(Money.new(1_00, "USD")).not_to eq nil
-    end
-
-    it "can be used to compare with an object that inherits from Money" do
-      klass = Class.new(Money)
-
-      expect(Money.new(1_00, "USD")).to     eq klass.new(1_00, "USD")
-      expect(Money.new(2_50, "USD")).to     eq klass.new(2_50, "USD")
-      expect(Money.new(2_50, "USD")).not_to eq klass.new(3_00, "USD")
-      expect(Money.new(1_00, "GBP")).not_to eq klass.new(1_00, "USD")
-    end
-
-    it 'allows comparison with zero' do
-      expect(Money.new(0, :usd)).to eq 0
-      expect(Money.new(0, :usd)).to eq 0.0
-      expect(Money.new(0, :usd)).to eq BigDecimal.new(0)
-      expect(Money.new(1, :usd)).to_not eq 0
-    end
-
-    it 'raises error for non-zero numerics' do
-      expect { Money.new(1_00, :usd) == 1 }.to raise_error ArgumentError
-      expect { Money.new(1_00, :usd) == -2.0 }.to raise_error ArgumentError
-      expect { Money.new(1_00, :usd) == Float::INFINITY }.to raise_error ArgumentError
-    end
-  end
-
-  describe "#eql?" do
-    it "returns true if and only if their amount and currency are equal" do
-      expect(Money.new(1_00, "USD").eql?(Money.new(1_00, "USD"))).to  be true
-      expect(Money.new(1_00, "USD").eql?(Money.new(1_00, "EUR"))).to  be false
-      expect(Money.new(1_00, "USD").eql?(Money.new(2_00, "USD"))).to  be false
-      expect(Money.new(1_00, "USD").eql?(Money.new(99_00, "EUR"))).to be false
-    end
-
-    it "returns false if used to compare with an object that doesn't inherit from Money" do
-      expect(Money.new(1_00, "USD").eql?(Object.new)).to  be false
-      expect(Money.new(1_00, "USD").eql?(Class)).to       be false
-      expect(Money.new(1_00, "USD").eql?(Kernel)).to      be false
-      expect(Money.new(1_00, "USD").eql?(/foo/)).to       be false
-      expect(Money.new(1_00, "USD").eql?(nil)).to         be false
-    end
-
-    it "can be used to compare with an object that inherits from Money" do
-      klass = Class.new(Money)
-
-      expect(Money.new(1_00, "USD").eql?(klass.new(1_00, "USD"))).to be true
-      expect(Money.new(2_50, "USD").eql?(klass.new(2_50, "USD"))).to be true
-      expect(Money.new(2_50, "USD").eql?(klass.new(3_00, "USD"))).to be false
-      expect(Money.new(1_00, "GBP").eql?(klass.new(1_00, "USD"))).to be false
-    end
-  end
-
-  describe "#<=>" do
-    it "compares the two object amounts (same currency)" do
-      expect((Money.new(1_00, "USD") <=> Money.new(1_00, "USD"))).to eq 0
-      expect((Money.new(1_00, "USD") <=> Money.new(99, "USD"))).to be > 0
-      expect((Money.new(1_00, "USD") <=> Money.new(2_00, "USD"))).to be < 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")
-      expect(target).to receive(:exchange_to).with(Money::Currency.new("USD")).and_return(Money.new(300_00, "USD"))
-      expect(Money.new(100_00, "USD") <=> target).to be < 0
-
-      target = Money.new(200_00, "EUR")
-      expect(target).to receive(:exchange_to).with(Money::Currency.new("USD")).and_return(Money.new(100_00, "USD"))
-      expect(Money.new(100_00, "USD") <=> target).to eq 0
-
-      target = Money.new(200_00, "EUR")
-      expect(target).to receive(:exchange_to).with(Money::Currency.new("USD")).and_return(Money.new(99_00, "USD"))
-      expect(Money.new(100_00, "USD") <=> target).to be > 0
-    end
-
-    it "returns nil if currency conversion fails, and therefore cannot be compared" do
-      target = Money.new(200_00, "EUR")
-      expect(target).to receive(:exchange_to).with(Money::Currency.new("USD")).and_raise(Money::Bank::UnknownRate)
-      expect(Money.new(100_00, "USD") <=> target).to be_nil
-    end
-
-    it "can be used to compare with an object that inherits from Money" do
-      klass = Class.new(Money)
-
-      expect(Money.new(1_00) <=> klass.new(1_00)).to eq 0
-      expect(Money.new(1_00) <=> klass.new(99)).to be > 0
-      expect(Money.new(1_00) <=> klass.new(2_00)).to be < 0
-    end
-
-    it "returns nill when comparing with an object that doesn't inherit from Money" do
-      expect(Money.new(1_00) <=> 100).to be_nil
-      expect(Money.new(1_00) <=> Object.new).to be_nil
-      expect(Money.new(1_00) <=> Class).to be_nil
-      expect(Money.new(1_00) <=> Kernel).to be_nil
-      expect(Money.new(1_00) <=> /foo/).to be_nil
-    end
-
-    it 'compares with numeric 0' do
-      expect(Money.usd(1) < 0).to eq false
-      expect(Money.usd(1) > 0.0).to eq true
-      expect(Money.usd(0) >= 0.0).to eq true
-    end
-  end
-
-  describe "#positive?" do
-    it "returns true if the amount is greater than 0" do
-      expect(Money.new(1)).to be_positive
-    end
-
-    it "returns false if the amount is 0" do
-      expect(Money.new(0)).not_to be_positive
-    end
-
-    it "returns false if the amount is negative" do
-      expect(Money.new(-1)).not_to be_positive
-    end
-  end
-
-  describe "#negative?" do
-    it "returns true if the amount is less than 0" do
-      expect(Money.new(-1)).to be_negative
-    end
-
-    it "returns false if the amount is 0" do
-      expect(Money.new(0)).not_to be_negative
-    end
-
-    it "returns false if the amount is greater than 0" do
-      expect(Money.new(1)).not_to be_negative
-    end
-  end
-
-  describe "#+" do
-    it "adds other amount to current amount (same currency)" do
-      expect(Money.new(10_00, "USD") + Money.new(90, "USD")).to eq 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")
-      expect(other).to receive(:exchange_to).with(Money::Currency.new("USD")).and_return(Money.new(9_00, "USD"))
-      expect(Money.new(10_00, "USD") + other).to eq Money.new(19_00, "USD")
-    end
-
-    it "adds Integer 0 to money and returns the same ammount" do
-      expect(Money.new(10_00) + 0).to eq Money.new(10_00)
-    end
-
-    it "preserves the class in the result when using a subclass of Money" do
-      special_money_class = Class.new(Money)
-      expect(special_money_class.new(10_00, "USD") + Money.new(90, "USD")).to be_a special_money_class
-    end
-  end
-
-  describe "#-" do
-    it "subtracts other amount from current amount (same currency)" do
-      expect(Money.new(10_00, "USD") - Money.new(90, "USD")).to eq 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")
-      expect(other).to receive(:exchange_to).with(Money::Currency.new("USD")).and_return(Money.new(9_00, "USD"))
-      expect(Money.new(10_00, "USD") - other).to eq Money.new(1_00, "USD")
-    end
-
-    it "subtract Integer 0 to money and returns the same ammount" do
-      expect(Money.new(10_00) - 0).to eq Money.new(10_00)
-    end
-
-    it "preserves the class in the result when using a subclass of Money" do
-      special_money_class = Class.new(Money)
-      expect(special_money_class.new(10_00, "USD") - Money.new(90, "USD")).to be_a special_money_class
-    end
-  end
-
-  describe "#*" do
-    it "multiplies Money by Integer 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|
-        expect(t[:a] * t[:b]).to eq 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(TypeError)
-    end
-
-    it "does not multiply Money by Money (different currency)" do
-      expect { Money.new(10, :USD) * Money.new(4, :EUR) }.to raise_error(TypeError)
-    end
-
-    it "does not multiply Money by an object which is NOT a number" do
-      expect { Money.new(10, :USD) *  'abc' }.to raise_error(TypeError)
-    end
-
-    it "preserves the class in the result when using a subclass of Money" do
-      special_money_class = Class.new(Money)
-      expect(special_money_class.new(10_00, "USD") * 2).to be_a special_money_class
-    end
-  end
-
-  describe "#/" do
-    it "divides Money by Integer 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(-3, :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)},
-      ]
-      ts.each do |t|
-        expect(t[:a] / t[:b]).to eq t[:c]
-      end
-    end
-
-    it "preserves the class in the result when using a subclass of Money" do
-      special_money_class = Class.new(Money)
-      expect(special_money_class.new(10_00, "USD") / 2).to be_a special_money_class
-    end
-
-    context 'rounding preference' do
-      before do
-        allow(Money).to receive(:rounding_mode).and_return(rounding_mode)
-      end
-
-      after do
-        allow(Money).to receive(:rounding_mode).and_call_original
-      end
-
-      context 'ceiling rounding' do
-        let(:rounding_mode) { BigDecimal::ROUND_CEILING }
-        it "obeys the rounding preference" do
-          expect(Money.new(10) / 3).to eq Money.new(4)
-        end
-      end
-
-      context 'floor rounding' do
-        let(:rounding_mode) { BigDecimal::ROUND_FLOOR }
-        it "obeys the rounding preference" do
-          expect(Money.new(10) / 6).to eq Money.new(1)
-        end
-      end
-
-      context 'half up rounding' do
-        let(:rounding_mode) { BigDecimal::ROUND_HALF_UP }
-        it "obeys the rounding preference" do
-          expect(Money.new(10) / 4).to eq Money.new(3)
-        end
-      end
-
-      context 'half down rounding' do
-        let(:rounding_mode) { BigDecimal::ROUND_HALF_DOWN }
-        it "obeys the rounding preference" do
-          expect(Money.new(10) / 4).to eq Money.new(2)
-        end
-      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|
-        expect(t[:a] / t[:b]).to eq 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|
-        expect(t[:b]).to receive(:exchange_to).once.with(t[:a].currency).and_return(Money.new(t[:b].cents * 2, :USD))
-        expect(t[:a] / t[:b]).to eq t[:c]
-      end
-    end
-
-    context "with infinite_precision", :infinite_precision do
-      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|
-          expect(t[:a] / t[:b]).to eq t[:c]
-        end
-      end
-    end
-  end
-
-  describe "#div" do
-    it "divides Money by Integer 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(-3, :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)},
-      ]
-      ts.each do |t|
-        expect(t[:a].div(t[:b])).to eq 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|
-        expect(t[:a].div(t[:b])).to eq 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|
-        expect(t[:b]).to receive(:exchange_to).once.with(t[:a].currency).and_return(Money.new(t[:b].cents * 2, :USD))
-        expect(t[:a].div(t[:b])).to eq t[:c]
-      end
-    end
-
-    context "with infinite_precision", :infinite_precision do
-      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|
-          expect(t[:a].div(t[:b])).to eq t[:c]
-        end
-      end
-    end
-  end
-
-  describe "#divmod" do
-    it "calculates division and modulo with Integer" 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|
-        expect(t[:a].divmod(t[:b])).to eq 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|
-        expect(t[:a].divmod(t[:b])).to eq 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|
-        expect(t[:b]).to receive(:exchange_to).once.with(t[:a].currency).and_return(Money.new(t[:b].cents * 2, :USD))
-        expect(t[:a].divmod(t[:b])).to eq t[:c]
-      end
-    end
-
-    context "with infinite_precision", :infinite_precision do
-      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|
-          expect(t[:a].divmod(t[:b])).to eq t[:c]
-        end
-      end
-    end
-
-    it "preserves the class in the result when dividing a subclass of Money by a fixnum" do
-      special_money_class = Class.new(Money)
-      expect(special_money_class.new(10_00, "USD").divmod(4).last).to be_a special_money_class
-    end
-
-    it "preserves the class in the result when using a subclass of Money by a subclass of Money" do
-      special_money_class = Class.new(Money)
-      expect(special_money_class.new(10_00, "USD").divmod(special_money_class.new(4_00)).last).to be_a special_money_class
-    end
-  end
-
-  describe "#modulo" do
-    it "calculates modulo with Integer" 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|
-        expect(t[:a].modulo(t[:b])).to eq 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|
-        expect(t[:a].modulo(t[:b])).to eq 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|
-        expect(t[:b]).to receive(:exchange_to).once.with(t[:a].currency).and_return(Money.new(t[:b].cents * 2, :USD))
-        expect(t[:a].modulo(t[:b])).to eq t[:c]
-      end
-    end
-  end
-
-  describe "#%" do
-    it "calculates modulo with Integer" 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|
-        expect(t[:a] % t[:b]).to eq 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|
-        expect(t[:a] % t[:b]).to eq 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|
-        expect(t[:b]).to receive(:exchange_to).once.with(t[:a].currency).and_return(Money.new(t[:b].cents * 2, :USD))
-        expect(t[:a] % t[:b]).to eq t[:c]
-      end
-    end
-  end
-
-  describe "#remainder" do
-    it "calculates remainder with Integer" 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|
-        expect(t[:a].remainder(t[:b])).to eq t[:c]
-      end
-    end
-  end
-
-  describe "#abs" do
-    it "returns the absolute value as a new Money object" do
-      n = Money.new(-1, :USD)
-      expect(n.abs).to eq Money.new( 1, :USD)
-      expect(n).to     eq Money.new(-1, :USD)
-    end
-
-    it "preserves the class in the result when using a subclass of Money" do
-      special_money_class = Class.new(Money)
-      expect(special_money_class.new(-1).abs).to be_a special_money_class
-    end
-  end
-
-  describe "#zero?" do
-    it "returns whether the amount is 0" do
-      expect(Money.new(0, "USD")).to be_zero
-      expect(Money.new(0, "EUR")).to be_zero
-      expect(Money.new(1, "USD")).not_to be_zero
-      expect(Money.new(10, "YEN")).not_to be_zero
-      expect(Money.new(-1, "EUR")).not_to be_zero
-    end
-  end
-
-  describe "#nonzero?" do
-    it "returns whether the amount is not 0" do
-      expect(Money.new(0, "USD")).not_to be_nonzero
-      expect(Money.new(0, "EUR")).not_to be_nonzero
-      expect(Money.new(1, "USD")).to be_nonzero
-      expect(Money.new(10, "YEN")).to be_nonzero
-      expect(Money.new(-1, "EUR")).to be_nonzero
-    end
-
-    it "has the same return-value semantics as Numeric#nonzero?" do
-      expect(Money.new(0, "USD").nonzero?).to be_nil
-
-      money = Money.new(1, "USD")
-      expect(money.nonzero?).to be_equal(money)
-    end
-  end
-
-  describe "#coerce" do
-    it "allows mathematical operations by coercing arguments" do
-      result = 2 * Money.new(4, 'USD')
-      expect(result).to eq Money.new(8, 'USD')
-    end
-
-    it "raises TypeError dividing by a Money (unless other is a Money)" do
-      expect {
-        2 / Money.new(2, 'USD')
-      }.to raise_exception(TypeError)
-    end
-
-    it "raises TypeError subtracting by a Money (unless other is a Money)" do
-      expect {
-        2 - Money.new(2, 'USD')
-      }.to raise_exception(TypeError)
-    end
-
-    it "raises TypeError adding by a Money (unless other is a Money)" do
-      expect {
-        2 + Money.new(2, 'USD')
-      }.to raise_exception(TypeError)
-    end
-
-    it "treats multiplication as commutative" do
-      expect {
-        2 * Money.new(2, 'USD')
-      }.to_not raise_exception
-      result = 2 * Money.new(2, 'USD')
-      expect(result).to eq(Money.new(4, 'USD'))
-    end
-
-    it "doesn't work with non-numerics" do
-      expect {
-        "2" * Money.new(2, 'USD')
-      }.to raise_exception(TypeError)
-    end
-
-    it "correctly handles <=>" do
-      expect {
-        2 < Money.new(2, 'USD')
-      }.to raise_exception(ArgumentError)
-
-      expect {
-        2 > Money.new(2, 'USD')
-      }.to raise_exception(ArgumentError)
-
-      expect {
-        2 <= Money.new(2, 'USD')
-      }.to raise_exception(ArgumentError)
-
-      expect {
-        2 >= Money.new(2, 'USD')
-      }.to raise_exception(ArgumentError)
-
-      expect(2 <=> Money.new(2, 'USD')).to be_nil
-    end
-
-    it 'compares with numeric 0' do
-      expect(0 < Money.usd(1)).to eq true
-      expect(0.0 > Money.usd(1)).to eq false
-      expect(0.0 >= Money.usd(0)).to eq true
-    end
-
-    it "raises exceptions for all numeric types, not just Integer" do
-      expect {
-        2.0 / Money.new(2, 'USD')
-      }.to raise_exception(TypeError)
-
-      expect {
-        Rational(2,3) / Money.new(2, 'USD')
-      }.to raise_exception(TypeError)
-
-      expect {
-        BigDecimal(2) / Money.new(2, 'USD')
-      }.to raise_exception(TypeError)
-    end
-  end
-
-  %w(+ - / <=> divmod remainder).each do |op|
-    describe "##{op}" do
-      subject { ->(other = self.other) { instance.send(op, other) } }
-      let(:instance) { Money.usd(1) }
-
-      context 'when conversions disallowed' do
-        around do |ex|
-          begin
-            old = Money.default_bank
-            Money.disallow_currency_conversion!
-            ex.run
-          ensure
-            Money.default_bank = old
-          end
-        end
-
-        context 'and other is money with different currency' do
-          let(:other) { Money.gbp(1) }
-          it { should raise_error Money::Bank::DifferentCurrencyError }
-
-          context 'even for zero' do
-            let(:instance) { Money.usd(0) }
-            let(:other) { Money.gbp(0) }
-            it { should raise_error Money::Bank::DifferentCurrencyError }
-          end
-        end
-      end
-    end
-  end
-end