stamina 0.3.0

data/test/stamina/markable_test.rb

@@ -0,0 +1,70 @@
+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

@@ -0,0 +1,66 @@
+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

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

data/test/stamina/sample_classify_test.rb

@@ -0,0 +1,149 @@
+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

@@ -0,0 +1,218 @@
+require 'test/unit'
+require 'stamina/errors'
+require 'stamina/stamina_test'
+require 'stamina/sample'
+module Stamina
+
+# Tests Sample class
+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
+  
+end # class SampleTest
+    
+end # module Stamina