stamina 0.4.0 → 0.5.0

data/test/stamina/induction/rpni_universal_sample.adl

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

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

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