stamina 0.4.0 → 0.5.0

data/test/stamina/markable_test.rb

@@ -1,70 +0,0 @@
-require 'test/unit'
-require 'stamina/markable'
-module Stamina
-  # Tests Loaded class
-  class MarkableTest < Test::Unit::TestCase
-
-    class MyMarkableObject
-      include Markable
-      def initialize
-        @data = {}
-      end
-    end
-
-    class MarkableObjectWithStateChanges < MyMarkableObject
-      def initialize
-        super
-        @changes = []
-      end
-
-      def state_changed(what, description)
-        @changes << what << description
-      end
-
-      def changes
-        @changes
-      end
-    end
-
-    # Tests the effect of setting a value
-    def test_value_assignments
-      @loaded = MyMarkableObject.new
-
-      assert_nil(@loaded[:myownkey])
-      assert_nil(@loaded["rr"])
-
-      @loaded[:myownkey] = "myownkey"
-      @loaded[12] = :twelve
-      assert_equal("myownkey", @loaded[:myownkey])
-      assert_equal(:twelve, @loaded[12])
-      assert_nil(@loaded["rr"])
-
-      @loaded[:myownkey] = 36
-      assert_equal(36, @loaded[:myownkey])
-      assert_equal(:twelve, @loaded[12])
-      assert_nil(@loaded["rr"])
-    end
-
-    # Tests the effect of setting a value
-    def test_value_assignments_statechange
-      @loaded = MarkableObjectWithStateChanges.new
-
-      assert_nil(@loaded[:myownkey])
-      assert_nil(@loaded["rr"])
-      assert_equal([],@loaded.changes)
-
-      @loaded[:myownkey] = "myownkey"
-      @loaded[12] = :twelve
-      assert_equal("myownkey", @loaded[:myownkey])
-      assert_equal(:twelve, @loaded[12])
-      assert_equal([:loaded_pair,[:myownkey,nil,"myownkey"],:loaded_pair,[12,nil,:twelve]],@loaded.changes)
-      assert_nil(@loaded["rr"])
-
-      @loaded[:myownkey] = 36
-      assert_equal(36, @loaded[:myownkey])
-      assert_equal(:twelve, @loaded[12])
-      assert_nil(@loaded["rr"])
-      assert_equal([:loaded_pair,[:myownkey,nil,"myownkey"],:loaded_pair,[12,nil,:twelve],:loaded_pair,[:myownkey,"myownkey",36]],@loaded.changes)
-    end
-  end
-end

data/test/stamina/randdfa.adl

@@ -1,66 +0,0 @@
-26 39
-0 false false
-1 false true
-2 false true
-3 false true
-4 false false
-5 false true
-6 true false
-7 false false
-8 false true
-9 false true
-10 false false
-11 false false
-12 false false
-13 false true
-14 false true
-15 false false
-16 false false
-17 false false
-18 false true
-19 false true
-20 false false
-21 false true
-22 false true
-23 false false
-24 false true
-25 false true
-0 1 1
-0 2 0
-3 4 1
-3 5 0
-6 7 0
-6 8 1
-2 9 1
-2 10 0
-11 12 1
-11 13 0
-12 4 0
-12 12 1
-14 15 1
-14 16 0
-17 0 0
-18 19 0
-18 0 1
-20 1 1
-20 18 0
-21 18 0
-15 21 0
-15 22 1
-9 5 0
-22 17 1
-8 1 1
-8 20 0
-13 23 0
-13 5 1
-4 19 1
-24 11 0
-23 24 0
-23 3 1
-10 25 1
-10 24 0
-19 14 1
-25 7 1
-7 1 1
-7 24 0
-1 10 0

data/test/stamina/sample.adl

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

data/test/stamina/sample_classify_test.rb

@@ -1,149 +0,0 @@
-require 'test/unit'
-require 'stamina/adl'
-require 'stamina/stamina_test'
-module Stamina
-  class Sample
-    # Tests Classify module, as installed on Sample and InputString classes.
-    class ClassifyTest < StaminaTest
-
-      # Tests Classify#correctly_classified_by? is correct on valid sample against
-      # small_dfa example
-      def test_valid_sample_correctly_classified_by_small_dfa
-        assert_equal(true, Sample.new.correctly_classified_by?(@small_dfa))
-        sample = ADL::parse_sample <<-SAMPLE
-          -
-          + b
-          + b c
-          - b c a
-          - b c a c
-          - b c a c a
-          - b c a a
-          + b c a b
-          + b c a b c a c b
-          - z
-          - b z
-        SAMPLE
-        assert_equal(true, sample.correctly_classified_by?(@small_dfa))
-      end
-
-      # Tests Classify#correctly_classified_by? is correct on invalid sample against
-      # small_dfa example
-      def test_invalid_sample_correctly_classified_by_small_dfa
-        sample = ADL::parse_sample <<-SAMPLE
-          -
-          + b
-          + b c
-          - b c a
-          # this one is reversed
-          + b c a c
-          - b c a c a
-          - b c a a
-          + b c a b
-          + b c a b c a c b
-          - z
-          - b z
-        SAMPLE
-        assert_equal(false, sample.correctly_classified_by?(@small_dfa))
-
-        sample = ADL::parse_sample <<-SAMPLE
-          -
-          + b
-          + b c
-          - b c a
-          - b c a c
-          - b c a c a
-          - b c a a
-          + b c a b
-          + b c a b c a c b
-          # this one is changed
-          + z
-          - b z
-        SAMPLE
-        assert_equal(false, sample.correctly_classified_by?(@small_dfa))
-
-        sample = ADL::parse_sample <<-SAMPLE
-          -
-          + b
-          + b c
-          - b c a
-          - b c a c
-          - b c a c a
-          - b c a a
-          + b c a b
-          # this one is changed
-          - b c a b c a c b
-          - z
-          - b z
-        SAMPLE
-        assert_equal(false, sample.correctly_classified_by?(@small_dfa))
-      end
-  
-      # Tests Classify#correctly_classified_by? is correct on valid sample against
-      # small_nfa example
-      def test_valid_sample_correctly_classified_by_small_nfa
-        assert_equal(true, Sample.new.correctly_classified_by?(@small_nfa))
-        sample = ADL::parse_sample <<-SAMPLE
-          +
-          + a
-          - a a
-          + a a b
-          + a b
-          + a b c a
-          - a b c
-          + a b b b b b b 
-          - a z
-          - z
-        SAMPLE
-        assert_equal(true, sample.correctly_classified_by?(@small_nfa))
-      end
-
-      # Tests Classify#correctly_classified_by? is correct on invalid sample against
-      # small_nfa example
-      def test_invalid_sample_correctly_classified_by_small_nfa
-        sample = ADL::parse_sample <<-SAMPLE
-          # this one is changed
-          -
-          + a
-          - a a
-          + a a b
-          + a b
-          + a b c a
-          - a b c
-          + a b b b b b b 
-          - a z
-          - z
-        SAMPLE
-        assert_equal(false, sample.correctly_classified_by?(@small_nfa))
-        sample = ADL::parse_sample <<-SAMPLE
-          +
-          + a
-          - a a
-          + a a b
-          # this one is changed
-          - a b
-          + a b c a
-          - a b c
-          + a b b b b b b 
-          - a z
-          - z
-        SAMPLE
-        assert_equal(false, sample.correctly_classified_by?(@small_nfa))
-        sample = ADL::parse_sample <<-SAMPLE
-          +
-          + a
-          # this one is changed
-          + a a
-          + a a b
-          + a b
-          + a b c a
-          - a b c
-          + a b b b b b b 
-          - a z
-          - z
-        SAMPLE
-        assert_equal(false, sample.correctly_classified_by?(@small_nfa))
-      end
-
-    end # class ClassifyTest
-  end # class Sample
-end # module Stamina

data/test/stamina/sample_test.rb

@@ -1,290 +0,0 @@
-require 'test/unit'
-require 'stamina/errors'
-require 'stamina/stamina_test'
-require 'stamina/sample'
-module Stamina
-  class SampleTest < StaminaTest
-    
-    # Converts a String to an InputString
-    def s(str)
-      Stamina::ADL::parse_string(str)
-    end
-    
-    # Tests Sample#empty?
-    def test_empty
-      assert_equal(true, Sample.new.empty?)
-      assert_equal(true, Sample[].empty?)
-      assert_equal(false, Sample['?'].empty?)
-      assert_equal(false, Sample['-'].empty?)
-      assert_equal(false, Sample['+'].empty?)
-      assert_equal(false, Sample['+ a b'].empty?)
-      assert_equal(false, Sample['+ a b', '- a'].empty?)
-      assert_equal(false, Sample['- a b'].empty?)
-    end
-    
-    # Tests Sample#size
-    def test_size_and_counts
-      s = Sample.new
-      assert_equal(0, s.size)
-      assert_equal(0, s.positive_count)
-      assert_equal(0, s.negative_count)
-      s << '+ a b'
-      assert_equal(1, s.size)
-      assert_equal(1, s.positive_count)
-      assert_equal(0, s.negative_count)
-      s << '+ a b'
-      assert_equal(2, s.size)
-      assert_equal(2, s.positive_count)
-      assert_equal(0, s.negative_count)
-      s << '+ a'
-      assert_equal(3, s.size)
-      assert_equal(3, s.positive_count)
-      assert_equal(0, s.negative_count)
-      s << '- a b c'
-      assert_equal(4, s.size)
-      assert_equal(3, s.positive_count)
-      assert_equal(1, s.negative_count)
-    end
-    
-    def test_same_string_can_be_added_many_times
-      s = Sample.new
-      10.times {|i| s << "+ a b"}
-      assert_equal(10, s.size)
-      assert_equal(10, s.positive_count)
-      assert_equal(0, s.negative_count)
-      strings = s.collect{|s| s}
-      assert_equal 10, strings.size
-    end
-    
-    # Tests Sample#<<
-    def test_append
-      s = Sample.new
-      assert_equal(s,s << '+',"Accepts empty string")
-      assert_equal(s,s << '+ a b a b a',"Accepts positive string")
-      assert_equal(s,s << '- a',"Accepts negative string")
-      assert_equal(s,s << '? a',"Accepts unlabeled string")
-    end
-    
-    # Tests Sample#include? on every kind of arguments it announce
-    def test_append_accepts_arguments_it_annouce
-      expected = Sample[
-        '+ a b a b', 
-        '+ a b',
-        '-',
-        '- a',
-        '+ a b a b a b'
-      ]
-      s = Sample.new
-      s << '+ a b a b'
-      s << ['+ a b', '-']
-      s << InputString.new('a', false)
-      s << Sample['+ a b a b a b', '-']
-      assert_equal(expected,s)
-    end
-    
-    # Tests that Sample#<< detects inconsistencies
-    # def test_append_detects_inconsistency
-    #   s = Sample.new
-    #   s << '+ a b'
-    #   s << '+ a b a b'
-    #   assert_raise InconsistencyError do
-    #     s << '- a b a b'
-    #   end
-    # end
-    
-    # Tests that Sample#<< detects inconsistencies
-    def test_append_detects_real_inconsistencies_only
-      s = Sample.new
-      s << '+ a b'
-      s << '+ a b a b'
-      assert_nothing_raised do
-        s << '- b'
-        s << '- a'
-        s << '- a b a'
-      end
-    end  
-    
-    # Tests each
-    def test_each
-      strings = ['+ a b a b', '+ a b', '+ a b', '- a', '+']
-      strings = strings.collect{|s| ADL::parse_string(s)}
-      s = Sample.new << strings
-      count = 0
-      s.each do |str|
-        assert_equal(true, strings.include?(str))
-        count += 1
-      end
-      assert_equal(strings.size, count)
-    end
-    
-    # Tests each_positive
-    def test_each_positive
-      sample = Sample[
-        '+',
-        '- b',
-        '+ a b a b',
-        '- a b a a'
-      ]
-      count = 0
-      sample.each_positive do |str|
-        assert str.positive?
-        count += 1
-      end
-      assert_equal 2, count
-      positives = sample.positive_enumerator.collect{|s| s}
-      assert_equal 2, positives.size
-      [s('+'), s('+ a b a b')].each do |str|
-        assert positives.include?(str)
-      end
-    end
-    
-    # Tests each_negative
-    def test_each_negative
-      sample = Sample[
-        '+',
-        '- b',
-        '+ a b a b',
-        '- a b a a'
-      ]
-      count = 0
-      sample.each_negative do |str|
-        assert str.negative?
-        count += 1
-      end
-      assert_equal 2, count
-      negatives = sample.negative_enumerator.collect{|s| s}
-      assert_equal 2, negatives.size
-      [s('- b'), s('- a b a a')].each do |str|
-        assert negatives.include?(str)
-      end
-    end
-    
-    # Tests Sample#include?
-    def test_include
-      strings = ['+ a b a b', '+ a b', '- a', '+']
-      s = Sample.new << strings
-      strings.each do |str|
-        assert_equal(true, s.include?(str))
-      end
-      assert_equal(true, s.include?(strings))
-      assert_equal(true, s.include?(s))
-      assert_equal(false, s.include?('+ a'))
-      assert_equal(false, s.include?('-'))
-      assert_equal(false, s.include?('+ a b a'))
-    end
-    
-    # Tests Sample#include? on every kind of arguments it announce
-    def test_include_accepts_arguments_it_annouce
-      s = Sample.new << ['+ a b a b', '+ a b', '- a', '+']
-      assert_equal true, s.include?('+ a b a b')
-      assert_equal true, s.include?(InputString.new('a b a b',true))
-      assert_equal true, s.include?(ADL::parse_string('+ a b a b'))
-      assert_equal true, s.include?(['+ a b a b', '+ a b'])
-      assert_equal true, s.include?(s)
-    end
-    
-    # Tests Sample#==
-    def test_equal
-      s1 = Sample['+ a b a b', '+', '- a']
-      s2 = Sample['+ a b a b', '+', '+ a']
-      assert_equal(true, s1==s1)
-      assert_equal(true, s2==s2)
-      assert_equal(false, s1==s2)
-      assert_equal(false, s1==Sample.new)
-      assert_equal(false, s2==Sample.new)
-    end
-    
-    # Test the signature
-    def test_signature
-      s = Sample.new
-      assert_equal '', s.signature
-      s = Sample.new << ['+ a b a b', '+ a b', '- a', '+']
-      assert_equal '1101', s.signature
-      s = Sample.new << ['+ a b a b', '+ a b', '- a', '?']
-      assert_equal '110?', s.signature
-      s = Stamina::ADL.parse_sample <<-SAMPLE
-        +
-        + a b
-        - a c
-        ? a d
-      SAMPLE
-      assert_equal '110?', s.signature
-    end
-
-    def test_to_pta_on_empty_sample
-      empty = Stamina::ADL::parse_automaton <<-EOF
-        1 0
-        0 true false
-      EOF
-      assert_equivalent empty, Sample.new.to_pta
-    end
-
-    def test_to_pta_on_lambda_accepting_sample
-      dfa = Stamina::ADL::parse_automaton <<-EOF
-        1 0
-        0 true true false
-      EOF
-      sample = Stamina::ADL::parse_sample <<-EOF
-        +
-      EOF
-      assert_equivalent dfa, sample.to_pta
-    end
-    
-    def test_to_pta_on_lambda_rejecting_sample
-      dfa = Stamina::ADL::parse_automaton <<-EOF
-        1 0
-        0 true false true
-      EOF
-      sample = Stamina::ADL::parse_sample <<-EOF
-        -
-      EOF
-      assert_equivalent dfa, sample.to_pta
-    end
-
-    def test_to_pta_respects_natural_ordering
-      dfa = Stamina::ADL::parse_automaton <<-EOF
-        3 2
-        0 true false
-        1 false true
-        2 false true
-        0 1 a
-        0 2 b
-      EOF
-      sample = Stamina::ADL::parse_sample <<-EOF
-        + a
-        + b
-      EOF
-      pta = sample.to_pta
-      assert_equivalent dfa, pta
-      assert_equal pta.ith_state(1), pta.dfa_reached("? a")
-      assert_equal pta.ith_state(2), pta.dfa_reached("? b")
-    end
-
-    def test_to_pta_on_realcase_example
-      dfa = Stamina::ADL::parse_automaton <<-EOF
-        5 4
-        0 true true
-        1 false true
-        2 false false true
-        3 false false true
-        4 false true
-        0 1 a
-        0 2 b
-        1 3 b
-        2 4 a
-      EOF
-      sample = Stamina::ADL::parse_sample <<-EOF
-        +
-        + a
-        + b a
-        - a b
-        - b
-      EOF
-      pta = sample.to_pta
-      assert_equivalent dfa, pta
-      assert_equal pta.ith_state(3), pta.dfa_reached("? a b")
-      assert_equal pta.ith_state(4), pta.dfa_reached("? b a")
-    end
-    
-  end # class SampleTest
-end # module Stamina