khammurabi 0.2

data/khammurabi-0.2/tests/test_constant_test_node_graph.rb

@@ -0,0 +1,404 @@
+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 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
+
+  end
+
+  class Test_Constant_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_single_constant
+      size = 1
+      object = Tester.new
+      objectToAdd = object.clone
+
+      graph = Engine.new
+      objectDescription = ObjectDescription.init( object )
+      objectProduction = ObjectProduction.init( objectDescription, graph )
+      graph.addObjectProduction( objectProduction )
+      graph.compile
+      
+      oin = graph.leaf( objectProduction )
+
+      instantiations = oin.instantiations
+      assert( instantiations.size == 0, "Instantiations size isn't 0, it's #{instantiations.size}" )
+      graph.addObject( objectToAdd )
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+    end
+
+    def test_two_constants
+      size = 2
+      objects = Array.new( size ) { Tester.new }
+      objects[ 0 ].val1 = objects[ 1 ].val1 = 4
+      objects[ 0 ].val2 = objects[ 1 ].val2 = 6
+      objects[ 0 ].val3,  objects[ 1 ].val3 = 9, 5
+
+      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
+      
+      graph = Engine.new
+      graph.addObjectProduction( objectProduction )
+      graph.compile
+
+      ( objects.size - 1 ).times do |idx|
+		  	#print "\n\nadding object  idx: #{idx}\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}\n\n"
+      graph.addObject( objects[ -1 ] )
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+      
+    end
+
+    def test_four_constants
+      size = 4
+      objects = Array.new( size ) { Tester.new }
+      objects[ 0 ].val1 = objects[ 1 ].val1 = objects[ 2 ].val1 = 2
+      objects[ 1 ].val2, objects[ 3 ].val2 = 3, 6
+      objects[ 0 ].val3, objects[ 2 ].val3 = 6, 9
+
+      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
+      
+      graph = Engine.new
+      graph.addObjectProduction( objectProduction )
+      graph.compile
+
+      ( 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}" )
+    end
+
+    def test_multiobject
+      size = 2
+      objects = Array.new( size ) { Tester.new }
+      objects.each { |object| object.val1, object.val2, object.val3 = 1, 2, 3 }
+      objectDescriptions = Array.new( size ) { ObjectDescription.new }
+      objectProduction = ObjectProduction.new
+      objectDescriptions.each_index do |index|
+		  	#print "index: #{index}\n"
+				objectDescription = objectDescriptions[ index ]
+				objectDescription.objectDescribing = objects[ index ]
+				objectDescription.parseObject
+				objectProduction.addObjectDescription( objectDescriptions[ index ] )
+      end
+      
+      graph = Engine.new
+      graph.addObjectProduction( objectProduction )
+      graph.compile
+
+      ( objects.size - 1 ).times do |idx|
+		  	#print "\n\nadding object  idx: #{idx}\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}\n\n"
+      graph.addObject( objects[ -1 ] )
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+    end
+
+    def test_two_multiobjects
+      size = 4
+      objects = Array.new( size ) { Tester.new }
+      for i in 0..1
+	  		objects[ i ].val1, objects[ i ].val2, objects[ i ].val3 = 1, 2, 3
+      end
+      for i in 2..3
+	  		objects[ i ].val1, objects[ i ].val2, objects[ i ].val3 = 4, 5, 6
+      end
+
+      objectDescriptions = Array.new( size ) { ObjectDescription.new }
+      objectProduction = ObjectProduction.new
+      objectDescriptions.each_index do |index|
+		  	#print "index: #{index}\n"
+				objectDescription = objectDescriptions[ index ]
+				objectDescription.objectDescribing = objects[ index ]
+				objectDescription.parseObject
+				objectProduction.addObjectDescription( objectDescriptions[ index ] )
+      end
+      
+      graph = Engine.new
+      graph.addObjectProduction( objectProduction )
+      graph.compile
+
+      ( objects.size - 1 ).times do |idx|
+		  	#print "\n\nadding object  idx: #{idx}\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}\n\n"
+      graph.addObject( objects[ -1 ] )
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+    end
+
+    def test_two_two_multiobjects
+      size = 6
+      objects = Array.new( size ) { Tester.new }
+      for i in 0..1
+	  		objects[ i ].val1, objects[ i ].val2, objects[ i ].val3 = 1, 2, 3
+      end
+      for i in 2..3
+	  		objects[ i ].val1, objects[ i ].val2, objects[ i ].val3 = 4, 5, 6
+      end
+      objects[ 4 ].val1, objects[ 4 ].val2, objects[ 4 ].val3 = 8, 9, 10
+      objects[ 5 ].val1, objects[ 5 ].val2, objects[ 5 ].val3 = 8, 9, 11
+
+      objectDescriptions = Array.new( size ) { ObjectDescription.new }
+      objectProduction = ObjectProduction.new
+      objectDescriptions.each_index do |index|
+		  	#print "index: #{index}\n"
+				objectDescription = objectDescriptions[ index ]
+				objectDescription.objectDescribing = objects[ index ]
+				objectDescription.parseObject
+				objectProduction.addObjectDescription( objectDescriptions[ index ] )
+      end
+      
+      graph = Engine.new
+      graph.addObjectProduction( objectProduction )
+      graph.compile
+
+      ( objects.size - 1 ).times do |idx|
+		  	#print "\n\nadding object  idx: #{idx}\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}\n\n"
+      graph.addObject( objects[ -1 ] )
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+    end
+
+    def test_less_than_constants
+      size = 2
+      objects = Array.new( size ) { Tester.new }
+      objects[ 0 ].setValues( 4, 6, 9 )
+			objects[ 1 ].setValues( 10, 15, 11 )
+			
+      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 ][ "@val1" ].valueTest = LessThanTest.init( 5 )
+      objectDescriptions[ 0 ][ "@val2" ].valueTest = EqualityTest.init( 6 )
+      objectDescriptions[ 0 ][ "@val3" ].valueTest = LessThanOrEqualTest.init( 9 )
+      objectDescriptions[ 1 ][ "@val1" ].valueTest = LessThanTest.init( 11 )
+      objectDescriptions[ 1 ][ "@val2" ].valueTest = LessThanOrEqualTest.init( 15 )
+      objectDescriptions[ 1 ][ "@val3" ].valueTest = EqualityTest.init( 11 )
+      objectDescriptions.each { |od| objectProduction.addObjectDescription( od ) }
+
+      objectsToAdd = Array.new
+      objects.each { |object| objectsToAdd.push( object.clone ) }
+      objectsToAdd[ 0 ].setValues( 3, 6, 9 )
+			objectsToAdd[ 1 ].setValues( 1, 15, 11 )
+
+      graph = Engine.new
+      graph.addObjectProduction( objectProduction )
+      #graph.setDebugging( true )
+			graph.compile
+
+      ( objects.size - 1 ).times do |idx|
+		  	#print "\n\nadding object  idx: #{idx}\n\n"
+				graph.addObject( objectsToAdd[ 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}\n\n"
+      graph.addObject( objectsToAdd[ -1 ] )
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+    end      
+
+    def test_greater_than_constants
+      size = 2
+      objects = Array.new( size ) { Tester.new }
+      objects[ 0 ].val1, objects[ 1 ].val1 = 6, 4
+      objects[ 0 ].val2, objects[ 1 ].val2 = 2, 16
+      objects[ 0 ].val3, objects[ 1 ].val3 = 100, 102
+      
+      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 ][ "@val1" ].valueTest = GreaterThanTest.init( 3 )
+      objectDescriptions[ 0 ][ "@val2" ].valueTest = EqualityTest.init( 2 )
+      objectDescriptions[ 0 ][ "@val3" ].valueTest = GreaterThanOrEqualTest.init( 50 )
+      objectDescriptions[ 1 ][ "@val1" ].valueTest = GreaterThanTest.init( 2 )
+      objectDescriptions[ 1 ][ "@val2" ].valueTest = GreaterThanOrEqualTest.init( 16 )
+      objectDescriptions[ 1 ][ "@val3" ].valueTest = EqualityTest.init( 102 )
+      objectDescriptions.each { |od| objectProduction.addObjectDescription( od ) }
+
+      objectsToAdd = Array.new
+      objects.each { |object| objectsToAdd.push( object.clone ) }
+      objectsToAdd[ 0 ].val1, objectsToAdd[ 0 ].val2, objectsToAdd[ 0 ].val3 = 7, 2, 100
+      objectsToAdd[ 1 ].val1, objectsToAdd[ 1 ].val2, objectsToAdd[ 1 ].val3 = 5, 16, 102
+
+      graph = Engine.new
+      graph.addObjectProduction( objectProduction )
+      graph.compile
+
+      ( objects.size - 1 ).times do |idx|
+		  	#print "\n\nadding object  idx: #{idx}\n\n"
+				graph.addObject( objectsToAdd[ 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}\n\n"
+      graph.addObject( objectsToAdd[ -1 ] )
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+    end      
+    
+    def test_less_greater_than_constants
+      size = 2
+      objects = Array.new( size ) { Tester.new }
+      objects[ 0 ].val1, objects[ 1 ].val1 = 6, 9
+      objects[ 0 ].val2, objects[ 1 ].val2 = 8, 10
+      objects[ 0 ].val3, objects[ 1 ].val3 = 5, 102
+      
+      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 ][ "@val1" ].valueTest = LessThanTest.init( 9 )
+      objectDescriptions[ 0 ][ "@val2" ].valueTest = GreaterThanTest.init( 5 )
+      objectDescriptions[ 0 ][ "@val3" ].valueTest = LessThanOrEqualTest.init( 5 )
+      objectDescriptions[ 1 ][ "@val1" ].valueTest = LessThanTest.init( 10 )
+      objectDescriptions[ 1 ][ "@val2" ].valueTest = EqualityTest.init( 10 )
+      objectDescriptions[ 1 ][ "@val3" ].valueTest = GreaterThanOrEqualTest.init( 102 )
+      objectDescriptions.each { |od| objectProduction.addObjectDescription( od ) }
+
+      objectsToAdd = Array.new
+      objects.each { |object| objectsToAdd.push( object.clone ) }
+      objectsToAdd[ 0 ].val1, objectsToAdd[ 0 ].val2, objectsToAdd[ 0 ].val3 = 5, 9, 5
+      objectsToAdd[ 1 ].val1, objectsToAdd[ 1 ].val2, objectsToAdd[ 1 ].val3 = 8, 10, 102
+
+      graph = Engine.new
+      graph.addObjectProduction( objectProduction )
+      graph.compile
+
+      ( objects.size - 1 ).times { |idx| graph.addObject( objectsToAdd[ idx ] ) }
+      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( objectsToAdd[ -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_single_constant' )
+      #suite << self.new( 'test_two_constants' )
+      #suite << self.new( 'test_four_constants' )
+      #suite << self.new( 'test_multiobject' )
+      #suite << self.new( 'test_two_multiobjects' )
+      #suite << self.new( 'test_two_two_multiobjects' )
+      #suite << self.new( 'test_less_than_constants' )
+      #suite << self.new( 'test_greater_than_constants' )
+      #suite << self.new( 'test_less_greater_than_constants' )
+      suite
+    end
+
+  end
+
+  require 'test/unit/ui/console/testrunner'
+
+  Test::Unit::UI::Console::TestRunner.run( Test_Constant_Test_Node_Graph )
+
+end

data/khammurabi-0.2/tests/test_graph.rb

@@ -0,0 +1,843 @@
+module MK
+
+  require 'test/unit'
+  require 'stringio'
+	require 'tracer'
+	require 'socket'
+	
+  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/Hostilities'
+	
+  class Tester
+  	
+		include Hostilities
+		
+	  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
+	
+		include Hostilities
+		
+    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 )
+			@val0 = a
+			@val1 = b
+			@val2 = c
+			@val3 = d
+		end
+
+  end
+
+	# This test class tests basic graph construction. Some code may be similar to other tests
+  class Test_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_single_constant
+      size = 1
+      object = Tester.new
+      objectToAdd = object.clone
+
+      graph = Engine.new
+      objectDescription = ObjectDescription.init( object )
+      objectProduction = ObjectProduction.init( objectDescription, graph )
+      graph.addObjectProduction( objectProduction )
+      graph.compile
+      
+      oin = graph.leaf( objectProduction )
+
+      instantiations = oin.instantiations
+      assert( instantiations.size == 0, "Instantiations size isn't 0, it's #{instantiations.size}" )
+      graph.addObject( objectToAdd )
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+    end
+
+    def test_two_constants
+      size = 2
+      objects = Array.new( size ) { Tester.new }
+      objects[ 0 ].val1 = objects[ 1 ].val1 = 4
+      objects[ 0 ].val2 = objects[ 1 ].val2 = 6
+      objects[ 0 ].val3,  objects[ 1 ].val3 = 9, 5
+
+      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
+      
+      graph = Engine.new
+      graph.addObjectProduction( objectProduction )
+      graph.compile
+
+      ( objects.size - 1 ).times do |idx|
+		  	#print "\n\nadding object  idx: #{idx}\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}\n\n"
+      graph.addObject( objects[ -1 ] )
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+      
+    end
+
+    def test_four_constants
+      size = 4
+      objects = Array.new( size ) { Tester.new }
+      objects[ 0 ].val1 = objects[ 1 ].val1 = objects[ 2 ].val1 = 2
+      objects[ 1 ].val2, objects[ 3 ].val2 = 3, 6
+      objects[ 0 ].val3, objects[ 2 ].val3 = 6, 9
+
+      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
+      
+      graph = Engine.new
+      graph.addObjectProduction( objectProduction )
+      graph.compile
+
+      ( 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}" )
+    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.compile
+
+      ( 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}" )
+    end
+
+    def test_two_variables_with_nonequality
+      size = 2
+      objects = Array.new( size ) { Tester.new }
+			objects[ 0 ].setValues( 1, 6, 1 )
+			objects[ 1 ].setValues( 2, 7, 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
+
+			#printer = ReteParseTreePrinter.init( graph.root )
+			#print "\n\n" + printer.printOn( StringIO.new ).string + "\n\n"
+			#exit
+
+			objects.each { |object| graph.addObject( object ) }
+
+      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.setValues( 1, 6, 2 )
+			graph.addObject( finalObject )
+
+      oin = graph.leaf( objectProduction )
+			instantiations = oin.instantiations
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+    end
+
+   def test_two_variables_with_nonequality2
+      size = 2
+      objects = Array.new( size ) { Tester.new }
+			objects[ 0 ].setValues( 6, 6, 9 )
+			objects[ 1 ].setValues( 7, 7, 9 )
+			
+      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
+
+      ( 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_three_variables
+      size = 3
+      objects = Array.new( size ) { Tester.new }
+			objects[ 0 ].setValues( 6,  2, 42 )
+			objects[ 1 ].setValues( 10, 2, 7  )
+			objects[ 2 ].setValues( 6,  8, 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}" )
+    end
+
+		def test_three_variables_with_nonequality
+      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 ) }
+
+      graph = Engine.new
+      graph.addObjectProduction( objectProduction )
+			#graph.setDebugging( true )
+			graph.compile
+
+      ( 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}" )
+		end
+
+		def test_three_variables_with_nonequality1
+      size = 3
+      objects = Array.new( size ) { Tester.new }
+			objects[ 0 ].setValues( nil, 1, nil )
+			objects[ 1 ].setValues( nil, 2, nil )
+			objects[ 2 ].setValues( nil, 2, nil )
+			
+      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", "Y", [ MK::InequalityTest.new ] )
+      objectDescriptions[ 2 ].setObjectAsVariable( "@val2", "Z", [ MK::InequalityTest.new ] )
+
+			# Make the test more simple
+			objectDescriptions.each { |od| od.deleteObjectOperation( "@val1" ); od.deleteObjectOperation( "@val3" ) }
+
+			# Add the object descriptions
+      objectDescriptions.each { |od| objectProduction.addObjectDescription( od ) }
+
+      graph = Engine.new
+      graph.addObjectProduction( objectProduction )
+			#graph.setDebugging( true )
+			#self.outfile = File.new( "output", "w" )
+			graph.compile
+
+			#printer = ReteParseTreePrinter.init( graph.root )
+			#print "\n\n" + printer.printOn( StringIO.new ).string + "\n\n"
+			#exit
+
+			graph.addObject( objects[ 2 ] )
+			graph.addObject( objects[ 0 ] )
+
+			oin = graph.leaf( objectProduction )
+			#Tracer.on
+      instantiations = oin.instantiations
+      assert( instantiations.size == 0, "Instantiations  #{oin.object_id} 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  #{oin.object_id} size isn't 1, it's #{instantiations.size}" )
+			#$defout.flush
+			Tracer.off
+    end
+
+    def test_four_variables
+      size = 4
+      objects = Array.new( size ) { Tester.new }
+			objects[ 0 ].setValues( 2, 101, 1000 )
+			objects[ 1 ].setValues( 2, 3,   4 )
+			objects[ 2 ].setValues( 2, 102, 4 )
+			objects[ 3 ].setValues( 2, 3,   4 )	
+			
+      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[ 1 ].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::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.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}" )
+    end
+
+    def test_five_variables
+      size = 5
+      objects = Array.new( size ) { Tester2.new }
+      # only variables in this test
+			objects[ 0 ].setValues( 1, 1,    2,    3 )
+			objects[ 1 ].setValues( 2, 1000, 2,    3 )
+			objects[ 2 ].setValues( 3, 1,    2,    3 )
+			objects[ 3 ].setValues( 4, 1001, 9,    3 )
+			objects[ 4 ].setValues( 5, 1,    1001, 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( "@val1", "X", MK::EqualityTest.new )
+      objectDescriptions[ 2 ].setObjectAsVariable( "@val1", "X", MK::EqualityTest.new )
+      objectDescriptions[ 4 ].setObjectAsVariable( "@val1", "X", MK::EqualityTest.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::InequalityTest.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
+				i = idx
+				#print "\n\nadding object  idx: #{i}\n\n"
+				graph.addObject( objects[ i ] )
+				#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}" )
+    end
+
+    def test_four_same_variables
+      size = 4
+      objects = Array.new( size ) { Tester.new }
+      objects.each { |object| object.val1, object.val2, object.val3 = 1, 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.each do |od| 
+		  	od.setObjectAsVariable( "@val3", "X", MK::EqualityTest.new )
+				objectProduction.addObjectDescription( od )
+      end
+      
+      graph = Engine.new
+      graph.addObjectProduction( objectProduction )
+      graph.compile
+
+      ( 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[ -1 ] )
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+    end
+
+    def test_multiobject
+      size = 2
+      objects = Array.new( size ) { Tester.new }
+      objects.each { |object| object.val1, object.val2, object.val3 = 1, 2, 3 }
+      objectDescriptions = Array.new( size ) { ObjectDescription.new }
+      objectProduction = ObjectProduction.new
+      objectDescriptions.each_index do |index|
+		  	#print "index: #{index}\n"
+				objectDescription = objectDescriptions[ index ]
+				objectDescription.objectDescribing = objects[ index ]
+				objectDescription.parseObject
+				objectProduction.addObjectDescription( objectDescriptions[ index ] )
+      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 do |idx|
+		  	#print "\n\nadding object  idx: #{idx}\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}\n\n"
+      graph.addObject( objects[ -1 ] )
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+    end
+
+    def test_two_multiobjects
+      size = 4
+      objects = Array.new( size ) { Tester.new }
+      for i in 0..1
+	  		objects[ i ].val1, objects[ i ].val2, objects[ i ].val3 = 1, 2, 3
+      end
+      for i in 2..3
+	  		objects[ i ].val1, objects[ i ].val2, objects[ i ].val3 = 4, 5, 6
+      end
+
+      objectDescriptions = Array.new( size ) { ObjectDescription.new }
+      objectProduction = ObjectProduction.new
+      objectDescriptions.each_index do |index|
+		  	#print "index: #{index}\n"
+				objectDescription = objectDescriptions[ index ]
+				objectDescription.objectDescribing = objects[ index ]
+				objectDescription.parseObject
+				objectProduction.addObjectDescription( objectDescriptions[ index ] )
+      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 do |idx|
+		  	#print "\n\nadding object  idx: #{idx}\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}\n\n"
+      graph.addObject( objects[ -1 ] )
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+    end
+
+    def test_two_two_multiobjects
+      size = 6
+      objects = Array.new( size ) { Tester.new }
+      for i in 0..1
+	  		objects[ i ].val1, objects[ i ].val2, objects[ i ].val3 = 1, 2, 3
+      end
+      for i in 2..3
+	  		objects[ i ].val1, objects[ i ].val2, objects[ i ].val3 = 4, 5, 6
+      end
+      objects[ 4 ].val1, objects[ 4 ].val2, objects[ 4 ].val3 = 8, 9, 10
+      objects[ 5 ].val1, objects[ 5 ].val2, objects[ 5 ].val3 = 8, 9, 11
+
+      objectDescriptions = Array.new( size ) { ObjectDescription.new }
+      objectProduction = ObjectProduction.new
+      objectDescriptions.each_index do |index|
+		  	#print "index: #{index}\n"
+				objectDescription = objectDescriptions[ index ]
+				objectDescription.objectDescribing = objects[ index ]
+				objectDescription.parseObject
+				objectProduction.addObjectDescription( objectDescriptions[ index ] )
+      end
+
+      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|
+		  	#print "\n\nadding object  idx: #{idx}\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}\n\n"
+      graph.addObject( objects[ -1 ] )
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+    end
+
+    def test_less_than_constants
+      size = 2
+      objects = Array.new( size ) { Tester.new }
+      objects[ 0 ].val1, objects[ 1 ].val1 = 4, 10
+      objects[ 0 ].val2, objects[ 1 ].val2 = 6, 15
+      objects[ 0 ].val3, objects[ 1 ].val3 = 9, 11
+      
+      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 ][ "@val1" ].valueTests = [ LessThanTest.init( 5 ) ]
+      objectDescriptions[ 0 ][ "@val2" ].valueTests = [ EqualityTest.init( 6 ) ]
+      objectDescriptions[ 0 ][ "@val3" ].valueTests = [ LessThanOrEqualTest.init( 9 ) ]
+      objectDescriptions[ 1 ][ "@val1" ].valueTests = [ LessThanTest.init( 11 ) ]
+      objectDescriptions[ 1 ][ "@val2" ].valueTests = [ LessThanOrEqualTest.init( 15 ) ]
+      objectDescriptions[ 1 ][ "@val3" ].valueTests = [ EqualityTest.init( 11 ) ]
+      objectDescriptions.each { |od| objectProduction.addObjectDescription( od ) }
+
+      objectsToAdd = Array.new
+      objects.each { |object| objectsToAdd.push( object.clone ) }
+      objectsToAdd[ 0 ].val1, objectsToAdd[ 0 ].val2, objectsToAdd[ 0 ].val3 = 3, 6, 9
+      objectsToAdd[ 1 ].val1, objectsToAdd[ 1 ].val2, objectsToAdd[ 1 ].val3 = 1, 15, 11
+
+      graph = Engine.new
+      graph.addObjectProduction( objectProduction )
+      graph.compile
+
+      ( objects.size - 1 ).times do |idx|
+		  	#print "\n\nadding object  idx: #{idx}\n\n"
+				graph.addObject( objectsToAdd[ 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}\n\n"
+      graph.addObject( objectsToAdd[ -1 ] )
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+    end      
+
+    def test_greater_than_constants
+      size = 2
+      objects = Array.new( size ) { Tester.new }
+      objects[ 0 ].val1, objects[ 1 ].val1 = 6, 4
+      objects[ 0 ].val2, objects[ 1 ].val2 = 2, 16
+      objects[ 0 ].val3, objects[ 1 ].val3 = 100, 102
+      
+      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 ][ "@val1" ].valueTests = [ GreaterThanTest.init( 3 ) ]
+      objectDescriptions[ 0 ][ "@val2" ].valueTests = [ EqualityTest.init( 2 ) ]
+      objectDescriptions[ 0 ][ "@val3" ].valueTests = [ GreaterThanOrEqualTest.init( 50 ) ]
+      objectDescriptions[ 1 ][ "@val1" ].valueTests = [ GreaterThanTest.init( 2 ) ]
+      objectDescriptions[ 1 ][ "@val2" ].valueTests = [ GreaterThanOrEqualTest.init( 16 ) ]
+      objectDescriptions[ 1 ][ "@val3" ].valueTests = [ EqualityTest.init( 102 ) ]
+      objectDescriptions.each { |od| objectProduction.addObjectDescription( od ) }
+
+      objectsToAdd = Array.new
+      objects.each { |object| objectsToAdd.push( object.clone ) }
+      objectsToAdd[ 0 ].val1, objectsToAdd[ 0 ].val2, objectsToAdd[ 0 ].val3 = 7, 2, 100
+      objectsToAdd[ 1 ].val1, objectsToAdd[ 1 ].val2, objectsToAdd[ 1 ].val3 = 5, 16, 102
+
+      graph = Engine.new
+      graph.addObjectProduction( objectProduction )
+      graph.compile
+
+      ( objects.size - 1 ).times do |idx|
+		  	#print "\n\nadding object  idx: #{idx}\n\n"
+				graph.addObject( objectsToAdd[ 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}\n\n"
+      graph.addObject( objectsToAdd[ -1 ] )
+      assert( instantiations.size == 1, "Instantiations size isn't 1, it's #{instantiations.size}" )
+    end      
+    
+    def test_less_greater_than_constants
+      size = 2
+      objects = Array.new( size ) { Tester.new }
+      objects[ 0 ].val1, objects[ 1 ].val1 = 6, 9
+      objects[ 0 ].val2, objects[ 1 ].val2 = 8, 10
+      objects[ 0 ].val3, objects[ 1 ].val3 = 5, 102
+      
+      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 ][ "@val1" ].valueTests = [ LessThanTest.init( 9 ) ]
+      objectDescriptions[ 0 ][ "@val2" ].valueTests = [ GreaterThanTest.init( 5 ) ]
+      objectDescriptions[ 0 ][ "@val3" ].valueTests = [ LessThanOrEqualTest.init( 5 ) ]
+      objectDescriptions[ 1 ][ "@val1" ].valueTests = [ LessThanTest.init( 10 ) ]
+      objectDescriptions[ 1 ][ "@val2" ].valueTests = [ EqualityTest.init( 10 ) ]
+      objectDescriptions[ 1 ][ "@val3" ].valueTests = [ GreaterThanOrEqualTest.init( 102 ) ]
+      objectDescriptions.each { |od| objectProduction.addObjectDescription( od ) }
+
+      objectsToAdd = Array.new
+      objects.each { |object| objectsToAdd.push( object.clone ) }
+      objectsToAdd[ 0 ].val1, objectsToAdd[ 0 ].val2, objectsToAdd[ 0 ].val3 = 5, 9, 5
+      objectsToAdd[ 1 ].val1, objectsToAdd[ 1 ].val2, objectsToAdd[ 1 ].val3 = 8, 10, 102
+
+      graph = Engine.new
+      graph.addObjectProduction( objectProduction )
+      graph.compile
+
+      ( objects.size - 1 ).times { |idx| graph.addObject( objectsToAdd[ idx ] ) }
+      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( objectsToAdd[ -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_single_constant' )
+      suite << self.new( 'test_two_constants' )
+      suite << self.new( 'test_four_constants' )
+      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_variables' )
+			suite << self.new( 'test_three_variables_with_nonequality' )
+      suite << self.new( 'test_three_variables_with_nonequality1' )
+			suite << self.new( 'test_four_variables' )
+      suite << self.new( 'test_five_variables' )
+      suite << self.new( 'test_multiobject' )
+      suite << self.new( 'test_two_multiobjects' )
+      suite << self.new( 'test_two_two_multiobjects' )
+      suite << self.new( 'test_four_same_variables' )
+      suite << self.new( 'test_less_than_constants' )
+      suite << self.new( 'test_greater_than_constants' )
+      suite << self.new( 'test_less_greater_than_constants' )
+			suite
+    end
+
+  end
+
+  require 'test/unit/ui/console/testrunner'
+
+  Test::Unit::UI::Console::TestRunner.run( Test_Graph )
+
+end