compsci 0.3.0.1 → 0.3.1.1

data/test/node.rb

@@ -1,4 +1,5 @@
 require 'compsci/node'
+require 'compsci/names'
 require 'minitest/autorun'
 
 include CompSci
@@ -10,14 +11,32 @@ describe Node do
     @emilio_estevez = Node.new 'emilio'
   end
 
+  it "must display_line" do
+    nodes = [@martin_sheen, @charlie_sheen, @emilio_estevez]
+    str = Node.display_line nodes: nodes, width: 80
+    # TODO: it was 78 once.  Why < 80?
+    expect(str.size).must_be :>=, 78  # it might overflow
+
+    str = Node.display_line nodes: nodes, width: 200
+    expect(str.size).must_be :>=, 198   # it won't overflow
+  end
+
+
   it "must start with no children" do
     [@martin_sheen, @charlie_sheen, @emilio_estevez].each { |n|
-      n.children.must_be_empty
+      expect(n.children.compact).must_be_empty
     }
   end
 
   it "must not respond to :parent" do
-    @martin_sheen.respond_to?(:parent).must_equal false
+    expect(@martin_sheen.respond_to?(:parent)).must_equal false
+  end
+
+  it "must create a tree by adding children" do
+    @martin_sheen[0] = @charlie_sheen
+    @martin_sheen[1] = @emilio_estevez
+    expect(@martin_sheen.children).must_include @charlie_sheen
+    expect(@martin_sheen.children).must_include @emilio_estevez
   end
 end
 
@@ -30,42 +49,142 @@ describe KeyNode do
 
   it "must start with no children" do
     [@martin_sheen, @charlie_sheen, @emilio_estevez].each { |n|
-      n.children.must_be_empty
+      expect(n.children.compact).must_be_empty
     }
   end
 
   it "must not respond to :parent" do
-    @martin_sheen.respond_to?(:parent).must_equal false
+    expect(@martin_sheen.respond_to?(:parent)).must_equal false
   end
 
   it "must have a key" do
-    @martin_sheen.key.must_equal 'marty'
-    @charlie_sheen.key.must_equal 'charles'
-    @emilio_estevez.key.must_equal 'emile'
-  end
-end
-
-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)
-    @martin_sheen.children.must_include @charlie_sheen
-
-    @martin_sheen.children.wont_include @emilio_estevez
-    @martin_sheen.add_child @emilio_estevez
-    @martin_sheen.children.must_include @emilio_estevez
-  end
-
-  it "must create children from scalars" do
-    @martin_sheen.new_child 'fake_emilio'
-    @martin_sheen.children.size.must_equal 1
-    @martin_sheen.children.first.value.must_equal 'fake_emilio'
-    @martin_sheen.children.wont_include @emilio_estevez
+    expect(@martin_sheen.key).must_equal 'marty'
+    expect(@charlie_sheen.key).must_equal 'charles'
+    expect(@emilio_estevez.key).must_equal 'emile'
+  end
+
+  describe "KeyNode.key_cmp_idx" do
+    it "must handle 2 or 3 child_slots" do
+      c2 = {
+        [1,2]  => 0,
+        [1,10] => 0,
+        [2,2]  => :raise,
+        [3,2]  => 1,
+        [10,2] => 1,
+      }
+      c3 = {
+        [1,2] => 0,
+        [1,10] => 0,
+        [2,2] => 1,
+        [3,2] => 2,
+        [10,2] => 2,
+      }
+
+      c2.each { |(new_key, key), expected|
+        if expected == :raise
+          expect(proc {
+            KeyNode.key_cmp_idx(new_key, key)
+          }).must_raise KeyNode::DuplicateKey
+        else
+          expect(KeyNode.key_cmp_idx(new_key, key)).must_equal expected
+        end
+      }
+
+      c3.each { |(new_key, key), expected|
+        expect(KeyNode.key_cmp_idx(new_key, key,
+                                   child_slots: 3)).must_equal expected
+      }
+    end
+  end
+
+  describe "Binary Search Tree" do
+    before do
+      @keys = Array.new(4) { |i| Names::WW2[i] }
+      @values = Array.new(4) { Names::SOLAR.sample }
+      @root = KeyNode.new(@values[0], key: @keys[0], children: 2)
+      1.upto(@keys.size - 1) { |i| @root.insert(@keys[i], @values[i]) }
+
+      # tree looks like:
+      # A:val1
+      #  B:val2
+      #   C:val3
+      #    D:val4
+    end
+
+    it "must link to inserted nodes" do
+      expect(@root.children).wont_be_empty
+      expect(@root.children[0]).must_be_nil
+      c1 = @root.children[1]
+      expect(c1).wont_be_nil
+      expect(c1.key).must_equal @keys[1]
+      expect(c1.children[0]).must_be_nil
+      cc1 = c1.children[1]
+      expect(cc1).wont_be_nil
+      expect(cc1.value).must_equal @values[2]
+      expect(cc1.children[0]).must_be_nil
+      ccc1 = cc1.children[1]
+      expect(ccc1).wont_be_nil
+      expect(ccc1.key).must_equal @keys[3]
+      expect(ccc1.value).must_equal @values[3]
+    end
+
+    it "must search nodes" do
+      node = nil
+      new_order = (0..9).to_a.shuffle
+      new_order.each { |i|
+        k, v = Names::NATO[i], Names::SOLAR.sample
+        if node.nil?
+          node = KeyNode.new(v, key: k, children: 2)
+        else
+          node.insert(k, v)
+        end
+      }
+
+      3.times {
+        key = Names::NATO[new_order.sample]
+        found = node.search key
+        expect(found).wont_be_nil
+        expect(found.key).must_equal key
+      }
+
+      expect(node.search(Names::SOLAR.sample)).must_be_nil
+    end
+
+    it "must accept or reject duplicates" do
+      expect(proc {
+               @root.insert(@keys[0], @values.sample)
+             }).must_raise KeyNode::DuplicateKey
+
+      node = KeyNode.new(@values[0], key: @keys[0], duplicates: true)
+      child = node.insert(@keys[0], @values[0])
+      expect(child).must_be_kind_of KeyNode
+      expect(node.children[1]).must_equal child
+      expect(node.children[0]).must_be_nil
+    end
+  end
+
+  describe "Ternary Search Tree" do
+    before do
+      @keys = Array.new(4) { |i| Names::NATO[i] }
+      @values = Array.new(4) { Names::SOLAR.sample }
+      @root = KeyNode.new(@values[0], key: @keys[0], children: 3)
+      1.upto(@keys.size - 1) { |i| @root.insert(@keys[i], @values[i]) }
+
+      # tree looks like:
+      # A:val1
+      #  B:val2
+      #   C:val3
+      #    D:val4
+    end
+
+    it "must insert a duplicate as the middle child" do
+      node3 = KeyNode.new(@values[0], key: @keys[0], children: 3)
+      child = node3.insert(@keys[0], @values[0])
+      expect(child).must_be_kind_of KeyNode
+      expect(node3.children[1]).must_equal child
+      expect(node3.children[0]).must_be_nil
+      expect(node3.children[2]).must_be_nil
+    end
   end
 end
 
@@ -78,63 +197,36 @@ describe ChildNode do
 
   it "must start with neither parent nor children" do
     [@martin_sheen, @charlie_sheen, @emilio_estevez].each { |n|
-      n.parent.nil?.must_equal true
-      n.children.must_be_empty
+      expect(n.parent).must_be_nil
+      expect(n.children.compact).must_be_empty
     }
   end
 
   it "must track parent and children" do
-    @charlie_sheen.set_parent(0, @martin_sheen)
-    @charlie_sheen.parent.must_equal @martin_sheen
-    @martin_sheen.children.must_include @charlie_sheen
-
-    @martin_sheen.children.wont_include @emilio_estevez
-    @martin_sheen.set_child(0, @emilio_estevez)
-    @martin_sheen.children.must_include @emilio_estevez
-    @emilio_estevez.parent.must_equal @martin_sheen
-  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)
-    @charlie_sheen.parent.must_equal @martin_sheen
-    @martin_sheen.children.must_include @charlie_sheen
-
-    @martin_sheen.children.wont_include @emilio_estevez
-    @martin_sheen.add_child @emilio_estevez
-    @martin_sheen.children.must_include @emilio_estevez
-    @emilio_estevez.parent.must_equal @martin_sheen
-  end
-
-  it "must determine a node's generation" do
-    @emilio_estevez.gen.must_equal 0
-    @martin_sheen.add_child @emilio_estevez
-    @emilio_estevez.gen.must_equal 1
-  end
-
-  it "must create children from scalars" do
-    @martin_sheen.new_child 'fake_emilio'
-    @martin_sheen.children.size.must_equal 1
-    @martin_sheen.children.first.value.must_equal 'fake_emilio'
-    @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'
-
-    @charlie_sheen.siblings.must_include @emilio_estevez
-    @charlie_sheen.siblings.wont_include @martin_sheen
-    @emilio_estevez.siblings.must_include @charlie_sheen
-    @martin_sheen.siblings.must_be_empty
-    @emilio_estevez.siblings.find { |n| n.value == 'fake_emilio' }.wont_be_nil
+    @martin_sheen[0] = @charlie_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[1] = @emilio_estevez
+    expect(@emilio_estevez.parent).must_equal @martin_sheen
+    expect(@martin_sheen.children).must_include @emilio_estevez
+    expect(@martin_sheen.children).must_include @charlie_sheen
+  end
+
+  it "must track siblings" do
+    @martin_sheen[0] = @charlie_sheen
+    @martin_sheen[1] = @emilio_estevez
+    expect(@charlie_sheen.siblings).must_include @emilio_estevez
+    # TODO: should siblings not include self?
+    # expect(@charlie_sheen.siblings).wont_include @charlie_sheen
+    expect(@charlie_sheen.siblings).must_include @charlie_sheen
+  end
+
+  it "must track generation" do
+    @martin_sheen[0] = @charlie_sheen
+    expect(@charlie_sheen.gen).must_equal 1
+    @charlie_sheen[0] = @emilio_estevez # kinky!
+    expect(@emilio_estevez.gen).must_equal 2
   end
 end

data/test/simplex_parse.rb

@@ -12,13 +12,13 @@ describe Simplex::Parse do
         "99x"   => [99.0, :x],
         "z"     => [ 1.0, :z],
         "-b"    => [-1.0, :b] }.each { |valid, expected|
-        P.term(valid).must_equal expected
+        expect(P.term(valid)).must_equal expected
       }
     end
 
     it "must reject invalid terms" do
       ["3xy", "24/7x", "x17", "2*x"].each { |invalid|
-        proc { P.term(invalid) }.must_raise RuntimeError
+        expect(proc { P.term(invalid) }).must_raise RuntimeError
       }
     end
   end
@@ -32,7 +32,7 @@ describe Simplex::Parse do
         "a - -b"            => { a:  1.0, b:  1.0 },
         "a A b"             => { a:  1.0, :A => 1.0, b: 1.0 },
       }.each { |valid, expected|
-        P.expression(valid).must_equal expected
+        expect(P.expression(valid)).must_equal expected
       }
     end
 
@@ -40,18 +40,18 @@ describe Simplex::Parse do
       ["a2 + b2 = c2",
        "x + xy",
        "x * 2"].each { |invalid|
-        proc { P.expression(invalid) }.must_raise P::Error
+        expect(proc { P.expression(invalid) }).must_raise P::Error
       }
     end
   end
 
   describe "Parse.tokenize" do
     it "ignores leading or trailing whitespace" do
-      P.tokenize("  5x + 2.9y ").must_equal ["5x", "+", "2.9y"]
+      expect(P.tokenize("  5x + 2.9y ")).must_equal ["5x", "+", "2.9y"]
     end
 
     it "ignores multiple spaces" do
-      P.tokenize("5x   +   2.9y").must_equal ["5x", "+", "2.9y"]
+      expect(P.tokenize("5x   +   2.9y")).must_equal ["5x", "+", "2.9y"]
     end
   end
 
@@ -61,7 +61,7 @@ describe Simplex::Parse do
         "0.94a - 22.1b <= -14.67" => [{ a: 0.94, b: -22.1 }, -14.67],
         "x <= 0"                  => [{ x: 1.0 }, 0],
       }.each { |valid, expected|
-        P.inequality(valid).must_equal expected
+        expect(P.inequality(valid)).must_equal expected
       }
     end
 
@@ -70,25 +70,33 @@ describe Simplex::Parse do
        "0.94a - 22.1b <= -14.67c",
        "x < 0",
       ].each { |invalid|
-        proc { P.inequality(invalid) }.must_raise P::Error
+        expect(proc { P.inequality(invalid) }).must_raise P::Error
       }
     end
   end
 end
 
 describe "Simplex.maximize" do
-  it "must problem stuff" do
+  it "must solve a problem" do
     prob = Simplex.problem(maximize: 'x + y',
                            constraints: ['2x + y <= 4',
                                          'x + 2y <= 3'])
     sol = prob.solution
-    sol.must_equal [Rational(5, 3), Rational(2, 3)]
+    expect(sol).must_equal [Rational(5, 3), Rational(2, 3)]
   end
 
-  it "must maximize stuff" do
-    Simplex.maximize('x + y',
-                     '2x + y <= 4',
-                     'x + 2y <= 3').must_equal [Rational(5, 3),
-                                                Rational(2, 3)]
+  it "must maximize" do
+    expect(Simplex.maximize('x + y',
+                            '2x + y <= 4',
+                            'x + 2y <= 3')).must_equal [Rational(5, 3),
+                                                        Rational(2, 3)]
+  end
+
+  it "must reject bad expressions" do
+    expect(proc { Simplex.maximize(5) }).must_raise ArgumentError
+    expect(proc {
+             Simplex.maximize('5')
+           }).must_raise Simplex::Parse::InvalidTerm
+#    proc { Simplex.maximize('5x') }.must_raise Simplex::Parse::InvalidTerm
   end
 end

data/test/timer.rb

@@ -7,8 +7,8 @@ describe Timer do
   describe "elapsed" do
     it "must return the block value and positive number" do
       answer, elapsed = Timer.elapsed { sleep 0.01; :foo }
-      answer.must_equal :foo
-      elapsed.must_be_close_to 0.015, 0.005
+      expect(answer).must_equal :foo
+      expect(elapsed).must_be_close_to 0.015, 0.01
     end
   end
 
@@ -16,7 +16,7 @@ describe Timer do
     it "must be positive" do
       start = Timer.now
       sleep 0.01
-      Timer.since(start).must_be_close_to 0.015, 0.005
+      expect(Timer.since(start)).must_be_close_to 0.015, 0.01
     end
   end
 
@@ -27,9 +27,9 @@ describe Timer do
         sleep 0.01
         :foo
       }
-      answer.must_equal :foo
-      avg_et.must_be_close_to 0.01, 0.005
-      Timer.since(start).must_be_close_to 0.15, 0.05
+      expect(answer).must_equal :foo
+      expect(avg_et).must_be_close_to 0.01, 0.005
+      expect(Timer.since(start)).must_be_close_to 0.15, 0.05
     end
 
     it "must repeat short loops and stop on time" do
@@ -42,8 +42,8 @@ describe Timer do
       _answer, avg_et = Timer.loop_avg(count: 5) {
         sleep 0.01
       }
-      avg_et.must_be_close_to 0.015, 0.005
-      Timer.since(start).must_be_close_to 0.1, 0.05
+      expect(avg_et).must_be_close_to 0.015, 0.005
+      expect(Timer.since(start)).must_be_close_to 0.1, 0.05
     end
 
     it "must not interrupt long loops" do
@@ -51,8 +51,8 @@ describe Timer do
       _answer, avg_et = Timer.loop_avg(seconds: 0.01) {
         sleep 0.1
       }
-      Timer.since(start).must_be_close_to avg_et, 0.05
-      avg_et.must_be_close_to 0.15, 0.05
+      expect(Timer.since(start)).must_be_close_to avg_et, 0.05
+      expect(avg_et).must_be_close_to 0.15, 0.05
     end
   end
 end