combinatorics 0.4.3 → 0.4.4

data/spec/cartesian_product/mixin_examples.rb

@@ -7,52 +7,52 @@ shared_examples_for "CartesianProduct::Mixin" do
     set     = subject[1]
     results = set.cartprod(set)
 
-    results.should be_kind_of(Enumerator)
+    expect(results).to be_kind_of(Enumerator)
   end
 
   it "the cartprod of two empty Set's should return an empty Set" do
     set     = subject[]
     results = set.cartprod([]).to_a
     
-    results.should be_empty
+    expect(results).to be_empty
   end
 
   it "the cartprod of a single empty set should return an empty Set" do
     set     = subject[1,2]
     results = set.cartprod([2,3],[]).to_a
     
-    results.should be_empty
+    expect(results).to be_empty
   end
 
   it "the cartprod of another empty set should also return an empty Set" do
     set     = subject[]
     results = set.cartprod([1]).to_a
     
-    results.should be_empty
+    expect(results).to be_empty
   end
 
   it "the cartprod of [1] and [1] should be [[1, 1]]" do
     set     = subject[1]
     results = set.cartprod([1]).to_a
     
-    results.should == [[1, 1]]
+    expect(results).to eq([[1, 1]])
   end
 
   it "the cartprod of [1, 2] and [3] should be [[1, 3], [2, 3]]" do
     set     = subject[1, 2]
     results = set.cartprod([3]).to_a
     
-    results.should =~ [[1, 3], [2, 3]]
+    expect(results).to match_array([[1, 3], [2, 3]])
   end
 
   it "the cartprod of [1, 2] and [3, 4] should be [[1, 3], [1, 4], [2, 3], [2, 4]]" do
     set     = subject[1, 2]
     results = set.cartprod([3, 4]).to_a
     
-    results.should =~ [
+    expect(results).to match_array([
       [1, 3], [1, 4],
       [2, 3], [2, 4]
-    ]
+    ])
   end
 
   it "the cartprod of ['a'].cartprod(['b', 'c', 'd']) should be [['a', 'b'], ['a', 'c'], ['a', 'd']]" do
@@ -60,7 +60,7 @@ shared_examples_for "CartesianProduct::Mixin" do
     set2    = subject['b', 'c', 'd']
     results = set1.cartprod(set2).to_a
     
-    results.should =~ [['a', 'b'], ['a', 'c'], ['a', 'd']]
+    expect(results).to match_array([['a', 'b'], ['a', 'c'], ['a', 'd']])
   end
 
   it "the cartprod of [0, 1] and [[2, 3], [4, 5]] should be [[0, 2, 4], [1, 2, 4], [0, 3, 4], [1, 3, 4], [0, 2, 5], [1, 2, 5], [0, 3, 5], [1, 3, 5]]" do
@@ -69,10 +69,10 @@ shared_examples_for "CartesianProduct::Mixin" do
     set3    = subject[4, 5]
     results = set1.cartprod(set2, set3).to_a
     
-    results.should =~ [
+    expect(results).to match_array([
       [0, 2, 4], [0, 2, 5], [0, 3, 4], [0, 3, 5],
       [1, 2, 4], [1, 2, 5], [1, 3, 4], [1, 3, 5],
-    ]
+    ])
   end
 
   it "should take an optional block argument" do
@@ -81,18 +81,18 @@ shared_examples_for "CartesianProduct::Mixin" do
 
     set.cartprod(set) { |result| results << result }
 
-    results.should == [[1, 1]]
+    expect(results).to eq([[1, 1]])
   end
 
   it "should alias cartprod to cartesian_product" do
     aset = subject[1]
 
-    aset.should respond_to(:cartesian_product)
+    expect(aset).to respond_to(:cartesian_product)
   end
 
   it "should alias cartprod to cartesian" do
     aset = subject[1]
 
-    aset.should respond_to(:cartesian)
+    expect(aset).to respond_to(:cartesian)
   end
 end

data/spec/choose/cardinality_spec.rb

@@ -6,123 +6,123 @@ describe Choose do
 
   describe "cardinality" do
     it "should raise RangeError if n is negative" do
-      lambda { subject.cardinality(-1) }.should raise_error(RangeError)
+      expect { subject.cardinality(-1) }.to raise_error(RangeError)
     end
 
     it "should raise RangeError if n is negative" do
-      lambda { subject.cardinality(-1, 1) }.should raise_error(RangeError)
+      expect { subject.cardinality(-1, 1) }.to raise_error(RangeError)
     end
 
     it "should raise RangeError if r is negative" do
-      lambda { subject.cardinality(1, -1) }.should raise_error(RangeError)
+      expect { subject.cardinality(1, -1) }.to raise_error(RangeError)
     end
 
     it "should raise RangeError if r is greater than n" do
-      lambda { subject.cardinality(2, 3) }.should raise_error(RangeError)
+      expect { subject.cardinality(2, 3) }.to raise_error(RangeError)
     end
 
     it "should return 1 for subject.cardinality(0)" do
-      subject.cardinality(0).should == 1
+      expect(subject.cardinality(0)).to eq(1)
     end
 
     it "should return 1 for subject.cardinality(1)" do
-      subject.cardinality(1).should == 1
+      expect(subject.cardinality(1)).to eq(1)
     end
 
     it "should return 2 for subject.cardinality(2)" do
-      subject.cardinality(2).should == 2
+      expect(subject.cardinality(2)).to eq(2)
     end
 
     it "should return 6 for subject.cardinality(3)" do
-      subject.cardinality(3).should == 6
+      expect(subject.cardinality(3)).to eq(6)
     end
 
     it "should return 24 for subject.cardinality(4)" do
-      subject.cardinality(4).should == 24
+      expect(subject.cardinality(4)).to eq(24)
     end
 
-    it "should return 0 for subject.cardinality(1, 0)" do
-      subject.cardinality(1, 0).should == 0
+    it "should return 1 for subject.cardinality(1, 0)" do
+      expect(subject.cardinality(1, 0)).to eq(1)
     end
 
     it "should return 1 for subject.cardinality(1, 1)" do
-      subject.cardinality(1, 1).should == 1
+      expect(subject.cardinality(1, 1)).to eq(1)
     end
 
     it "should return 2 for subject.cardinality(2, 1)" do
-      subject.cardinality(2, 1).should == 2
+      expect(subject.cardinality(2, 1)).to eq(2)
     end
 
     it "should return 1 for subject.cardinality(2, 2)" do
-      subject.cardinality(2, 2).should == 1
+      expect(subject.cardinality(2, 2)).to eq(1)
     end
 
     it "should return 3 for subject.cardinality(3, 1)" do
-      subject.cardinality(3, 1).should == 3
+      expect(subject.cardinality(3, 1)).to eq(3)
     end
 
     it "should return 3 for subject.cardinality(3, 2)" do
-      subject.cardinality(3, 2).should == 3
+      expect(subject.cardinality(3, 2)).to eq(3)
     end
 
     it "should return 1 for subject.cardinality(3, 3)" do
-      subject.cardinality(3, 3).should == 1
+      expect(subject.cardinality(3, 3)).to eq(1)
     end
 
     it "should return 4 for subject.cardinality(4, 1)" do
-      subject.cardinality(4, 1).should == 4
+      expect(subject.cardinality(4, 1)).to eq(4)
     end
 
     it "should return 6 for subject.cardinality(4, 2)" do
-      subject.cardinality(4, 2).should == 6
+      expect(subject.cardinality(4, 2)).to eq(6)
     end
 
     it "should return 4 for subject.cardinality(4, 3)" do
-      subject.cardinality(4, 3).should == 4
+      expect(subject.cardinality(4, 3)).to eq(4)
     end
 
     it "should return 1 for subject.cardinality(4, 4)" do
-      subject.cardinality(4, 4).should == 1
+      expect(subject.cardinality(4, 4)).to eq(1)
     end
 
     it "should return 15 for subject.cardinality(6, 4)" do
-      subject.cardinality(6, 4).should == 15
+      expect(subject.cardinality(6, 4)).to eq(15)
     end
 
     it "should return 3628800 for subject.cardinality(10)" do
-      subject.cardinality(10).should == 3628800
+      expect(subject.cardinality(10)).to eq(3628800)
     end
   end
 
   describe "cardinality_all" do
     it "should return [] for subject.cardinality_all(0)" do
-      subject.cardinality_all(0).should be_empty
+      expect(subject.cardinality_all(0)).to be_empty
     end
 
     it "should return [1] for subject.cardinality_all(1)" do
-      subject.cardinality_all(1).should == [1]
+      expect(subject.cardinality_all(1)).to eq([1])
     end
 
     it "should return [2, 1] for subject.cardinality_all(2)" do
-      subject.cardinality_all(2).should == [2, 1]
+      expect(subject.cardinality_all(2)).to eq([2, 1])
     end
 
     it "should return [3, 3, 1] for subject.cardinality_all(3)" do
-      subject.cardinality_all(3).should == [3, 3, 1]
+      expect(subject.cardinality_all(3)).to eq([3, 3, 1])
     end
 
     it "should return [4, 6, 4, 1] for subject.cardinality_all(4)" do
-      subject.cardinality_all(4).should == [4, 6, 4, 1]
+      expect(subject.cardinality_all(4)).to eq([4, 6, 4, 1])
     end
 
     it "should allow specifying the range of `r` values" do
-      subject.cardinality_all(10,5..10).should == [
+      expect(subject.cardinality_all(10,5..10)).to eq([
         252, 210, 120, 45, 10, 1
-      ]
+      ])
     end
 
     it "should raise RangeError for subject.cardinality_all(-1)" do
-      lambda { subject.cardinality_all(-1) }.should raise_error(RangeError)
+      expect { subject.cardinality_all(-1) }.to raise_error(RangeError)
     end
 
     it "should wrap cardinality with Choose.C" do

data/spec/choose/mixin_examples.rb

@@ -8,41 +8,41 @@ shared_examples_for "Choose::Mixin" do
     set     = subject[]
     results = set.choose(0).to_a
 
-    results.should == [empty_set]
+    expect(results).to eq([empty_set])
   end
 
   it "should return [[]] for [1].choose(0).to_a" do
     set     = subject[1]
     results = set.choose(0).to_a
     
-    results.should == [empty_set]
+    expect(results).to eq([empty_set])
   end
 
   it "should return [[1]] for [1].choose(1).to_a" do
     set     = subject[1]
     results = set.choose(1).to_a
     
-    results.should == [Set[1]]
+    expect(results).to eq([Set[1]])
   end
 
   it "should return [[1], [2]] for [1, 2].choose(1).to_a" do
     set     = subject[1, 2]
     results = set.choose(1).to_a
     
-    results.should =~ [Set[1], Set[2]]
+    expect(results).to match_array([Set[1], Set[2]])
   end
 
   it "should return [[1, 2]] for [1, 2].choose(2).to_a" do
     set     = subject[1, 2]
     results = set.choose(2).to_a
     
-    results.should == [Set[1, 2]]
+    expect(results).to eq([Set[1, 2]])
   end
 
   it "should filter out repeated elements" do
     set1 = subject[1,1,2,3]
     set2 = subject[1,2,3]
 
-    set1.choose(2).to_a.should == set2.choose(2).to_a
+    expect(set1.choose(2).to_a).to eq(set2.choose(2).to_a)
   end
 end

data/spec/combinatorics_spec.rb

@@ -3,6 +3,6 @@ require 'combinatorics/version'
 
 describe Combinatorics do
   it "should have a VERSION constant" do
-    subject.const_get('VERSION').should_not be_empty
+    expect(subject.const_get('VERSION')).not_to be_empty
   end
 end

data/spec/derange/mixin_examples.rb

@@ -7,28 +7,28 @@ shared_examples_for "Derange::Mixin" do
     set     = subject[]
     results = set.derange.to_a
     
-    results.should == [[]]
+    expect(results).to eq([[]])
   end
 
   it "should return [[]] for [1].derange.to_a" do
     set     = subject[1]
     results = set.derange.to_a
 
-    results.should == [[]]
+    expect(results).to eq([[]])
   end
 
   it "should return [[2, 1]] for [1, 2].derange.to_a" do
     set     = subject[1, 2]
     results = set.derange.to_a
 
-    results.should == [[2, 1]]
+    expect(results).to eq([[2, 1]])
   end
 
   it "should return [[2, 1, 4, 3], [2, 3, 4, 1], [2, 4, 1, 3], [3, 1, 4, 2], [3, 4, 1, 2], [3, 4, 2, 1], [4, 1, 2, 3], [4, 3, 1, 2], [4, 3, 2, 1]] for [1, 2, 3, 4].derange.to_a" do
     set     = [1, 2, 3, 4]
     results = set.derange.to_a
     
-    results.should == [
+    expect(results).to eq([
       [2, 1, 4, 3],
       [2, 3, 4, 1],
       [2, 4, 1, 3],
@@ -38,7 +38,7 @@ shared_examples_for "Derange::Mixin" do
       [4, 1, 2, 3],
       [4, 3, 1, 2],
       [4, 3, 2, 1]
-    ]
+    ])
   end
 
   it "should take an optional block argument" do
@@ -47,6 +47,6 @@ shared_examples_for "Derange::Mixin" do
 
     set.derange { |deranged| results << deranged }
 
-    results.should == [[2, 3, 1], [3, 1, 2]]
+    expect(results).to eq([[2, 3, 1], [3, 1, 2]])
   end
 end

data/spec/enumerator_spec.rb

@@ -3,6 +3,6 @@ require 'combinatorics/enumerator'
 
 describe Combinatorics::Enumerator do
   it "should auto-detect the Enumerator class" do
-    Combinatorics::Enumerator.should_not be_nil
+    expect(Combinatorics::Enumerator).not_to be_nil
   end
 end

data/spec/extensions/math_spec.rb

@@ -12,89 +12,89 @@ describe Math do
 
   describe "sigma" do
     it "should return 6 for sigma(1..3)" do
-      subject.sigma(1..3).should == 6
+      expect(subject.sigma(1..3)).to eq(6)
     end
 
     it "should return 60 for sigma(3..5)" do
-      subject.sigma(3..5).should == 12
+      expect(subject.sigma(3..5)).to eq(12)
     end
 
     it "should take an optional block argument" do
       result = subject.sigma(1..5) { |i| i * 2 }
 
-      result.should == (1 * 2) + (2 * 2) + (3 * 2) + (4 * 2) + (5 * 2)
+      expect(result).to eq((1 * 2) + (2 * 2) + (3 * 2) + (4 * 2) + (5 * 2))
     end
   end
 
   describe "pi" do
     it "should return 24 for pi(1..4)" do
-      subject.pi(1..4).should == 24
+      expect(subject.pi(1..4)).to eq(24)
     end
 
     it "should return 30 for pi(5..6)" do
-      subject.pi(5..6).should == 30
+      expect(subject.pi(5..6)).to eq(30)
     end
 
     it "should take an optional block argument" do
       result = subject.pi(1..3) { |i| i * 2 }
 
-      result.should == (1 * 2) * (2 * 2) * (3 * 2)
+      expect(result).to eq((1 * 2) * (2 * 2) * (3 * 2))
     end
   end
 
   describe "factorial" do
     it "should return 1 for factorial(0)" do
-      subject.factorial(0).should == 1
+      expect(subject.factorial(0)).to eq(1)
     end
 
     it "should return 1 for factorial(1)" do
-      subject.factorial(1).should == 1
+      expect(subject.factorial(1)).to eq(1)
     end
 
     it "should return 2 for factorial(2)" do
-      subject.factorial(2).should == 2
+      expect(subject.factorial(2)).to eq(2)
     end
 
     it "should return 6 for factorial(3)" do
-      subject.factorial(3).should == 6
+      expect(subject.factorial(3)).to eq(6)
     end
     
     it "should return 3628800 for factorial(10)" do
-      subject.factorial(10).should == 3628800
+      expect(subject.factorial(10)).to eq(3628800)
     end
 
     it "should raise RangeError for factorial(-1)" do
-      lambda { subject.factorial(-1) }.should raise_error(RangeError)
+      expect { subject.factorial(-1) }.to raise_error(RangeError)
     end
   end
 
   describe "subfactorial" do
     it "should return 1 for subfactorial(0)" do
-      subject.subfactorial(0).should == 1
+      expect(subject.subfactorial(0)).to eq(1)
     end
 
     it "should return 0 for subfactorial(1)" do
-      subject.subfactorial(1).should == 0
+      expect(subject.subfactorial(1)).to eq(0)
     end
 
     it "should return 1 for subfactorial(2)" do
-      subject.subfactorial(2).should == 1
+      expect(subject.subfactorial(2)).to eq(1)
     end
 
     it "should return 2 for subfactorial(3)" do
-      subject.subfactorial(3).should == 2
+      expect(subject.subfactorial(3)).to eq(2)
     end
 
     it "should return 9 for subfactorial(4)" do
-      subject.subfactorial(4).should == 9
+      expect(subject.subfactorial(4)).to eq(9)
     end
 
     it "should return 44 for subfactorial(5)" do
-      subject.subfactorial(5).should == 44
+      expect(subject.subfactorial(5)).to eq(44)
     end
 
     it "should raise RangeError for subfactorial(-1)" do
-      lambda { subject.subfactorial(-1) }.should raise_error(RangeError)
+      expect { subject.subfactorial(-1) }.to raise_error(RangeError)
     end
   end
 end

data/spec/extensions/range_spec.rb

@@ -4,11 +4,11 @@ require 'combinatorics/extensions/range'
 describe Range do
   describe "&" do
     it "should pick the maximum beginning value" do
-      ((100..200) & (150..200)).first.should == 150
+      expect(((100..200) & (150..200)).first).to eq(150)
     end
 
     it "should pick the minimum ending value" do
-      ((100..150) & (100..200)).last.should == 150
+      expect(((100..150) & (100..200)).last).to eq(150)
     end
   end
 
@@ -16,28 +16,28 @@ describe Range do
     subject { 1..10 }
 
     it "should iterate over every beginning value" do
-      subject.upto(5..10).to_a.should == [
+      expect(subject.upto(5..10).to_a).to eq([
         (1..10),
         (2..10),
         (3..10),
         (4..10),
         (5..10)
-      ]
+      ])
     end
 
     it "should iterate over every ending value" do
-      subject.upto(1..15).to_a.should == [
+      expect(subject.upto(1..15).to_a).to eq([
         (1..10),
         (1..11),
         (1..12),
         (1..13),
         (1..14),
         (1..15)
-      ]
+      ])
     end
 
     it "should not iterate up to lower bounding ranges" do
-      subject.upto(0..5).to_a.should be_empty
+      expect(subject.upto(0..5).to_a).to be_empty
     end
   end
 
@@ -45,28 +45,28 @@ describe Range do
     subject { 5..15 }
 
     it "should iterate over every beginning value" do
-      subject.downto(1..15).to_a.should == [
+      expect(subject.downto(1..15).to_a).to eq([
         (5..15),
         (4..15),
         (3..15),
         (2..15),
         (1..15)
-      ]
+      ])
     end
 
     it "should iterate over every ending value" do
-      subject.downto(5..10).to_a.should == [
+      expect(subject.downto(5..10).to_a).to eq([
         (5..15),
         (5..14),
         (5..13),
         (5..12),
         (5..11),
         (5..10)
-      ]
+      ])
     end
 
     it "should not iterate down to upward bounding ranges" do
-      subject.downto(10..20).to_a.should be_empty
+      expect(subject.downto(10..20).to_a).to be_empty
     end
   end
 end

data/spec/generator_spec.rb

@@ -3,6 +3,6 @@ require 'combinatorics/generator'
 
 describe Combinatorics::Generator do
   it "should auto-detect the Generator class" do
-    Combinatorics::Generator.should_not be_nil
+    expect(Combinatorics::Generator).not_to be_nil
   end
 end

data/spec/list_comprehension_spec.rb

@@ -6,46 +6,46 @@ describe "Array#comprehension" do
   it "should return an Enumerator object if no block is given" do
     a = [1..5]
 
-    a.comprehension.should_not be_kind_of(Array)
+    expect(a.comprehension).not_to be_kind_of(Array)
   end
 
   it "should yield iterations to the given block" do
     range = (1..5)
     a = [range]
 
-    a.comprehension.to_a.should == [[1],[2],[3],[4],[5]]
+    expect(a.comprehension.to_a).to eq([[1],[2],[3],[4],[5]])
   end
 
   it "should do nothing an Array of all non-enumerable objects" do
     a = [1,2,3]
 
-    a.comprehension.to_a.should == [a]
+    expect(a.comprehension.to_a).to eq([a])
   end
 
   it "should pass through an empty Array" do
     a = []
 
-    a.comprehension.to_a.should == [a]
+    expect(a.comprehension.to_a).to eq([a])
   end
 
   it "should iterate over the values within an enumerable value" do
     range = (1..5)
     a = [range]
 
-    a.comprehension.to_a.should == [[1],[2],[3],[4],[5]]
+    expect(a.comprehension.to_a).to eq([[1],[2],[3],[4],[5]])
   end
 
   it "should iterate over repeating values" do
     range = [1,2,3,1,2,4]
     a = [range]
 
-    a.comprehension.to_a.should == [[1],[2],[3],[1],[2],[4]]
+    expect(a.comprehension.to_a).to eq([[1],[2],[3],[1],[2],[4]])
   end
 
   it "should iterate over values from a generator" do
     a = [Combinatorics::Generator.new { |g| 5.times { |i| g.yield i } }]
 
-    a.comprehension.to_a.should == [[0],[1],[2],[3],[4]]
+    expect(a.comprehension.to_a).to eq([[0],[1],[2],[3],[4]])
   end
 
   it "should iterate over values from a non-repeating generator" do
@@ -58,16 +58,16 @@ describe "Array#comprehension" do
       }
     ]
 
-    a.comprehension.to_a.should == [
+    expect(a.comprehension.to_a).to eq([
       [1,0],[1,1],[1,2],[1,3],[1,4],
       [2,0],[2,2],[2,4],[2,6],[2,8]
-    ]
+    ])
   end
 
   it "should ignore non-enumerable values" do
     range = (1..5)
     a = [1,range]
 
-    a.comprehension.to_a.should == [[1,1],[1,2],[1,3],[1,4],[1,5]]
+    expect(a.comprehension.to_a).to eq([[1,1],[1,2],[1,3],[1,4],[1,5]])
   end
 end