ds 0.0.2 → 0.0.3

data/test/test_array_x.rb

@@ -5,6 +5,8 @@ describe ArrayX do
   before do
     @asc = [1,3,6,9,10,13].extend(ArrayX)
     @desc = [9,8,7,7,4,3,2].extend(ArrayX)
+    @short = [1,2].extend(ArrayX)
+
     @empty = [].extend(ArrayX)
     @one = [3].extend(ArrayX)
     @not_sorted = [3,4,9,1,1,2,8].extend(ArrayX)
@@ -15,16 +17,34 @@ describe ArrayX do
     assert @asc.sorted?
     assert @empty.sorted?
     assert @one.sorted?
+    assert @short.sorted? 
     refute @not_sorted.sorted?
-  end
+    assert @desc.sorted?(:desc)
+    refute @desc.sorted?(:asc)
+    assert @asc.sorted?(:asc)
+    refute @asc.sorted?(:desc)
+    refute @not_sorted.sorted?(:des)
+    refute @not_sorted.sorted?(:asc)
+    assert @short.sorted?(:asc)
+    refute @short.sorted?(:desc)
+    
+    assert @one.sorted?(:asc)
+    assert @one.sorted?(:asc)
 
-  it "#push_uniq should push element only if it is not already in array."  do
-    @asc.size.must_equal 6 
-    @asc.push_uniq(3).must_equal 1
-    @asc.size.must_equal 6
+  end
+  
+  it "#duplications? should check if array has duplicates." do
+    refute @asc.duplications?
+    assert @desc.duplications?
+    assert @not_sorted.duplications?
+    refute @empty.duplications?
+  end
 
-    @empty.push_uniq(3).must_equal 0
-    @empty.must_equal [3]
+  it "#tail should return array without first element." do
+    @asc.tail.must_equal [3,6,9,10,13]
+    @short.tail.must_equal [2]
+    @one.tail.must_equal []
+    @empty.tail.must_be_nil
   end
 end
 

data/test/test_binary_heap.rb

@@ -6,7 +6,7 @@ describe BinaryHeap do
     @arr = [9,8,4,5,11,6]
     @arr2 = [4,2,9,11,3,5,1]
     @heap = BinaryHeap.new(*@arr)
-    @heap2 = BinaryHeap.new(*@arr2)
+    @heap2 = BinaryHeap.max(*@arr2)
   end
 
   it "should create heap from array" do
@@ -18,18 +18,36 @@ describe BinaryHeap do
     @heap.insert(13).to_a.must_equal  [13,9,11,5,8,4,6]
   end
 
+  it "#shift should remove element from heap maintaining heap relation." do
+    @heap.shift.must_equal 11
+    @heap.to_a.must_equal [9,8,6,5,4]
+    @heap.shift.must_equal 9
+    @heap.to_a.must_equal [8,5,6,4]
+    @heap.shift.must_equal 8
+    @heap.to_a.must_equal [6,5,4]
+    @heap.shift.must_equal 6
+    @heap.to_a.must_equal [5,4]
+    @heap.shift.must_equal 5
+    @heap.to_a.must_equal [4]
+    @heap.shift.must_equal 4
+    @heap.shift.must_be_nil
+  end
+
   describe "Minimal Heap" do
 
     before do
       @min_heap = BinaryHeap.new(*@arr){|parent,child| parent < child}
+      @min_heap2 = BinaryHeap.min(*@arr)
     end
 
     it "should create heap from array." do
       @min_heap.to_a.must_equal [4,5,6,8,11,9]
+      @min_heap2.to_a.must_equal [4,5,6,8,11,9]
     end
 
     it "#insert should insert new element to the heap maintaining heap relation." do
       @min_heap.insert(3).to_a.must_equal [3,5,4,8,11,9,6]
+      @min_heap2.insert(3).to_a.must_equal [3,5,4,8,11,9,6]
     end
   end
 end

data/test/test_binary_search_tree.rb

@@ -3,6 +3,8 @@ require 'help'
 describe BinarySearchTree do
 
   before do
+
+
     t = BinarySearchTree.new(7)
     c1 = t.insert 5
     c2 = t.insert 8
@@ -16,13 +18,18 @@ describe BinarySearchTree do
 
     @bin_tree = BinaryTree.new
     [2,5,8,9,11,12,14].each{|x| @bin_tree.insert(x)}
-
+    
   end
 
   it "should be valid  Binary Search Tree." do
     assert BinarySearchTree.valid?(@bst)
   end
 
+  it "#from_array should create new valid BinarySearchTree." do
+    b = BinarySearchTree.from_array([8,1,5,2,7,6,3])
+    assert BinarySearchTree.valid?(b)
+    TreeWalker.new(b).traverse(:inorder).must_equal [1,2,3,5,6,7,8]
+  end
 
   it "not every Binary Tree is valid Binary Search Tree." do
     refute BinarySearchTree.valid?(@bin_tree)

data/test/test_binary_tree.rb

@@ -10,6 +10,10 @@ describe BinaryTree do
     @izo_tree = BinaryTree.new
     [2,7,8,3,11,12,14].each{|x| @izo_tree.insert(x)}
 
+    @small_tree = BinaryTree.new(2)
+    @small_tree << BinaryTree.new(7)
+    @small_tree << BinaryTree.new(8)
+
     @bin_walker = TreeWalker.new(@bin_tree)
 
   end
@@ -35,7 +39,7 @@ describe BinaryTree do
   end
 
   it "#lowest_height should return node which lies closest to the root." do
-    assert @bin_tree.lowest_height.must_equal 9 
+    assert @bin_tree.lowest_height.data.must_equal 9 
   end
 
   it "#mirror should mirror tree." do
@@ -45,6 +49,8 @@ describe BinaryTree do
 
   it "#isometric should check if tree is isometric to antother." do
     assert @bin_tree.izometric?(@izo_tree)
+    assert @izo_tree.izometric?(@bin_tree)
+    refute @bin_tree.izometric?(@small_tree)
   end
 
 end

data/test/test_complete_binary_tree.rb

@@ -4,27 +4,55 @@ describe CompleteBinaryTree do
 
   before do
     @tree = CompleteBinaryTree.new(1,2,3,4,5,6,7)
+    @empty_tree = CompleteBinaryTree.new
+  end
+
+  it "#<< should add new element." do
+    @empty_tree << 1
+    @empty_tree << 2
+    @empty_tree.root.must_equal 1
   end
 
   it "#root should return root of the tree." do
     @tree.root.must_equal 1
   end
 
+  it "#left_index should return index of left child" do
+    @tree.left_index(0).must_equal 1
+    @tree.left_index(1).must_equal 3
+  end
+
+  it "#right_index should return index of left child" do
+    @tree.right_index(0).must_equal 2
+    @tree.right_index(1).must_equal 4
+  end
+
+  it "#parent_index should return index of left child" do
+    @tree.parent_index(1).must_equal 0
+    @tree.parent_index(3).must_equal 1
+  end
+
   it "#left should return left child" do
-    @tree.left(1).must_equal 2
-    @tree.left(2).must_equal 4
+    @tree.left(0).must_equal 2
+    @tree.left(1).must_equal 4
   end
 
   it "#right should return right child" do
-    @tree.right(1).must_equal 3
-    @tree.right(2).must_equal 5
+    @tree.right(0).must_equal 3
+    @tree.right(1).must_equal 5
   end
 
   it "#parent should return parent." do
+    @tree.parent(3).must_equal 2
     @tree.parent(4).must_equal 2
-    @tree.parent(5).must_equal 2
-    @tree.parent(2).must_equal 1
+    @tree.parent(1).must_equal 1
+  end
+
+  it "#children should return children." do
+    @tree.children(0).must_equal [2,3]
   end
 
+
+
 end
  

data/test/test_digraph.rb

@@ -63,7 +63,7 @@ describe Digraph do
 
     it "#add_edge should add new edge." do
       @digraph.add_edges([Edge.new("Marc","Kate")])
-      @digraph.vertex_size.must_equal 6
+      @digraph.vertex_size.must_equal 5
       assert @digraph.edge?("Marc","Kate")
       refute @digraph.edge?("Kate","Marc")
       refute @digraph.edge?("Tom","Kate")

data/test/test_graph.rb

@@ -37,9 +37,18 @@ describe Graph do
     refute @graph.edge?("Tom","Kate")
   end
 
+  it "#add should add new edge to graph." do
+    @graph.add('Jack','Lukas')
+    @graph.vertex_size.must_equal 4
+    assert @graph.edge?("Jack","Lukas")
+    assert @graph.edge?("Lukas","Jack")
+  end
+
+
+
   it "#remove_edge should remove edge." do
     @graph.remove("Marc","Jack")
-    @graph.vertex_size.must_equal 3
+    @graph.vertex_size.must_equal 4
     refute @graph.edge?("Marc","Jack")
     refute @graph.edge?("Jack","Marc")
   end

data/test/test_list.rb

@@ -5,6 +5,9 @@ describe List do
   before do
     @list = List.from_array([1,2,3,4])
     @list2 = List.from_array([4,5,7])
+
+    @numbers =  List.from_array((1..10).to_a)
+    @even_numbers = List.from_array([2,4,6,8,10])
   end
 
   it "#from_array should transform array to list." do
@@ -49,12 +52,17 @@ describe List do
     @list.insert_before(7,@list.tail)
     @list.to_a.must_equal [8,1,9,2,3,7,4]
 
+    proc { @list.insert_before(1,nil)}.must_raise  ListError
   end
 
   it "#insert_after should insert new element after another." do
     second = @list.head.next
     @list.insert_after(9,second)
     @list.to_a.must_equal [1,2,9,3,4]
+
+    tail = @list.tail
+    @list.insert_after(11,tail)
+    @list.to_a.must_equal [1,2,9,3,4,11]
   end
 
 
@@ -100,6 +108,11 @@ describe List do
     @list2.merge(@list).to_a.must_equal [1,2,3,4,4,5,7]
   end
 
+  it "#merge should be symetric operation." do
+    @list.merge(@list2).to_a.must_equal [1,2,3,4,4,5,7]
+  end
+
+
   it "#orderize should order elements by evaluating block." do
     not_sorted_list = List.from_array([3,-1,0,-8,2,0,1])
     not_sorted_list.orderize{|elem| elem <=> 0}.to_a.must_equal [-1,-8,0,0,3,2,1]
@@ -107,6 +120,11 @@ describe List do
 
   it "#remove! should remove all elements that occur on the other list." do
     @list.remove!(@list2).to_a.must_equal [1,2,3]
+    @numbers.remove!(@even_numbers).to_a.must_equal [1,3,5,7,9]
+  end
+  
+  it "#remove! should remove all elements that occur on the other list#2." do
+    @list2.remove!(@list).to_a.must_equal [5,7]
   end
 
   it "#looped? should check if list has cycle." do
@@ -114,9 +132,16 @@ describe List do
     refute @list.looped?
   end
 
+  it "#each_with_index should iterate list." do
+    h = {}
+    @list.each_with_index{|e,i| h[i] = e.data}
+    h.must_equal({0 => 1, 1 => 2, 2 => 3, 3 => 4})
+  end
+
   it "should include Enumerable methods." do
-    @list.map{ |e| e }.must_equal [1,2,3,4]
-    @list.inject(0){ |mem, var| mem = mem + var }.must_equal 10
+    @list.map{ |e| e.data }.must_equal [1,2,3,4]
+    @list.inject(0){ |mem, var| mem = mem + var.data }.must_equal 10
+    @list.find { |e| e.data == 1.0  }.data.must_equal 1
   end
 
 
@@ -134,5 +159,37 @@ describe List do
 
   end
 
+  if ENV['BENCH']
+    describe "performance" do
+    
+      before do
+        @arr = (1..10_000).to_a.sort_by{rand}
+
+        10000.times do |n|
+          @list.append 4
+        end
+      end
+
+
+      bench_performance_constant "#append should be const operation.", 0.999 do |n|
+        n.times do
+          @list.append 3
+        end
+      end
+
+      bench_performance_constant "#prepend should be const operation.", 0.999 do |n|
+        n.times do
+          @list.prepend 3
+        end
+      end
+
+      bench_performance_linear "#reverse! should be linear operation.", 0.999 do |n|
+        list =List.from_array(@arr[0..n])
+        list.reverse!
+      end
+
+    end
   end
 
+end
+

data/test/test_ordered_set.rb

@@ -0,0 +1,28 @@
+require 'help'
+
+describe "OrderedSet" do
+
+  before do
+    @set = OrderedSet.new
+    @set.push(:first).must_equal 0
+  end
+
+  it "#push should add new element to set and return its index." do
+    @set.push(:second).must_equal 1
+    @set.push(:first).must_equal 0
+  end
+
+  it "#index should return element index." do
+    @set.index(:first).must_equal 0
+    @set.push(:second)
+    @set.index(:second).must_equal 1
+    @set.index(:non_exist).must_be_nil
+  end
+
+  it "#to_a should return array." do
+    @set.push(:second)
+    @set.to_a.must_equal [:first,:second]
+  end
+
+end
+

data/test/test_pair.rb

@@ -0,0 +1,26 @@
+require 'help'
+
+describe Pair do
+
+  before do
+    @pair = Pair.new(1,2)
+  end
+
+  it "#first should return first element of a pair" do
+    @pair.first.must_equal 1
+  end
+
+  it "#key should return first element of a pair" do
+    @pair.key.must_equal 1
+  end
+
+  it "#second should return second element of a pair" do
+    @pair.second.must_equal 2
+  end
+
+  it "#value should return second element of a pair" do
+    @pair.value.must_equal 2
+  end
+  
+end
+

data/test/test_priority_queue.rb

@@ -0,0 +1,134 @@
+require 'help'
+
+describe PriorityQueue do
+
+  describe "Empty Priority Queue" do
+
+    before do
+      @empty_queue = PriorityQueue.new
+    end
+
+    it "should be empty." do
+      assert @empty_queue.empty?
+    end
+
+    it "should have zero elements." do
+      @empty_queue.length.must_equal 0
+    end
+  end
+
+
+  describe "Not empty priority queue" do
+
+    before do
+      @queue = PriorityQueue.new
+      @queue.enqueue :important, 2
+      @queue.enqueue :not_important, 1
+    end
+
+    it "should not be empty." do
+      refute @queue.empty?
+      @queue.length.must_equal 2
+
+    end
+
+    it "#peek should return element with highest priority." do
+      @queue.peek.must_equal :important
+    end
+
+
+    it "#enqueue and #push should add element to priority queue." do
+      @queue.enqueue :very_important, 5
+      @queue.push :nevermind, 0
+      @queue.length.must_equal 4
+    end
+
+    it "#dequeue and #shift should remove element with highest priority." do
+      x = @queue.dequeue
+      @queue.length.must_equal 1
+      x.must_equal :important
+      @queue.dequeue.must_equal :not_important
+      @queue.length.must_equal 0
+      @queue.dequeue.must_be_nil
+    end
+  end
+
+  describe "Priority Queue with duplications" do
+
+    before do
+      @dup_queue = PriorityQueue.new
+      @dup_queue.enqueue :same_important, 2
+      @dup_queue.enqueue :important, 2
+      @dup_queue.enqueue :not_important, 1
+    end
+
+    it "should not be empty" do
+      refute @dup_queue.empty?
+      @dup_queue.length.must_equal 3
+    end
+
+    it "#peek should return element with highest priority." do
+      assert [:important,:same_important].include? @dup_queue.peek
+      @dup_queue.dequeue
+      assert [:important,:same_important].include? @dup_queue.peek
+      @dup_queue.dequeue
+      @dup_queue.peek.must_equal :not_important
+    end
+
+    it "#enqueue and #push should add element to priority queue." do
+      @dup_queue.push :nevermind, 0
+      @dup_queue.push :another_important, 2
+      @dup_queue.length.must_equal 5
+    end
+
+    it "#dequeue and #shift should remove element with highest priority." do
+      x  = @dup_queue.dequeue
+      assert [:important,:same_important].include? x
+      @dup_queue.length.must_equal 2
+
+      @dup_queue.enqueue :important, 2
+      @dup_queue.length.must_equal 3
+      @dup_queue.dequeue.must_equal :important
+      @dup_queue.dequeue.must_equal :important
+    end
+  end
+
+
+  if ENV['BENCH']
+    describe "performance" do
+
+      before do
+        
+        @queue = PriorityQueue.new
+        10000.times do |n|
+          @queue.push :elem, rand(10)
+        end
+
+        @empty_queue = PriorityQueue.new
+      end
+
+
+      bench_performance_constant "#accessing max element should be const operation.", 0.999 do |n|
+        n.times do
+          @queue.peek
+        end
+      end
+
+
+      bench_performance_constant "#removing max element should be log operation.", 0.999 do |n|
+        n.times do
+          @queue.dequeue
+        end
+      end
+
+      bench_performance_constant "creating new priority queue should be linear operation.", 0.999 do |n|
+        n.times do
+          @empty_queue.push :elem, rand(10)
+        end
+      end
+
+
+
+    end
+  end
+end