khammurabi 0.2

data/khammurabi-0.2/tests/test_variable_test_node.rb

@@ -0,0 +1,445 @@
+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'
+	require 'nist/khammurabi/ZombieNode'
+	require 'nist/khammurabi/Cluster'
+	require 'nist/khammurabi/TokenCluster'
+	require 'nist/khammurabi/ClusterManager'
+	
+  class Tester_Variable
+    attr :val1, true
+    attr :val2, true
+    attr :val3, true
+
+    def initialize
+      @val1 = @val2 = @val3 = nil
+    end
+		def setValues( a, b, c )
+			@val1 = a
+			@val2 = b
+			@val3 = c
+		end
+		def to_s 
+				"val1: #{self.val1} val2: #{self.val2} val3: #{self.val3}"
+		end
+  end
+
+  class Tester_Variable2
+    attr :val0, true
+    attr :val1, true
+    attr :val2, true
+    attr :val3, true
+
+    def initialize
+      @val0 = @val1 = @val2 = @val3 = nil
+    end
+		def setValues( a, b, c, d )
+			self.val0 = a
+			self.val1 = b
+			self.val2 = c
+			self.val3 = d
+		end
+  end
+
+	# This class fascilitates VariableTestNode testing with hand-build-graphs
+	# "inequality" in the testing means that the tests that some VariableTestNode's use
+	# are inequality tests (the test the VariableTestNode uses returns true when the objects input into it are unequal),
+	# not that the tokens input are unequal
+  class Test_Variable_Test_Node < Test::Unit::TestCase
+
+    attr_accessor :graphA
+
+    def objectA
+      t = Tester_Variable.new
+      t.val1 = 5
+      t.val2 = 10
+      #t.val3 = 15
+      t
+    end
+		
+		def objectB
+      t = Tester_Variable.new
+      t.val1 = 2
+      t.val2 = 10
+      #t.val3 = 15
+      t
+    end
+
+		def objectC
+      t = Tester_Variable.new
+      t.val1 = 3
+      t.val2 = 10
+      #t.val3 = 15
+      t
+    end
+
+		# Two VariableObjectOperations with equality
+		def test_two_with_equality
+			engine = MK::Engine.new
+			vtne = MK::VariableTestNodeExecutor.init( engine )
+		 	vtn1 = MK::VariableTestNode.init( "vtn1", MK::VariableObjectOperation.init( MK::EqualityTest.new, "@val1", true, "X" ), vtne, engine, nil, level = 0 )
+			vtn2 = MK::VariableTestNode.init( "vtn2", MK::VariableObjectOperation.init( MK::EqualityTest.new, "@val1", true, "X" ), vtne, engine, nil, level = 0 )
+			j1 = MK::GraphNodeJoiner.init( "j1", vtn1, vtn2, engine )
+			vtn1.setChild( j1 )
+			vtn2.setChild( j1 )
+			zn = MK::ZombieNode.init( "zn1", engine )
+			zn.setParent( j1 )
+			j1.setChild( zn )
+			vtne.variableTestNodes = [ vtn1, vtn2 ]
+			
+			cm = ClusterManager.new
+			
+			token1 = Token.init( ObjectGraphWrapper.init( objectA ), "+", Time.now )
+			token2 = Token.init( ObjectGraphWrapper.init( objectA ), "+", Time.now )
+			cm.createCluster( [ token1 ], TokenCluster )
+			cm.createCluster( [ token2 ], TokenCluster )
+			
+			vtn1.registerToken( token1 )
+			vtn1.execute
+			
+			assert( vtn1.tokens.size == 1, "vtn1.tokens.size != 1, bad" )
+			
+			vtn2.registerToken( token2 )
+			vtn2.execute
+			
+			assert( vtn1.tokens.size == 0, "vtn1.tokens.size != 0, bad" )
+			assert( vtn2.tokens.size == 0, "vtn2.tokens.size != 0, bad" )
+			
+			assert( zn.tokens.size == 1, "zn.tokens.size != 1, bad" )
+		end
+		
+		# Three VariableObjectOperations with equality
+		def test_three_with_equality
+			engine = MK::Engine.new
+			vtne = MK::VariableTestNodeExecutor.init( engine )
+		 	vtn1 = MK::VariableTestNode.init( "vtn1", MK::VariableObjectOperation.init( MK::EqualityTest.new, "@val1", true, "X" ), vtne, engine, nil, level = 0 )
+			vtn2 = MK::VariableTestNode.init( "vtn2", MK::VariableObjectOperation.init( MK::EqualityTest.new, "@val1", true, "X" ), vtne, engine, nil, level = 0 )
+			vtn3 = MK::VariableTestNode.init( "vtn3", MK::VariableObjectOperation.init( MK::EqualityTest.new, "@val1", true, "X" ), vtne, engine, nil, level = 0 )
+			j1 = MK::GraphNodeJoiner.init( "j1", vtn1, vtn2, engine )
+			j2 = MK::GraphNodeJoiner.init( "j2", j1, vtn3, engine )
+			zn = MK::ZombieNode.init( "zombie, *shiver*", engine )
+			cm = ClusterManager.new
+			
+			vtn1.setChild( j1 )
+			vtn2.setChild( j1 )
+			j1.setChild( j2 )
+			vtn3.setChild( j2 )
+			
+			zn.setParent( j2 )
+			j2.setChild( zn )
+			
+			vtne.variableTestNodes = [ vtn1, vtn2, vtn3 ]
+			
+			token1 = Token.init( ObjectGraphWrapper.init( objectA ), "+", Time.now )
+			token2 = Token.init( ObjectGraphWrapper.init( objectA ), "+", Time.now )
+			token3 = Token.init( ObjectGraphWrapper.init( objectA ), "+", Time.now )
+			badToken = Token.init( ObjectGraphWrapper.init( objectB ), "+", Time.now )
+			
+			cm.createCluster( [ token1 ], TokenCluster )
+			cm.createCluster( [ token2 ], TokenCluster )
+			cm.createCluster( [ token3 ], TokenCluster )
+			cm.createCluster( [ badToken ], TokenCluster )
+			
+			vtn1.registerToken( token1 )
+			assert( vtn1.tokens.size == 1, "vtn1.tokens.size != 1, bad" )
+			vtn2.registerToken( token2 )
+			assert( vtn2.tokens.size == 1, "vtn2.tokens.size != 1, bad" )
+			
+			vtn3.registerToken( badToken )
+			vtn3.execute
+			[ vtn1, vtn2, vtn3 ].each { |node| assert( node.tokens.size == 1, "Node token size isn't 1, bad" ) }
+			
+			vtn3.registerToken( token3 )
+			vtn3.execute
+			
+			assert( zn.tokens.size == 1, "zn.tokens.size != 1, bad" )
+			otherNodes = [ vtn1, vtn2, j1, j2 ]
+			otherNodes.each { |on| assert( on.tokens.size == 0, "I got a node of type #{on.class} that has a token, but it shouldn't" ) }
+			assert( vtn3.tokens.size == 1, "vtn3.tokens.size != 1, bad" )
+		end
+
+		# Test a graph with many nodes
+		def test_many_with_equality
+			size = 20
+			engine = MK::Engine.new
+			vtne = MK::VariableTestNodeExecutor.init( engine )
+			vtns = Array.new
+			tokens = Array.new
+			cm = ClusterManager.new
+			size.times do |a|
+				vtns[ a ] = MK::VariableTestNode.init( "vtn1", MK::VariableObjectOperation.init( MK::EqualityTest.new, "@val1", true, "X" ), vtne, engine, nil, level = 0 )
+				vtne.addVariableTestNode( vtns[ a ] )
+				tokens[ a ] = Token.init( ObjectGraphWrapper.init( objectA ), "+", Time.now )
+				cm.createCluster( [ tokens[ a ] ], TokenCluster )
+			end
+	
+			# join all the leaves together
+			graphLeaves = Array.new
+			graphLeaves.concat( vtns )
+			bottom = nil
+			name = 0
+			while graphLeaves.size > 1
+				joiner = GraphNodeJoiner.init( name, graphLeaves.first, graphLeaves.second, engine )
+				joiner.debug = false # self.debug
+				name = name + 1
+				graphLeaves.first.setChild( joiner )
+				graphLeaves.second.setChild( joiner )
+				bottom = joiner
+				graphLeaves.shift
+				graphLeaves.shift
+				graphLeaves.unshift( joiner )
+			end
+			
+			zn = ZombieNode.init( "zombie, *shudder*", engine )
+			zn.setParent( bottom )
+			bottom.setChild( zn )
+
+			( size - 1 ).times do |a|
+				vtns[ a ].registerToken( tokens[ a ] )
+				vtns[ a ].execute
+				assert( vtns[ a ].tokens.size == 1, "vtns[#{a}].tokens.size != 1, bad" )
+			end
+			
+			( size - 1 ).times { |a| assert( vtns[ a ].tokens.size == 1, "vtns[#{a}].tokens.size != 1, bad" ) }
+
+			vtns[ -1 ].registerToken( tokens[ -1 ] )
+			vtns[ -1 ].execute
+			
+			size.times { |a| assert( vtns[ a ].tokens.size == 0, "vtns[#{a}].tokens.size != 0, bad" ) }
+			assert( zn.tokens.size == 1, "zn.tokens.size != 1, bad" )
+		end
+		
+		# Three VariableObjectOperations with equality with two variables (one node is missing in the second variable)
+		def test_three_with_equality2
+			engine = MK::Engine.new
+			vtne = MK::VariableTestNodeExecutor.init( engine )
+		 	rn = RootNode.new
+			vtn1 = MK::VariableTestNode.init( "vtn1", MK::VariableObjectOperation.init( MK::EqualityTest.new, "@val1", true, "X" ), vtne, engine, nil, level = 0 )
+			vtn2 = MK::VariableTestNode.init( "vtn2", MK::VariableObjectOperation.init( MK::EqualityTest.new, "@val1", true, "X" ), vtne, engine, nil, level = 0 )
+			vtn3 = MK::VariableTestNode.init( "vtn3", MK::VariableObjectOperation.init( MK::EqualityTest.new, "@val1", true, "X" ), vtne, engine, nil, level = 0 )
+			vtne2 = MK::VariableTestNodeExecutor.init( engine )
+			vtn1_2 = MK::VariableTestNode.init( "vtn1_2", MK::VariableObjectOperation.init( MK::EqualityTest.new, "@val2", true, "Y" ), vtne2, engine, nil, level = 1 )
+			vtn3_2 = MK::VariableTestNode.init( "vtn3_2", MK::VariableObjectOperation.init( MK::EqualityTest.new, "@val2", true, "Y" ), vtne2, engine, nil, level = 1 )
+			rn.setChildren( [ vtn1, vtn2, vtn3 ] )
+			
+			j1 = MK::GraphNodeJoiner.init( "j1", vtn2, vtn1_2, engine )
+			j2 = MK::GraphNodeJoiner.init( "j2", j1, vtn3_2, engine )
+			zn = MK::ZombieNode.init( "zombie, *shiver*", engine )
+			cm = ClusterManager.new
+			
+			vtn1.makeChildConnection( vtn1_2 )
+			vtn2.addChild( j1 )
+			vtn3.makeChildConnection( vtn3_2 )
+			vtn1_2.addChild( j1 )
+			vtn3_2.makeChildConnection( j2 )
+			j1.makeChildConnection( j2 )
+			j2.makeChildConnection( zn )
+			
+			vtne.variableTestNodes = [ vtn1, vtn2, vtn3 ]
+			vtne2.variableTestNodes = [ vtn1_2, vtn3_2 ]
+			vtne2.name = "VTNE2"
+			
+			#[ vtn1, vtn2, vtn3, vtn1_2, vtn3_2, vtne, vtne2, j1, j2, zn ].each { |e| e.debug = true }
+			
+			token1   = Token.init( ObjectGraphWrapper.init( objectA ), Token.add, Time.now, 0 )
+			token2   = Token.init( ObjectGraphWrapper.init( objectA ), Token.add, Time.now, 1 )
+			token3   = Token.init( ObjectGraphWrapper.init( objectA ), Token.add, Time.now, 2 )
+			badToken = Token.init( ObjectGraphWrapper.init( objectB ), Token.add, Time.now, 3 )
+			
+			cm.createCluster( [ token1 ], TokenCluster )
+			cm.createCluster( [ token2 ], TokenCluster )
+			cm.createCluster( [ token3 ], TokenCluster )
+			cm.createCluster( [ badToken ], TokenCluster )
+			
+			#print "Registering 1\n"
+			vtn1.registerToken( token1 )
+			assert( vtn1.tokens.size == 1, "vtn1.tokens.size != 1, bad" )
+			#print "Registering 2\n"
+			vtn2.registerToken( token2 )
+			assert( vtn2.tokens.size == 1, "vtn2.tokens.size != 1, bad" )
+			
+			#print "Registering bad\n"
+			vtn3.registerToken( badToken )
+			vtn3.execute
+			[ vtn1, vtn2, vtn3 ].each { |node| assert( node.tokens.size == 1, "Node token size isn't 1, bad" ) }
+			
+			#print "Registering 3\n"
+			vtn3.registerToken( token3 )
+			vtn3.execute
+
+			#[ vtn1, vtn2, vtn3, vtn1_2, vtn3_2, j1, j2, zn ].each { |node| print "I am a #{node.class} with name: #{node.name} and have #{node.tokens.size} tokens\n" }
+			assert( zn.tokens.size == 1, "zn.tokens.size != 1, bad. it is: #{zn.tokens.size}" )
+			otherNodes = [ vtn1, vtn2, j1, j2 ]
+			otherNodes.each { |on| assert( on.tokens.size == 0, "I got a node of type #{on.class} that has a token, but it shouldn't" ) }
+			assert( vtn3.tokens.size == 1, "vtn3.tokens.size != 1, bad" )
+		end
+
+		def test_two_with_inequality
+			engine = MK::Engine.new
+			vtne = MK::VariableTestNodeExecutor.init( engine )
+		 	vtn1 = MK::VariableTestNode.init( "vtn1", MK::VariableObjectOperation.init( MK::EqualityTest.new, "@val1", true, "X" ), vtne, engine, nil, level = 0 )
+			vtn2 = MK::VariableTestNode.init( "vtn2", MK::VariableObjectOperation.init( MK::InequalityTest.new, "@val1", true, "X" ), vtne, engine, nil, level = 0 )
+			j1 = MK::GraphNodeJoiner.init( "j1", vtn1, vtn2, engine )
+			vtn1.setChild( j1 )
+			vtn2.setChild( j1 )
+			zn = MK::ZombieNode.init( "zn1", engine )
+			zn.setParent( j1 )
+			j1.setChild( zn )
+			vtne.variableTestNodes = [ vtn1, vtn2 ]
+
+			cm = ClusterManager.new
+
+			token1 = Token.init( ObjectGraphWrapper.init( objectA ), "+", Time.now )
+			token2 = Token.init( ObjectGraphWrapper.init( objectB ), "+", Time.now )
+			cm.createCluster( [ token1 ], TokenCluster )
+			cm.createCluster( [ token2 ], TokenCluster )
+
+			vtn1.registerToken( token1 )
+			vtn1.execute
+
+			assert( vtn1.tokens.size == 1, "vtn1.tokens.size != 1, bad" )
+
+			vtn2.registerToken( token2 )
+			vtn2.execute
+
+			assert( vtn1.tokens.size == 0, "vtn1.tokens.size != 0, bad" )
+			assert( vtn2.tokens.size == 0, "vtn2.tokens.size != 0, bad" )
+
+			assert( zn.tokens.size == 1, "zn.tokens.size != 1, bad" )
+		end
+
+		def test_three_with_inequality
+			engine = MK::Engine.new
+			vtne = MK::VariableTestNodeExecutor.init( engine )
+		 	vtn1 = MK::VariableTestNode.init( "vtn1", MK::VariableObjectOperation.init( MK::EqualityTest.new,   "@val1", true, "X" ), vtne, engine, nil, level = 0 )
+			vtn2 = MK::VariableTestNode.init( "vtn2", MK::VariableObjectOperation.init( MK::InequalityTest.new, "@val1", true, "X" ), vtne, engine, nil, level = 0 )
+			vtn3 = MK::VariableTestNode.init( "vtn3", MK::VariableObjectOperation.init( MK::InequalityTest.new, "@val1", true, "X" ), vtne, engine, nil, level = 0 )
+			j1 = MK::GraphNodeJoiner.init( "j1", vtn1, vtn2, engine )
+			j2 = MK::GraphNodeJoiner.init( "j2", j1, vtn3, engine )
+			zn = MK::ZombieNode.init( "zombie, *shiver*", engine )
+			cm = ClusterManager.new
+			
+			vtn1.setChild( j1 )
+			vtn2.setChild( j1 )
+			j1.setChild( j2 )
+			vtn3.setChild( j2 )
+			
+			zn.setParent( j2 )
+			j2.setChild( zn )
+			
+			vtne.variableTestNodes = [ vtn1, vtn2, vtn3 ]
+			
+			token1 = Token.init( ObjectGraphWrapper.init( objectA ), "+", Time.now )
+			token2 = Token.init( ObjectGraphWrapper.init( objectB ), "+", Time.now )
+			token3 = Token.init( ObjectGraphWrapper.init( objectC ), "+", Time.now )
+			badToken = Token.init( ObjectGraphWrapper.init( objectB ), "+", Time.now )
+			
+			cm.createCluster( [ token1 ], TokenCluster )
+			cm.createCluster( [ token2 ], TokenCluster )
+			cm.createCluster( [ token3 ], TokenCluster )
+			cm.createCluster( [ badToken ], TokenCluster )
+			
+			vtn1.registerToken( token1 )
+			assert( vtn1.tokens.size == 1, "vtn1.tokens.size != 1, bad" )
+			vtn2.registerToken( token2 )
+			assert( vtn2.tokens.size == 1, "vtn2.tokens.size != 1, bad" )
+			
+			vtn3.registerToken( token3 )
+			vtn3.execute
+			
+			assert( zn.tokens.size == 1, "zn.tokens.size != 1, bad" )
+			otherNodes = [ vtn1, vtn2, j1, j2 ]
+			otherNodes.each { |on| assert( on.tokens.size == 0, "I got a node of type #{on.class} that has a token, but it shouldn't" ) }
+			
+			vtn3.registerToken( badToken )
+			vtn3.execute
+			assert( vtn3.tokens.size == 1, "vtn3.tokens.size != 1, bad" )
+		end
+		
+		# Test a graph with many nodes
+		def test_many_with_inequality
+			size = 20
+			engine = MK::Engine.new
+			vtne = MK::VariableTestNodeExecutor.init( engine )
+			vtns = Array.new
+			tokens = Array.new
+			cm = ClusterManager.new
+			onoff = true
+			size.times do |a|
+				onoff = ( onoff == false )
+				test = MK::EqualityTest if onoff == true
+				test = MK::InequalityTest if onoff == false
+				vtns[ a ] = MK::VariableTestNode.init( "vtn1", MK::VariableObjectOperation.init( test.new, "@val1", true, "X" ), vtne, engine, nil, level = 0 )
+				vtne.addVariableTestNode( vtns[ a ] )
+				object = objectA if onoff == true
+				object = objectB if onoff == false
+				tokens[ a ] = Token.init( ObjectGraphWrapper.init( object ), "+", Time.now )
+				cm.createCluster( [ tokens[ a ] ], TokenCluster )
+			end
+
+			# join all the leaves together
+			graphLeaves = Array.new
+			graphLeaves.concat( vtns )
+			bottom = nil
+			name = 0
+			while graphLeaves.size > 1
+				joiner = GraphNodeJoiner.init( name, graphLeaves.first, graphLeaves.second, engine )
+				joiner.debug = false # self.debug
+				name = name + 1
+				graphLeaves.first.setChild( joiner )
+				graphLeaves.second.setChild( joiner )
+				bottom = joiner
+				graphLeaves.shift
+				graphLeaves.shift
+				graphLeaves.unshift( joiner )
+			end
+			
+			zn = ZombieNode.init( "zombie, *shudder*", engine )
+			zn.setParent( bottom )
+			bottom.setChild( zn )
+
+			( size - 1 ).times do |a|
+				vtns[ a ].registerToken( tokens[ a ] )
+				vtns[ a ].execute
+				assert( vtns[ a ].tokens.size == 1, "vtns[#{a}].tokens.size != 1, bad" )
+			end
+			
+			( size - 1 ).times { |a| assert( vtns[ a ].tokens.size == 1, "vtns[#{a}].tokens.size != 1, bad" ) }
+			
+			vtns[ -1 ].registerToken( tokens[ -1 ] )
+			vtns[ -1 ].execute
+			
+			size.times { |a| assert( vtns[ a ].tokens.size == 0, "vtns[#{a}].tokens.size != 0, bad" ) }
+			assert( zn.tokens.size == 1, "zn.tokens.size != 1, bad" )
+		end
+
+    def self.suite
+      suite = Test::Unit::TestSuite.new 
+      suite << self.new( 'test_two_with_equality' )
+			suite << self.new( 'test_three_with_equality' )
+			suite << self.new( 'test_three_with_equality2' )
+			suite << self.new( 'test_three_with_inequality' )
+			suite << self.new( 'test_many_with_equality' )
+			suite << self.new( 'test_two_with_inequality' )
+			suite << self.new( 'test_many_with_inequality' )  # This test is slow.. comment out when not needed
+			suite
+    end
+
+  end
+
+  require 'test/unit/ui/console/testrunner'
+
+  Test::Unit::UI::Console::TestRunner.run( Test_Variable_Test_Node )
+
+end

data/khammurabi-0.2/tests/test_variable_test_node_graph.rb

@@ -0,0 +1,587 @@
+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 Tester
+    attr :val1, true
+    attr :val2, true
+    attr :val3, true
+
+    def initialize
+      @val1 = @val2 = @val3 = nil
+    end
+		def setValues( a, b, c )
+			@val1 = a
+			@val2 = b
+			@val3 = c
+		end
+		def to_s 
+				"val1: #{self.val1} val2: #{self.val2} val3: #{self.val3}"
+		end
+  end
+
+  class Tester2
+    attr :val0, true
+    attr :val1, true
+    attr :val2, true
+    attr :val3, true
+
+    def initialize
+      @val0 = @val1 = @val2 = @val3 = nil
+    end
+		def setValues( a, b, c, d )
+			self.val0 = a
+			self.val1 = b
+			self.val2 = c
+			self.val3 = d
+		end
+  end
+
+  class Test_Variable_Test_Node_Graph < Test::Unit::TestCase
+
+    attr_accessor :graphA
+
+    def objectA
+      t = Tester.new
+      t.val1 = 5
+      t.val2 = 10
+      #t.val3 = 15
+      t
+    end
+
+    def test_two_variables
+      size = 2
+      objects = Array.new( size ) { Tester.new }
+      objects[ 0 ].val1 = objects[ 0 ].val2 = objects[ 1 ].val1 = 6
+      objects[ 1 ].val2 = 7
+      objects[ 0 ].val3 = objects[ 1 ].val3 = 8
+			
+      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( "@val3", "Y", 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"
+			
+      ( 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}" )
+
+      graph.addObject( objects[ -1 ] )
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+			Token.resetTokenIDCount
+    end
+
+    def test_two_variables_with_nonequality
+      size = 2
+      objects = Array.new( size ) { Tester.new }
+      objects[ 0 ].val1 = objects[ 0 ].val2 = objects[ 1 ].val1 = 6
+      objects[ 1 ].val2 = 7
+      objects[ 0 ].val3 = 1
+			objects[ 1 ].val3 = 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( "@val3", "Y", MK::EqualityTest.new )
+				objectProduction.addObjectDescription( objectDescriptions[ idx ] )
+      end
+      
+      graph = Engine.new
+			graph.addObjectProduction( objectProduction )
+      #graph.setDebugging( true )
+      graph.compile
+
+      ( objects.size ).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
+			finalObject = Tester.new
+			finalObject.val1, finalObject.val2, finalObject.val3 = 6, 6, 2
+			graph.addObject( finalObject )
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+			Token.resetTokenIDCount
+    end
+
+   def test_two_variables_with_nonequality2
+      size = 2
+      objects = Array.new( size ) { Tester.new }
+      objects[ 0 ].setValues( 6, 7, nil )
+			objects[ 1 ].setValues( 7, 8, nil )
+
+      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( "@val2", "Y", MK::InequalityTest.new )
+			objectDescriptions[ 1 ].setObjectAsVariable( "@val2", "Y", 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}" )
+			Token.resetTokenIDCount
+    end
+
+    def test_three_variables
+      size = 3
+      objects = Array.new( size ) { Tester.new }
+			objects[ 0 ].val1, objects[ 1 ].val1, objects[ 2 ].val1 = 6, 10, 6
+      objects[ 0 ].val2, objects[ 1 ].val2, objects[ 2 ].val2 = 2, 2, 8
+      objects[ 0 ].val1, objects[ 1 ].val3, objects[ 2 ].val3 = 42, 7, 7
+
+      objectProduction = ObjectProduction.new
+      objectDescriptions = Array.new( size ) { ObjectDescription.new }
+      objectDescriptions.each_index do |idx| 
+	  		objectDescriptions[ idx ].objectDescribing = objects[ idx ]
+				objectDescriptions[ idx ].parseObject
+      end
+
+      objectDescriptions[ 0 ].setObjectAsVariable( "@val2", "X", MK::EqualityTest.new )
+      objectDescriptions[ 1 ].setObjectAsVariable( "@val2", "X", MK::EqualityTest.new )
+      objectDescriptions[ 1 ].setObjectAsVariable( "@val3", "Y", MK::EqualityTest.new )
+      objectDescriptions[ 2 ].setObjectAsVariable( "@val3", "Y", MK::EqualityTest.new )
+
+      objectDescriptions.each { |od| objectProduction.addObjectDescription( od ) }
+      
+      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 do |idx|
+				#print "\n\nAdding object  idx: #{idx} and it is: #{objects[idx].to_s}\n\n"
+				graph.addObject( objects[ idx ] )
+      end
+
+      oin = graph.leaf( objectProduction )
+
+      instantiations = oin.instantiations
+      assert( instantiations.size == 0, "Instantiations size isn't 0, it's #{instantiations.size}" )
+
+      #print "\n\nAdding object  idx: #{objects.size - 1} it is: #{objects[-1].to_s}\n\n"
+      graph.addObject( objects[ -1 ] )
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+			Token.resetTokenIDCount
+    end
+		
+		def test_three_same_variables
+			size = 3
+      objects = Array.new( size ) { Tester.new }
+			objects[ 0 ].setValues( 5, 5, 5 )
+			objects[ 1 ].setValues( 5, 5, 5 )
+			objects[ 2 ].setValues( 5, 5, 5 )
+			
+      objectProduction = ObjectProduction.new
+      objectDescriptions = Array.new( size ) { ObjectDescription.new }
+      objectDescriptions.each_index do |idx| 
+	  		objectDescriptions[ idx ].objectDescribing = objects[ idx ]
+				objectDescriptions[ idx ].parseObject
+      end
+
+      objectDescriptions[ 0 ].setObjectAsVariable( "@val2", "X", MK::EqualityTest.new )
+      objectDescriptions[ 1 ].setObjectAsVariable( "@val2", "X", MK::EqualityTest.new )
+      objectDescriptions[ 2 ].setObjectAsVariable( "@val2", "X", MK::EqualityTest.new )
+      objectDescriptions[ 0 ].setObjectAsVariable( "@val3", "Y", MK::EqualityTest.new )
+      objectDescriptions[ 1 ].setObjectAsVariable( "@val3", "Y", MK::EqualityTest.new )
+			objectDescriptions[ 2 ].setObjectAsVariable( "@val3", "Y", MK::EqualityTest.new )
+      objectDescriptions[ 0 ].setObjectAsVariable( "@val1", "Z", MK::EqualityTest.new )
+      objectDescriptions[ 1 ].setObjectAsVariable( "@val1", "Z", MK::EqualityTest.new )
+			objectDescriptions[ 2 ].setObjectAsVariable( "@val1", "Z", MK::EqualityTest.new )
+
+      objectDescriptions.each { |od| objectProduction.addObjectDescription( od ) }
+      
+			#self.outfile = "outfile"
+			#self.type == 2
+			
+      graph = Engine.new
+      graph.addObjectProduction( objectProduction )
+			#graph.setDebugging( true )
+			graph.compile
+			
+			#print "TEST_THREE_SAME_VARIABLES\n"
+			#printer = ReteParseTreePrinter.init( graph.root )
+			#print "\n\n" + printer.printOn( StringIO.new ).string + "\n\n"
+			#exit
+      
+      ( objects.size - 1 ).times do |idx|
+				#print "\n\nadding object  idx: #{idx} and it is: #{objects[idx].to_s}\n\n"
+				graph.addObject( objects[ idx ] )
+      end
+			
+      oin = graph.leaf( objectProduction )
+      instantiations = oin.instantiations
+      assert( instantiations.size == 0, "Instantiations size isn't 0, it's #{instantiations.size}" )
+      
+      #print "\n\nadding object  idx: #{objects.size - 1} it is: #{objects[-1].to_s}\n\n"
+      graph.addObject( objects[ -1 ] )
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+			Token.resetTokenIDCount
+		end
+		
+		def test_three_variables9
+      size = 3
+      objects = Array.new( size ) { Tester.new }
+			objects[ 0 ].setValues( 6,  1, 2 )
+			objects[ 1 ].setValues( 10, 1, 3 )
+			objects[ 2 ].setValues( 7,  2, 3 )
+
+      objectProduction = ObjectProduction.new
+      objectDescriptions = Array.new( size ) { ObjectDescription.new }
+      objectDescriptions.each_index do |idx| 
+	  		objectDescriptions[ idx ].objectDescribing = objects[ idx ]
+				objectDescriptions[ idx ].parseObject
+      end
+
+      objectDescriptions[ 0 ].setObjectAsVariable( "@val2", "X", MK::EqualityTest.new )
+      objectDescriptions[ 1 ].setObjectAsVariable( "@val2", "X", MK::EqualityTest.new )
+      objectDescriptions[ 2 ].setObjectAsVariable( "@val2", "X", MK::InequalityTest.new )
+      objectDescriptions[ 0 ].setObjectAsVariable( "@val3", "Y", MK::InequalityTest.new )
+      objectDescriptions[ 1 ].setObjectAsVariable( "@val3", "Y", MK::EqualityTest.new )
+			objectDescriptions[ 2 ].setObjectAsVariable( "@val3", "Y", MK::EqualityTest.new )
+
+      objectDescriptions.each { |od| objectProduction.addObjectDescription( od ) }
+
+			#self.outfile = "outfile"
+			#self.type == 2
+
+      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 do |idx|
+				#print "\n\nadding object  idx: #{idx} and it is: #{objects[idx].to_s}\n\n"
+				graph.addObject( objects[ idx ] )
+      end
+
+      oin = graph.leaf( objectProduction )
+      instantiations = oin.instantiations
+      assert( instantiations.size == 0, "Instantiations size isn't 0, it's #{instantiations.size}" )
+
+      #print "\n\nadding object  idx: #{objects.size - 1} it is: #{objects[-1].to_s}\n\n"
+      graph.addObject( objects[ -1 ] )
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+			Token.resetTokenIDCount
+		end
+
+		def test_four_same_variables
+			size = 4
+      objects = Array.new( size ) { Tester.new }
+			objects[ 0 ].setValues( 5, 5, 5 )
+			objects[ 1 ].setValues( 5, 5, 5 )
+			objects[ 2 ].setValues( 5, 5, 5 )
+			objects[ 3 ].setValues( 5, 5, 5 )
+			
+      objectProduction = ObjectProduction.new
+      objectDescriptions = Array.new( size ) { ObjectDescription.new }
+      objectDescriptions.each_index do |idx| 
+	  		objectDescriptions[ idx ].objectDescribing = objects[ idx ]
+				objectDescriptions[ idx ].parseObject
+      end
+
+      objectDescriptions[ 0 ].setObjectAsVariable( "@val2", "X", MK::EqualityTest.new )
+      objectDescriptions[ 1 ].setObjectAsVariable( "@val2", "X", MK::EqualityTest.new )
+      objectDescriptions[ 2 ].setObjectAsVariable( "@val2", "X", MK::EqualityTest.new )
+      objectDescriptions[ 3 ].setObjectAsVariable( "@val2", "X", MK::EqualityTest.new )
+      objectDescriptions[ 0 ].setObjectAsVariable( "@val3", "Y", MK::EqualityTest.new )
+      objectDescriptions[ 1 ].setObjectAsVariable( "@val3", "Y", MK::EqualityTest.new )
+			objectDescriptions[ 2 ].setObjectAsVariable( "@val3", "Y", MK::EqualityTest.new )
+			objectDescriptions[ 3 ].setObjectAsVariable( "@val3", "Y", MK::EqualityTest.new )
+      objectDescriptions[ 0 ].setObjectAsVariable( "@val1", "Z", MK::EqualityTest.new )
+      objectDescriptions[ 1 ].setObjectAsVariable( "@val1", "Z", MK::EqualityTest.new )
+			objectDescriptions[ 2 ].setObjectAsVariable( "@val1", "Z", MK::EqualityTest.new )
+			objectDescriptions[ 3 ].setObjectAsVariable( "@val1", "Z", MK::EqualityTest.new )
+
+      objectDescriptions.each { |od| objectProduction.addObjectDescription( od ) }
+      
+			#self.outfile = "outfile"
+			#self.type == 2
+			
+      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 do |idx|
+				#print "\n\nadding object  idx: #{idx} and it is: #{objects[idx].to_s}\n\n"
+				graph.addObject( objects[ idx ] )
+      end
+			
+      oin = graph.leaf( objectProduction )
+      instantiations = oin.instantiations
+      assert( instantiations.size == 0, "Instantiations size isn't 0, it's #{instantiations.size}" )
+
+      #print "\n\nadding object  idx: #{objects.size - 1} it is: #{objects[-1].to_s}\n\n"
+      graph.addObject( objects[ -1 ] )
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+			Token.resetTokenIDCount
+		end
+
+    def test_four_variables
+      size = 4
+      objects = Array.new( size ) { Tester.new }
+			objects[ 0 ].setValues( 2, 101, 1000 )
+			objects[ 1 ].setValues( 5, 3,   4 )
+			objects[ 2 ].setValues( 2, 102, 4 )
+      objects[ 3 ].setValues( 3, 2,   99 )
+			
+      objectProduction = ObjectProduction.new
+      objectDescriptions = Array.new( size ) { ObjectDescription.new }
+      objectDescriptions.each_index do |idx| 	
+		  	objectDescriptions[ idx ].objectDescribing = objects[ idx ]
+				objectDescriptions[ idx ].parseObject
+      end
+
+      objectDescriptions[ 0 ].setObjectAsVariable( "@val1", "X", MK::EqualityTest.new )
+      objectDescriptions[ 2 ].setObjectAsVariable( "@val1", "X", MK::EqualityTest.new )
+
+      objectDescriptions[ 1 ].setObjectAsVariable( "@val2", "Y", MK::EqualityTest.new )
+      objectDescriptions[ 3 ].setObjectAsVariable( "@val2", "Y", MK::InequalityTest.new )
+
+      objectDescriptions[ 1 ].setObjectAsVariable( "@val3", "Z", MK::EqualityTest.new )
+      objectDescriptions[ 2 ].setObjectAsVariable( "@val3", "Z", MK::EqualityTest.new )
+      objectDescriptions[ 3 ].setObjectAsVariable( "@val3", "Z", MK::InequalityTest.new )
+			#print "equality: id0: #{objectDescriptions[0].object_id} od1: #{objectDescriptions[1].object_id}\n"
+			#print "#{objectDescriptions[0]===objectDescriptions[1]}\n"
+			#exit
+			
+      objectDescriptions.each { |od| objectProduction.addObjectDescription( od ) }
+
+      graph = Engine.new
+      graph.addObjectProduction( objectProduction )
+      graph.compile
+			
+			#printer = ReteParseTreePrinter.init( graph.root )
+			#print "\n\n" + printer.printOn( StringIO.new ).string + "\n\n"
+			#exit
+      
+      ( objects.size - 1 ).times do |idx|
+		  	i = ( objects.size - 1 ) - idx
+				#print "\n\nadding object  idx: #{idx}\n\n"
+				graph.addObject( objects[ i ] )
+      end
+
+      oin = graph.leaf( objectProduction )
+
+      instantiations = oin.instantiations
+      assert( instantiations.size == 0, "Instantiations size isn't 0, it's #{instantiations.size}" )
+
+      #print "\n\nadding object  idx: #{objects.size - 1}\n\n"
+      graph.addObject( objects[ 0 ] )
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+			Token.resetTokenIDCount
+    end
+
+    def test_five_variables
+      size = 5
+      objects = Array.new( size ) { Tester2.new }
+      # only variables in this test
+			objects[ 0 ].setValues( 5, 1, 2, 3 )
+			objects[ 1 ].setValues( 5, 2, 2, 3 )
+			objects[ 2 ].setValues( 5, 3, 2, 3 )
+			objects[ 3 ].setValues( 5, 4, 2, 3 )
+			objects[ 4 ].setValues( 7, 5, 2, 3 )
+
+      objectProduction = ObjectProduction.new
+      objectDescriptions = Array.new( size ) { ObjectDescription.new }
+      objectDescriptions.each_index do |idx| 
+				objectDescriptions[ idx ].objectDescribing = objects[ idx ]
+				objectDescriptions[ idx ].parseObject
+				#objectDescriptions[ idx ][ "@clusters" ].testMe = false
+      end
+
+      objectDescriptions[ 0 ].setObjectAsVariable( "@val0", "X", MK::EqualityTest.new )
+      objectDescriptions[ 1 ].setObjectAsVariable( "@val0", "X", MK::EqualityTest.new )
+      objectDescriptions[ 2 ].setObjectAsVariable( "@val0", "X", MK::EqualityTest.new )
+      objectDescriptions[ 3 ].setObjectAsVariable( "@val0", "X", MK::EqualityTest.new )
+      objectDescriptions[ 4 ].setObjectAsVariable( "@val0", "X", MK::InequalityTest.new )
+
+      objectDescriptions[ 0 ].setObjectAsVariable( "@val2", "Y", MK::EqualityTest.new )
+      objectDescriptions[ 1 ].setObjectAsVariable( "@val2", "Y", MK::EqualityTest.new )
+      objectDescriptions[ 2 ].setObjectAsVariable( "@val2", "Y", MK::EqualityTest.new )
+      objectDescriptions[ 3 ].setObjectAsVariable( "@val2", "Y", MK::EqualityTest.new )
+      objectDescriptions[ 4 ].setObjectAsVariable( "@val2", "Y", MK::EqualityTest.new )
+      
+			objectDescriptions[ 0 ].setObjectAsVariable( "@val3", "Z", MK::EqualityTest.new )
+      objectDescriptions[ 1 ].setObjectAsVariable( "@val3", "Z", MK::EqualityTest.new )
+      objectDescriptions[ 2 ].setObjectAsVariable( "@val3", "Z", MK::EqualityTest.new )
+      objectDescriptions[ 3 ].setObjectAsVariable( "@val3", "Z", MK::EqualityTest.new )
+      objectDescriptions[ 4 ].setObjectAsVariable( "@val3", "Z", MK::EqualityTest.new )
+
+      objectDescriptions.each { |od| objectProduction.addObjectDescription( od ) }
+
+      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 do |idx|
+		  	#i = ( objects.size - 1 ) - idx
+				#print "\n\nadding object  idx: #{idx}\n\n"
+				graph.addObject( objects[ idx ] )
+				#exit if idx == 1
+      end
+
+      oin = graph.leaf( objectProduction )
+
+      instantiations = oin.instantiations
+      assert( instantiations.size == 0, "Instantiations size isn't 0, it's #{instantiations.size}" )
+
+      #print "\n\nadding object  idx: #{objects.size - 1}\n\n"
+      graph.addObject( objects[ -1 ] )
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+			Token.resetTokenIDCount
+    end
+
+    def test_five_variables_with_many_inequalities
+      size = 5
+      objects = Array.new( size ) { Tester2.new }
+      # only variables in this test
+			objects[ 0 ].setValues( 6,   1, 10, 3 )
+			objects[ 1 ].setValues( 5,   2, 2,  2 )
+			objects[ 2 ].setValues( 100, 3, 2,  3 )
+			objects[ 3 ].setValues( 5,   4, 2,  4 )
+			objects[ 4 ].setValues( 7,   5, 10, 4 )
+
+      objectProduction = ObjectProduction.new
+      objectDescriptions = Array.new( size ) { ObjectDescription.new }
+      objectDescriptions.each_index do |idx| 
+				objectDescriptions[ idx ].objectDescribing = objects[ idx ]
+				objectDescriptions[ idx ].parseObject
+				#objectDescriptions[ idx ][ "@clusters" ].testMe = false
+      end
+
+      objectDescriptions[ 0 ].setObjectAsVariable( "@val0", "X", MK::InequalityTest.new )
+      objectDescriptions[ 1 ].setObjectAsVariable( "@val0", "X", MK::EqualityTest.new )
+      objectDescriptions[ 2 ].setObjectAsVariable( "@val0", "X", MK::InequalityTest.new )
+      objectDescriptions[ 3 ].setObjectAsVariable( "@val0", "X", MK::EqualityTest.new )
+      objectDescriptions[ 4 ].setObjectAsVariable( "@val0", "X", MK::InequalityTest.new )
+
+      objectDescriptions[ 0 ].setObjectAsVariable( "@val2", "Y", MK::InequalityTest.new )
+      objectDescriptions[ 1 ].setObjectAsVariable( "@val2", "Y", MK::EqualityTest.new )
+      objectDescriptions[ 2 ].setObjectAsVariable( "@val2", "Y", MK::EqualityTest.new )
+      objectDescriptions[ 3 ].setObjectAsVariable( "@val2", "Y", MK::EqualityTest.new )
+      objectDescriptions[ 4 ].setObjectAsVariable( "@val2", "Y", MK::InequalityTest.new )
+      
+			objectDescriptions[ 0 ].setObjectAsVariable( "@val3", "Z", MK::InequalityTest.new )
+      objectDescriptions[ 1 ].setObjectAsVariable( "@val3", "Z", MK::InequalityTest.new )
+      objectDescriptions[ 2 ].setObjectAsVariable( "@val3", "Z", MK::InequalityTest.new )
+      objectDescriptions[ 3 ].setObjectAsVariable( "@val3", "Z", MK::EqualityTest.new )
+      objectDescriptions[ 4 ].setObjectAsVariable( "@val3", "Z", MK::EqualityTest.new )
+
+      objectDescriptions.each { |od| objectProduction.addObjectDescription( od ) }
+
+      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 do |idx|
+		  	#i = ( objects.size - 1 ) - idx
+				#print "\n\nadding object  idx: #{idx}\n\n"
+				graph.addObject( objects[ idx ] )
+				#exit if idx == 1
+      end
+
+      oin = graph.leaf( objectProduction )
+
+      instantiations = oin.instantiations
+      assert( instantiations.size == 0, "Instantiations size isn't 0, it's #{instantiations.size}" )
+
+      #print "\n\nadding object  idx: #{objects.size - 1}\n\n"
+      graph.addObject( objects[ -1 ] )
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+			Token.resetTokenIDCount
+    end
+
+    def self.suite
+      suite = Test::Unit::TestSuite.new
+      suite << self.new( 'test_two_variables' )
+			suite << self.new( 'test_two_variables_with_nonequality' )
+			suite << self.new( 'test_two_variables_with_nonequality2' )
+			suite << self.new( 'test_three_same_variables' )
+      suite << self.new( 'test_three_variables9' )
+			suite << self.new( 'test_four_variables' )
+      suite << self.new( 'test_four_same_variables' )
+			suite << self.new( 'test_five_variables' )
+			suite << self.new( 'test_five_variables_with_many_inequalities' )
+      suite
+    end
+
+  end
+
+  require 'test/unit/ui/console/testrunner'
+
+  Test::Unit::UI::Console::TestRunner.run( Test_Variable_Test_Node_Graph )
+
+end