yargi 0.1.0

data/test/yargi/digraph_test.rb

@@ -0,0 +1,360 @@
+require 'test/unit'
+require 'yargi'
+
+module Yargi
+  class DigraphTest < Test::Unit::TestCase
+    
+    module Until; end
+    module If; end
+    
+    # Creates a digraph instance under @digraph
+    def setup
+      @digraph = Yargi::Digraph.new
+    end
+    
+    def test_to_vertices
+      untils = @digraph.add_n_vertices(5, Until)
+      ifs = @digraph.add_n_vertices(5, If)
+      assert_equal [untils[0]], @digraph.send(:to_vertices, untils[0])
+      assert_equal [untils[0], untils[1]], @digraph.send(:to_vertices, [untils[0], untils[1]])
+      assert_equal [untils[0], untils[1]], @digraph.send(:to_vertices, untils[0], untils[1])
+      assert_equal untils, @digraph.send(:to_vertices, Until)
+      assert_equal ifs, @digraph.send(:to_vertices, If)
+      assert_equal (untils+ifs).sort, @digraph.send(:to_vertices, [Until, If])
+      assert_equal (untils+ifs).sort, @digraph.send(:to_vertices, Until, If)
+      assert_equal (untils+ifs).sort, @digraph.send(:to_vertices, [Until, If, untils[0]])
+      assert_equal (untils+ifs).sort, @digraph.send(:to_vertices, Until, If, untils[0])
+    end
+    
+    def test_to_edges
+      untils = @digraph.add_n_vertices(5, Until)
+      ifs = @digraph.add_n_vertices(5, If)
+      untils_to_ifs = @digraph.connect(untils, ifs)
+      ifs_to_untils = @digraph.connect(ifs, untils)
+      assert_equal [untils_to_ifs[0]], @digraph.send(:to_edges, untils_to_ifs[0])
+      assert_equal [untils_to_ifs[0], untils_to_ifs[1]], @digraph.send(:to_edges, untils_to_ifs[0], untils_to_ifs[1])
+      assert_equal [untils_to_ifs[0], untils_to_ifs[1]], @digraph.send(:to_edges, [untils_to_ifs[0], untils_to_ifs[1]])
+      assert_equal @digraph.edges, @digraph.send(:to_edges, untils_to_ifs, ifs_to_untils)
+      assert_equal untils_to_ifs, @digraph.send(:to_edges, Proc.new{|e| Until===e.source})
+      assert_equal ifs_to_untils, @digraph.send(:to_edges, Proc.new{|e| If===e.source})
+    end
+    
+    def test_extend_returns_self_hypothese
+      assert_equal self, self.extend(Until)
+    end
+    
+    def test_vertices
+      v1 = @digraph.add_vertex({:kind => :point})
+      v2 = @digraph.add_vertex({:kind => :point})
+      v3 = @digraph.add_vertex({:kind => :end})
+      assert_equal :point, v1.kind
+      assert_equal :end, v3.kind
+      assert_equal VertexSet[v1, v2, v3], @digraph.vertices
+      assert_equal v1, @digraph.vertices[0]
+      assert_equal VertexSet[v1], @digraph.vertices {|v| v.index==0}
+      assert_equal VertexSet[v1, v3], @digraph.vertices {|v| v.index==0 or v.index==2}
+      assert_equal VertexSet[v1, v2], @digraph.vertices {|v| v[:kind]==:point}
+      assert_nothing_raised { @digraph.send(:check_sanity) }
+    end
+    
+    def test_vertices_with_mods
+      untils = @digraph.add_n_vertices(5, Until)
+      ifs = @digraph.add_n_vertices(5, If)
+      assert_equal untils, @digraph.vertices(Until)
+      assert_equal ifs, @digraph.vertices(If)
+      assert_equal (untils+ifs), @digraph.vertices(Yargi::NONE|Until|If)
+    end
+    
+    def test_vertices_with_both
+      untils = @digraph.add_n_vertices(5, Until)
+      ifs = @digraph.add_n_vertices(5, If)
+      assert_equal(VertexSet[@digraph.vertices[0]], @digraph.vertices(Until) do |v|
+        v.index==0
+      end)
+      assert_equal(VertexSet[], @digraph.vertices(If) do |v|
+        v.index==0
+      end)
+    end
+    
+    def test_module_extended_vertices
+      v1 = @digraph.add_vertex(Until)
+      v2 = @digraph.add_vertex(If)
+      assert Until===v1
+      assert If===v2
+      assert_equal VertexSet[v1], @digraph.vertices {|v| Until===v}
+      assert_equal VertexSet[v2], @digraph.vertices {|v| If===v}
+    end
+    
+    def test_tag
+      v1, v2 = @digraph.add_n_vertices(2)
+      v1.tag(Until)
+      v2.tag(If, Until)
+      assert Until===v1
+      assert If===v2 and Until===v2
+    end
+    
+    def test_edges
+      v1, v2, v3 = @digraph.add_n_vertices(3)
+      e12, e23, e32, e21 = @digraph.connect_all([v1, v2], [v2, v3], [v3, v2], [v2, v1])
+      assert_equal EdgeSet[e12, e23], @digraph.edges {|e| e.index<=1}
+      assert_nothing_raised { @digraph.send(:check_sanity) }
+    end
+    
+    def test_each_vertex
+      v1, v2, v3 = @digraph.add_n_vertices(3)
+      seen = []
+      @digraph.each_vertex {|v| seen << v}
+      assert_equal [v1, v2, v3], seen
+    end
+    
+    def test_each_vertex_with_filter
+      v1, v2, v3, v4, v5 = @digraph.add_n_vertices(5)
+      seen = []
+      filter = Yargi.predicate {|elm| elm.index<3}
+      @digraph.each_vertex(filter) {|v| seen << v}
+      assert_equal [v1, v2, v3], seen
+      seen = []
+      filter = Yargi.predicate {|elm| elm.index>=3}
+      @digraph.each_vertex(filter) {|v| seen << v}
+      assert_equal [v4, v5], seen
+    end
+    
+    def test_each_edge
+      v1, v2, v3 = @digraph.add_n_vertices(3)
+      edges = @digraph.connect_all([v1, v2], [v2, v3], [v3, v2], [v2, v1])
+      seen = []
+      @digraph.each_edge {|e| seen << e}
+      assert_equal edges, seen
+    end
+    
+    def test_add_vertex
+      v1 = @digraph.add_vertex({:style => :begin})
+      assert_not_nil v1
+      assert_equal @digraph, v1.graph
+      assert_equal :begin, v1[:style]
+      assert_equal VertexSet[v1], @digraph.vertices
+      assert_equal 0, v1.index
+      
+      v2 = @digraph.add_vertex({:style => :end})
+      assert_not_nil v2
+      assert_equal :end, v2[:style]
+      assert_equal VertexSet[v1, v2], @digraph.vertices
+      assert_equal 0, v1.index
+      assert_equal 1, v2.index
+      assert_nothing_raised { @digraph.send(:check_sanity) }
+    end
+    
+    def test_add_n_vertices
+      v1, v2, v3 = @digraph.add_n_vertices(3, {:hello => "world"})
+      assert_equal VertexSet[v1, v2, v3], @digraph.vertices
+      assert_equal [0, 1, 2], [v1.index, v2.index, v3.index]
+      v1[:hello] = "world1"
+      v2[:hello] = "world2"
+      v3[:hello] = "world3"
+      assert_equal ["world1", "world2", "world3"], @digraph.vertices.collect{|v| v[:hello]}
+      assert_nothing_raised { @digraph.send(:check_sanity) }
+    end
+    
+    def test_add_n_vertices_with_block
+      vertices = @digraph.add_n_vertices(5, Until) do |v,i|
+        v.set_mark(:mark, i)
+      end
+      vertices.each_with_index do |v,i|
+        assert_equal i, v.mark
+        assert Until===v
+      end
+      assert_equal [0, 1, 2, 3, 4], vertices.get_mark(:mark)
+    end
+    
+    def test_connect
+      v1, v2 = @digraph.add_n_vertices(2)
+      edge = @digraph.connect(v1, v2, {:label => "hello"})
+      assert_equal @digraph, edge.graph
+      assert_not_nil edge
+      assert_equal 0, edge.index
+      assert_equal "hello", edge[:label]
+      assert_equal v1, edge.source
+      assert_equal v2, edge.target
+      assert_equal EdgeSet[edge], @digraph.edges
+      
+      assert_equal EdgeSet[], v1.in_edges
+      assert_equal EdgeSet[edge], v1.out_edges
+      assert_equal EdgeSet[], v2.out_edges
+      assert_equal EdgeSet[edge], v2.in_edges
+      assert_nothing_raised { @digraph.send(:check_sanity) }
+    end
+    
+    def test_connect_all
+      v1, v2 = @digraph.add_n_vertices(2)
+      e1, e2 = @digraph.connect_all([v1, v2], [v2, v1])
+      assert_equal VertexSet[v1, v2], @digraph.vertices
+      assert_equal EdgeSet[e1, e2], @digraph.edges
+      assert_equal VertexSet[v1, v2], e1.extremities
+      assert_equal VertexSet[v2, v1], e2.extremities
+      assert_equal EdgeSet[e1], v1.out_edges
+      assert_equal EdgeSet[e2], v1.in_edges
+      assert_equal EdgeSet[e2], v2.out_edges
+      assert_equal EdgeSet[e1], v1.out_edges
+      assert_nothing_raised { @digraph.send(:check_sanity) }
+    end
+    
+    def test_connect_all_with_marks
+      v1, v2 = @digraph.add_n_vertices(2)
+      e1, e2 = @digraph.connect_all([v1, v2, {:hello => "world"}], [v2, v1, {:hello => "world"}])
+      assert_equal VertexSet[v1, v2], @digraph.vertices
+      assert_equal EdgeSet[e1, e2], @digraph.edges
+      assert_equal VertexSet[v1, v2], e1.extremities
+      assert_equal VertexSet[v2, v1], e2.extremities
+      assert_equal EdgeSet[e1], v1.out_edges
+      assert_equal EdgeSet[e2], v1.in_edges
+      assert_equal EdgeSet[e2], v2.out_edges
+      assert_equal EdgeSet[e1], v1.out_edges
+      assert_equal "world", e1[:hello]
+      assert_equal "world", e2[:hello]
+      e1[:hello] = "world1"
+      assert_equal "world", e2[:hello]
+      assert_nothing_raised { @digraph.send(:check_sanity) }
+    end
+    
+    def test_remove_edge
+      v1, v2 = @digraph.add_n_vertices(2)
+      edge = @digraph.connect(v1, v2)
+      @digraph.remove_edge(edge)
+      assert_equal VertexSet[v1, v2], @digraph.vertices
+      assert_equal EdgeSet[], @digraph.edges
+      assert_equal EdgeSet[], v1.in_edges
+      assert_equal EdgeSet[], v1.out_edges
+      assert_equal EdgeSet[], v2.in_edges
+      assert_equal EdgeSet[], v2.out_edges
+      
+      e1 = @digraph.connect(v1, v2)
+      e2 = @digraph.connect(v2, v1)
+      assert_equal VertexSet[v1, v2], @digraph.vertices
+      assert_equal EdgeSet[e1, e2], @digraph.edges
+      assert_equal EdgeSet[e2], v1.in_edges
+      assert_equal EdgeSet[e1], v1.out_edges
+      assert_equal EdgeSet[e1], v2.in_edges
+      assert_equal EdgeSet[e2], v2.out_edges
+      @digraph.remove_edge(e1)
+      assert_equal VertexSet[v1, v2], @digraph.vertices
+      assert_equal EdgeSet[e2], @digraph.edges
+      assert_equal EdgeSet[e2], v1.in_edges
+      assert_equal EdgeSet[], v1.out_edges
+      assert_equal EdgeSet[], v2.in_edges
+      assert_equal EdgeSet[e2], v2.out_edges
+      assert_equal 0, e2.index
+      assert_nothing_raised { @digraph.send(:check_sanity) }
+    end
+    
+    def test_remove_edges
+      v1, v2, v3 = @digraph.add_n_vertices(3)
+      e12 = @digraph.connect(v1, v2)
+      e23 = @digraph.connect(v2, v3)
+      e32 = @digraph.connect(v3, v2)
+      e21 = @digraph.connect(v2, v1)
+      @digraph.remove_edges(e12, e23, e32, e21)
+      assert_equal EdgeSet[], @digraph.edges
+      [v1, v2, v3].each do |v|
+        assert_equal EdgeSet[], v.in_edges
+        assert_equal EdgeSet[], v.out_edges
+      end
+      assert_equal [-1], [e12, e23, e32, e21].collect {|e| e.index}.uniq
+      
+      e12 = @digraph.connect(v1, v2)
+      e23 = @digraph.connect(v2, v3)
+      e32 = @digraph.connect(v3, v2)
+      e21 = @digraph.connect(v2, v1)
+      @digraph.remove_edges(e12, e32)
+      assert_equal [-1], [e12, e32].collect {|e| e.index}.uniq
+      assert_equal EdgeSet[e23, e21], @digraph.edges
+      assert_equal 0, e23.index
+      assert_equal 1, e21.index
+      assert_equal EdgeSet[e23, e21], v2.out_edges
+      assert_equal EdgeSet[e23], v3.in_edges
+      assert_equal EdgeSet[e21], v1.in_edges
+      assert_nothing_raised { @digraph.send(:check_sanity) }
+    end
+    
+    def test_remove_vertex
+      v1, v2, v3 = @digraph.add_n_vertices(3)
+      e12 = @digraph.connect(v1, v2)
+      e23 = @digraph.connect(v2, v3)
+      e32 = @digraph.connect(v3, v2)
+      e21 = @digraph.connect(v2, v1)
+      @digraph.remove_vertex(v1)
+      assert_equal -1, v1.index
+      assert_equal VertexSet[v2, v3], @digraph.vertices
+      assert_equal [0, 1], @digraph.vertices.collect{|v| v.index}
+      assert_equal EdgeSet[e23, e32], @digraph.edges
+      assert_equal EdgeSet[e23], v2.out_edges
+      assert_equal EdgeSet[e32], v2.in_edges
+      assert_nothing_raised { @digraph.send(:check_sanity) }
+    end
+    
+    def test_reconnect
+      v1, v2 = @digraph.add_n_vertices(2)
+      edge = @digraph.connect(v1, v2)
+      @digraph.reconnect(edge, v2, v1)
+      assert_equal VertexSet[v1, v2], @digraph.vertices
+      assert_equal EdgeSet[edge], @digraph.edges
+      assert_equal v2, edge.source
+      assert_equal v1, edge.target
+      assert_equal EdgeSet[edge], v1.in_edges
+      assert_equal EdgeSet[edge], v2.out_edges
+      assert_nothing_raised { @digraph.send(:check_sanity) }
+    end
+    
+    def test_connect_returns_flatten_set
+      sources = @digraph.add_n_vertices(5)
+      edges = @digraph.connect(sources, sources)
+      assert_equal 25, edges.length
+    end
+        
+    # def test_remove_vertex_with_block
+    #   v1, v2, v3 = @digraph.add_n_vertices(3)
+    #   e12 = @digraph.connect(v1, v2)
+    #   e23 = @digraph.connect(v2, v3)
+    #   e32 = @digraph.connect(v3, v2)
+    #   e21 = @digraph.connect(v2, v1)
+    #   @digraph.remove_vertex(v3) do |g,ine,oute|
+    #     g.reconnect(ine, nil, v1)
+    #     g.reconnect(oute, v1, nil)
+    #     assert (v3.in_edges+v3.out_edges).empty?
+    #   end
+    #   assert_equal [e12, e23, e32, e21], @digraph.edges
+    #   assert_equal [v1, v2], e12.extremities
+    #   assert_equal [v2, v1], e23.extremities
+    #   assert_equal [v1, v2], e32.extremities
+    #   assert_equal [v2, v1], e21.extremities
+    #   assert_equal [e21, e23], v1.in_edges
+    #   assert_equal [e12, e32], v1.out_edges
+    #   assert_equal [e12, e32], v2.in_edges
+    #   assert_equal [e23, e21], v2.out_edges
+    #   assert_nothing_raised { @digraph.send(:check_sanity) }
+    # end
+    # 
+    # def test_remove_vertex_with_block_using_edge_shortcuts
+    #   v1, v2, v3 = @digraph.add_n_vertices(3)
+    #   e12 = @digraph.connect(v1, v2)
+    #   e23 = @digraph.connect(v2, v3)
+    #   e32 = @digraph.connect(v3, v2)
+    #   e21 = @digraph.connect(v2, v1)
+    #   @digraph.remove_vertex(v3) do |g,ine,oute|
+    #     ine.each do |e| e.target = v1 end
+    #     oute.each do |e| e.source = v1 end
+    #     assert (v3.in_edges+v3.out_edges).empty?
+    #   end
+    #   assert_equal [e12, e23, e32, e21], @digraph.edges
+    #   assert_equal [v1, v2], e12.extremities
+    #   assert_equal [v2, v1], e23.extremities
+    #   assert_equal [v1, v2], e32.extremities
+    #   assert_equal [v2, v1], e21.extremities
+    #   assert_equal [e21, e23], v1.in_edges
+    #   assert_equal [e12, e32], v1.out_edges
+    #   assert_equal [e12, e32], v2.in_edges
+    #   assert_equal [e23, e21], v2.out_edges
+    #   assert_nothing_raised { @digraph.send(:check_sanity) }
+    # end
+    
+  end
+end

data/test/yargi/digraph_vertex_test.rb

@@ -0,0 +1,61 @@
+require 'test/unit'
+require 'yargi'
+
+module Yargi
+  class Digraph
+    
+    class VertexTest < Test::Unit::TestCase
+      
+      module Center; end
+      module AtOne; end
+      module AtTwo; end
+  
+      # Builds the star graph under @star
+      def setup
+        @star = Yargi::Digraph.new
+        @center = @star.add_vertex(Center)
+        @atone = @star.add_n_vertices(10, AtOne)
+        @attwo = @star.add_n_vertices(10, AtTwo)
+        @center_to_one = @star.connect(@center, @atone)
+        @one_to_two = @atone.zip(@attwo).collect do |pair|
+          @star.connect(pair[0], pair[1])
+        end
+        @one_to_two = VertexSet.new(@one_to_two)
+      end
+      
+      def test_in_and_out_edges
+        assert_equal EdgeSet[], @center.in_edges
+        assert_equal @center_to_one, @center.out_edges
+        assert_equal @center_to_one, @atone.collect{|v| v.in_edges}.flatten
+      end
+      
+      def test_in_adjacent
+        @atone.each {|v| assert_equal VertexSet[@center], v.in_adjacent}
+        @atone.each {|v| assert_equal VertexSet[@center], v.in_adjacent(Center)}
+        @atone.each {|v| assert_equal VertexSet[], v.in_adjacent(AtOne)}
+        assert_equal VertexSet[@center], @atone.in_adjacent
+        assert @atone.in_adjacent(AtOne).empty?
+        assert_equal VertexSet[@center], @atone.in_adjacent(Center)
+      end
+      
+      def test_out_adjacent
+        @atone.each_with_index {|v,i| assert_equal @attwo[i,1], v.out_adjacent}
+        @atone.each_with_index {|v,i| assert_equal @attwo[i,1], v.out_adjacent(AtTwo)}
+        @atone.each_with_index {|v,i| assert_equal VertexSet[], v.in_adjacent(AtOne)}
+        assert_equal @attwo, @atone.out_adjacent
+        assert @atone.out_adjacent(AtOne).empty?
+        assert_equal @attwo, @atone.out_adjacent(AtTwo)
+      end
+      
+      def test_adjacent
+        assert_equal @atone, @center.adjacent
+        assert_equal (@attwo+[@center]).sort, @atone.adjacent.sort
+        assert_equal @atone.sort, @attwo.adjacent.sort
+        assert_equal @star.vertices, (@atone+[@center]).adjacent.sort
+        assert_equal @atone, (@atone+[@center]).adjacent(AtOne).sort
+      end
+      
+    end # class VertexTest
+    
+  end
+end

data/test/yargi/documentation_test.rb

@@ -0,0 +1,44 @@
+require 'test/unit'
+require 'yargi'
+
+module Yargi
+  
+  # Here to check that what's in the documentation is correct
+  class DocumentationTest < Test::Unit::TestCase
+
+    module Source; end
+    module Sink; end
+
+    def test_README_example
+      # create a directed graph
+      digraph = Yargi::Digraph.new
+  
+      # create 10 source and 5 sink vertices, tag them with user modules
+      sources = digraph.add_n_vertices(5, Source)
+      assert VertexSet===sources
+  
+      # connect source to sink states
+      edges = digraph.connect(sources, sources)
+      assert EdgeSet===edges
+  
+      # put some dot attributes
+      sources.add_marks(:shape => 'circle', :label => '')
+      edges.add_marks do |e|
+        {:label => "From #{e.source.index} to #{e.target.index}"}
+      end
+  
+      # and print it
+      dir = File.expand_path(File.dirname(__FILE__))
+      dotfile = File.join(dir,"README-example.dot")
+      gitfile = File.join(dir,"README-example.gif")
+      File.open(dotfile, 'w') {|f| f << digraph.to_dot}
+      begin
+        `dot -Tgif -o #{gitfile} #{dotfile}`
+      rescue => ex
+        $STDERR << "dot test failed, probably not installed\n#{ex.message}"
+      end
+    end
+
+  end # class DocumentationTest
+  
+end

data/test/yargi/element_set_test.rb

@@ -0,0 +1,17 @@
+require 'test/unit'
+require 'yargi'
+
+module Yargi
+  class ElementSetTest < Test::Unit::TestCase
+    
+    def test_flatten
+      e = ElementSet[ElementSet[1, 2, 3], ElementSet[4, 5, 6]]
+      assert_equal ElementSet[1, 2, 3, 4, 5, 6], e.flatten
+
+      e = EdgeSet[EdgeSet[1, 2, 3], EdgeSet[4, 5, 6], 7]
+      assert EdgeSet===e
+      assert_equal EdgeSet[1, 2, 3, 4, 5, 6, 7], e.flatten
+    end
+    
+  end
+end

data/test/yargi/hypotheses_test.rb

@@ -0,0 +1,30 @@
+require 'test/unit'
+
+module Yargi
+  
+  # Checks some hypotheses that we make about Ruby 
+  class HypothesesTest < Test::Unit::TestCase
+    
+    def test_method_missing_handles_block_as_expected
+      p = Object.new
+      def p.say_hello
+        who = block_given? ? yield : "anonymous"
+        "Hello #{who}"
+      end
+      o = Object.new
+      def o.set_obj(obj)
+        @obj = obj
+      end
+      def o.method_missing(name, *args, &block)
+        @obj.send(name, *args, &block)
+      end
+      assert_equal "Hello anonymous", p.say_hello
+      assert_equal "Hello blambeau", p.say_hello {"blambeau"}
+      o.set_obj(p)
+      assert_equal "Hello anonymous", o.say_hello
+      assert_equal "Hello blambeau", o.say_hello {"blambeau"}
+    end
+    
+  end # class HypothesesTest
+
+end

data/test/yargi/markable_test.rb

@@ -0,0 +1,56 @@
+require 'test/unit'
+require 'yargi'
+
+module Yargi
+  class MarkableTest < Test::Unit::TestCase
+    
+    def setup
+      @object = Object.new
+      @object.extend Yargi::Markable
+    end
+    
+    def test_mark_set_and_get
+      @object.set_mark("hello", "world")
+      assert_equal "world", @object.get_mark("hello")
+      @object.set_mark("hello", "world1")
+      assert_equal "world1", @object.get_mark("hello")
+    end
+    
+    def test_mark_set_and_get_though_hash_api
+      @object["hello"] = "world"
+      assert_equal "world", @object["hello"]
+      @object["hello"] = "world1"
+      assert_equal "world1", @object["hello"]
+    end
+    
+    def test_friendly_methods
+      @object.set_mark(:first, 1)
+      assert_equal 1, @object.first
+      @object[:first] = 1
+      assert_equal 1, @object.first
+      @object.first = 2
+      assert_equal 2, @object.first
+    end
+    
+    def test_it_is_not_intrusive
+      @object[:merge_marks] = 1
+      assert_nothing_raised do
+        @object.merge_marks "hello" => "marks"
+      end
+      assert_equal 1, @object[:merge_marks]
+      assert_equal "marks", @object["hello"]
+    end
+    
+    def test_to_h
+      @object.set_mark(:me, "blambeau")
+      @object.add_marks(:hello => "world", :who => "yarvi", :nil => nil)
+      expected = {:me => "blambeau", :hello => "world", :who => "yarvi", :nil => nil}
+      assert_equal expected, @object.to_h(false)
+      expected = {:me => "blambeau", :hello => "world", :who => "yarvi"}
+      assert_equal expected, @object.to_h(true)
+      expected = {:me => "blambeau", :hello => "world", :who => "yarvi"}
+      assert_equal expected, @object.to_h()
+    end
+    
+  end
+end

data/test/yargi/predicate_test.rb

@@ -0,0 +1,90 @@
+require 'test/unit'
+require 'yargi'
+
+module Yargi
+  
+  # Tests all predidate classes
+  class PredicateTest < Test::Unit::TestCase
+    
+    def test_to_predicate
+      assert TruePredicate===Predicate.to_predicate(nil)
+      assert TruePredicate===Predicate.to_predicate(true)
+      assert FalsePredicate===Predicate.to_predicate(false)
+      assert TagPredicate===Predicate.to_predicate(Yargi)
+      assert TagPredicate===Predicate.to_predicate(PredicateTest)
+      assert LambdaPredicate===(Predicate.to_predicate {|elm| true})
+      proc = Proc.new {|elm| true}
+      assert LambdaPredicate===Predicate.to_predicate(proc)
+      assert AndPredicate === (Predicate.to_predicate(Yargi) {|elm| true})
+    end
+    
+    def test_tag_predicate
+      p = TagPredicate.new(Test::Unit::TestCase)
+      assert p===self
+      assert_equal false, p===p
+    end
+    
+    def test_lambda_predicate
+      p = LambdaPredicate.new {|elm| Test::Unit::TestCase===elm}
+      assert p===self
+      assert_equal false, p===p
+    end
+    
+    def test_not_predicate
+      p = TagPredicate.new(Test::Unit::TestCase)
+      p = NotPredicate.new(p)
+      assert_equal false, p===self
+      assert_equal true, p===p
+    end
+    
+    def test_and_predicate
+      assert_equal true, Object===self
+      p1 = TagPredicate.new(Object)
+      p2 = LambdaPredicate.new {|elm| elm.respond_to?(:test_and_predicate)}
+      anded = AndPredicate.new(p1, p2)
+      assert_equal true, anded===self
+      assert_equal false, anded==="hello"
+    end
+    
+    def test_or_predicate
+      p1 = LambdaPredicate.new {|elm| elm.respond_to?(:upcase)}
+      p2 = LambdaPredicate.new {|elm| elm.respond_to?(:test_and_predicate)}
+      ored = OrPredicate.new(p1, p2)
+      assert_equal true, ored===self
+      assert_equal true, ored==="hello"
+      assert_equal false, ored===12
+    end
+    
+    def test_not_accepts_modules
+      p = NotPredicate.new(Test::Unit::TestCase)
+      assert_equal false, p===self
+      assert_equal true, p==="hello"
+    end
+    
+    def test_ruby_shortcuts
+      all = Yargi::ALL
+      none = Yargi::NONE
+      p = all & Test::Unit::TestCase
+      assert_equal true, p===self
+      assert_equal false, p==="hello"
+      p = p.not()
+      assert_equal false, p===self
+      assert_equal true, p==="hello"
+      
+      respond = LambdaPredicate.new {|elm| elm.respond_to?(:test_and_predicate)}
+      assert_equal true, respond===self
+      p = all & Test::Unit::TestCase & respond
+      assert_equal true, p===self
+      
+      ored = none|all
+      assert_equal true, ored===self
+      
+      ored = none|respond|String
+      assert_equal true, ored===self
+      assert_equal true, ored==="hello"
+      assert_equal false, ored===12
+    end
+    
+  end # class PredicateTest
+  
+end