khammurabi 0.2

data/khammurabi-0.2/tests/test_multi_children_selector_node.rb

@@ -0,0 +1,203 @@
+module MK
+
+  require 'test/unit'
+  require 'stringio'
+
+  require 'nist/khammurabi/Engine'
+  require 'nist/khammurabi/TestNode'
+  require 'nist/khammurabi/VariableTestNode'
+  require 'nist/khammurabi/InstantiatorNode'
+  require 'nist/khammurabi/ObjectProduction'
+  require 'nist/khammurabi/ArrayAddon'
+  require 'nist/khammurabi/GraphNode'
+  require 'nist/khammurabi/ValueTestSuite'
+	require 'nist/khammurabi/Cluster'
+	require 'nist/khammurabi/ClusterManager'
+	require 'nist/khammurabi/ZombieNode'
+	require 'nist/khammurabi/MultiChildrenSelectorNode'
+	require 'nist/khammurabi/ObjectGraphWrapper'
+	
+  class Tester
+    attr :val1, true
+    attr :val2, true
+    attr :val3, true
+		attr :cluster, true # Array
+    def initialize
+      self.val1 = self.val2 = self.val3 = nil
+			self.cluster = nil
+    end
+		def to_s 
+      "val1: #{self.val1} val2: #{self.val2} val3: #{self.val3}"
+		end
+  end
+
+  class Test_Multi_Children_Selector_Node < Test::Unit::TestCase
+
+    attr_accessor :graphA
+
+    def objectA
+      t = Tester.new
+      t.val1 = 5
+      t.val2 = 10
+      #t.val3 = 15
+      t
+    end
+
+		def objectB
+      t = Tester.new
+      t.val1 = 1
+      t.val2 = 10
+      #t.val3 = 15
+      t
+    end
+
+		# Test to make sure that each child of the MultiChildrenArbitratorNode gets a single token
+		def test_select1
+			engine = Engine.new
+			mcsn = MultiChildrenSelectorNode.init( "mcsn", engine, false )
+			zns = Array.new
+			tokens = Array.new
+			size = 2
+			size.times do |a|
+				zns.push( ZombieNode.init( "ZombieNode #{a}", engine ) )
+				mcsn.addChild( zns[ a ] )
+				zns[ a ].setParent( mcsn )
+				tokens.push( Token.init( ObjectGraphWrapper.init( Tester.new ), "Token #{a}", Time.now ) )
+			end
+
+			size.times do |a|
+				mcsn.registerToken( tokens[ a ] )
+				mcsn.execute
+			end
+			
+			size.times do |a|
+				assert( zns[ a ].tokens.size == 1, "ZombieNode #{a}'s tokens size is #{zns[a].tokens.size} while it should be 1" )
+			end
+		end
+
+		# Test to make sure that each child of the MultiChildrenArbitratorNode gets a single token with many more cases
+		def test_select2
+			engine = Engine.new
+			mcsn = MultiChildrenSelectorNode.init( "mcsn", engine, false )
+			zns = Array.new
+			tokens = Array.new
+			size = 20
+			size.times do |a|
+				zns.push( ZombieNode.init( "ZombieNode #{a}", engine ) )
+				mcsn.addChild( zns[ a ] )
+				zns[ a ].setParent( mcsn )
+				tokens.push( Token.init( ObjectGraphWrapper.init( Tester.new ), "Token #{a}", Time.now ) )
+			end
+
+			size.times do |a|
+				mcsn.registerToken( tokens[ a ] )
+				mcsn.execute
+			end
+			
+			size.times do |a|
+				assert( zns[ a ].tokens.size == 1, "ZombieNode #{a}'s tokens size is #{zns[a].tokens.size} while it should be 1" )
+			end
+		end
+
+		# Test using sittingChildren
+		def test_sitting_children
+			engine = MK::Engine.new
+			mcsn = MK::MultiChildrenSelectorNode.init( "mcsn", engine, false )
+			ctn1 = MK::ConstantTestNode.init( "ctn1", MK::ConstantObjectOperation.init( MK::EqualityTest.init( 10 ), "@val1", true ), engine, mcsn )
+			ctn2 = MK::ConstantTestNode.init( "ctn2", MK::ConstantObjectOperation.init( MK::EqualityTest.init( 12 ), "@val1", true ), engine, mcsn )
+			ctn3 = MK::ConstantTestNode.init( "ctn3", MK::ConstantObjectOperation.init( MK::EqualityTest.init( 12 ), "@val1", true ), engine, mcsn )
+			zn1 = MK::ZombieNode.init( "Zombie!! nooo!!", engine )
+			zn2 = MK::ZombieNode.init( "Zombie!! nooo (2)!!", engine )
+			zn3 = MK::ZombieNode.init( "Zombie!! nooo (3)!!", engine )
+			ctn1.makeChildConnection( zn1 )
+			ctn2.makeChildConnection( zn2 )
+			ctn3.makeChildConnection( zn3 )
+			mcsn.makeChildConnection( ctn1 )
+			mcsn.makeChildConnection( ctn2 )
+			mcsn.makeChildConnection( ctn3 )
+			
+			tokens = Array.new
+			3.times do |a|
+				tokens.push( Token.init( ObjectGraphWrapper.init( Tester.new ), "Token #{a}", Time.now ) )
+			end
+			tokens[ 0 ].objectGraphWrappers.first.object.val1 = 12
+			tokens[ 1 ].objectGraphWrappers.first.object.val1 = 12
+		
+			2.times do |a|
+				mcsn.registerToken( tokens[ a ] )
+				mcsn.execute
+			end
+			
+			assert( zn1.tokens.size == 0, "zn1.tokens.size != 0 (it's: #{zn1.tokens.size})" )
+			assert( zn2.tokens.size == 1, "zn2.tokens.size != 1 (it's: #{zn2.tokens.size})" )
+			assert( zn3.tokens.size == 1, "zn3.tokens.size != 1 (it's: #{zn3.tokens.size})" )
+			
+		end
+		
+		# Test using sittingChildren.. a little more complex
+		def test_sitting_children2
+			engine = MK::Engine.new
+			mcsn = MK::MultiChildrenSelectorNode.init( "mcsn", engine, false )
+			ctn1 = MK::ConstantTestNode.init( "ctn1", MK::ConstantObjectOperation.init( MK::EqualityTest.init( 10 ), "@val1", true ), engine, mcsn )
+			ctn2 = MK::ConstantTestNode.init( "ctn2", MK::ConstantObjectOperation.init( MK::EqualityTest.init( 10 ), "@val1", true ), engine, mcsn )
+			ctn3 = MK::ConstantTestNode.init( "ctn3", MK::ConstantObjectOperation.init( MK::EqualityTest.init( 10 ), "@val1", true ), engine, mcsn )
+			ctn4 = MK::ConstantTestNode.init( "ctn4", MK::ConstantObjectOperation.init( MK::EqualityTest.init( 12 ), "@val1", true ), engine, mcsn )
+			ctn5 = MK::ConstantTestNode.init( "ctn5", MK::ConstantObjectOperation.init( MK::EqualityTest.init( 12 ), "@val1", true ), engine, mcsn )
+			ctn6 = MK::ConstantTestNode.init( "ctn6", MK::ConstantObjectOperation.init( MK::EqualityTest.init( 12 ), "@val1", true ), engine, mcsn )
+			zn1 = MK::ZombieNode.init( "Zombie!! nooo!!", engine )
+			zn2 = MK::ZombieNode.init( "Zombie!! nooo (2)!!", engine )
+			zn3 = MK::ZombieNode.init( "Zombie!! nooo (3)!!", engine )
+			zn4 = MK::ZombieNode.init( "Zombie!! nooo (4)!!", engine )
+			zn5 = MK::ZombieNode.init( "Zombie!! nooo (5)!!", engine )
+			zn6 = MK::ZombieNode.init( "Zombie!! nooo (6)!!", engine )
+			ctn1.makeChildConnection( zn1 )
+			ctn2.makeChildConnection( zn2 )
+			ctn3.makeChildConnection( zn3 )
+			ctn4.makeChildConnection( zn4 )
+			ctn5.makeChildConnection( zn5 )
+			ctn6.makeChildConnection( zn6 )
+			mcsn.makeChildConnection( ctn1 )
+			mcsn.makeChildConnection( ctn2 )
+			mcsn.makeChildConnection( ctn3 )
+			mcsn.makeChildConnection( ctn4 )
+			mcsn.makeChildConnection( ctn5 )
+			mcsn.makeChildConnection( ctn6 )
+			
+			tokens = Array.new
+			5.times do |a|
+				tokens.push( Token.init( ObjectGraphWrapper.init( Tester.new ), "Token #{a}", Time.now ) )
+			end
+			tokens[ 0 ].objectGraphWrappers.first.object.val1 = 12
+			tokens[ 1 ].objectGraphWrappers.first.object.val1 = 12
+			tokens[ 2 ].objectGraphWrappers.first.object.val1 = 12
+			tokens[ 3 ].objectGraphWrappers.first.object.val1 = 10
+			tokens[ 4 ].objectGraphWrappers.first.object.val1 = 10
+		
+			5.times do |a|
+				mcsn.registerToken( tokens[ a ] )
+				mcsn.execute
+			end
+			
+			assert( zn4.tokens.size == 1, "zn4.tokens.size != 1 (it's: #{zn4.tokens.size})" )
+			assert( zn5.tokens.size == 1, "zn5.tokens.size != 1 (it's: #{zn5.tokens.size})" )
+			assert( zn6.tokens.size == 1, "zn6.tokens.size != 1 (it's: #{zn6.tokens.size})" )			
+			assert( zn1.tokens.size == 1, "zn1.tokens.size != 1 (it's: #{zn1.tokens.size})" )			
+			assert( zn2.tokens.size == 1, "zn2.tokens.size != 1 (it's: #{zn1.tokens.size})" )			
+		end
+		
+		def self.suite
+      suite = Test::Unit::TestSuite.new
+			suite << self.new( 'test_select1' )
+			suite << self.new( 'test_select2' )
+			suite << self.new( 'test_sitting_children' )
+			suite << self.new( 'test_sitting_children2' )
+			suite
+    end
+
+  end
+
+  require 'test/unit/ui/console/testrunner'
+
+  Test::Unit::UI::Console::TestRunner.run( Test_Multi_Children_Selector_Node )
+
+end

data/khammurabi-0.2/tests/test_object_description.rb

@@ -0,0 +1,177 @@
+module MK
+
+  require 'test/unit'
+  require 'stringio'
+	require 'tracer'
+	
+  require 'nist/khammurabi/Engine'
+  require 'nist/khammurabi/TestNode'
+  require 'nist/khammurabi/VariableTestNode'
+  require 'nist/khammurabi/InstantiatorNode'
+  require 'nist/khammurabi/ObjectProduction'
+  require 'nist/khammurabi/ArrayAddon'
+  require 'nist/khammurabi/GraphNode'
+  require 'nist/khammurabi/ValueTestSuite'
+	require 'nist/khammurabi/Cluster'
+	require 'nist/khammurabi/ClusterManager'
+	require 'nist/khammurabi/ZombieNode'
+	
+  class Tester_Object_Description
+    attr :val1, true
+    attr :val2, true
+    attr :val3, true
+		attr :clusters, true
+    def initialize
+      self.val1 = self.val2 = self.val3 = self.clusters = nil
+    end
+		def to_s 
+      "val1: #{self.val1} val2: #{self.val2} val3: #{self.val3}"
+		end
+  end
+
+	class Tester_Object_Description2
+    attr :val1, true
+    attr :val2, true
+    attr :val3, true
+		attr :val4, true
+		attr :val5, true
+		attr :clusters, true
+    def initialize
+      self.val1 = self.val2 = self.val3 = self.clusters = nil
+    end
+		def to_s 
+      "val1: #{self.val1} val2: #{self.val2} val3: #{self.val3}"
+		end
+  end
+
+	# This test class tests TokenCluster functionality without a graph behind it
+	# It utilizes VariableTestNode's, but does not build a graph
+  class Test_Object_Description < Test::Unit::TestCase
+
+    attr_accessor :graphA
+
+    def objectA
+      t = Tester_Object_Description.new
+      t.val1 = 5
+      t.val2 = 10
+      t.val3 = 11
+      t
+    end
+
+    def objectD
+      t = Tester_Object_Description2.new
+      t.val1 = 5
+      t.val2 = 10
+			t.val3 = t.val4 = t.val5 = 11
+      #t.val3 = 15
+      t
+    end
+    
+		def test_parseObject
+			t = objectA
+			od = ObjectDescription.init( t )
+			od.parseObject
+			testNode = od[ "@val1" ]
+			assert( testNode.class == ConstantObjectOperation, "testNode's class isn't ConstantObjectOperation" )
+			assert( testNode.templateTestValue.first == 5, "its not 5!" )
+			testNode = od[ "@val2" ]
+			assert( testNode.templateTestValue.first == 10, "its not 10!" )
+		end
+		
+		def test_clone
+			t = objectA
+			t.val2 = 15
+			od = ObjectDescription.init( t )
+			od.parseObject
+			assert( od[ "@val2" ].templateTestValue.first == 15, "First one isn't 15" )
+			od2 = od.clone
+			assert( od2[ "@val2" ].templateTestValue.first == 15, "It's not 15, but #{od2["@val2"].templateTestValue}" )
+		end
+		
+		def test_concat
+			od = ObjectDescription.new
+			od.objectOperations[ "@val1" ] = ConstantObjectOperation.init( LessThanOrEqualTest.init( 5 ), "@val1", true ) 
+			od2 = ObjectDescription.new
+			od2.objectOperations[ "@val2" ] = ConstantObjectOperation.init( GreaterThanOrEqualTest.init( 10 ), "@val1", true )
+			od2.objectOperations[ "@val3" ] = ConstantObjectOperation.init( EqualityTest.init( 10 ), "@val1", true )
+			od3 = od.concat( od2 )
+			assert( od3.objectOperations.keys.size == 3, "od3's object operations' size isn't 3" )
+			assert( od3.objectOperations[ "@val1" ].class == ConstantObjectOperation, "@val1 doesn't exist after concatenation" )
+			assert( od3.objectOperations[ "@val2" ].class == ConstantObjectOperation, "@val2 doesn't exist after concatenation" )
+			assert( od3.objectOperations[ "@val3" ].class == ConstantObjectOperation, "@val3 doesn't exist after concatenation" )
+		end
+	
+		def test_sizes
+			od1 = ObjectDescription.init( objectA ) 
+			assert( od1.constants.size == 4, "od1.constants.size != 4, it is: #{od1.constants.size}" )
+			assert( od1.variables.size == 0, "od1.variables.size != 0, it is: #{od1.variables.size}" )
+			od1.setObjectAsVariable( "@val1", "X", MK::EqualityTest.new )
+			assert( od1.constants.size == 3, "od1.constants.size != 3, it is: #{od1.constants.size}" )
+			assert( od1.variables.size == 1, "od1.variables.size != 1, it is: #{od1.variables.size}" )
+		
+			od4 = ObjectDescription.init( objectD )
+			od4.setObjectAsVariable( "@val1", "X", MK::EqualityTest.new )
+			od4.setObjectAsVariable( "@val2", "X", MK::EqualityTest.new )
+			od4.setObjectAsVariable( "@val3", "X", MK::EqualityTest.new )
+			assert( od4.constants.size == 3, "od4.constants != 3, it is: #{od4.constants.size}" )
+			assert( od4.variables.size == 3, "od4.constants != 3, it is: #{od4.variables.size}" )
+		end	
+
+		def test_equalequal
+			od1 = ObjectDescription.init( objectA )
+			od2 = ObjectDescription.init( objectA )
+			assert( od1 == od2, "od1 != od2, bad" )
+		end
+
+		def test_equalequalequal
+			od1 = ObjectDescription.init( objectA )
+			objectd = objectD
+			od2 = ObjectDescription.init( objectd )
+			assert( od1 === od2, "od1 !== od2, bad" )
+
+			od2.objectOperations[ "@val2" ].valueTests.first.testValue = 100
+			assert( !(od1 === od2), "od1 === od2, bad" )
+			
+			od3 = ObjectDescription.init( objectA )
+			assert( od1 === od3, "od1 !== od3, bad" )
+
+			od4 = ObjectDescription.init( objectA )
+			od4.setObjectAsVariable( "@val3", "X", MK::EqualityTest.new )
+			assert( od1 === od4, "od1 !== od4, bad" )
+			od4.setObjectAsVariable( "@val2", "X", MK::EqualityTest.new )
+			assert( od1 === od4, "od1 !== od4, bad" )
+			od4.setObjectAsVariable( "@val1", "X", MK::EqualityTest.new )
+			assert( od1 === od4, "od1 !== od4, bad" )
+
+			od4.setObjectAsConstant( "@val1", MK::EqualityTest.init( 60 ) )
+			od1.setObjectAsConstant( "@val1", MK::EqualityTest.init( 50 ) )
+			assert( !(od1 === od4), "od1 === od4, but it shouldn't" )
+
+			# Try all variables vs all constants
+			od5 = ObjectDescription.init( objectA )
+			od6 = ObjectDescription.init( objectA )
+			od6.setObjectAsVariable( "@val1", "X", MK::EqualityTest.new )
+			od6.setObjectAsVariable( "@val2", "Y", MK::EqualityTest.new )
+			od6.setObjectAsVariable( "@val3", "Z", MK::EqualityTest.new )
+			assert( od6 === od5, "od6 !== od5, but it should" )
+			assert( od5 === od6, "od5 !== od6, but it should" )
+		end
+		
+		def self.suite
+			suite = Test::Unit::TestSuite.new
+			suite << self.new( 'test_parseObject' )
+			suite << self.new( 'test_clone' )
+			suite << self.new( 'test_concat' )
+			suite << self.new( 'test_sizes' )
+			suite << self.new( 'test_equalequal' )
+			suite << self.new( 'test_equalequalequal' )
+			suite
+		end
+	
+  end
+
+  require 'test/unit/ui/console/testrunner'
+
+  Test::Unit::UI::Console::TestRunner.run( Test_Object_Description )
+
+end

data/khammurabi-0.2/tests/test_person_graph.rb

@@ -0,0 +1,202 @@
+module MK
+
+  require 'test/unit'
+  require 'stringio'
+
+  require 'nist/khammurabi/Engine'
+  require 'nist/khammurabi/TestNode'
+  require 'nist/khammurabi/VariableTestNode'
+  require 'nist/khammurabi/InstantiatorNode'
+  require 'nist/khammurabi/ObjectProduction'
+  require 'nist/khammurabi/ArrayAddon'
+  require 'nist/khammurabi/GraphNode'
+  require 'nist/khammurabi/ValueTestSuite'
+	require 'nist/khammurabi/ReteParseTreePrinter'
+	
+  class Person
+    attr :age, true
+    attr :sex, true
+    attr :weight, true
+
+    def initialize
+      self.age = 1
+			self.sex = 'f'
+			self.weight = 120
+    end
+		def to_s 
+			"age: #{self.age} sex: #{self.sex} weight: #{self.weight}"
+		end
+  end
+
+  class Test_Graph < Test::Unit::TestCase
+
+    attr_accessor :graphA
+
+    def person
+      p = Person.new
+			p
+		end
+    
+		def test_1
+			objects = [ self.person, self.person ]
+			size = 2
+			
+			objectProduction = ObjectProduction.new
+			objectDescriptions = Array.new( size ) { ObjectDescription.new }
+      objectDescriptions.each_index do |idx| 
+		  	objectDescriptions[ idx ].objectDescribing = objects[ idx ]
+				objectDescriptions[ idx ].parseObject
+				objectDescriptions[ idx ].setObjectAsVariable( "@age", "age", [ MK::EqualityTest.new ] )
+				objectProduction.addObjectDescription( objectDescriptions[ idx ] )
+      end
+      
+      graph = Engine.new
+			graph.addObjectProduction( objectProduction )
+      #graph.setDebugging( true )
+      graph.compile
+
+			#printer = ReteParseTreePrinter.init( graph.root )
+			#print "\n\n" + printer.printOn( StringIO.new ).string + "\n\n"
+			#exit
+			
+			( objects.size - 1 ).times { |idx| graph.addObject( objects[ idx ] ) }
+
+      oin = graph.leaf( objectProduction ) 
+
+      instantiations = oin.instantiations
+      assert( instantiations.size == 0, "Instantiations size isn't 0, it's #{instantiations.size}" )
+
+			# Match the objects now and make sure it works
+			graph.addObject( objects[ -1 ] )
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+		end
+		
+		def test_2
+			objects = [ self.person, self.person ]
+			size = 2
+			
+			objectProduction = ObjectProduction.new
+			objectDescriptions = Array.new( size ) { ObjectDescription.new }
+      objectDescriptions.each_index do |idx| 
+		  	objectDescriptions[ idx ].objectDescribing = objects[ idx ]
+				objectDescriptions[ idx ].parseObject
+				objectDescriptions[ idx ].setObjectAsVariable( "@age", "age", [ MK::EqualityTest.new ] )
+				objectDescriptions[ idx ].setObjectAsVariable( "@sex", "sex", [ MK::EqualityTest.new ] )
+				objectProduction.addObjectDescription( objectDescriptions[ idx ] )
+      end
+      
+      graph = Engine.new
+			graph.addObjectProduction( objectProduction )
+      #graph.setDebugging( true )
+      graph.compile
+
+			#printer = ReteParseTreePrinter.init( graph.root )
+			#print "\n\n" + printer.printOn( StringIO.new ).string + "\n\n"
+			#exit
+			
+			( objects.size - 1 ).times { |idx| graph.addObject( objects[ idx ] ) }
+
+      oin = graph.leaf( objectProduction ) 
+
+      instantiations = oin.instantiations
+      assert( instantiations.size == 0, "Instantiations size isn't 0, it's #{instantiations.size}" )
+
+			# Match the objects now and make sure it works
+			graph.addObject( objects[ -1 ] )
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+		end
+
+		def test_3
+			objects = [ self.person, self.person, self.person ]
+			size = 3
+			
+			objects[ 2 ].weight = 5
+			objectProduction = ObjectProduction.new
+			objectDescriptions = Array.new( size ) { ObjectDescription.new }
+      objectDescriptions.each_index do |idx| 
+		  	objectDescriptions[ idx ].objectDescribing = objects[ idx ]
+				objectDescriptions[ idx ].parseObject
+				objectDescriptions[ idx ].setObjectAsVariable( "@age", "age", [ MK::EqualityTest.new ] )
+				objectProduction.addObjectDescription( objectDescriptions[ idx ] )
+      end
+			objectDescriptions[ 0 ].setObjectAsVariable( "@sex", "sex", [ MK::EqualityTest.new ] )
+			objectDescriptions[ 1 ].setObjectAsVariable( "@sex", "sex", [ MK::EqualityTest.new ] )
+      
+      graph = Engine.new
+			graph.addObjectProduction( objectProduction )
+      #graph.setDebugging( true )
+      graph.compile
+
+			#printer = ReteParseTreePrinter.init( graph.root )
+			#print "\n\n" + printer.printOn( StringIO.new ).string + "\n\n"
+			#exit
+			
+			( objects.size - 1 ).times { |idx| graph.addObject( objects[ idx ] ) }
+
+      oin = graph.leaf( objectProduction ) 
+
+      instantiations = oin.instantiations
+      assert( instantiations.size == 0, "Instantiations size isn't 0, it's #{instantiations.size}" )
+			
+			# Match the objects now and make sure it works
+			graph.addObject( objects[ -1 ] )
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+		end
+
+		def test_4
+			objects = [ self.person, self.person, self.person ]
+			objects[ 0 ].weight = 1
+			objects[ 1 ].weight = 2
+			objects[ 2 ].weight = 3
+			
+			size = 3
+			
+			objectProduction = ObjectProduction.new
+			objectDescriptions = Array.new( size ) { ObjectDescription.new }
+      objectDescriptions.each_index do |idx| 
+		  	objectDescriptions[ idx ].objectDescribing = objects[ idx ]
+				objectDescriptions[ idx ].parseObject
+				objectProduction.addObjectDescription( objectDescriptions[ idx ] )
+      end
+			objectDescriptions[ 0 ].setObjectAsVariable( "@age", "age", [ MK::EqualityTest.new ] )
+			objectDescriptions[ 1 ].setObjectAsVariable( "@age", "age", [ MK::EqualityTest.new ] )
+			objectDescriptions[ 1 ].setObjectAsVariable( "@sex", "sex", [ MK::EqualityTest.new ] )
+			objectDescriptions[ 2 ].setObjectAsVariable( "@sex", "sex", [ MK::EqualityTest.new ] )
+	      
+      graph = Engine.new
+			graph.addObjectProduction( objectProduction )
+      #graph.setDebugging( true )
+      graph.compile
+
+			#printer = ReteParseTreePrinter.init( graph.root )
+			#print "\n\n" + printer.printOn( StringIO.new ).string + "\n\n"
+			#exit
+			
+			( objects.size - 1 ).times { |idx| graph.addObject( objects[ idx ] ) }
+
+      oin = graph.leaf( objectProduction )
+
+      instantiations = oin.instantiations
+      assert( instantiations.size == 0, "Instantiations size isn't 0, it's #{instantiations.size}" )
+			
+			# Match the objects now and make sure it works
+			graph.addObject( objects[ -1 ] )
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+		end
+
+    def self.suite
+      suite = Test::Unit::TestSuite.new 
+      suite << self.new( 'test_1' )
+			suite << self.new( 'test_2' )
+			suite << self.new( 'test_3' )
+			suite << self.new( 'test_4' )
+      suite
+    end
+
+  end
+
+  require 'test/unit/ui/console/testrunner'
+
+  Test::Unit::UI::Console::TestRunner.run( Test_Graph )
+
+end