rlsm 1.0.0 → 1.1.0

data/test/test_regexp.rb

@@ -0,0 +1,440 @@
+require File.join(File.dirname(__FILE__), 'helpers')
+
+require "rlsm/regexp"
+
+context "Parsing of a regexp:" do
+  before :each do
+    @a = RLSM::RE::Prim[ 'a' ]
+    @b = RLSM::RE::Prim[ 'b' ]
+    @c = RLSM::RE::Prim[ 'c' ]
+    @d = RLSM::RE::Prim[ 'd' ]
+
+    @aab = [@a, @a, @b] 
+  end
+
+  test "RegExp::new : Should require an argument." do
+    assert_raises ArgumentError do
+      RLSM::RegExp.new
+    end
+  end
+
+  test "RegExp::new : Should check that parentheses are balanced." do
+    assert_raises RegExpError do
+      RLSM::RegExp.new "(ab(cUd)"
+    end
+
+    assert_raises RegExpError do
+      RLSM::RegExp.new "ab)((cUd)"
+    end
+  end
+
+  test "RegExp::new : Should parse empty string." do
+    re = RLSM::RegExp.new ""
+
+    assert_equal( RLSM::RE::EmptySet[], re.parse_tree )
+  end
+
+  test "RegExp::new : Should parse string with only parenthesis." do
+    re = RLSM::RegExp.new "()(())"
+
+    assert_equal( RLSM::RE::EmptySet[], re.parse_tree )
+  end
+
+  test "RegExp::new : Should parse string with only parenthesis and stars." do
+    re = RLSM::RegExp.new "()*((*))"
+
+    assert_equal( RLSM::RE::EmptySet[], re.parse_tree )
+  end
+
+  test "RegExp::new : Should parse empty word." do
+    re = RLSM::RegExp.new "@"
+
+    assert_equal( RLSM::RE::EmptyWord[], re.parse_tree )
+  end
+
+  test "RegExp::new : Should parse a single character." do
+    re = RLSM::RegExp.new "a"
+
+    assert_equal( RLSM::RE::Prim['a'], re.parse_tree )
+  end
+
+  test "RegExp::new : Should parse multiple characters." do
+    re = RLSM::RegExp.new "aab"
+
+    assert_equal( RLSM::RE::Concat[ @aab ], re.parse_tree )
+  end
+
+  test "RegExp::new : Should ignore surrounding parenthesis." do
+    re = RLSM::RegExp.new "(((aab)))"
+
+    assert_equal( RLSM::RE::Concat[ @aab ],
+                  re.parse_tree )
+  end
+
+  test "RegExp::new : Should parse a trivial regexp with a kleene star." do
+    re = RLSM::RegExp.new "a*"
+    expected = 
+
+    assert_equal( RLSM::RE::Star[ RLSM::RE::Prim['a'] ], re.parse_tree )
+  end
+
+  test "RegExp::new : Should parse a simple regexp with a kleene star." do
+    re = RLSM::RegExp.new "(aab)*"
+
+    assert_equal( RLSM::RE::Star[ RLSM::RE::Concat[ @aab ] ], re.parse_tree )
+  end
+
+  test "RegExp::new : Should simplify multiple stars." do
+    re = RLSM::RegExp.new "a***"
+
+    assert_equal( RLSM::RE::Star[ RLSM::RE::Prim['a'] ],
+                  re.parse_tree )
+  end
+
+  test "RegExp::new : Should simplify multiple empty words." do
+    re = RLSM::RegExp.new "@@@"
+
+    assert_equal( RLSM::RE::EmptyWord[],
+                  re.parse_tree )
+  end
+
+  test "RegExp::new : Should simplify stars after empty words." do
+    re = RLSM::RegExp.new "@*"
+
+    assert_equal( RLSM::RE::EmptyWord.new,
+                  re.parse_tree )
+  end
+  
+  test "RegExp::new : Should simplify empty words in a simple expression." do
+    re = RLSM::RegExp.new "@aa@b@"
+
+    assert_equal( RLSM::RE::Concat[ @aab ],
+                  re.parse_tree )
+  end
+
+  test "RegExp::new : Should parse a simple union." do
+    re = RLSM::RegExp.new "aab|b|ac"
+    expected = RLSM::RE::Union[ [RLSM::RE::Concat[ @aab ], 
+                                 RLSM::RE::Concat[ [@a,@c] ],
+                                 @b] ]
+
+    assert_equal( expected, re.parse_tree )
+  end
+
+  test "RegExp::new : Should ignore obviously unnedded parenthesis." do
+    re = RLSM::RegExp.new "(@)aa(b)"
+
+    assert_equal( RLSM::RE::Concat[ @aab ],
+                  re.parse_tree )
+  end
+
+  test "RegExp::new : Should parse a concatenation with a kleene star." do
+    re = RLSM::RegExp.new "aba*"
+    expected = RLSM::RE::Concat[ [@a, @b, RLSM::RE::Star[ @a ]] ]
+    assert_equal( expected, re.parse_tree )
+  end
+
+  test "RegExp::new : Should parse a union in a star expression." do
+    re = RLSM::RegExp.new "(a|b)*"
+    expected = RLSM::RE::Star[ RLSM::RE::Union[ [@a, @b] ] ]
+    assert_equal( expected, re.parse_tree )
+  end
+
+  test "RegExp::new : Should parse a union in a concat expression." do
+    re = RLSM::RegExp.new "ab(a|b)b"
+    expected = RLSM::RE::Concat[ [@a, @b, RLSM::RE::Union[ [@a,@b] ], @b] ]
+
+    assert_equal( expected, re.parse_tree )
+  end
+
+  test "RegExp::new : Should parse a complexer union." do
+    re = RLSM::RegExp.new "a*|aab|ba(aab)*bb"
+    concat = RLSM::RE::Concat[ [@b,@a, RLSM::RE::Star[ RLSM::RE::Concat[@aab] ], @b, @b] ]
+    expected = RLSM::RE::Union[ [RLSM::RE::Star[@a], RLSM::RE::Concat[@aab], concat] ]
+
+    assert_equal expected, re.parse_tree
+  end
+
+  test "RegExp::new : Should parse a nested union." do
+    re = RLSM::RegExp.new "a(a|b)|a*"
+    expected = 
+      RLSM::RE::Union[ [RLSM::RE::Concat[[@a, RLSM::RE::Union[[@a,@b]]]], RLSM::RE::Star[@a]] ]
+
+    assert_equal expected, re.parse_tree
+  end
+
+  test "RegExp::new : Should treat empty parenthesis as empty set." do
+    re1 = RLSM::RegExp.new "()*"
+    re2 = RLSM::RegExp.new "ab()"
+
+    assert_equal RLSM::RE::EmptySet[], re1.parse_tree
+    assert_equal RLSM::RE::EmptySet[], re2.parse_tree
+  end
+
+  test "RegExp::new : Should ignore union with an empty set." do
+    re = RLSM::RegExp.new "a||b"
+    
+    expected = RLSM::RE::Union[ [ RLSM::RE::Prim[ 'a' ], RLSM::RE::Prim[ 'b' ] ] ]
+
+    assert_equal expected, re.parse_tree
+  end
+end
+
+context "Properties of a SyntaxNode:" do
+  test "SyntaxNode#null? : Should return true for EmptySet." do
+    assert RLSM::RE::EmptySet[].null?
+  end
+
+  test "SyntaxNode#null? : Should return true for EmptyWord." do
+    assert RLSM::RE::EmptyWord[].null?
+  end
+
+  test "SyntaxNode#null? : Should return false for Prim." do
+    refute RLSM::RE::Prim[ 'a' ].null?
+  end
+
+  test "SyntaxNode#null? : Should return true for a Star." do
+    assert RLSM::RE::Star[ RLSM::RE::Prim[ 'a' ] ].null?
+  end
+
+  test "SyntaxNode#null? : Should return true for a union with at least one nullable entry." do
+    parse_tree = RLSM::RE::Union[ [RLSM::RE::Prim[ 'a' ], RLSM::RE::EmptyWord[]] ]
+    assert parse_tree.null?
+  end
+
+  test "SyntaxNode#null? : Should return false for a union with no nullable entries." do
+    parse_tree = RLSM::RE::Union[ [RLSM::RE::Prim[ 'a' ], RLSM::RE::Prim[ 'b' ]] ]
+    refute parse_tree.null?
+  end
+
+  test "SyntaxNode#null? : Should return false for a concat with at least one non null entry." do
+    parse_tree = RLSM::RE::Concat[ [RLSM::RE::Star[ RLSM::RE::Prim[ 'a' ] ], RLSM::RE::Prim[ 'b' ]] ]
+    refute parse_tree.null?
+  end
+
+  test "SyntaxNode#null? : Should return true for a concat with only nullable entries." do
+    parse_tree = RLSM::RE::Concat[ [RLSM::RE::Star[RLSM::RE::Prim[ 'a' ]],RLSM::RE::Star[RLSM::RE::Prim[ 'b' ]]] ]
+    assert parse_tree.null?
+  end
+
+  test "SyntaxNode#first : Should return empty Array for EmptySet." do
+    assert_equal [], RLSM::RE::EmptySet[].first
+  end
+
+  test "SyntaxNode#first : Should return empty Array for EmptyWord." do
+    assert_equal [], RLSM::RE::EmptyWord[].first
+  end
+
+  test "SyntaxNode#first : Should return first character of a Prim in an Array." do
+    assert_equal ['a'], RLSM::RE::Prim[ 'a' ].first
+    assert_equal ['b'], RLSM::RE::Prim[ 'b' ].first
+  end
+
+  test "SyntaxNode#first : Should return first of the content of a star." do
+    assert_equal ['a'], RLSM::RE::Star[ RLSM::RE::Prim[ 'a' ] ].first
+  end
+
+  test "SyntaxNode#first : Should return union of first for all factors of a union." do
+    parse_tree = RLSM::RE::Union[ [RLSM::RE::Prim[ 'c' ], RLSM::RE::Prim[ 'b' ]] ]
+
+    assert_equal ['b','c'], parse_tree.first
+  end
+
+  test "SyntaxNode#first : Should return union of first upto first nonnull entry in concat." do
+    parse_tree1 = RLSM::RE::Concat[[RLSM::RE::Prim[ 'b' ],RLSM::RE::Prim[ 'a' ]] ]
+    parse_tree2 = RLSM::RE::Concat[[RLSM::RE::Star[RLSM::RE::Prim['c']], RLSM::RE::Prim['b']]]
+
+    assert_equal ['b'], parse_tree1.first
+    assert_equal ['b','c'], parse_tree2.first
+  end
+
+  test "SyntaxNode#last : Should return empty Array for EmptySet." do
+    assert_equal [], RLSM::RE::EmptySet[].last
+  end
+
+  test "SyntaxNode#last : Should return empty Array for EmptyWord." do
+    assert_equal [], RLSM::RE::EmptyWord[].last
+  end
+
+  test "SyntaxNode#last : Should return last character of a Prim in an Array." do
+    assert_equal ['f'], RLSM::RE::Prim[ 'f' ].last
+    assert_equal ['b'], RLSM::RE::Prim[ 'b' ].last
+  end
+
+  test "SyntaxNode#last : Should return last of the content of a star." do
+    assert_equal ['f'], RLSM::RE::Star[ RLSM::RE::Prim[ 'f' ] ].last
+  end
+
+  test "SyntaxNode#last : Should return union of last for all factors of a union." do
+    parse_tree = RLSM::RE::Union[ [RLSM::RE::Prim[ 'd' ], RLSM::RE::Prim[ 'b' ]] ]
+
+    assert_equal ['b','d'], parse_tree.last
+  end
+
+  test "SyntaxNode#last : Should return union of last upto first nonnull entry in concat." do
+    parse_tree1 = RLSM::RE::Concat[ [RLSM::RE::Prim[ 'c' ], RLSM::RE::Prim[ 'b' ]] ]
+    parse_tree2 = RLSM::RE::Concat[[RLSM::RE::Prim['c'], RLSM::RE::Star[ RLSM::RE::Prim['d']]]]
+
+    assert_equal ['b'], parse_tree1.last
+    assert_equal ['c','d'], parse_tree2.last
+  end
+
+  test "SyntaxNode#follow : Should return nil for EmptySet." do
+    assert_equal nil, RLSM::RE::EmptySet[].follow
+  end
+
+  test "SyntaxNode#follow : Should return nil for EmptyWord." do
+    assert_equal nil, RLSM::RE::EmptyWord[].follow
+  end
+
+  test "SyntaxNode#follow : Should return empty Array for a single letter expression." do
+    assert_equal [], RLSM::RE::Prim[ 'a' ].follow
+  end
+
+  test "SyntaxNode#follow : Should return every length two substring for a star." do
+    assert_equal [['a','a']], RLSM::RE::Star[ RLSM::RE::Prim[ 'a' ] ].follow
+  end
+
+  test "SyntaxNode#follow : Should return every length two substring for a union." do
+    concat = RLSM::RE::Concat[ %w(c c d).map { |char| RLSM::RE::Prim[char] } ]
+    parse_tree = RLSM::RE::Union[ [RLSM::RE::Star[ RLSM::RE::Prim[ 'a' ] ],
+                                   RLSM::RE::Prim[ 'b' ],
+                                   concat ] ]
+    assert_equal [['a','a'], ['c','c'], ['c','d']], parse_tree.follow
+  end
+
+  test "SyntaxNode#follow : Should return every length two substring for a concat." do
+    parse_tree = RLSM::RE::Concat[ [RLSM::RE::Star[ RLSM::RE::Prim[ 'a' ] ],
+                                RLSM::RE::Prim[ 'b' ],
+                                RLSM::RE::Union[ [RLSM::RE::Prim[ 'c' ], RLSM::RE::Prim[ 'd' ]] ] ] ]
+    assert_equal [['a','a'], ['a','b'], ['b','c'], ['b','d']], parse_tree.follow
+  end
+end
+
+context "Simplification of regexps:" do
+  before :each do
+    @a = RLSM::RE::Prim[ 'a' ]
+    @b = RLSM::RE::Prim[ 'b' ]
+    @c = RLSM::RE::Prim[ 'c' ]
+    @d = RLSM::RE::Prim[ 'd' ]
+
+    @aab = [@a, @a, @b] 
+  end
+
+  test "RegExp::new : Should simplify (@)* to @" do
+    assert_equal RLSM::RE::EmptyWord[], RLSM::RegExp.new("(@)*").parse_tree
+  end
+
+  test "RegExp::new : Should ignore unneeded empty words in a union." do
+    re = RLSM::RegExp.new "@|b|a*"
+    
+    expected = RLSM::RE::Union[ [ RLSM::RE::Star[ @a ], @b ] ]
+
+    assert_equal expected, re.parse_tree
+  end
+
+  test "RegExp::new : Should multiple empty words in a union reduce to one." do
+    re = RLSM::RegExp.new "@|b|@"
+    
+    expected = RLSM::RE::Union[ [ RLSM::RE::EmptyWord[], @b ] ]
+
+    assert_equal expected, re.parse_tree
+  end
+
+  test "RegExp::new : Should simplify multiple identical entries in a union." do
+    re = RLSM::RegExp.new "@|b|b"
+
+    expected = RLSM::RE::Union[ [ RLSM::RE::EmptyWord[], @b ] ]
+
+    assert_equal expected, re.parse_tree
+  end
+
+  test "RegExp::new : Should simplify a empty word in a stared union." do
+    re = RLSM::RegExp.new "(@|a|b)*"
+    expected = RLSM::RE::Star[RLSM::RE::Union[ [@a, @b ] ]]
+    assert_equal expected, re.parse_tree
+  end
+
+  test "RegExp::new : Should simplify something like (a|a*|b) to (a*|b)" do
+    re = RLSM::RegExp.new "(a|a*|b)"
+    expected = RLSM::RE::Union[ [RLSM::RE::Star[@a], @b ] ]
+    assert_equal expected, re.parse_tree
+  end
+
+  test "RegExp::new : Should simplify something like (a|a*)* to a*" do
+    re = RLSM::RegExp.new "(a|a*)*"
+    expected = RLSM::RE::Star[ @a ]
+    assert_equal expected, re.parse_tree
+  end
+
+#   test "RegExp::new : Should simplify something like (aab|bab) to (a|b)ab." do
+#     re = RLSM::RegExp.new "(aab|bab)"
+#     expected = RLSM::RE::Concat[ [RLSM::RE::Union[ [@a,@b] ], @a, @b] ]
+#     assert_equal expected, re.parse_tree
+#   end
+  
+#   test "RegExp::new : Should simplify something like (abb|aba) to ab(a|b)."
+end
+
+context "Equality of regular expressions:" do
+  test "RegExp#== : Should return true for identical string representations." do
+    re1 = RLSM::RegExp.new "a(b)(a|b)"
+    re2 = RLSM::RegExp.new "ab(a||b)"
+
+    assert re1 == re2
+  end
+
+  test "RegExp#== : Should return false if first of two regexpes differs." do
+    re1 = RLSM::RegExp.new "(a|b)a"
+    re2 = RLSM::RegExp.new "(b|a)a"
+
+    assert re1 == re2
+    refute re1 == RLSM::RegExp.new("(b|a)b")
+  end
+
+  test "RegExp#== : Should return false if last of two regexpes differs." do
+    re1 = RLSM::RegExp.new "a(a|b)"
+    re2 = RLSM::RegExp.new "a(b|a)"
+
+    assert re1 == re2
+    refute re1 == RLSM::RegExp.new("a(b|c)")
+  end
+
+  test "RegExp#== : Should return true if two regexps only differs in order in a union." do
+    re1 = RLSM::RegExp.new "a(a|b)a"
+    re2 = RLSM::RegExp.new "a(b|a)a"
+
+    assert re1 == re2
+  end
+
+  test "RegExp#== : Should return true if two regexps only differs in factorisation." do
+    re1 = RLSM::RegExp.new "a(a|b)a"
+    re2 = RLSM::RegExp.new "(aba|aaa)"
+    re3 = RLSM::RegExp.new "aba"
+
+    assert re1 == re2, "Oho?"
+    refute re3 == re1, "Huh?"
+  end
+end
+
+context "Calculation with regular expressions:" do
+  test "RegExp::+ : Should concatenate two regexps." do
+    re1 = RLSM::RegExp.new "ab(a|b)"
+    re2 = RLSM::RegExp.new "ab"
+
+    assert_equal RLSM::RegExp.new("ab(a|b)ab"), re1 + re2 
+  end
+
+  test "RegExp::| : Should unite two regexps." do
+    re1 = RLSM::RegExp.new "ab(a|b)"
+    re2 = RLSM::RegExp.new "ab"
+
+    assert_equal RLSM::RegExp.new("ab(a|b)|ab"), re1 | re2 
+  end
+
+  test "RegExp::star : Should star a regexp." do
+    re = RLSM::RegExp.new "ab(a|b)"
+
+    assert_equal RLSM::RegExp.new("(ab(a|b))*"), re.star 
+  end
+end

metadata

@@ -1,63 +1,132 @@
 --- !ruby/object:Gem::Specification 
 name: rlsm
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors: 
-- asmodis
+- Gunther Diemant
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-03-10 00:00:00 +01:00
+date: 2009-10-09 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: hoe
+  name: minitest
   type: :development
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.8.2
+        version: "0"
     version: 
-description: "This is a ruby implementation of three concepts: - Deterministic Finite Automata (DFA) - Regular Expressions (in the sense of theoretical computer sience) - Monoids (an algebraic construct)"
-email: 
-- g.diemant@gmx.net
-executables: 
-- smon
-extensions: []
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: |+
+  = rlsm
+  rlsm stands for *R*egular *L*anguages and *S*yntactic *M*onoids.
+  
+  Source is availible from
+    http://github.com/asmodis/rlsm
+  
+  RDoc-Documentation is availible from
+    http://rlsm.rubyforge.org
+  
+  == DESCRIPTION:
+  
+  This is a ruby implementation of three concepts:
+   - Deterministic Finite Automata
+   - Regular Expressions (in the sense of theoretical computer sience)
+   - Monoids
+  
+  
+  == SYNOPSIS:
+  
+    require 'rlsm'
+    
+    m = RLSM::Monoid.new '012 112 212'
+    m.syntactic? # => true
+    m.isomorph_to?(m) # => true
+    m.commutative? # => false
+  
+  == INSTALL:
+  
+    gem install rlsm 
+  
+  
+  == LICENSE:
+  
+  (The MIT License)
+  
+  Copyright (c) 2009 Gunther Diemant <g.diemant@gmx.net>
+  
+  Permission is hereby granted, free of charge, to any person obtaining
+  a copy of this software and associated documentation files (the
+  'Software'), to deal in the Software without restriction, including
+  without limitation the rights to use, copy, modify, merge, publish,
+  distribute, sublicense, and/or sell copies of the Software, and to
+  permit persons to whom the Software is furnished to do so, subject to
+  the following conditions:
+  
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of the Software.
+  
+  THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+  
+email: g.diemant@gmx.net
+executables: []
 
+extensions: 
+- ext/array/extconf.rb
+- ext/binop/extconf.rb
+- ext/monoid/extconf.rb
 extra_rdoc_files: 
-- History.txt
-- Manifest.txt
-- README.txt
+- README
 files: 
-- History.txt
-- Manifest.txt
-- README.txt
-- Rakefile
-- bin/smon
-- data/monoids.db
-- lib/database.rb
-- lib/monkey_patching/array_ext.rb
-- lib/rlsm.rb
+- lib/rlsm/binary_operation.rb
 - lib/rlsm/dfa.rb
+- lib/rlsm/helper.rb
 - lib/rlsm/monoid.rb
-- lib/rlsm/re.rb
-- lib/smon/base.rb
-- lib/smon/db.rb
-- lib/smon/dot.rb
-- lib/smon/latex.rb
-- lib/smon/smon.rb
-- stdarb.tex
+- lib/rlsm/regexp.rb
+- lib/rlsm/regexp_parser.rb
+- lib/rlsm.rb
+- ext/array/array_c_ext.c
+- ext/binop/binop_c_ext.c
+- ext/monoid/monoid_c_ext.c
+- ext/array/extconf.rb
+- ext/binop/extconf.rb
+- ext/monoid/extconf.rb
+- test/helpers.rb
+- test/test_binop.rb
+- test/test_dfa.rb
+- test/test_monoid.rb
+- test/test_regexp.rb
+- Rakefile
+- README
 has_rdoc: true
-homepage: http://www.github.com/asmodis/rlsm
+homepage: http://github.com/asmodis/rlsm
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --main
-- README.txt
+- README
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -75,9 +144,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: rlsm
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
-summary: "This is a ruby implementation of three concepts: - Deterministic Finite Automata (DFA) - Regular Expressions (in the sense of theoretical computer sience) - Monoids (an algebraic construct)"
-test_files: []
-
+specification_version: 3
+summary: Library for investigating regular languages and syntactic monoids.
+test_files: 
+- test/test_binop.rb
+- test/test_dfa.rb
+- test/test_monoid.rb
+- test/test_regexp.rb