stamina 0.3.0

data/test/stamina/induction/redblue_universal_expected.adl

@@ -0,0 +1,4 @@
+1 2
+0 true true
+0 0 a
+0 0 b

data/test/stamina/induction/redblue_universal_sample.adl

@@ -0,0 +1,5 @@
++
++ a b b 
++ a
++ a a a a a
++ a a a

data/test/stamina/induction/rpni_inria_expected.adl

@@ -0,0 +1,7 @@
+2 4
+0 true true
+1 false false
+0 0 a
+0 1 b
+1 1 a
+1 0 b

data/test/stamina/induction/rpni_inria_sample.adl

@@ -0,0 +1,9 @@
++
++ a
++ b b
++ b b a
++ b a a b
++ b a a a b a
+- b
+- a b
+- a b a

data/test/stamina/induction/rpni_test.rb

@@ -0,0 +1,129 @@
+require File.join(File.dirname(__FILE__), "induction_test")
+module Stamina
+  module Induction
+    class RPNITest < Stamina::Induction::InductionTest
+      include Stamina::Induction::Commons
+      
+      # Factors a ready to be used RPNI instance with an initial UnionFind.
+      def rpni(ufds)
+        rpni = RPNI.new(:verbose => false)
+        rpni.instance_eval do
+          @ufds = ufds
+        end
+        rpni
+      end
+      
+      # Returns index-th state of the PTA
+      def s(index)
+        @pta.ith_state(index)
+      end
+      
+      def test_compatible_merge_and_determinize_without_determinize
+        rpni = rpni(factor_ufds)
+        assert_equal true, rpni.merge_and_determinize(0, 4)
+        assert_equal [0, 1, 2, 3, 0, 5, 6, 7, 8, 9], rpni.ufds.to_a
+      end
+      
+      def test_compatible_merge_and_determinize_with_one_determinize
+        rpni = rpni(factor_ufds)
+        assert_equal true, rpni.merge_and_determinize(2, 7)
+        assert_equal [0, 1, 2, 3, 4, 5, 6, 2, 5, 6], rpni.ufds.to_a
+      end
+      
+      def test_incompatible_merge_and_determinize_without_determinize
+        rpni = rpni(factor_ufds)
+        assert_equal false, rpni.merge_and_determinize(0, 1)
+        assert_equal [0, 0, 2, 3, 4, 5, 6, 7, 8, 9], rpni.ufds.to_a
+      end
+      
+      def test_incompatible_merge_and_determinize_with_two_determinize
+        rpni = rpni(factor_ufds)
+        assert_equal false, rpni.merge_and_determinize(5, 0)
+        assert_equal [0, 1, 2, 3, 4, 0, 6, 2, 0, 9], rpni.ufds.to_a
+      end
+      
+      def execution_step(rpni, i, j, success, expected=nil)
+        before = rpni.ufds.to_a
+        assert_equal success, rpni.successfull_merge_or_nothing(i, j)
+        if success
+          assert_equal(expected, rpni.ufds.to_a) if expected  
+        else
+          assert_equal before, rpni.ufds.to_a
+        end
+      end
+      
+      def test_step_by_step_whole_execution
+        rpni = rpni(factor_ufds)
+        execution_step(rpni,1,0,false)
+        execution_step(rpni,2,0,true,[0, 1, 0, 3, 4, 1, 0, 4, 8, 9])
+        execution_step(rpni,3,0,false)
+        execution_step(rpni,3,1,true,[0, 1, 0, 1, 4, 1, 0, 4, 8, 9])
+        execution_step(rpni,4,0,true,[0, 1, 0, 1, 0, 1, 0, 0, 1, 0])
+        
+        ufds = factor_ufds
+        rpni = rpni(ufds)
+        assert_equal [0, 1, 0, 1, 0, 1, 0, 0, 1, 0], rpni.main(ufds).to_a
+      end
+      
+      def test_main_whole_execution
+        ufds = factor_ufds
+        rpni = rpni(ufds)
+        assert_equal [0, 1, 0, 1, 0, 1, 0, 0, 1, 0], rpni.main(ufds).to_a
+      end
+      
+      def test_execute_whole_execution
+        expected = Stamina::ADL.parse_automaton <<-EOF
+          2 4
+          0 true true
+          1 false false
+          0 0 b
+          0 1 a
+          1 0 b
+          1 1 a
+        EOF
+        dfa = RPNI.execute(@sample)
+        assert_equal true, @sample.correctly_classified_by?(dfa)
+        assert_equal @sample.signature, dfa.signature(@sample)
+        assert_nil equivalent?(expected, dfa)
+      end
+      
+      def test_on_dedicated_examples
+        here = File.dirname(__FILE__)
+        Dir["#{here}/rpni_*_sample.adl"].each do |sample_file|
+          name = (/^rpni_(.*?)_sample.adl$/.match(File.basename(sample_file)))[1]
+          sample = Stamina::ADL.parse_sample_file(sample_file)
+          expected = Stamina::ADL.parse_automaton_file(File.join(here, "rpni_#{name}_expected.adl"))
+          assert sample.correctly_classified_by?(expected)
+          dfa = RPNI.execute(sample)
+          assert sample.correctly_classified_by?(dfa)
+          assert_equal sample.signature, dfa.signature(sample)
+          assert_nil equivalent?(expected, dfa)
+        end
+      end
+      
+      # Tests on characteristic sample
+      def test_on_public_characteristic_example
+        example_folder = File.join(File.dirname(__FILE__), '..', '..', '..', 'example', 'basic')
+        sample = Stamina::ADL.parse_sample_file(File.join(example_folder, 'characteristic_sample.adl'))
+        rpnied = Stamina::Induction::RPNI.execute(sample)
+        assert_equal 4, rpnied.state_count
+        s0, = rpnied.initial_state
+        s1 = rpnied.dfa_step(s0, 'b')
+        s2 = rpnied.dfa_step(s0, 'a')
+        s3 = rpnied.dfa_step(s2, 'b')
+        assert_equal true, s0.accepting?
+        assert_equal true, s3.accepting?
+        assert_equal false, s1.accepting?
+        assert_equal false, s2.accepting?
+        assert_equal s1, s1.dfa_step('a')
+        assert_equal s1, s1.dfa_step('b')
+        assert_equal s2, s2.dfa_step('a')
+        assert_equal s3, s2.dfa_step('b')
+        assert_equal s3, s3.dfa_step('b')
+        assert_equal s0, s3.dfa_step('a')
+        assert_equal sample.signature, rpnied.signature(sample)
+      end
+      
+    end
+  end
+end

data/test/stamina/induction/rpni_test_pta.dot

@@ -0,0 +1,22 @@
+digraph G {
+  graph [rankdir="LR"];
+  0 [color="green" shape="doublecircle" style="filled"];
+  1 [color="red" shape="circle" style="filled"];
+  2 [color="black" shape="circle" style="filled" fillcolor="white"];
+  3 [color="red" shape="circle" style="filled"];
+  4 [color="black" shape="doublecircle" style="filled"  fillcolor="white"];
+  5 [color="black" shape="circle" style="filled"  fillcolor="white"];
+  6 [color="black" shape="doublecircle" style="filled" fillcolor="white"];
+  7 [color="black" shape="circle" style="filled" fillcolor="white"];
+  8 [color="red" shape="circle" style="filled"];
+  9 [color="black" shape="doublecircle" style="filled" fillcolor="white"];
+  0 -> 1 [label="a"];
+  1 -> 3 [label="a"];
+  1 -> 4 [label="b"];
+  0 -> 2 [label="b"];
+  2 -> 5 [label="a"];
+  5 -> 7 [label="b"];
+  7 -> 8 [label="a"];
+  7 -> 9 [label="b"];
+  2 -> 6 [label="b"];
+}

data/test/stamina/induction/rpni_universal_expected.adl

@@ -0,0 +1,4 @@
+1 2
+0 true true
+0 0 a
+0 0 b

data/test/stamina/induction/rpni_universal_sample.adl

@@ -0,0 +1,4 @@
++ a b b a b a a a a a a
++ a b b a b a a a a a a a a a a
+
+

data/test/stamina/induction/union_find_test.rb

@@ -0,0 +1,124 @@
+require 'test/unit'
+require 'stamina/induction/union_find'
+module Stamina
+  module Induction
+    class UnionFindTest < Test::Unit::TestCase
+      
+      def assert_whole_find_is(expected, ufds)
+        0.upto(expected.size-1) do |i|
+          assert_equal expected[i], ufds.find(i)
+        end
+      end
+      
+      def test_initially
+        ufds = UnionFind.new(5)
+        assert_equal 5, ufds.size
+        0.upto(ufds.size-1) do |i|
+          assert_equal i, ufds.find(i)
+          assert_equal true, ufds.leader?(i)
+        end
+      end
+      
+      def test_one_union
+        ufds = UnionFind.new(5)
+        ufds.union(3,0)
+        assert_whole_find_is [0, 1, 2, 0, 4], ufds
+        assert_equal true, ufds.leader?(0)
+        assert_equal false, ufds.leader?(3)
+
+        ufds = UnionFind.new(5)
+        ufds.union(0,3)
+        assert_whole_find_is [0, 1, 2, 0, 4], ufds
+      end
+      
+      def test_two_unions
+        ufds = UnionFind.new(5)
+        ufds.union(3,0)
+        ufds.union(4,3)
+        assert_whole_find_is [0, 1, 2, 0, 0], ufds
+        assert_equal true, ufds.leader?(0)
+        assert_equal false, ufds.leader?(3)
+        assert_equal false, ufds.leader?(4)
+      end
+
+      def test_three_unions
+        ufds = UnionFind.new(5)
+        ufds.union(3,0)
+        ufds.union(1,2)
+        ufds.union(2,4)
+        assert_equal true, ufds.leader?(0)
+        assert_equal true, ufds.leader?(1)
+        assert_equal false, ufds.leader?(2)
+        assert_equal false, ufds.leader?(3)
+        assert_equal false, ufds.leader?(4)
+      end
+      
+      def test_union_supports_identity_union
+        ufds = UnionFind.new(5)
+        ufds.union(0,0)
+        assert_whole_find_is [0, 1, 2, 3, 4], ufds
+        ufds.union(1,0)
+        assert_whole_find_is [0, 0, 2, 3, 4], ufds
+        ufds.union(1,0)
+        assert_whole_find_is [0, 0, 2, 3, 4], ufds
+        ufds.union(0,1)
+        assert_whole_find_is [0, 0, 2, 3, 4], ufds
+      end
+      
+      def test_dup
+        ufds = UnionFind.new(5)
+        ufds.union(3,0)
+        copy = ufds.dup
+        (0...5).each {|i| assert_equal ufds.find(i), copy.find(i)}
+        copy.union(4,3)
+        assert_equal 0, copy.find(4)
+        assert_equal 4, ufds.find(4)
+      end
+      
+      def test_transactional_support
+        ufds = UnionFind.new(5)
+        ufds.save_point
+        ufds.union(3,0)
+        assert_whole_find_is [0, 1, 2, 0, 4], ufds
+        ufds.commit
+        assert_whole_find_is [0, 1, 2, 0, 4], ufds
+        ufds.save_point
+        ufds.union(4,3)
+        assert_whole_find_is [0, 1, 2, 0, 0], ufds
+        ufds.rollback
+        assert_whole_find_is [0, 1, 2, 0, 4], ufds
+      end
+      
+      def test_validity_of_rdoc_example
+        # create a union-find for 10 elements
+        ufds = Stamina::Induction::UnionFind.new(10) do |index|
+          # each element will be associated with a hash with data of interest:
+          # smallest element, greatest element and concatenation of names
+          {:smallest => index, :greatest => index, :names => index.to_s}
+        end
+    
+        # each element is its own leader
+        assert_equal true, (0...10).all?{|s| ufds.leader?(s)}
+        assert_equal false, (0...10).all?{|s| ufds.slave?(s)}
+    
+        # and their respective group number are the element indices themselve
+        assert_equal [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], ufds.to_a
+    
+        # now, let merge 4 with 0
+        ufds.union(0, 4) do |d0, d4|
+          {:smallest => d0[:smallest] < d4[:smallest] ? d0[:smallest] : d4[:smallest],
+           :greatest => d0[:smallest] > d4[:smallest] ? d0[:smallest] : d4[:smallest],
+           :names => d0[:names] + " " + d4[:names]}
+        end
+    
+        # let see what happens on group numbers
+        assert_equal [0, 1, 2, 3, 0, 5, 6, 7, 8, 9], ufds.to_a
+    
+        # let now have a look on mergeable_data of the group of 0 (same result for 4)
+        expected = {:smallest => 0, :greatest => 4, :names => "0 4"}
+        assert_equal expected, ufds.mergeable_data(0)
+      end
+      
+    end
+  end
+end

data/test/stamina/input_string_test.rb

@@ -0,0 +1,323 @@
+require 'test/unit'
+require 'stamina/input_string'
+module Stamina
+  
+# Tests InputString class
+class InputStringTest < Test::Unit::TestCase
+  
+  # Tests on empty string
+  def test_on_empty_string
+    # with empty array of symbols, positively labeled
+    s = InputString.new([], true)
+    assert_equal(0, s.size)
+    assert_equal(true, s.empty?)
+    assert_equal(true, s.lambda?)
+    assert_equal([], s.symbols)
+    assert_equal(true, s.symbols.frozen?)
+    assert_equal(true, s.positive?)
+    assert_equal(false, s.negative?)
+    assert_equal(false, s.unlabeled?)
+    assert_equal(true, s.label)
+    
+    # with empty array of symbols, negatively labeled
+    s = InputString.new([], false)
+    assert_equal(0, s.size)
+    assert_equal(true, s.empty?)
+    assert_equal(true, s.lambda?)
+    assert_equal([], s.symbols)
+    assert_equal(true, s.symbols.frozen?)
+    assert_equal(false, s.positive?)
+    assert_equal(true, s.negative?)
+    assert_equal(false, s.unlabeled?)
+    assert_equal(false, s.label)
+    
+    # with empty array of symbols, unlabeled
+    s = InputString.new([], nil)
+    assert_equal(0, s.size)
+    assert_equal(true, s.empty?)
+    assert_equal(true, s.lambda?)
+    assert_equal([], s.symbols)
+    assert_equal(true, s.symbols.frozen?)
+    assert_equal(false, s.positive?)
+    assert_equal(false, s.negative?)
+    assert_equal(true, s.unlabeled?)
+    assert_equal(nil, s.label)
+    
+    # with empty string, positively labeled
+    s = InputString.new('', true)
+    assert_equal(0, s.size)
+    assert_equal(true, s.lambda?)
+    assert_equal(true, s.empty?)
+    assert_equal([], s.symbols)
+    assert_equal(true, s.symbols.frozen?)
+    assert_equal(true, s.positive?)
+    assert_equal(false, s.negative?)
+    assert_equal(false, s.unlabeled?)
+    
+    # with empty string, negatively labeled
+    s = InputString.new('', false)
+    assert_equal(0, s.size)
+    assert_equal(true, s.lambda?)
+    assert_equal(true, s.empty?)
+    assert_equal([], s.symbols)
+    assert_equal(true, s.symbols.frozen?)
+    assert_equal(false, s.positive?)
+    assert_equal(true, s.negative?)
+    assert_equal(false, s.unlabeled?)
+    
+    # with empty string, unlabeled
+    s = InputString.new('', nil)
+    assert_equal(0, s.size)
+    assert_equal(true, s.lambda?)
+    assert_equal(true, s.empty?)
+    assert_equal([], s.symbols)
+    assert_equal(true, s.symbols.frozen?)
+    assert_equal(false, s.positive?)
+    assert_equal(false, s.negative?)
+    assert_equal(true, s.unlabeled?)
+
+    # with empty string with trailing whitespaces, positively labeled
+    s = InputString.new("   ", true)
+    assert_equal(0, s.size)
+    assert_equal(true, s.lambda?)
+    assert_equal(true, s.empty?)
+    assert_equal([], s.symbols)
+    assert_equal(true, s.symbols.frozen?)
+    assert_equal(true, s.positive?)
+    assert_equal(false, s.negative?)
+    assert_equal(false, s.unlabeled?)
+    
+    # with empty string with trailing whitespaces, negatively labeled
+    s = InputString.new("  ", false)
+    assert_equal(0, s.size)
+    assert_equal(true, s.lambda?)
+    assert_equal(true, s.empty?)
+    assert_equal([], s.symbols)
+    assert_equal(true, s.symbols.frozen?)
+    assert_equal(false, s.positive?)
+    assert_equal(true, s.negative?)
+    assert_equal(false, s.unlabeled?)
+    
+    # with empty string with trailing whitespaces, unlabeled
+    s = InputString.new("  ", nil)
+    assert_equal(0, s.size)
+    assert_equal(true, s.lambda?)
+    assert_equal(true, s.empty?)
+    assert_equal([], s.symbols)
+    assert_equal(true, s.symbols.frozen?)
+    assert_equal(false, s.positive?)
+    assert_equal(false, s.negative?)
+    assert_equal(true, s.unlabeled?)
+
+    # with empty string with trailing whitespaces, negatively labeled
+    s = InputString.new(" \n  \t \t\n ", false)
+    assert_equal(0, s.size)
+    assert_equal(true, s.empty?)
+    assert_equal([], s.symbols)
+  end
+  
+  # Tests with a string of only one character
+  def test_on_one_character_string
+    # with array of symbols, positively labeled
+    s = InputString.new(['a'], true)
+    assert_equal(1, s.size)
+    assert_equal(false, s.empty?)
+    assert_equal(false, s.lambda?)
+    assert_equal(['a'], s.symbols)
+    assert_equal(true, s.symbols.frozen?)
+    assert_equal(true, s.positive?)
+    assert_equal(false, s.negative?)
+    assert_equal(false, s.unlabeled?)
+    assert_equal(true, s.label)
+    
+    # with empty array of symbols, negatively labeled
+    s = InputString.new(['a'], false)
+    assert_equal(1, s.size)
+    assert_equal(false, s.empty?)
+    assert_equal(['a'], s.symbols)
+    assert_equal(true, s.symbols.frozen?)
+    assert_equal(false, s.positive?)
+    assert_equal(true, s.negative?)
+    assert_equal(false, s.label)
+    
+    # with empty array of symbols, unlabeled
+    s = InputString.new(['a'], nil)
+    assert_equal(1, s.size)
+    assert_equal(false, s.empty?)
+    assert_equal(['a'], s.symbols)
+    assert_equal(true, s.symbols.frozen?)
+    assert_equal(false, s.positive?)
+    assert_equal(false, s.negative?)
+    assert_equal(true, s.unlabeled?)
+    assert_equal(nil, s.label)
+    
+    # with empty string, positively labeled
+    s = InputString.new('a', true)
+    assert_equal(1, s.size)
+    assert_equal(false, s.empty?)
+    assert_equal(['a'], s.symbols)
+    assert_equal(true, s.symbols.frozen?)
+    assert_equal(true, s.positive?)
+    assert_equal(false, s.negative?)
+    
+    # with empty string, negatively labeled
+    s = InputString.new('a', false)
+    assert_equal(1, s.size)
+    assert_equal(false, s.empty?)
+    assert_equal(['a'], s.symbols)
+    assert_equal(true, s.symbols.frozen?)
+    assert_equal(false, s.positive?)
+    assert_equal(true, s.negative?)
+
+    # with empty string with trailing whitespaces, positively labeled
+    s = InputString.new("a  ", true)
+    assert_equal(1, s.size)
+    assert_equal(false, s.empty?)
+    assert_equal(['a'], s.symbols)
+
+    # with empty string with trailing whitespaces, positively labeled
+    s = InputString.new("  a", true)
+    assert_equal(1, s.size)
+    assert_equal(false, s.empty?)
+    assert_equal(['a'], s.symbols)
+
+    # with empty string with trailing whitespaces, positively labeled
+    s = InputString.new("  \na  \t \n", true)
+    assert_equal(1, s.size)
+    assert_equal(false, s.empty?)
+    assert_equal(['a'], s.symbols)
+  end
+  
+  def test_negate
+    assert_equal InputString.new([], true), InputString.new([], false).negate 
+    assert_equal InputString.new([], false), InputString.new([], true).negate 
+    assert_equal InputString.new([], nil), InputString.new([], nil).negate 
+    assert_equal InputString.new(['a'], true), InputString.new(['a'], false).negate 
+    assert_equal InputString.new(['a'], false), InputString.new(['a'], true).negate 
+    assert_equal InputString.new(['a'], nil), InputString.new(['a'], nil).negate 
+  end
+  
+  # Tests on a small size string.
+  def test_on_small_size_string
+    s = InputString.new(['a', 'b', 'c', 'a'], true)
+    assert_equal(false, s.empty?)
+    assert_equal(4, s.size)
+    assert_equal(['a', 'b', 'c', 'a'], s.symbols)
+    assert_equal(true, s.positive?)
+
+    s = InputString.new('a b c a', false)
+    assert_equal(false, s.empty?)
+    assert_equal(4, s.size)
+    assert_equal(['a', 'b', 'c', 'a'], s.symbols)
+    assert_equal(false, s.positive?)
+
+    s = InputString.new('a b c a', nil)
+    assert_equal(false, s.empty?)
+    assert_equal(4, s.size)
+    assert_equal(['a', 'b', 'c', 'a'], s.symbols)
+    assert_equal(true, s.unlabeled?)
+
+    s = InputString.new('a b c a', false)
+    assert_equal(false, s.empty?)
+    assert_equal(4, s.size)
+    assert_equal(['a', 'b', 'c', 'a'], s.symbols)
+
+    s = InputString.new("  a b   c a\t", true)
+    assert_equal(false, s.empty?)
+    assert_equal(4, s.size)
+    assert_equal(['a', 'b', 'c', 'a'], s.symbols)
+  end
+  
+  # Tests that s.symbols.dup returns a modifiable array
+  def test_symbols_duplication_may_be_modified
+    s = InputString.new([''], true)
+    assert_equal(false, s.symbols.dup.frozen?)
+    
+    s = InputString.new(['a' 'b' 'c' 'a'], true)
+    assert_equal(false, s.symbols.dup.frozen?)
+    
+    s = InputString.new('', true)
+    assert_equal(false, s.symbols.dup.frozen?)
+    
+    s = InputString.new('a b c a', true)
+    assert_equal(false, s.symbols.dup.frozen?)
+  end
+  
+  # Tests InputString#==
+  def test_equality
+    s = InputString.new([], true)
+    assert_equal(s, InputString.new([], true))
+    assert_equal(s, InputString.new('', true))
+    assert_equal(s, InputString.new(' ', true))
+    assert_not_equal(s, InputString.new([], false))
+    assert_not_equal(s, InputString.new(['a'], false))
+    assert_not_equal(s, InputString.new([], nil))
+
+    s = InputString.new([], false)
+    assert_equal(s, InputString.new([], false))
+    assert_equal(s, InputString.new('', false))
+    assert_equal(s, InputString.new(' ', false))
+    assert_not_equal(s, InputString.new([], true))
+    assert_not_equal(s, InputString.new(['a'], true))
+    assert_not_equal(s, InputString.new([], nil))
+
+    s = InputString.new([], nil)
+    assert_equal(s, InputString.new([], nil))
+    assert_equal(s, InputString.new('', nil))
+    assert_not_equal(s, InputString.new([], true))
+    assert_not_equal(s, InputString.new(['a'], true))
+    assert_not_equal(s, InputString.new([], false))
+    assert_not_equal(s, InputString.new(['a'], false))
+      
+    s = InputString.new('a b a b', true)
+    assert_equal(s, InputString.new("a b \n a b", true))
+    assert_equal(s, InputString.new(['a', 'b', 'a', 'b'], true))
+    assert_not_equal(s, InputString.new(['a', 'b', 'a', 'b'], false))
+    assert_not_equal(s, InputString.new(['a', 'b', 'a'], true))
+    assert_not_equal(s, InputString.new([], true))
+  end
+  
+  def test_equality_2
+    assert InputString.new('+', true)==InputString.new('+', true)
+    assert InputString.new('+ a b', true)==InputString.new('+ a b', true)
+    
+    strings = [InputString.new('+', true), InputString.new('+', true)]
+    assert_equal 1, strings.uniq.size
+  end
+  
+  # Tests that input string accept other objects than strings as symbols
+  def test_input_string_accept_any_symbol_object
+    s = InputString.new([1, 2], true)
+    assert_equal(2, s.size)
+    assert_equal([1, 2], s.symbols)
+  end
+  
+  def test_input_string_may_be_used_as_hash_key
+    str = InputString.new('a b a b', true)
+    neg = InputString.new('a b a b', false)
+    unl = InputString.new('a b a b', nil)
+    h = {}
+    h[str] = 1
+    assert h.has_key?(str)
+    assert_equal 1, h[str]
+    assert !h.has_key?(neg)
+    assert !h.has_key?(unl)
+    h[neg] = 2
+    assert h.has_key?(str)
+    assert_equal 1, h[str]
+    assert h.has_key?(neg)
+    assert_equal 2, h[neg]
+    assert !h.has_key?(unl)
+    h[unl] = 3
+    assert h.has_key?(str)
+    assert_equal 1, h[str]
+    assert h.has_key?(neg)
+    assert_equal 2, h[neg]
+    assert h.has_key?(unl)
+    assert_equal 3, h[unl]
+  end
+  
+end # class InputStringTest
+
+end # module Stamina
+