stamina 0.3.0

data/test/stamina/automaton_to_dot_test.rb

@@ -0,0 +1,64 @@
+require 'test/unit'
+require 'stamina'
+module Stamina
+  module Utils
+    class DotTest < Test::Unit::TestCase
+    
+      def setup
+        @automaton = Automaton.new do |a|
+          add_state(:initial => true, :accepting => false)
+          add_state(:initial => false, :accepting => true)
+          add_state(:initial => false, :accepting => true, :error => true)
+          connect(0, 1, 'a')
+          connect(1, 0, 'b')
+          connect(1, 2, 'a')
+          connect(2, 2, nil)
+        end
+      end
+    
+      def test_attributes2dot
+        attrs = {:label => 'hello'}
+        assert_equal 'label="hello"', @automaton.send(:attributes2dot, attrs)
+        attrs = {:label => 'hello', :color => 'red'}
+        assert_equal 'color="red" label="hello"', @automaton.send(:attributes2dot, attrs)
+        attrs = {:label => 'O"Neil'}
+        assert_equal 'label="O\"Neil"', @automaton.send(:attributes2dot, attrs)
+      end
+    
+      def test_automaton_to_dot_with_default_rewriter
+        expected = <<-EOF
+          #digraph G {
+          #  graph [rankdir="LR"];
+          #  0 [color="black" fillcolor="green" shape="circle" style="filled"];
+          #  1 [color="black" fillcolor="white" shape="doublecircle" style="filled"];
+          #  2 [color="black" fillcolor="red" shape="doublecircle" style="filled"];
+          #  0 -> 1 [label="a"];
+          #  1 -> 0 [label="b"];
+          #  1 -> 2 [label="a"];
+          #  2 -> 2 [label=""];
+          #}
+        EOF
+        expected = expected.gsub(/^\s+#/,'')
+        assert_equal expected, @automaton.to_dot
+      end
+    
+      def test_automaton_with_specific_rewriter
+        expected = <<-EOF
+          #digraph G {
+          #  graph [];
+          #  0 [accepting="false" initial="true"];
+          #  1 [accepting="true" initial="false"];
+          #  2 [accepting="true" error="true" initial="false"];
+          #  0 -> 1 [symbol="a"];
+          #  1 -> 0 [symbol="b"];
+          #  1 -> 2 [symbol="a"];
+          #  2 -> 2 [symbol=""];
+          #}
+        EOF
+        expected = expected.gsub(/^\s+#/,'')
+        assert_equal expected, @automaton.to_dot {|elm,kind| elm.data}
+      end
+    
+    end
+  end
+end

data/test/stamina/automaton_walking_test.rb

@@ -0,0 +1,206 @@
+require 'test/unit'
+require 'stamina/stamina_test'
+module Stamina
+  class Automaton
+    # Tests Walking module on Automaton class
+    class WalkingTest < StaminaTest
+
+      # Tests Walking#step on examples
+      def test_step_on_examples
+        assert_equal([], @small_dfa.step(0, 'b'))
+        assert_equal(@small_dfa.ith_states(1), @small_dfa.step(0, 'a'))
+        assert_equal(@small_dfa.ith_states(1,3), @small_dfa.step([0,1], 'a').sort)
+        assert_equal(@small_dfa.ith_states(1), @small_dfa.step([0,2], 'a').sort)
+    
+        assert_equal([], @small_nfa.step(0, 'b'))
+        assert_equal(@small_nfa.ith_states(1), @small_nfa.step(0, 'a'))
+        assert_equal([], @small_nfa.step(2, 'b'))
+        assert_equal(@small_nfa.ith_states(2,3), @small_nfa.step(1, 'b').sort)
+        assert_equal(@small_nfa.ith_states(0,1), @small_nfa.step([0,3], 'a').sort)
+      end
+  
+      # Tests Walking#dfa_step on examples
+      def test_step_on_examples
+        assert_equal(nil, @small_dfa.dfa_step(0, 'b'))
+        assert_equal(@small_dfa.ith_state(1), @small_dfa.dfa_step(0, 'a'))
+        assert_equal(@small_dfa.ith_states(1), @small_dfa.dfa_step([0], 'a'))
+        assert_equal(@small_dfa.ith_states(1,3), @small_dfa.dfa_step([0,1], 'a').sort)
+        assert_equal(@small_dfa.ith_states(1), @small_dfa.dfa_step([0,2], 'a').sort)
+      end
+  
+      # Tests Walking#delta on examples
+      def test_delta_on_examples
+        assert_equal([], @small_dfa.delta(0, 'b'))
+        assert_equal(@small_dfa.ith_states(1), @small_dfa.delta(0, 'a'))
+        assert_equal(@small_dfa.ith_states(1,3), @small_dfa.delta([0,1], 'a').sort)
+        assert_equal(@small_dfa.ith_states(1), @small_dfa.delta([0,2], 'a').sort)
+    
+        assert_equal([], @small_nfa.delta(0, 'b'))
+        assert_equal(@small_nfa.ith_states(1), @small_nfa.delta(0, 'a'))
+        assert_equal(@small_nfa.ith_states(1,2,3), @small_nfa.delta(2, 'b').sort)
+        assert_equal(@small_nfa.ith_states(1,2,3), @small_nfa.delta(1, 'b').sort)
+        assert_equal(@small_nfa.ith_states(0,1), @small_nfa.delta([0,3], 'a').sort)
+      end
+  
+      # Tests Walking#dfa_delta on examples
+      def test_delta_on_examples
+        assert_equal(nil, @small_dfa.dfa_delta(0, 'b'))
+        assert_equal(@small_dfa.ith_state(1), @small_dfa.dfa_delta(0, 'a'))
+        assert_equal(@small_dfa.ith_states(1,3), @small_dfa.dfa_delta([0,1], 'a').sort)
+        assert_equal(@small_dfa.ith_states(1), @small_dfa.dfa_delta([0,2], 'a').sort)
+      end
+  
+      # Tests Walking#split on examples
+      def test_split_on_examples
+        assert_equal([[], @small_dfa.ith_states(3), []], @small_dfa.split('?'))
+        assert_equal([[], @small_dfa.ith_states(3), ['a']], @small_dfa.split('? a'))
+        assert_equal([['b'], @small_dfa.ith_states(2), []], @small_dfa.split('? b'))
+        assert_equal([['b'], @small_dfa.ith_states(2), ['a']], @small_dfa.split('? b a'))
+        assert_equal([['b','c'], @small_dfa.ith_states(0), []], @small_dfa.split('? b c'))
+      
+        assert_equal([[], @small_nfa.ith_states(0,3), []], @small_nfa.split('?'))
+        assert_equal([[], @small_nfa.ith_states(0,3), ['b']], @small_nfa.split('? b'))
+        assert_equal([['a'], @small_nfa.ith_states(0,1), []], @small_nfa.split('? a',nil,true))
+        assert_equal([['a'], @small_nfa.ith_states(0,1), ['c']], @small_nfa.split('? a c',nil,true))
+        assert_equal([['a','b'], @small_nfa.ith_states(1,2,3), []], @small_nfa.split('? a b',nil,true))
+      end
+  
+      # Tests Walking#dfa_split on examples
+      def test_split_on_examples
+        assert_equal([[], @small_dfa.ith_state(3), []], @small_dfa.dfa_split('?'))
+        assert_equal([[], @small_dfa.ith_state(3), ['a']], @small_dfa.dfa_split('? a'))
+        assert_equal([['b'], @small_dfa.ith_state(2), []], @small_dfa.dfa_split('? b'))
+        assert_equal([['b'], @small_dfa.ith_state(2), ['a']], @small_dfa.dfa_split('? b a'))
+        assert_equal([['b','c'], @small_dfa.ith_state(0), []], @small_dfa.dfa_split('? b c'))
+        assert_equal([['b','c'], @small_dfa.ith_states(0), []], @small_dfa.dfa_split('? b c',[3]))
+      end
+  
+      # Tests Walking#reached on examples 
+      def test_reached_on_examples
+        assert_equal([], @small_dfa.reached('? a a'))
+        assert_equal(@small_dfa.ith_states(2), @small_dfa.reached('? b'))
+        assert_equal(@small_dfa.ith_states(1), @small_dfa.reached('? b c a c'))
+        assert_equal(@small_dfa.ith_states(1), @small_dfa.reached('? a c', @small_dfa.ith_state(0)))
+        assert_equal(@small_dfa.ith_states(1), @small_dfa.reached('? a c',0))
+        assert_equal(@small_dfa.ith_states(1), @small_dfa.reached('? a',[0]))
+        assert_equal(@small_dfa.ith_states(1,3), @small_dfa.reached('? a',[0,1]))
+        assert_equal(@small_dfa.ith_states(2), @small_dfa.reached('? b',[3,1]))
+        assert_equal(@small_dfa.ith_states(2), @small_dfa.reached('? b',[0,3,1]))
+      
+        assert_equal(@small_nfa.ith_states(0,3), @small_nfa.reached('?').sort)
+        assert_equal(@small_nfa.ith_states(0,1), @small_nfa.reached('? a').sort)
+        assert_equal(@small_nfa.ith_states(1,2,3), @small_nfa.reached('? a b').sort)
+      end
+
+      # Tests Walking#dfa_reached on examples  
+      def test_dfa_reached_on_examples
+        assert_equal(nil, @small_dfa.dfa_reached('? a a'))
+        assert_equal(@small_dfa.ith_state(2), @small_dfa.dfa_reached('? b'))
+        assert_equal(@small_dfa.ith_state(1), @small_dfa.dfa_reached('? b c a c'))
+        assert_equal(@small_dfa.ith_state(1), @small_dfa.dfa_reached('? a c', @small_dfa.ith_state(0)))
+        assert_equal(@small_dfa.ith_state(1), @small_dfa.dfa_reached('? a c',0))
+        assert_equal(@small_dfa.ith_states(1), @small_dfa.dfa_reached('? a',[0]))
+        assert_equal(@small_dfa.ith_states(1,3), @small_dfa.dfa_reached('? a',[0,1]))
+        assert_equal(@small_dfa.ith_states(2), @small_dfa.dfa_reached('? b',[3,1]))
+        assert_equal(@small_dfa.ith_states(2), @small_dfa.dfa_reached('? b',[0,3,1]))
+      end
+  
+      # Tests Walking#dfa_reached
+      def test_dfa_reached_on_simple_deterministic_automaton
+        s0, s1 = nil
+        fa = Automaton.new do |fa|
+          s0 = fa.add_state(:initial => true)
+          s1 = fa.add_state
+          fa.connect(s0, s1, 'a')
+          fa.connect(s1, s0, 'b')
+        end 
+        assert_equal(s0, fa.dfa_reached('? '))
+        assert_equal(s1, fa.dfa_reached('? a'))
+        assert_equal(s0, fa.dfa_reached('? a b'))
+        assert_equal(s1, fa.dfa_reached('? a b a'))
+        assert_equal(s0, fa.dfa_reached('? a b a b'))
+        assert_nil(fa.dfa_reached('? a a'))
+        assert_nil(fa.dfa_reached('? b'))
+        assert_nil(fa.dfa_reached('? a b b'))
+      end
+    
+      # Tests Walking#reached on a deterministic automaton
+      def test_reached_on_simple_deterministic_automaton
+        s0, s1 = nil
+        fa = Automaton.new do |fa|
+          s0 = fa.add_state(:initial => true)
+          s1 = fa.add_state
+          fa.connect(s0, s1, 'a')
+          fa.connect(s1, s0, 'b')
+        end 
+        assert_equal([s0], fa.reached('?'))
+        assert_equal([s1], fa.reached('? a'))
+        assert_equal([s0], fa.reached('? a b'))
+        assert_equal([s1], fa.reached('? a b a'))
+        assert_equal([s0], fa.reached('? a b a b'))
+        assert_equal([], fa.reached('? a a'))
+        assert_equal([], fa.reached('? b'))
+        assert_equal([], fa.reached('? a b b'))
+      end
+  
+      # Tests Walking#reached on a non-deterministic automaton.
+      def test_reached_on_non_deterministic_automaton
+        s0, s1, s2, s3, s4 = nil
+        fa = Automaton.new do |fa|
+          s0 = fa.add_state(:initial => true)    #
+          s1, s2, s3, s4 = fa.add_n_states(4)    #         s1  -b->  s3
+          fa.connect(s0, s1, 'a')                #      a
+          fa.connect(s0, s2, 'a')                # s0
+          fa.connect(s1, s3, 'b')                #      a
+          fa.connect(s2, s4, 'c')                #         s2  -c->  s4
+        end                                      #
+        assert_equal([], s2.delta('b'))
+        assert_equal([s0], fa.reached('?'))
+        assert_equal([], fa.reached('? c'))
+        assert_equal([s1,s2], fa.reached('? a').sort)
+        assert_equal([s3], fa.reached('? a b'))
+        assert_equal([s4], fa.reached('? a c'))
+        assert_equal([s1,s2], fa.reached('? a').sort)
+      
+        # add a looping b on s2
+        fa.connect(s2, s2, 'b')
+        assert_equal([s2,s3], fa.reached('? a b').sort)
+    
+        # add an epsilon from s2 to s1 
+        fa.connect(s2, s1, nil)
+        assert_equal([s1,s2], fa.reached('? a').sort)
+        assert_equal([s1,s2,s3], fa.reached('? a b').sort)
+      end
+  
+      # Tests Walking#accepts? and Walking#rejects?
+      def test_accepts_and_rejects
+        fa = Automaton.new do
+          add_state(:initial => true)
+          add_state(:accepting => true)
+          add_state(:error => true)
+          add_state(:accepting => true, :error => true)
+          connect(0,1,'a')
+          connect(1,0,'b')
+          connect(0,2,'b')
+          connect(1,3,'a')
+        end
+        assert_equal(false, fa.accepts?("?"))
+        assert_equal(true, fa.accepts?("? a"))
+        assert_equal(false, fa.accepts?("? a b"))
+        assert_equal(true, fa.accepts?("? a b a"))
+        assert_equal(false, fa.accepts?("? z"), "not accepts? on no state")
+        assert_equal(false, fa.accepts?("? b"), "not accepts? on non accepting error state")
+        assert_equal(false, fa.accepts?("? a a"), "not accepts? on accepting error state")
+      
+        assert_equal(true, fa.rejects?("?"))
+        assert_equal(false, fa.rejects?("? a"))
+        assert_equal(true, fa.rejects?("? a b"))
+        assert_equal(false, fa.rejects?("? a b a"))
+        assert_equal(true, fa.rejects?("? z"), "rejects? on no state")
+        assert_equal(true, fa.rejects?("? b"), "rejects? on non accepting error state")
+        assert_equal(true, fa.rejects?("? a a"), "rejects? on accepting error state")
+      end
+    
+    end # class WalkingTest
+  end # class Automaton
+end # module Stamina

data/test/stamina/exit.rb

@@ -0,0 +1,3 @@
+# This file is only used in the test, to check that some parsing method do not
+# execute ruby code. If not the case, a SystemExit will be raised
++ Kernel.exit(-1)

data/test/stamina/induction/induction_test.rb

@@ -0,0 +1,70 @@
+require 'test/unit'
+require 'stamina'
+require 'stamina/induction/union_find'
+require 'stamina/induction/commons'
+module Stamina
+  module Induction
+    class InductionTest < Test::Unit::TestCase
+      include Stamina::Induction::Commons
+      
+      # Asserts that two states are equivalent and recurse.
+      def equivalent_states!(s1, s2, equivalences)
+        return "#{s1.index} and #{s2.index} don't agree on flags" \
+          unless s1.initial? == s2.initial? \
+             and s1.accepting? == s2.accepting? \
+             and s1.error? == s2.error?
+        return "#{s1.index} and #{s2.index} don't agree on out symbols #{s1.out_symbols.inspect} #{s2.out_symbols.inspect}"\
+          unless s1.out_symbols.sort == s2.out_symbols.sort
+        equivalences[s1.index] = s2.index
+        s1.out_symbols.each do |symbol|
+          s1_target = s1.dfa_step(symbol)
+          s2_target = s2.dfa_step(symbol)
+          return false if (s1_target.nil? or s2_target.nil?)
+          if equivalences.has_key?(s1_target.index)
+            return "#{s1.index} and #{s2.index} don't agree on #{symbol}"\
+              unless equivalences[s1_target.index]==s2_target.index
+          else
+            return msg \
+              if msg=equivalent_states!(s1_target, s2_target, equivalences)
+          end
+        end
+        nil
+      end
+      
+      # Checks if two DFAs are equivalent.
+      def equivalent?(dfa1, dfa2)
+        return "not same number of states" unless dfa1.state_count==dfa2.state_count
+        equivalent_states!(dfa1.initial_state, dfa2.initial_state, {})
+      end
+      
+      # Puts a PTA under @pta
+      def setup
+        @sample = Stamina::ADL.parse_sample <<-EOF
+          +
+          - a
+          - a a
+          + a b
+          - b a b a
+          + b a b b
+          + b b
+        EOF
+        @pta = sample2pta(@sample)
+      end
+      
+      # Returns index-th state of the PTA
+      def s(index)
+        @pta.ith_state(index)
+      end
+      
+      # Factors a UnionFind instance from the PTA under @pta.
+      def factor_ufds
+        pta2ufds(@pta)
+      end
+      
+      # Just to avoid a stupid ruby error on empty test units.
+      def test_empty
+      end
+      
+    end
+  end # module Induction
+end # module Stamina

data/test/stamina/induction/redblue_mergesamestatebug_expected.adl

@@ -0,0 +1,19 @@
+6 12
+0 true false
+1 false true
+2 false false
+3 false false
+4 false false
+5 false false
+0 1 0
+0 1 1
+1 2 0
+1 1 1
+2 0 0
+2 3 1
+3 4 0
+3 4 1
+4 5 0
+4 1 1
+5 0 0
+5 2 1

data/test/stamina/induction/redblue_mergesamestatebug_pta.dot

@@ -0,0 +1,64 @@
+digraph G {
+  graph [rankdir="LR"];
+  0 [color="black" fillcolor="green" shape="circle" style="filled"];
+  1 [color="black" fillcolor="white" shape="doublecircle" style="filled"];
+  2 [color="black" fillcolor="white" shape="circle" style="filled"];
+  3 [color="black" fillcolor="white" shape="circle" style="filled"];
+  4 [color="black" fillcolor="white" shape="circle" style="filled"];
+  5 [color="black" fillcolor="white" shape="circle" style="filled"];
+  6 [color="black" fillcolor="white" shape="circle" style="filled"];
+  7 [color="black" fillcolor="white" shape="circle" style="filled"];
+  8 [color="black" fillcolor="white" shape="circle" style="filled"];
+  9 [color="black" fillcolor="white" shape="circle" style="filled"];
+  10 [color="black" fillcolor="white" shape="circle" style="filled"];
+  11 [color="black" fillcolor="white" shape="circle" style="filled"];
+  12 [color="black" fillcolor="red" shape="circle" style="filled"];
+  13 [color="black" fillcolor="white" shape="circle" style="filled"];
+  14 [color="black" fillcolor="white" shape="circle" style="filled"];
+  15 [color="black" fillcolor="red" shape="circle" style="filled"];
+  16 [color="black" fillcolor="red" shape="circle" style="filled"];
+  17 [color="black" fillcolor="white" shape="circle" style="filled"];
+  18 [color="black" fillcolor="red" shape="circle" style="filled"];
+  19 [color="black" fillcolor="white" shape="doublecircle" style="filled"];
+  20 [color="black" fillcolor="white" shape="circle" style="filled"];
+  21 [color="black" fillcolor="white" shape="circle" style="filled"];
+  22 [color="black" fillcolor="white" shape="doublecircle" style="filled"];
+  23 [color="black" fillcolor="white" shape="circle" style="filled"];
+  24 [color="black" fillcolor="white" shape="circle" style="filled"];
+  25 [color="black" fillcolor="white" shape="circle" style="filled"];
+  26 [color="black" fillcolor="white" shape="circle" style="filled"];
+  27 [color="black" fillcolor="white" shape="doublecircle" style="filled"];
+  28 [color="black" fillcolor="white" shape="circle" style="filled"];
+  29 [color="black" fillcolor="white" shape="circle" style="filled"];
+  30 [color="black" fillcolor="white" shape="doublecircle" style="filled"];
+  0 -> 2 [label="1"];
+  2 -> 4 [label="1"];
+  4 -> 7 [label="1"];
+  7 -> 11 [label="1"];
+  11 -> 15 [label="0"];
+  0 -> 1 [label="0"];
+  1 -> 3 [label="0"];
+  3 -> 6 [label="1"];
+  6 -> 10 [label="1"];
+  10 -> 14 [label="0"];
+  14 -> 18 [label="1"];
+  18 -> 20 [label="0"];
+  20 -> 22 [label="1"];
+  18 -> 21 [label="1"];
+  21 -> 23 [label="0"];
+  23 -> 24 [label="0"];
+  24 -> 26 [label="1"];
+  26 -> 28 [label="1"];
+  28 -> 29 [label="0"];
+  29 -> 30 [label="1"];
+  24 -> 25 [label="0"];
+  25 -> 27 [label="0"];
+  14 -> 17 [label="0"];
+  17 -> 19 [label="1"];
+  6 -> 9 [label="0"];
+  9 -> 13 [label="0"];
+  13 -> 16 [label="1"];
+  3 -> 5 [label="0"];
+  5 -> 8 [label="0"];
+  8 -> 12 [label="0"];
+}

data/test/stamina/induction/redblue_mergesamestatebug_sample.adl

@@ -0,0 +1,9 @@
+- 1 1 1 1 0
++ 0
+- 0 0 1 1 0 1
++ 0 0 1 1 0 1 0 1
++ 0 0 1 1 0 1 1 0 0 1 1 0 1
++ 0 0 1 1 0 1 1 0 0 0 0
++ 0 0 1 1 0 0 1
+- 0 0 1 0 0 1
+- 0 0 0 0 0

data/test/stamina/induction/redblue_test.rb

@@ -0,0 +1,83 @@
+require File.join(File.dirname(__FILE__), "induction_test")
+module Stamina
+  module Induction
+    class RedBlueTest < Stamina::Induction::InductionTest
+      
+      # Factors a ready to be tested RedBlue instance
+      def redblue(ufds)
+        redblue = Stamina::Induction::RedBlue.new(:verbose => false)
+        redblue.instance_eval do
+          @ufds = ufds
+        end
+        redblue
+      end
+      
+      def test_merge_and_determinize_score
+        redblue = redblue(factor_ufds)
+        assert_equal nil, redblue.merge_and_determinize_score(1, 0)
+        assert_equal 1, redblue.merge_and_determinize_score(1, 3)
+        assert_equal 1, redblue.merge_and_determinize_score(2, 0)
+      end
+      
+      def test_main_whole_execution
+        ufds = factor_ufds
+        redblue = redblue(ufds)
+        assert_equal [0, 1, 0, 1, 0, 1, 0, 0, 1, 0], redblue.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 = RedBlue.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}/redblue_*_sample.adl"].each do |sample_file|
+          name = (/^redblue_(.*?)_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, "redblue_#{name}_expected.adl"))
+          assert sample.correctly_classified_by?(expected)
+          dfa = RedBlue.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'))
+        redblued = Stamina::Induction::RedBlue.execute(sample)
+        assert_equal 4, redblued.state_count
+        s0, = redblued.initial_state
+        s1 = redblued.dfa_step(s0, 'b')
+        s2 = redblued.dfa_step(s0, 'a')
+        s3 = redblued.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, redblued.signature(sample)
+      end
+      
+    end
+  end
+end