khammurabi 0.2

data/khammurabi-0.2/tests/test_root_node.rb

@@ -0,0 +1,101 @@
+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/RootNode'
+	require 'nist/khammurabi/ZombieNode'
+
+  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_Root_Node < Test::Unit::TestCase
+
+    attr_accessor :graphA
+
+    def objectA
+      t = Tester.new
+      t.val1 = 5
+      t.val2 = 10
+      #t.val3 = 15
+      t
+    end
+
+		# This test just assures that RootNode passes on arbitrary tokens
+    def test_pass_root_node
+			engine = Engine.new
+			rootNode = RootNode.init( "root", engine, false )
+			zn = ZombieNode.init( "Zombie! Run!", engine )
+			rootNode.makeChildConnection( zn )
+
+			assert( zn.tokens.size == 0, "(0) Zombie should have 0 tokens but has #{zn.tokens.size}" )
+			tokens = Array.new
+			3.times do |a|
+				rootNode.registerToken( Token.init( ObjectGraphWrapper.init( Tester.new ), a, Time.now ) )
+			end
+
+			rootNode.execute
+			assert( zn.tokens.size == 3, "(0) Zombie should have 3 tokens but has #{zn.tokens.size}" ) 
+    end      
+
+		# This test just assures that RootNode passes on arbitrary tokens (slightly different than above)
+    def test_pass2_root_node
+			engine = Engine.new
+			rootNode = RootNode.init( "root", engine, false )
+			zn = ZombieNode.init( "zombie", engine )
+			rootNode.makeChildConnection( zn )
+
+			assert( zn.tokens.size == 0, "(1) Zombie should have 0 tokens but has #{zn.tokens.size}" )
+			tokens = Array.new
+			3.times do |a|
+				rootNode.registerToken( Token.init( ObjectGraphWrapper.init( Tester.new ), a, Time.now ) )
+				rootNode.execute
+			end
+			assert( zn.tokens.size == 3, "(1) Zombie should have 3 tokens but has #{zn.tokens.size}" ) 
+    end
+
+    def self.suite
+      suite = Test::Unit::TestSuite.new 
+      suite << self.new( 'test_pass_root_node' )
+      suite << self.new( 'test_pass2_root_node' )
+      suite
+    end
+
+  end
+
+  require 'test/unit/ui/console/testrunner'
+
+  Test::Unit::UI::Console::TestRunner.run( Test_Root_Node )
+
+end

data/khammurabi-0.2/tests/test_token.rb

@@ -0,0 +1,166 @@
+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/RootNode'
+	require 'nist/khammurabi/ZombieNode'
+	require 'nist/khammurabi/ConstantTestNode'
+	
+  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
+		def ==( other ); ( self.val1 == other.val1 and self.val2 == other.val2 and self.val3 == other.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_Token < 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 = 5
+      t.val2 = 20
+      #t.val3 = 15
+      t
+    end
+    
+		def test_new_from_two
+			# Test basic newFromTwo
+			ogw1 = ObjectGraphWrapper.init( objectA )
+			ogw2 = ObjectGraphWrapper.init( objectA )
+			token1 = Token.init( ogw1, Token.add, Time.now, 0 )
+			token2 = Token.init( ogw2, Token.add, Time.now, 1 )
+			concatted_token1 = Token.newFromTwo( token1, token2 )
+			assert( concatted_token1.objectGraphWrappers.size == 2, "concatted_token1.objectGraphWrappers.size != 2 but is #{concatted_token1.objectGraphWrappers.size}, bad" )
+			assert( concatted_token1.objectGraphWrappers.includeID?( ogw1 ), "!concatted_token1.objectGraphWrappers.includeID?( ogw1 ), bad" )
+			assert( concatted_token1.objectGraphWrappers.includeID?( ogw2 ), "!concatted_token1.objectGraphWrappers.includeID?( ogw2 ), bad" )
+			#assert( concatted_token1.tokenID == 3, "concatted_token1.tokenID != 3, it is: #{concatted_token1.tokenID}" )
+			assert( concatted_token1.inheritedIDs == [ token1.tokenID, token2.tokenID ], "concatted_token1.inheritedIDs != [ 0, 1 ]" )
+
+			# Test more complicated newFromTwo
+			concatted_token2 = Token.newFromTwo( concatted_token1, token2 )
+			# since concatted_token1 already has token2, it shouldn't be added
+			assert( concatted_token2.objectGraphWrappers.size == 2, "concatted_token2.objectGraphWrappers.size != 2 but is #{concatted_token2.objectGraphWrappers.size}, bad" )
+
+			# Another 'more complicated' one
+			ogw3 = ObjectGraphWrapper.init( objectA )
+			token3 = Token.init( ogw3, Token.add, Time.now, 2 )
+			concatted_token2 = Token.newFromTwo( concatted_token1, token3 )
+			assert( concatted_token2.objectGraphWrappers.size == 3, "concatted_token2.objectGraphWrappers.size != 3 but is #{concatted_token2.objectGraphWrappers.size}, bad" )
+		end
+		
+		def test_bracket
+			ogw1 = ObjectGraphWrapper.init( objectA )
+			ogw2 = ObjectGraphWrapper.init( objectA )
+			token1 = Token.init( ogw1, Token.add, Time.now, 0 )
+			token2 = Token.init( ogw2, Token.add, Time.now, 1 )
+			concatted_token1 = Token[ token1, token2 ]
+			assert( concatted_token1.objectGraphWrappers.size == 2, "concatted_token1.objectGraphWrappers.size != 2 but is #{concatted_token1.objectGraphWrappers.size}, bad" )
+			assert( concatted_token1.objectGraphWrappers.includeID?( ogw1 ), "!concatted_token1.objectGraphWrappers.includeID?( ogw1 ), bad" )
+			assert( concatted_token1.objectGraphWrappers.includeID?( ogw2 ), "!concatted_token1.objectGraphWrappers.includeID?( ogw2 ), bad" )
+			assert( concatted_token1.inheritedIDs == [ token1.tokenID, token2.tokenID ], "concatted_token1.inheritedIDs != [ 0, 1 ]" )
+		end
+	
+		def test_clone
+			ogw1 = ObjectGraphWrapper.init( objectA )
+			token1 = Token.init( ogw1, Token.add, Time.now, 0 )
+			token2 = token1.clone
+			assert( token1.tokenID == token2.tokenID, "token1.tokenID != token2.tokenID, it is #{token1.tokenID}, bad" )
+			assert( token1.owner == token2.owner, "token1.owner != token2.owner, it is #{token1.owner}, bad" )
+			assert( token1.cluster == token2.cluster, "token1.cluster != token2.cluster, it is #{token1.cluster}, bad" )
+			assert( !token2.objectGraphWrappers.equal?( token1.objectGraphWrappers ), "ogw's are equal, not good" )
+			assert( !token2.objectGraphWrappers.first.equal?( ogw1 ), "ogw1 is equal, not good" )
+			assert( token1.objectGraphWrappers.first == ogw1, "first != ogw1, not good" )
+		end
+		
+		def test_concats
+			ogw1 = ObjectGraphWrapper.init( objectA )
+			token1 = Token.init( ogw1, Token.add, Time.now, 0 )
+			ogw2 = ObjectGraphWrapper.init( objectB )
+			token2 = Token.init( ogw2, Token.add, Time.now, 1 )
+			token3 = token2.concat( token1 )
+			assert( token2.objectGraphWrappers.size == 1, "size isn't right" )
+			assert( token1.objectGraphWrappers.size == 1, "size isn't right (1)" )
+			assert( token3.objectGraphWrappers.size == 2, "size isn't right (2)" )
+			assert( token3.objectGraphWrappers.first == ogw2, "Doesn't equal ogw2, bad" )
+			assert( token3.objectGraphWrappers.second == ogw1, "Doesn't equal ogw1, bad" )
+
+			token2.concat!( token3 )
+			assert( token2.objectGraphWrappers.size == 3, "Size isn't right for token2, should be 3 but is #{token2.objectGraphWrappers.size}" )
+			assert( token2.objectGraphWrappers.first == ogw2, "Doesn't equal ogw2 (1), bad" )
+			assert( token2.objectGraphWrappers.second == ogw2, "Doesn't equal ogw2 (1), bad" )
+			assert( token2.objectGraphWrappers.third == ogw1, "Doesn't equal ogw1 (1), bad" )
+			assert( token1.objectGraphWrappers.size == 1, "size isn't right (1)" )
+		end
+		
+		def test_equalequal
+			token1 = Token.init( ObjectGraphWrapper.init( objectA ), Token.add, Time.now, 0 )
+			token2 = Token.init( ObjectGraphWrapper.init( objectA ), Token.add, Time.now, 1 )
+			assert( token1 == token2, "token1 should == token2" )
+			
+			token3 = Token.init( ObjectGraphWrapper.init( objectB ), Token.add, Time.now, 1 )
+			assert( token1 != token3, "token1 should != token3" )
+		end
+		
+		def test_owner
+			engine = Engine.new
+			ctn = ConstantTestNode.init( "ctn", ConstantObjectOperation.init( MK::EqualityTest.init( 5 ), "@val1", true ), engine, nil )
+			token = Token.init( ObjectGraphWrapper.init( "hi" ), MK::Token.add, Time.now )
+			ctn.registerToken( token )
+			assert( token.owner != nil, "token's owner is nil, bad" )
+		end
+		
+		def self.suite
+      suite = Test::Unit::TestSuite.new 
+      suite << self.new( 'test_new_from_two' )
+			suite << self.new( 'test_bracket' )
+			suite << self.new( 'test_clone' )
+			suite << self.new( 'test_concats' )
+			suite << self.new( 'test_equalequal' )
+			suite << self.new( 'test_owner' )
+      suite
+    end
+
+  end
+
+  require 'test/unit/ui/console/testrunner'
+
+  Test::Unit::UI::Console::TestRunner.run( Test_Token )
+
+end

data/khammurabi-0.2/tests/test_token_cluster.rb

@@ -0,0 +1,324 @@
+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
+    attr :val1, true
+    attr :val2, true
+    attr :val3, true
+		attr :clusters, true # Array
+    def initialize
+      self.val1 = self.val2 = self.val3 = nil
+			self.clusters = Array.new
+    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_Graph < Test::Unit::TestCase
+
+    attr_accessor :graphA
+
+    def objectA
+      t = Tester.new
+      t.val1 = 5
+      t.val2 = 10
+      #t.val3 = 15
+      t
+    end
+    
+		# Tests a single cluster with matchesWith?
+		def test_cluster1
+			engine = Engine.new
+			object1 = self.objectA
+			object2 = self.objectA
+
+			###### Graph Creation ######################################################################################
+			vtn1 =	VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::EqualityTest.new ], "@val2", true, "X" ), nil, engine, nil )
+			vtn2 =	VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::EqualityTest.new ], "@val2", true, "X" ), nil, engine, nil )
+			############################################################################################################
+			
+			###### Object Creation #####################################################################################
+			token1 = Token.init( ObjectGraphWrapper.init( object1 ), 0, Time.now, 0 )
+			token2 = Token.init( ObjectGraphWrapper.init( object2 ), 1, Time.now, 1 )
+			vtn1.registerToken( token1 )
+			vtn2.registerToken( token2 )
+			############################################################################################################
+			
+			clusterManager = ClusterManager.new
+			cluster = clusterManager.createCluster( token1, TokenCluster )
+			assert( cluster.size == 1, "Cluster's size isn't 1, it's #{cluster.size}" )
+			#assert( token1.clusters.size == 1, "Object's cluster size isn't 1, it's #{object1.clusters.size}" )
+
+			retval = cluster.matchesWith?( token2 ).first
+			assert( retval.include?( TokenCluster.matchValue ), "retval is #{retval} but should be TokenCluster.matchValue (It doesn't match, but it should)" )
+		end	
+			
+		# Tests a single cluster with matchesWith?
+		def test_token_cluster_match
+			engine = Engine.new
+			object1 = self.objectA
+			object2 = self.objectA
+
+			###### Graph Creation ######################################################################################
+			vtn1 =	VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::EqualityTest.new ], "@val2", true, "X" ), nil, engine, nil )
+			vtn2 =	VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::EqualityTest.new ], "@val2", true, "X" ), nil, engine, nil )
+			############################################################################################################
+			
+			###### Object Creation #####################################################################################
+			token1 = Token.init( ObjectGraphWrapper.init( object1 ), 0, Time.now, 0 )
+			token2 = Token.init( ObjectGraphWrapper.init( object2 ), 1, Time.now, 1 )
+			vtn1.registerToken( token1 )
+			vtn2.registerToken( token2 )
+			############################################################################################################
+			
+			clusterManager = ClusterManager.new
+			cluster1 = clusterManager.createCluster( token1, TokenCluster )
+			cluster2 = clusterManager.createCluster( token2, TokenCluster )
+
+			retval = cluster1.matchesWith?( cluster2 ).first
+			assert( retval.include?( TokenCluster.matchValue ), "retval is #{retval} but should be TokenCluster.matchValue (It doesn't match, but it should)" )
+		end	
+			
+		# Tests a cluster with two elements against matchesWith? and also with matchesWith? with an object that doesn't match
+		def test_cluster2
+			engine = Engine.new
+			object1 = self.objectA
+			object2 = self.objectA
+			object3 = self.objectA
+			object4 = self.objectA
+			object4.val2 = 2
+			object3.val2 = 1
+			
+			###### Graph Creation ######################################################################################
+			vtn1 =	VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::EqualityTest.new ], "@val2", true, "X" ), nil, engine, nil )
+			vtn2 =	VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::EqualityTest.new ], "@val2", true, "X" ), nil, engine, nil )
+			vtn3 =	VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::EqualityTest.new ], "@val2", true, "X" ), nil, engine, nil )
+			vtn4 =	VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::InequalityTest.new ], "@val2", true, "X" ), nil, engine, nil )
+			############################################################################################################
+			
+			###### Object Creation #####################################################################################
+			token1 = Token.init( ObjectGraphWrapper.init( object1 ), 0, Time.now, 0 )
+			token2 = Token.init( ObjectGraphWrapper.init( object2 ), 1, Time.now, 1 )
+			token3 = Token.init( ObjectGraphWrapper.init( object3 ), 2, Time.now, 2 )
+			token4 = Token.init( ObjectGraphWrapper.init( object4 ), 3, Time.now, 3 )
+			vtn1.registerToken( token1 )
+			vtn2.registerToken( token2 )
+			vtn3.registerToken( token3 )
+			vtn4.registerToken( token4 )
+			############################################################################################################
+			
+			clusterManager = ClusterManager.new
+			cluster = clusterManager.createCluster( [ token1, token2 ], TokenCluster )
+			assert( cluster.size == 2, "Cluster's size isn't 2, it's #{cluster.size}" )
+			
+			retval = cluster.matchesWith?( token2 ).first
+			assert( retval.include?( TokenCluster.inClusterValue ), "retval doesn't have a TokenCluster.inClusterValue, it is: #{retval.join( " " )}" )
+			assert( retval.include?( TokenCluster.matchValue ), "retval doens't have a TokenCluster.matchValue, it is: #{retval.join( " " )}" )
+			
+			retval = cluster.matchesWith?( token4 ).first
+			assert( retval.include?( TokenCluster.matchValue ), "It doesn't match (1), but should. retval is: #{retval.join( " " )}" )
+			
+			retval = cluster.matchesWith?( token3 ).first
+			assert( retval.include?( TokenCluster.matchFailureValue ), "It matches, but shouldn't. retval is: #{retval.join( " " )}" )
+		end	
+		
+		# A cluster that contains two elements, both of which don't match
+		def test_broken_cluster
+			engine = Engine.new
+			object1 = self.objectA
+			object2 = self.objectA
+			object3 = self.objectA
+			object2.val2 = 1
+			
+			###### Graph Creation ######################################################################################
+			vtn1 =	VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::EqualityTest.new ], "@val2", true, "X" ), nil, engine, nil )
+			vtn2 =	VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::EqualityTest.new ], "@val2", true, "X" ), nil, engine, nil )
+			vtn3 =	VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::EqualityTest.new ], "@val2", true, "X" ), nil, engine, nil )
+			############################################################################################################
+			
+			###### Object Creation #####################################################################################
+			token1 = Token.init( ObjectGraphWrapper.init( object1 ), 0, Time.now )
+			token2 = Token.init( ObjectGraphWrapper.init( object2 ), 1, Time.now )
+			token3 = Token.init( ObjectGraphWrapper.init( object3 ), 2, Time.now )
+			vtn1.registerToken( token1 )
+			vtn2.registerToken( token2 )
+			vtn3.registerToken( token3 )
+			############################################################################################################
+			
+			clusterManager = ClusterManager.new
+			cluster = clusterManager.createCluster( [ token1, token2 ], TokenCluster )
+			#print "this cluster's ID: #{cluster.clusterID}\n"
+			#exit
+			
+			ret = cluster.matchesWith?( token2 )
+			retval = ret.first
+			failRecord = ret.second
+			
+			assert( retval.include?( TokenCluster.matchFailureValue ), "Retval should have a matchFailureValue but doesn't. it is: #{retval.join( " " )}" )
+			assert( retval.include?( TokenCluster.inClusterValue ), "Retval should have an inClusterValue but doesn't. it is: #{retval.join( " " )}" )
+			assert( failRecord.size == 1, "failRecord's size is #{failRecord.size} while it should be 1" )
+			assert( failRecord.includeID?( token1 ), "failRecord doesn't include token1, it is: #{failRecord.join( " " )}" )
+			cluster.delete( token2 )
+			assert( cluster.size == 1, "(1) Cluster size isn't right" )
+
+			assert( !token2.cluster.equal?( cluster ), "Token's cluster doesn't match" )			
+		end
+
+		# A cluster with 4 elements with various tests is mached against a token that matches, and also
+		# one that doesn't match
+		def test_complicated_cluster
+			engine = Engine.new
+			object1 = self.objectA
+			object2 = self.objectA
+			object3 = self.objectA
+			object4 = self.objectA
+			object5 = self.objectA
+			badObject = self.objectA
+			
+			object1.val2 = 1
+			object2.val2 = 2
+			object3.val2 = 2
+			object4.val2 = 3
+			object5.val2 = 4
+			badObject.val2 = -10
+			
+			###### Graph Creation ######################################################################################
+			vtn1   = VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::InequalityTest.new ], "@val2", true, "X" ), nil, engine, nil )
+			vtn2   = VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::EqualityTest.new ],    "@val2", true, "X" ), nil, engine, nil )
+			vtn3   = VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::EqualityTest.new ],    "@val2", true, "X" ), nil, engine, nil )
+			vtn4   = VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::InequalityTest.new ], "@val2", true, "X" ), nil, engine, nil )
+			vtn5   = VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::InequalityTest.new ], "@val2", true, "X" ), nil, engine, nil )
+			badVtn = VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::EqualityTest.new ],    "@val2", true, "X" ), nil, engine, nil )
+			#vtn1.debug = vtn2.debug = vtn3.debug = vtn4.debug = vtn5.debug = badVtn.debug = true
+			############################################################################################################
+			
+			###### Object Creation #####################################################################################
+			token1 = Token.init( ObjectGraphWrapper.init( object1 ), 0, Time.now )
+			token2 = Token.init( ObjectGraphWrapper.init( object2 ), 1, Time.now )
+			token3 = Token.init( ObjectGraphWrapper.init( object3 ), 2, Time.now )
+			token4 = Token.init( ObjectGraphWrapper.init( object4 ), 3, Time.now )
+			token5 = Token.init( ObjectGraphWrapper.init( object5 ), 4, Time.now )
+			badToken = Token.init( ObjectGraphWrapper.init( badVtn ), 5, Time.now )
+			vtn1.registerToken( token1 )
+			vtn2.registerToken( token2 )
+			vtn3.registerToken( token3 )
+			vtn4.registerToken( token4 )
+			vtn5.registerToken( token5 )
+			badVtn.registerToken( badToken )
+			############################################################################################################
+			
+			clusterManager = ClusterManager.new
+			cluster = clusterManager.createCluster( [ token1, token2, token3, token4 ], TokenCluster )
+			#cluster.debug = true
+			
+			retval = cluster.matchesWith?( token5 ).first
+			assert( retval.include?( TokenCluster.matchValue ), "It doesn't match, but it should. retval is: #{retval.join( " " )}" )
+
+			retval = cluster.matchesWith?( badToken ).first
+			assert( retval.include?( TokenCluster.matchFailureValue ), "It matches, but it shouldn't. retval is: #{retval.join( " " )}" )
+		end	
+
+		def test_complicated_cluster2
+			engine = Engine.new
+			objects = Array.new
+			10.times { |a| objects.push( self.objectA ) } 
+			objects[ 0 ].val2, objects[ 3 ].val2, objects[ 5 ].val2, objects[ 7 ].val2 = 1, 4, 6, 8
+			objects[ 1 ].val2 = objects[ 2 ].val2 = objects[ 4 ].val2 =  objects[ 6 ].val2 = objects[ 8 ].val2 = objects[ 9 ].val2 = 10
+			badObject = self.objectA
+			badObject.val2 = -10
+			###### Graph Creation ######################################################################################
+			vtn1 =	VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::InequalityTest.new ], "@val2", true, "X" ), nil, engine, nil )
+			vtn2 =	VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::EqualityTest.new ],    "@val2", true, "X" ), nil, engine, nil )
+			vtn3 =	VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::EqualityTest.new ],    "@val2", true, "X" ), nil, engine, nil )
+			vtn4 =	VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::InequalityTest.new ], "@val2", true, "X" ), nil, engine, nil )
+			vtn5 =	VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::EqualityTest.new ],    "@val2", true, "X" ), nil, engine, nil )
+			vtn6 =	VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::InequalityTest.new ], "@val2", true, "X" ), nil, engine, nil )
+			vtn7 =	VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::EqualityTest.new ],    "@val2", true, "X" ), nil, engine, nil )
+			vtn8 =	VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::InequalityTest.new ], "@val2", true, "X" ), nil, engine, nil )
+			vtn9 =	VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::EqualityTest.new ],    "@val2", true, "X" ), nil, engine, nil )
+			vtn10 =	VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::EqualityTest.new ],    "@val2", true, "X" ), nil, engine, nil )
+			vtn11 =	VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::EqualityTest.new ],    "@val2", true, "X" ), nil, engine, nil )
+			vtns = [ vtn1, vtn2, vtn3, vtn4, vtn5, vtn6, vtn7, vtn8, vtn9, vtn10 ]
+			############################################################################################################
+			
+			###### Object Creation #####################################################################################
+			tokens = Array.new
+			10.times do |a| 
+				tokens.push( Token.init( ObjectGraphWrapper.init( objects[ a ] ), a, Time.now ) )
+				vtns[ a ].registerToken( tokens[ a ] )
+			end
+			badToken = Token.init( ObjectGraphWrapper.init( badObject ), -10, Time.now ) 
+			vtn11.registerToken( badToken )
+			############################################################################################################
+			
+			clusterManager = ClusterManager.new
+			cluster = clusterManager.createCluster( tokens[0..8], TokenCluster )
+		
+			retval = cluster.matchesWith?( tokens[ 9 ] ).first
+			assert( retval.include?( TokenCluster.matchValue ), "It doesn't match, but it should. retval is: #{retval.join( " " )}" )
+
+			retval = cluster.matchesWith?( badToken ).first
+			assert( retval.include?( TokenCluster.matchFailureValue ), "It matches, but shouldn't. retval is: #{retval.join( " " )}" )
+		end	
+
+				# Tests a single cluster with matchesWith?
+		def test_same_owner_match
+			engine = Engine.new
+			object1 = self.objectA
+			object2 = self.objectA
+
+			###### Graph Creation ######################################################################################
+			vtn1 =	VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::EqualityTest.new ], "@val2", true, "X" ), nil, engine, nil )
+			############################################################################################################
+			
+			###### Object Creation #####################################################################################
+			token1 = Token.init( ObjectGraphWrapper.init( object1 ), 0, Time.now, 0 )
+			token2 = Token.init( ObjectGraphWrapper.init( object2 ), 1, Time.now, 1 )
+			vtn1.registerToken( token1 )
+			vtn1.registerToken( token2 )
+			############################################################################################################
+			
+			clusterManager = ClusterManager.new
+			cluster1 = clusterManager.createCluster( token1, TokenCluster )
+			cluster2 = clusterManager.createCluster( token2, TokenCluster )
+
+			retval = cluster1.matchesWith?( cluster2 ).first
+			assert( retval.include?( TokenCluster.sameOwnerValue ), "retval doesn't have same owner, it is: #{retval.join( " " )}" )
+		end	
+
+    def self.suite
+      suite = Test::Unit::TestSuite.new
+      suite << self.new( 'test_cluster1' )
+      suite << self.new( 'test_cluster2' )
+			suite << self.new( 'test_complicated_cluster' )
+			suite << self.new( 'test_complicated_cluster2' )
+			suite << self.new( 'test_token_cluster_match' )
+			suite << self.new( 'test_same_owner_match' )
+      suite
+    end
+
+  end
+
+  require 'test/unit/ui/console/testrunner'
+
+  Test::Unit::UI::Console::TestRunner.run( Test_Graph )
+
+end