algorithms 0.6.1 → 1.0.0

data/spec/heap_spec.rb

@@ -7,29 +7,29 @@ describe Containers::Heap do
   end
   
   it "should not let you merge with non-heaps" do
-    lambda { @heap.merge!(nil) }.should raise_error
-    lambda { @heap.merge!([]) }.should raise_error
+    expect { @heap.merge!(nil) }.to raise_error(ArgumentError)
+    expect { @heap.merge!([]) }.to raise_error(ArgumentError)
   end
   
   describe "(empty)" do
   
     it "should return nil when getting the maximum" do
-      @heap.max!.should be_nil
+      expect(@heap.max!).to be_nil
     end
     
     it "should let you insert and remove one item" do
-      @heap.size.should eql(0)
+      expect(@heap.size).to eql(0)
       
       @heap.push(1)
-      @heap.size.should eql(1)
+      expect(@heap.size).to eql(1)
       
-      @heap.max!.should eql(1)
-      @heap.size.should eql(0)
+      expect(@heap.max!).to eql(1)
+      expect(@heap.size).to eql(0)
     end
     
     it "should let you initialize with an array" do
       @heap = Containers::MaxHeap.new([1,2,3])
-      @heap.size.should eql(3)
+      expect(@heap.size).to eql(3)
     end
 
   end
@@ -38,25 +38,25 @@ describe Containers::Heap do
     before(:each) do
       @random_array = []
       @num_items = 100
-      @num_items.times { |x| @random_array << rand(@num_items) }
+      @num_items.times { @random_array << rand(@num_items) }
       @heap = Containers::MaxHeap.new(@random_array)
     end
     
     it "should display the correct size" do
-      @heap.size.should eql(@num_items)
+      expect(@heap.size).to eql(@num_items)
     end
     
     it "should have a next value" do
-      @heap.next.should be_true
-      @heap.next_key.should be_true
+      expect(@heap.next).to be_truthy
+      expect(@heap.next_key).to be_truthy
     end
     
     it "should delete random keys" do
-      @heap.delete(@random_array[0]).should eql(@random_array[0])
-      @heap.delete(@random_array[1]).should eql(@random_array[1])
+      expect(@heap.delete(@random_array[0])).to eql(@random_array[0])
+      expect(@heap.delete(@random_array[1])).to eql(@random_array[1])
       ordered = []
       ordered << @heap.max! until @heap.empty?
-      ordered.should eql( @random_array[2..-1].sort.reverse )
+      expect(ordered).to eql( @random_array[2..-1].sort.reverse )
     end
     
     it "should delete all keys" do
@@ -64,15 +64,15 @@ describe Containers::Heap do
       @random_array.size.times do |t|
         ordered << @heap.delete(@random_array[t])
       end
-      @heap.should be_empty
-      ordered.should eql( @random_array )
+      expect(@heap).to be_empty
+      expect(ordered).to eql( @random_array )
     end
 
     it "should be in max->min order" do
       ordered = []
       ordered << @heap.max! until @heap.empty?
       
-      ordered.should eql(@random_array.sort.reverse)
+      expect(ordered).to eql(@random_array.sort.reverse)
     end
     
     it "should change certain keys" do
@@ -84,12 +84,12 @@ describe Containers::Heap do
       heap.change_key(8, 0)
       ordered = []
       ordered << heap.min! until heap.empty?
-      ordered.should eql( [8,3,4,5,6,7,9,10,101,100] )
+      expect(ordered).to eql( [8,3,4,5,6,7,9,10,101,100] )
     end
     
     it "should not delete keys it doesn't have" do
-      @heap.delete(:nonexisting).should be_nil
-      @heap.size.should eql(@num_items)
+      expect(@heap.delete(:nonexisting)).to be_nil
+      expect(@heap.size).to eql(@num_items)
     end
     
     it "should delete certain keys" do
@@ -101,19 +101,19 @@ describe Containers::Heap do
       heap.delete(100)
       ordered = []
       ordered << heap.min! until heap.empty?
-      ordered.should eql( [3,4,6,7,8,9,10,101] )
+      expect(ordered).to eql( [3,4,6,7,8,9,10,101] )
     end
     
     it "should let you merge with another heap" do
       numbers = [1,2,3,4,5,6,7,8]
       otherheap = Containers::MaxHeap.new(numbers)
-      otherheap.size.should eql(8)
+      expect(otherheap.size).to eql(8)
       @heap.merge!(otherheap)
       
       ordered = []
       ordered << @heap.max! until @heap.empty?
       
-      ordered.should eql( (@random_array + numbers).sort.reverse)
+      expect(ordered).to eql( (@random_array + numbers).sort.reverse)
     end
     
     describe "min-heap" do
@@ -122,7 +122,7 @@ describe Containers::Heap do
         ordered = []
         ordered << @heap.min! until @heap.empty?
     
-        ordered.should eql(@random_array.sort)
+        expect(ordered).to eql(@random_array.sort)
       end
     end
     

data/spec/kd_tree_spec.rb

@@ -6,7 +6,7 @@ describe Containers::KDTree do
     kdtree = Containers::KDTree.new( {0 => [4, 3], 1 => [3, 0], 2 => [-1, 2], 3 => [6, 4],
                                      4 => [3, -5], 5 => [-2, -5] })
     closest_2 = kdtree.find_nearest([0, 0], 2)
-    closest_2.should eql([[5, 2], [9, 1]])
+    expect(closest_2).to eql([[5, 2], [9, 1]])
   end
   
   it "should work for real-life example from facebook puzzle" do
@@ -28,7 +28,7 @@ describe Containers::KDTree do
     }
     
     expected = File.read(File.join(File.dirname(__FILE__), 'kd_expected_out.txt'))
-    expected.should eql(out)
+    expect(expected).to eql(out)
   end
   
 end

data/spec/map_gc_mark_spec.rb

@@ -21,9 +21,9 @@ if !(defined? RUBY_ENGINE && RUBY_ENGINE == 'jruby')
       # Check if any instances were swept
       count = 0
       ObjectSpace.each_object(anon_key_class) { |x| count += 1 }
-      count.should eql(200)
+      expect(count).to eql(200)
       ObjectSpace.each_object(anon_val_class) { |x| count += 1 }
-      count.should eql(400)
+      expect(count).to eql(400)
     end
   end
 end

data/spec/priority_queue_spec.rb

@@ -8,32 +8,32 @@ describe Containers::PriorityQueue do
   
   describe "(empty priority queue)" do
     it "should return 0 for size and be empty" do
-      @q.size.should eql(0)
-      @q.should be_empty
+      expect(@q.size).to eql(0)
+      expect(@q).to be_empty
     end
     
     it "should not return anything" do
-      @q.next.should be_nil
-      @q.pop.should be_nil
-      @q.delete(1).should be_nil
-      @q.has_priority?(1).should be_false
+      expect(@q.next).to be_nil
+      expect(@q.pop).to be_nil
+      expect(@q.delete(1)).to be_nil
+      expect(@q.has_priority?(1)).to be false
     end
     
     it "should give the correct size when adding items" do
       20.times do |i|
-        @q.size.should eql(i)
+        expect(@q.size).to eql(i)
         @q.push(i, i)
       end
       10.times do |i|
-        @q.size.should eql(20-i)
+        expect(@q.size).to eql(20-i)
         @q.pop
       end
       10.times do |i|
-        @q.size.should eql(i+10)
+        expect(@q.size).to eql(i+10)
         @q.push(i, i)
       end
       @q.delete(5)
-      @q.size.should eql(19)
+      expect(@q.size).to eql(19)
     end
   end
   
@@ -45,31 +45,31 @@ describe Containers::PriorityQueue do
     end
     
     it "should next/pop the highest priority" do
-      @q.next.should eql("Alaska")
-      @q.size.should eql(3)
-      @q.pop.should eql("Alaska")
-      @q.size.should eql(2)
+      expect(@q.next).to eql("Alaska")
+      expect(@q.size).to eql(3)
+      expect(@q.pop).to eql("Alaska")
+      expect(@q.size).to eql(2)
     end
     
     it "should not be empty" do
-      @q.should_not be_empty
+      expect(@q).not_to be_empty
     end
     
     it "should has_priority? priorities it has" do
-      @q.has_priority?(50).should be_true
-      @q.has_priority?(10).should be_false
+      expect(@q.has_priority?(50)).to be true
+      expect(@q.has_priority?(10)).to be false
     end      
     
     it "should return nil after popping everything" do
       3.times do 
         @q.pop
       end
-      @q.pop.should be_nil
+      expect(@q.pop).to be_nil
     end
     
     it "should delete things it has and not things it doesn't" do
-      @q.delete(50).should eql("Alaska")
-      @q.delete(10).should eql(nil)
+      expect(@q.delete(50)).to eql("Alaska")
+      expect(@q.delete(10)).to eql(nil)
     end
   end
 end

data/spec/queue_spec.rb

@@ -8,20 +8,20 @@ describe "empty queue" do
 
 
   it "should return nil when sent #pop" do
-    @queue.pop.should be_nil
+    expect(@queue.pop).to be_nil
   end
 
   it "should return a size of 1 when sent #push" do
     @queue.push(1)
-    @queue.size.should eql(1)
+    expect(@queue.size).to eql(1)
   end
 
   it "should return nil when sent #next" do
-    @queue.next.should be_nil
+    expect(@queue.next).to be_nil
   end
 
   it "should return empty?" do
-    @queue.empty?.should be_true
+    expect(@queue.empty?).to be true
   end
 end
 
@@ -33,29 +33,29 @@ describe "non-empty queue" do
   end
 
   it "should return first pushed object" do
-    @queue.pop.should eql(10)
+    expect(@queue.pop).to eql(10)
   end
 
   it "should return the size" do
-    @queue.size.should eql(2)
+    expect(@queue.size).to eql(2)
   end
 
   it "should not return empty?" do
-    @queue.empty?.should be_false
+    expect(@queue.empty?).to be false
   end
 
   it "should iterate in FIFO order" do
     arr = []
     @queue.each { |obj| arr << obj }
-    arr.should eql([10, "10"])
+    expect(arr).to eql([10, "10"])
   end
 
   it "should return nil after all gets" do
     2.times do
       @queue.pop
     end
-    @queue.pop.should be_nil
-    @queue.next.should be_nil
+    expect(@queue.pop).to be_nil
+    expect(@queue.next).to be_nil
   end
 
 end

data/spec/rb_tree_map_spec.rb

@@ -4,30 +4,30 @@ require 'algorithms'
 shared_examples "empty rbtree" do
   it "should let you push stuff in" do
     100.times { |x| @tree[x] = x }
-    @tree.size.should eql(100)
+    expect(@tree.size).to eql(100)
   end
 
   it "should be empty?" do
-    @tree.empty?.should be_true
+    expect(@tree.empty?).to be true
   end
 
   it "should return 0 for height" do
-    @tree.height.should eql(0)
+    expect(@tree.height).to eql(0)
   end
 
   it "should return 0 for size" do
-    @tree.size.should eql(0)
+    expect(@tree.size).to eql(0)
   end
 
   it "should return nil for max and min" do
-    @tree.min.should be_nil
-    @tree.max.should be_nil
-    @tree.min_key.should be_nil
-    @tree.max_key.should be_nil
+    expect(@tree.min).to be_nil
+    expect(@tree.max).to be_nil
+    expect(@tree.min_key).to be_nil
+    expect(@tree.max_key).to be_nil
   end
 
   it "should not delete" do
-    @tree.delete(:non_existing).should be_nil
+    expect(@tree.delete(:non_existing)).to be_nil
   end
 end
 
@@ -39,52 +39,52 @@ shared_examples "non-empty rbtree" do
   end
 
   it "should return correct size (uniqify items first)" do
-    @tree.should_not be_empty
-    @tree.size.should eql(@random_array.uniq.size)
+    expect(@tree).not_to be_empty
+    expect(@tree.size).to eql(@random_array.uniq.size)
   end
 
   it "should return correct max and min" do
-    @tree.min_key.should eql(@random_array.min)
-    @tree.max_key.should eql(@random_array.max)
-    @tree.min[0].should eql(@random_array.min)
-    @tree.max[0].should eql(@random_array.max)
+    expect(@tree.min_key).to eql(@random_array.min)
+    expect(@tree.max_key).to eql(@random_array.max)
+    expect(@tree.min[0]).to eql(@random_array.min)
+    expect(@tree.max[0]).to eql(@random_array.max)
   end
 
   it "should not #has_key? keys it doesn't have" do
-    @tree.has_key?(100000).should be_false
+    expect(@tree.has_key?(100000)).to be false
   end
 
   it "should #has_key? keys it does have" do
-    @tree.has_key?(@random_array[0]).should be_true
+    expect(@tree.has_key?(@random_array[0])).to be true
   end
 
   it "should remove all keys" do
     ordered = []
     @random_array.uniq.each do |key|
-      @tree.has_key?(key).should eql(true)
+      expect(@tree.has_key?(key)).to eql(true)
       ordered << @tree.delete(key)
-      @tree.has_key?(key).should eql(false)
+      expect(@tree.has_key?(key)).to eql(false)
     end
-    ordered.should eql(@random_array.uniq)
+    expect(ordered).to eql(@random_array.uniq)
   end
 
   it "should delete_min keys correctly" do
     ascending = []
     ascending << @tree.delete_min until @tree.empty?
-    ascending.should eql(@random_array.uniq.sort)
+    expect(ascending).to eql(@random_array.uniq.sort)
   end
 
   it "should delete_max keys correctly" do
     descending = []
     descending << @tree.delete_max until @tree.empty?
-    descending.should eql(@random_array.uniq.sort.reverse)
+    expect(descending).to eql(@random_array.uniq.sort.reverse)
   end
 
   it "should let you iterate with #each" do
     counter = 0
     sorted_array = @random_array.uniq.sort
     @tree.each do |key, val|
-      key.should eql(sorted_array[counter])
+      expect(key).to eql(sorted_array[counter])
       counter += 1
     end
   end

data/spec/search_spec.rb

@@ -8,21 +8,21 @@ describe "search algorithms" do
     n = 1000
     @rand_array = Array.new(n) { rand(n) }.sort
     
-    Algorithms::Search.binary_search(@rand_array, @rand_array.first).should eql(@rand_array.first)
-    Algorithms::Search.binary_search(@rand_array, 999999).should be_nil
-    Algorithms::Search.binary_search(@rand_array, nil).should be_nil
+    expect(Algorithms::Search.binary_search(@rand_array, @rand_array.first)).to eql(@rand_array.first)
+    expect(Algorithms::Search.binary_search(@rand_array, 999999)).to be_nil
+    expect(Algorithms::Search.binary_search(@rand_array, nil)).to be_nil
   end
   
   it "should use kmp_search to find substrings it has" do
     string = "ABC ABCDAB ABCDABCDABDE"
-    Algorithms::Search.kmp_search(string, "ABCDABD").should eql(15)
-    Algorithms::Search.kmp_search(string, "ABCDEF").should be_nil
-    Algorithms::Search.kmp_search(string, nil).should be_nil
-    Algorithms::Search.kmp_search(string, "").should be_nil
-    Algorithms::Search.kmp_search(nil, "ABCD").should be_nil
+    expect(Algorithms::Search.kmp_search(string, "ABCDABD")).to eql(15)
+    expect(Algorithms::Search.kmp_search(string, "ABCDEF")).to be_nil
+    expect(Algorithms::Search.kmp_search(string, nil)).to be_nil
+    expect(Algorithms::Search.kmp_search(string, "")).to be_nil
+    expect(Algorithms::Search.kmp_search(nil, "ABCD")).to be_nil
   end
   
   it "should let you include Search in String to enable instance methods" do
-    "ABC ABCDAB ABCDABCDABDE".kmp_search("ABCDABD").should eql(15)
+    expect("ABC ABCDAB ABCDABCDABDE".kmp_search("ABCDABD")).to eql(15)
   end
 end