compsci 0.3.0.1 → 0.3.1.1

data/test/flex_node.rb

@@ -0,0 +1,226 @@
+require 'compsci/flex_node'
+require 'minitest/autorun'
+
+include CompSci
+
+describe FlexNode do
+  before do
+    @martin_sheen = FlexNode.new 'martin'
+    @charlie_sheen = FlexNode.new 'charlie'
+    @emilio_estevez = FlexNode.new 'emilio'
+  end
+
+  it "must track children" do
+    @charlie_sheen.add_parent(@martin_sheen)
+    expect(@martin_sheen.children).must_include @charlie_sheen
+    expect(@martin_sheen.children).wont_include @emilio_estevez
+
+    @martin_sheen.add_child @emilio_estevez
+    expect(@martin_sheen.children).must_include @emilio_estevez
+  end
+
+  it "must create children from scalars" do
+    @martin_sheen.new_child 'fake_emilio'
+    expect(@martin_sheen.children.size).must_equal 1
+    expect(@martin_sheen.children.first.value).must_equal 'fake_emilio'
+    expect(@martin_sheen.children).wont_include @emilio_estevez
+  end
+
+  it "does depth-first search" do
+    vals = (0..30).to_a
+    root = FlexNode.new vals.shift
+    root.new_child vals.shift
+    root.new_child vals.shift
+    root.children.each { |c|
+      c.new_child vals.shift
+      c.new_child vals.shift
+
+        c.children.each { |cc|
+          cc.new_child vals.shift
+          cc.new_child vals.shift
+        }
+    }
+
+    visited = []
+    root.df_search { |n|
+      visited << n.value
+      false
+    }
+    expect(visited).wont_be_empty
+    expect(visited).must_equal [0, 1, 3, 5, 6, 4, 7, 8, 2, 9, 11, 12, 10, 13, 14]
+  end
+
+  it "does breadth-first search" do
+    vals = (0..30).to_a
+    root = FlexNode.new vals.shift
+    root.new_child vals.shift
+    root.new_child vals.shift
+    root.children.each { |c|
+      c.new_child vals.shift
+      c.new_child vals.shift
+
+      c.children.each { |cc|
+        cc.new_child vals.shift
+        cc.new_child vals.shift
+      }
+    }
+
+    visited = []
+    root.bf_search { |n|
+      visited << n.value
+      false
+    }
+    expect(visited).wont_be_empty
+    expect(visited).must_equal [0, 1, 2, 3, 4, 9, 10, 5, 6, 7, 8, 11, 12, 13, 14]
+  end
+
+  describe "Binary FlexNode" do
+    before do
+      @root = FlexNode.new 100
+      @child_slots = 2
+    end
+
+    it "must have an open parent" do
+      expect(@root.open_parent?(@child_slots)).must_equal true
+      expect(@root.open_parent(@child_slots)).must_equal @root
+    end
+
+    it "must push a value onto an open parent" do
+      opc = @root.open_parent(@child_slots).children.size
+      @root.push 27, @child_slots
+      expect(@root.open_parent(@child_slots).children.size).must_equal opc + 1
+    end
+
+    it "must display properly via @root" do
+      item_count = 31
+      # tree already has a root node
+      (item_count - 1).times { @root.push(rand(99), @child_slots) }
+      str = @root.display
+      line_count = str.split("\n").size
+      expect(line_count).must_equal Math.log(item_count + 1, 2).ceil
+    end
+
+    describe "searching" do
+      before do
+        @root = FlexNode.new 42
+        @child_slots = 2
+        99.times { |i| @root.push(i, @child_slots) }
+      end
+
+      it "must find 42 quickly" do
+        count = 0
+        expect(@root.df_search { |n|
+          count += 1
+          n.value == 42
+        }).must_equal @root
+        expect(count).must_equal 1
+
+        count = 0
+        expect(@root.bf_search { |n|
+          count += 1
+          n.value == 42
+        }).must_equal @root
+        expect(count).must_equal 1
+      end
+
+      it "must find 99 slowly" do
+        count = 0
+        @root.df_search { |n|
+          count += 1
+          n.value == 99
+        }
+        expect(count).must_equal 100
+
+        count = 0
+        @root.bf_search { |n|
+          count += 1
+          n.value == 99
+        }
+        expect(count).must_equal 100
+      end
+
+      it "must find 81 accordingly" do
+        count = 0
+        @root.df_search { |n|
+          count += 1
+          n.value == 81
+        }
+        expect(count).must_equal 42
+
+        count = 0
+        @root.bf_search { |n|
+          count += 1
+          n.value == 81
+        }
+        expect(count).must_equal 83
+      end
+    end
+  end
+end
+
+
+
+
+describe ChildFlexNode do
+  before do
+    @martin_sheen = ChildFlexNode.new 'martin'
+    @charlie_sheen = ChildFlexNode.new 'charlie'
+    @emilio_estevez = ChildFlexNode.new 'emilio'
+  end
+
+  it "must track parent and children" do
+    @charlie_sheen.add_parent(@martin_sheen)
+    expect(@charlie_sheen.parent).must_equal @martin_sheen
+    expect(@martin_sheen.children).must_include @charlie_sheen
+    expect(@martin_sheen.children).wont_include @emilio_estevez
+
+    @martin_sheen.add_child @emilio_estevez
+    expect(@martin_sheen.children).must_include @emilio_estevez
+    expect(@emilio_estevez.parent).must_equal @martin_sheen
+  end
+
+  it "must determine a node's generation" do
+    expect(@emilio_estevez.gen).must_equal 0
+    @martin_sheen.add_child @emilio_estevez
+    expect(@emilio_estevez.gen).must_equal 1
+  end
+
+  it "must create children from scalars" do
+    @martin_sheen.new_child 'fake_emilio'
+    expect(@martin_sheen.children.size).must_equal 1
+    expect(@martin_sheen.children.first.value).must_equal 'fake_emilio'
+    expect(@martin_sheen.children).wont_include @emilio_estevez
+  end
+
+  it "must recognize siblings" do
+    @charlie_sheen.add_parent @martin_sheen
+    @emilio_estevez.add_parent @martin_sheen
+    @martin_sheen.new_child 'fake_emilio'
+
+    expect(@charlie_sheen.siblings).must_include @emilio_estevez
+    expect(@charlie_sheen.siblings).wont_include @martin_sheen
+    expect(@emilio_estevez.siblings).must_include @charlie_sheen
+    expect(@martin_sheen.siblings).must_be_empty
+    expect(@emilio_estevez.siblings.find { |n|
+             n.value == 'fake_emilio'
+           }).wont_be_nil
+  end
+
+  describe "Quaternary ChildFlexNode" do
+    before do
+      @root = ChildFlexNode.new 42
+      @child_slots = 4
+    end
+
+    it "must have an open parent" do
+      expect(@root.open_parent?(@child_slots)).must_equal true
+      expect(@root.open_parent(@child_slots)).must_equal @root
+    end
+
+    it "must push a value onto an open parent" do
+      opc = @root.open_parent(@child_slots).children.size
+      @root.push 27, @child_slots
+      expect(@root.open_parent(@child_slots).children.size).must_equal opc + 1
+    end
+  end
+end

data/test/heap.rb

@@ -11,39 +11,39 @@ describe Heap do
     end
 
     it "must satisfy the heap property" do
-      @maxheap.heap?.must_equal true
-      @maxheap.array.wont_equal @inserts
-      @maxheap.array.wont_equal @inserts.reverse
+      expect(@maxheap.heap?).must_equal true
+      expect(@maxheap.array).wont_equal @inserts
+      expect(@maxheap.array).wont_equal @inserts.reverse
     end
 
     it "must recognize heap violations" do
       @maxheap.array.unshift 0
-      @maxheap.heap?.must_equal false
+      expect(@maxheap.heap?).must_equal false
       @maxheap.array.shift
-      @maxheap.heap?.must_equal true
+      expect(@maxheap.heap?).must_equal true
 
       @maxheap.array.push 10
-      @maxheap.heap?.must_equal false
+      expect(@maxheap.heap?).must_equal false
       @maxheap.sift_up @maxheap.last_idx
-      @maxheap.heap?.must_equal true
+      expect(@maxheap.heap?).must_equal true
     end
 
     it "must pop" do
-      @maxheap.pop.must_equal 10
-      @maxheap.peek.wont_equal 10
-      @maxheap.heap?.must_equal true
+      expect(@maxheap.pop).must_equal 10
+      expect(@maxheap.peek).wont_equal 10
+      expect(@maxheap.heap?).must_equal true
     end
 
     it "must heapish?" do
-      @maxheap.array[0].must_be :>, @maxheap.array[1]
-      @maxheap.heapish?(0, 1).must_equal true
+      expect(@maxheap.array[0]).must_be :>, @maxheap.array[1]
+      expect(@maxheap.heapish?(0, 1)).must_equal true
     end
 
     it "must heapiest" do
-      @maxheap.heapiest([1, 2]).must_equal 1
-      @maxheap.heapiest([3, 4]).must_equal 4
-      @maxheap.heapiest([5, 6]).must_equal 6
-      @maxheap.heapiest([7, 8]).must_equal 8
+      expect(@maxheap.heapiest([1, 2])).must_equal 1
+      expect(@maxheap.heapiest([3, 4])).must_equal 4
+      expect(@maxheap.heapiest([5, 6])).must_equal 6
+      expect(@maxheap.heapiest([7, 8])).must_equal 8
     end
   end
 
@@ -54,38 +54,38 @@ describe Heap do
     end
 
     it "must satisfy the heap property" do
-      @minheap.heap?.must_equal true
-      @minheap.array.must_equal @inserts
+      expect(@minheap.heap?).must_equal true
+      expect(@minheap.array).must_equal @inserts
     end
 
     it "must recognize heap violations" do
       @minheap.array.unshift 10
-      @minheap.heap?.must_equal false
+      expect(@minheap.heap?).must_equal false
       @minheap.array.shift
-      @minheap.heap?.must_equal true
+      expect(@minheap.heap?).must_equal true
 
       @minheap.array.push 0
-      @minheap.heap?.must_equal false
+      expect(@minheap.heap?).must_equal false
       @minheap.sift_up @minheap.last_idx
-      @minheap.heap?.must_equal true
+      expect(@minheap.heap?).must_equal true
     end
 
     it "must pop" do
-      @minheap.pop.must_equal 1
-      @minheap.peek.wont_equal 1
-      @minheap.heap?.must_equal true
+      expect(@minheap.pop).must_equal 1
+      expect(@minheap.peek).wont_equal 1
+      expect(@minheap.heap?).must_equal true
     end
 
     it "must heapish?" do
-      @minheap.array[0].must_be :<, @minheap.array[1]
-      @minheap.heapish?(0, 1).must_equal true
+      expect(@minheap.array[0]).must_be :<, @minheap.array[1]
+      expect(@minheap.heapish?(0, 1)).must_equal true
     end
 
     it "must heapiest" do
-      @minheap.heapiest([1, 2]).must_equal 1
-      @minheap.heapiest([3, 4]).must_equal 3
-      @minheap.heapiest([5, 6]).must_equal 5
-      @minheap.heapiest([7, 8]).must_equal 7
+      expect(@minheap.heapiest([1, 2])).must_equal 1
+      expect(@minheap.heapiest([3, 4])).must_equal 3
+      expect(@minheap.heapiest([5, 6])).must_equal 5
+      expect(@minheap.heapiest([7, 8])).must_equal 7
     end
   end
 
@@ -96,38 +96,38 @@ describe Heap do
     end
 
     it "must satisfy the heap property" do
-      @heap3.heap?.must_equal true
-      @heap3.array.wont_equal @inserts
-      @heap3.array.wont_equal @inserts.reverse
+      expect(@heap3.heap?).must_equal true
+      expect(@heap3.array).wont_equal @inserts
+      expect(@heap3.array).wont_equal @inserts.reverse
     end
 
     it "must recognize heap violations" do
       @heap3.array.unshift 0
-      @heap3.heap?.must_equal false
+      expect(@heap3.heap?).must_equal false
       @heap3.array.shift
-      @heap3.heap?.must_equal true
+      expect(@heap3.heap?).must_equal true
 
       @heap3.array.push 10
-      @heap3.heap?.must_equal false
+      expect(@heap3.heap?).must_equal false
       @heap3.sift_up @heap3.last_idx
-      @heap3.heap?.must_equal true
+      expect(@heap3.heap?).must_equal true
     end
 
     it "must pop" do
-      @heap3.pop.must_equal 10
-      @heap3.peek.wont_equal 10
-      @heap3.heap?.must_equal true
+      expect(@heap3.pop).must_equal 10
+      expect(@heap3.peek).wont_equal 10
+      expect(@heap3.heap?).must_equal true
     end
 
     it "must heapish?" do
-      @heap3.array[0].must_be :>, @heap3.array[1]
-      @heap3.heapish?(0, 1).must_equal true
+      expect(@heap3.array[0]).must_be :>, @heap3.array[1]
+      expect(@heap3.heapish?(0, 1)).must_equal true
     end
 
     it "must heapiest" do
-      @heap3.heapiest([1, 2, 3]).must_equal 2
-      @heap3.heapiest([4, 5, 6]).must_equal 6
-      @heap3.heapiest([7, 8, 9]).must_equal 9
+      expect(@heap3.heapiest([1, 2, 3])).must_equal 2
+      expect(@heap3.heapiest([4, 5, 6])).must_equal 6
+      expect(@heap3.heapiest([7, 8, 9])).must_equal 9
     end
   end
 end

data/test/names.rb

@@ -1,5 +1,6 @@
 require 'compsci/names'
 require 'compsci/names/greek'
+require 'compsci/names/pokemon'
 require 'minitest/autorun'
 
 include CompSci
@@ -7,91 +8,129 @@ include CompSci
 describe Names do
   describe "alphabetic constants" do
     it "must have size 26" do
-      Names::WW1.size.must_equal 26
-      Names::WW2.size.must_equal 26
-      Names::NATO.size.must_equal 26
-      Names::ENGLISH_UPPER.size.must_equal 26
-      Names::ENGLISH_LOWER.size.must_equal 26
+      expect(Names::WW1.size).must_equal 26
+      expect(Names::WW2.size).must_equal 26
+      expect(Names::NATO.size).must_equal 26
+      expect(Names::ENGLISH_UPPER.size).must_equal 26
+      expect(Names::ENGLISH_LOWER.size).must_equal 26
     end
   end
 
   describe "Names.assign" do
     it "must handle English / ASCII strings" do
       upper_lower = Names::ENGLISH_UPPER + Names::ENGLISH_LOWER
-      Names.assign('cat', Names::ENGLISH_UPPER).must_equal 'C'
-      Names.assign('Cat', Names::ENGLISH_UPPER).must_equal 'C'
-      Names.assign('cat', Names::ENGLISH_LOWER).must_equal 'c'
-      Names.assign('Cat', Names::ENGLISH_LOWER).must_equal 'c'
-      Names.assign('Cat', upper_lower).must_equal 'C'
-      Names.assign('cat', upper_lower).must_equal 'c'
-      Names.assign('cat', Names::NATO).must_equal :charlie
-      Names.assign('Cat', Names::NATO).must_equal :charlie
-      Names.assign('Dog', Names::CRYPTO).must_equal :david
-      Names.assign('2', Names::PLANETS).must_equal :earth
-    end
+      expect(Names.assign('cat', Names::ENGLISH_UPPER)).must_equal 'C'
+      expect(Names.assign('Cat', Names::ENGLISH_UPPER)).must_equal 'C'
+      expect(Names.assign('cat', Names::ENGLISH_LOWER)).must_equal 'c'
+      expect(Names.assign('Cat', Names::ENGLISH_LOWER)).must_equal 'c'
+      expect(Names.assign('Cat', upper_lower)).must_equal 'C'
+      expect(Names.assign('cat', upper_lower)).must_equal 'c'
+      expect(Names.assign('cat', Names::NATO)).must_equal :charlie
+      expect(Names.assign('Cat', Names::NATO)).must_equal :charlie
+      expect(Names.assign('Dog', Names::CRYPTO)).must_equal :david
+      expect(Names.assign('2', Names::PLANETS)).must_equal :earth end
 
     it "must handle integers" do
       upper_lower = Names::ENGLISH_UPPER + Names::ENGLISH_LOWER
-      Names.assign(36, upper_lower).must_equal 'k'
-      Names.assign(0, upper_lower).must_equal 'A'
-      Names.assign(0, Names::ENGLISH_UPPER).must_equal 'A'
-      Names.assign(3, Names::ENGLISH_LOWER).must_equal 'd'
-      Names.assign(3, Names::PLANETS).must_equal :mars
+      expect(Names.assign(36, upper_lower)).must_equal 'k'
+      expect(Names.assign(0, upper_lower)).must_equal 'A'
+      expect(Names.assign(0, Names::ENGLISH_UPPER)).must_equal 'A'
+      expect(Names.assign(3, Names::ENGLISH_LOWER)).must_equal 'd'
+      expect(Names.assign(3, Names::PLANETS)).must_equal :mars
     end
   end
 
   describe Names::Greek do
     describe "greek alphabetic constants" do
       it "must have size 24" do
-        Names::Greek::UPPER.size.must_equal 24
-        Names::Greek::LOWER.size.must_equal 24
-        Names::Greek::SYMBOLS.size.must_equal 24
-        Names::Greek::CHAR_MAP.size.must_equal 24
+        expect(Names::Greek::UPPER.size).must_equal 24
+        expect(Names::Greek::LOWER.size).must_equal 24
+        expect(Names::Greek::SYMBOLS.size).must_equal 24
+        expect(Names::Greek::CHAR_MAP.size).must_equal 24
       end
     end
 
     describe "SYMBOLS26" do
       it "must work well with Names.assign" do
         s26 = Names::Greek::SYMBOLS26
-        Names.assign('iota', s26).must_equal :iota
-        Names.assign('jota', s26).must_equal :xi
-        Names.assign('Query', s26).must_equal :xi
-        Names.assign('who', s26).must_equal :xi
-        Names.assign('zeta', s26).must_equal :omega
-        Names.assign(0, s26).must_equal :alpha
-        Names.assign('1', s26).must_equal :beta
+        expect(Names.assign('iota', s26)).must_equal :iota
+        expect(Names.assign('jota', s26)).must_equal :xi
+        expect(Names.assign('Query', s26)).must_equal :xi
+        expect(Names.assign('who', s26)).must_equal :xi
+        expect(Names.assign('zeta', s26)).must_equal :omega
+        expect(Names.assign(0, s26)).must_equal :alpha
+        expect(Names.assign('1', s26)).must_equal :beta
       end
     end
-  end
 
-  describe "Greek.sym" do
-    it "must handle strings and integers" do
-      Names::Greek.sym('cat').must_equal :gamma
-      Names::Greek.sym('Cat').must_equal :gamma
-      Names::Greek.sym('zeta').must_equal :omega
-      Names::Greek.sym(0).must_equal :alpha
-      Names::Greek.sym('1').must_equal :beta
-      Names::Greek.sym(23).must_equal :omega
+    describe "Greek.sym" do
+      it "must handle strings and integers" do
+        expect(Names::Greek.sym('cat')).must_equal :gamma
+        expect(Names::Greek.sym('Cat')).must_equal :gamma
+        expect(Names::Greek.sym('zeta')).must_equal :omega
+        expect(Names::Greek.sym(0)).must_equal :alpha
+        expect(Names::Greek.sym('1')).must_equal :beta
+        expect(Names::Greek.sym(23)).must_equal :omega
+      end
     end
-  end
 
-  describe "Greek.lower" do
-    it "must handle strings and integers" do
-      third = Names::Greek::LOWER[2]
-      Names::Greek.lower('cat').must_equal third
-      Names::Greek.lower('Cat').must_equal third
-      Names::Greek.lower(2).must_equal third
-      Names::Greek.lower('2').must_equal third
+    describe "Greek.lower" do
+      it "must handle strings and integers" do
+        third = Names::Greek::LOWER[2]
+        expect(Names::Greek.lower('cat')).must_equal third
+        expect(Names::Greek.lower('Cat')).must_equal third
+        expect(Names::Greek.lower(2)).must_equal third
+        expect(Names::Greek.lower('2')).must_equal third
+      end
+    end
+
+    describe "Greek.upper" do
+      it "must handle strings and integers" do
+        fourth = Names::Greek::UPPER[3]
+        expect(Names::Greek.upper('dog')).must_equal fourth
+        expect(Names::Greek.upper('Dog')).must_equal fourth
+        expect(Names::Greek.upper(3)).must_equal fourth
+        expect(Names::Greek.upper('3')).must_equal fourth
+      end
     end
   end
 
-  describe "Greek.upper" do
-    it "must handle strings and integers" do
-      fourth = Names::Greek::UPPER[3]
-      Names::Greek.upper('dog').must_equal fourth
-      Names::Greek.upper('Dog').must_equal fourth
-      Names::Greek.upper(3).must_equal fourth
-      Names::Greek.upper('3').must_equal fourth
+  describe Names::Pokemon do
+    it "must have an array" do
+      ary = Names::Pokemon.array
+      expect(ary).must_be_kind_of Array
+      expect(ary.size).must_be :>, 99
+    end
+
+    it "must have a hash keyed by first letter" do
+      hsh = Names::Pokemon.hash
+      expect(hsh).must_be_kind_of Hash
+      expect(hsh.size).must_equal 26
+      expect(hsh['n']).must_be_kind_of Array
+      expect(hsh['n'].first).must_be_kind_of String
+      expect(hsh['n'].first).must_match(/^n/)
+    end
+
+    it "must grep for charizard" do
+      ary = Names::Pokemon.grep(/^char/, all: true)
+      expect(ary).must_include 'charizard'
+      char = Names::Pokemon.grep(/^char/, all: false)
+      expect(char).wont_equal 'charizard'
+      expect(char).must_equal 'charmander'
+    end
+
+    it "must convert vals to key letters" do
+      [5, '5', 'food', 'Food'].each { |valid|
+        expect(Names::Pokemon.key(valid)).must_equal 'f'
+      }
+
+      ['---', Names::Pokemon].each { |invalid_raise|
+        expect(proc { Names::Pokemon.key(invalid_raise) }).must_raise Exception
+      }
+
+      [4359873548].each { |invalid_nil|
+        expect(Names::Pokemon.key(invalid_nil).nil?).must_equal true
+      }
     end
   end
 end