khammurabi 0.2

data/khammurabi-0.2/tests/test_cluster.rb

@@ -0,0 +1,188 @@
+module MK
+
+  require 'test/unit'
+  require 'stringio'
+
+  require 'nist/khammurabi/Engine'
+  require 'nist/khammurabi/TestNode'
+  require 'nist/khammurabi/VariableTestNode'
+  require 'nist/khammurabi/InstantiatorNode'
+  require 'nist/khammurabi/ObjectProduction'
+  require 'nist/khammurabi/ArrayAddon'
+  require 'nist/khammurabi/GraphNode'
+  require 'nist/khammurabi/ValueTestSuite'
+	require 'nist/khammurabi/Cluster'
+	require 'nist/khammurabi/ClusterManager'
+	require 'nist/khammurabi/ZombieNode'
+	require 'nist/khammurabi/Hostilities'
+	
+  class Tester_Cluster
+
+		include Hostilities
+
+		attr :val1, true
+    attr :val2, true
+    attr :val3, true
+		attr :cluster, true # Array
+		attr :hostilities, true # Array
+
+		def initialize
+      self.val1 = self.val2 = self.val3 = nil
+			self.cluster = nil
+			self.hostilities = Array.new
+			self
+		end
+		def to_s 
+      "val1: #{self.val1} val2: #{self.val2} val3: #{self.val3}"
+		end
+  end
+
+  class Test_Cluster < Test::Unit::TestCase
+		
+		include Hostilities
+		
+    attr_accessor :graphA
+		attr :hostilities, true # Array
+		
+    def objectA
+      t = Tester_Cluster.new
+      t.val1 = 5
+      t.val2 = 10
+			self.hostilities = Array.new
+      #t.val3 = 15
+      t
+    end
+		
+		def test_cluster_naming
+			# This must be the first test..
+			cm = ClusterManager.new
+			cluster = cm.createCluster
+			assert( cluster.name == "Cluster 0", "The cluster's name, #{cluster.name} isn't correct" )
+			cluster2 = cm.createCluster
+			assert( cluster2.name == "Cluster 1", "(1) The cluster's name, #{cluster2.name} isn't correct" )
+		end
+
+		def test_cluster_elements1
+			cm = ClusterManager.new
+			cluster = cm.createCluster
+			t1 = Tester_Cluster.new
+			t2 = Tester_Cluster.new
+			#ts = [ Tester_Cluster.new, Tester_Cluster.new ]
+			ts = [ t1, t2 ]
+			cluster.add( ts[ 0 ] )
+			assert( cluster.size == 1, "(0) The cluster's size #{cluster.size} should be 1" )
+			cluster.add( ts[ 0 ] )
+			assert( cluster.size == 1, "(1) The cluster's size #{cluster.size} should be 1" )
+			cluster.add( ts[ 1 ] )
+			assert( cluster.size == 2, "(2) The cluster's size #{cluster.size} should be 1" )
+			cluster.add( ts[ 1 ] )
+			assert( cluster.size == 2, "(3) The cluster's size #{cluster.size} should be 1" )
+		end
+			
+		def test_cluster_elements2
+			cm = ClusterManager.new
+			cluster = cm.createCluster
+			ts = [ Tester_Cluster.new, Tester_Cluster.new, Tester_Cluster.new ]
+			cluster.add( ts[ 0 ] )
+			cluster.add( ts[ 1 ] )
+			assert( cluster.size == 2, "The cluster's size: #{cluster.size} should be 2" )
+			cluster.deleteID( ts[ 1 ] )
+			assert( cluster.size == 1, "The cluster's size: #{cluster.size} should be 2" )
+			cluster.deleteID( ts[ 1 ] )
+			assert( cluster.size == 1, "The cluster's size: #{cluster.size} should be 2" )
+		end
+		
+		def test_multi_init
+			cm = ClusterManager.new
+			cluster = cm.createCluster( [ Tester_Cluster.new, Tester_Cluster.new, Tester_Cluster.new, Tester_Cluster.new ] )
+			assert( cluster.size == 4, "Cluster's size should be 4" )
+			cluster.elements.each do |element|
+				assert( element.cluster == cluster, "Element's cluster isn't cluster" )
+			end
+		end
+		
+		def test_contain
+			cm = ClusterManager.new
+			cluster = cm.createCluster
+			ts = [ Tester_Cluster.new, Tester_Cluster.new ]
+			cluster.add( ts[ 0 ] )
+			assert( !cluster.contain?( ts[ 1 ] ), "Cluster shouldn't contain? this element" )
+			assert( cluster.contain?( ts[ 0 ] ), "Cluster should contain? this element" )
+		end
+		
+		def test_hostility1
+			cm = ClusterManager.new
+			ts = [ Tester_Cluster.new, Tester_Cluster.new ]
+			cluster = cm.createCluster( ts ) # [ ts[ 0 ], ts[ 1 ] ] )
+			assert( cluster.size == 2, "Cluster's size should be 2" )
+			print "00 it's object id: #{ts[0].object_id}\n"
+			cluster.becomeHostileTo( ts[ 0 ] )
+			print "11 it's object id: #{ts[0].object_id}\n"
+			assert( cluster.isHostileTo?( ts[ 0 ] ) == true, "Cluster isn't correctly hostile to element" )
+			assert( cluster.size == 1, "Cluster's size should be 1" )
+			cluster.add( ts[ 0 ] )
+			assert( cluster.size == 1, "(1) Cluster's size should be 1 but is: #{cluster.size}" )
+			cluster.becomeFriendlyTo( ts[ 0 ] )
+			assert( cluster.size == 1, "(2) Cluster's size should be 1 but is: #{cluster.size}" )
+			cluster.add( ts[ 0 ] )
+			assert( cluster.size == 2, "(1)Cluster's size should be 2 but is: #{cluster.size}" )
+		end
+
+		def test_hostility2
+			cm = ClusterManager.new
+			t1, t2 = Tester_Cluster.new, Tester_Cluster.new
+			cluster = cm.createCluster( [ t1, t2 ] )
+			assert( cluster.size == 2, "Cluster's size should be 2" )
+			cluster.becomeHostileTo( t1 )
+			assert( cluster.isHostileTo?( t1 ) == true, "Cluster isn't correctly hostile to element" )
+			assert( cluster.size == 1, "Cluster's size should be 1 but is #{cluster.size}" )
+			cluster.add( t1 )
+			assert( cluster.size == 1, "(1) Cluster's size should be 1 but is: #{cluster.size}" )
+			cluster.becomeFriendlyTo( t1 )
+			assert( cluster.size == 1, "(2) Cluster's size should be 1 but is: #{cluster.size}" )
+			cluster.add( t1 )
+			assert( cluster.size == 2, "(1)Cluster's size should be 2 but is: #{cluster.size}" )
+		end
+
+		def test_equality
+			cm = ClusterManager.new
+			t1, t2, t3, t4 = Tester_Cluster.new, Tester_Cluster.new, Tester_Cluster.new, Tester_Cluster.new
+			cluster1 = cm.createCluster( [ t1, t2, t3 ] )
+			cluster2 = cm.createCluster( [ t1, t2, t3 ] )
+			cluster3 = cm.createCluster( [ t2, t3, t4 ] )
+			cluster4 = cm.createCluster( [ t1, t2, t3, t4 ] )
+			assert( cluster1 == cluster2, "Cluster1 != cluster2, which shouldn't be" )
+			assert( cluster1 != cluster3, "Cluster1 == cluster3, which shouldn't be" )
+			assert( cluster1 != cluster4, "Cluster1 == cluster4, which shouldn't be" )
+		end
+
+		def test_contain
+			t1, t2 = Tester_Cluster.new, Tester_Cluster.new
+			cm = ClusterManager.new
+			cluster = cm.createCluster
+			cluster.add( t1 )
+			assert( !cluster.contain?( t2 ), "Cluster shouldn't have this element" )
+			assert( cluster.contain?( t1 ), "Cluster should have this element" )
+		end
+
+    def self.suite
+      suite = Test::Unit::TestSuite.new
+      suite << self.new( 'test_cluster_naming' )
+			suite << self.new( 'test_cluster_elements1' )
+			suite << self.new( 'test_cluster_elements2' )
+			suite << self.new( 'test_multi_init' )
+			suite << self.new( 'test_contain' )
+			#suite << self.new( 'test_hostility1' )
+			suite << self.new( 'test_hostility2' )
+			suite << self.new( 'test_equality' )
+			suite << self.new( 'test_contain' )
+			suite
+    end
+
+  end
+
+  require 'test/unit/ui/console/testrunner'
+
+  Test::Unit::UI::Console::TestRunner.run( Test_Cluster )
+
+end

data/khammurabi-0.2/tests/test_cluster_graph.rb

@@ -0,0 +1,393 @@
+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 buidling the graph with the engine 
+  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 )
+			#cluster.debug = true
+			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.join( " " )} but should contain a matchValue" )
+		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 doensn't have an inClusterValue but should. retval 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 )
+			retval = cluster.matchesWith?( token2 ).first
+
+			assert( retval.include?( TokenCluster.inClusterValue ), "Retval should be -1 but is #{retval}" )
+
+			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 that contains two elements, both of which initially match, but then don't later in the tree
+		def test_broken_cluster2
+			engine = Engine.new
+			object1 = self.objectA
+			object2 = self.objectA
+			object2.val2 = 1098
+
+			###### Graph Creation ##################################################################################################################
+			vtn1 =	VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::EqualityTest.new ], "@val1", true, "X" ), nil, engine, nil, 0 )
+			vtn2 =	VariableTestNode.init( "1", VariableObjectOperation.init( [ MK::EqualityTest.new ], "@val1", true, "X" ), nil, engine, nil, 0 )
+			vtn3 =	VariableTestNode.init( "2", VariableObjectOperation.init( [ MK::EqualityTest.new ], "@val2", true, "Y" ), nil, engine, nil, 1 )
+			vtn4 =	VariableTestNode.init( "3", VariableObjectOperation.init( [ MK::EqualityTest.new ], "@val2", true, "Y" ), nil, engine, nil, 1 )
+			#engine.setDebugging( true )
+			zn1 = ZombieNode.init( "zombie!! 1", engine )
+			zn2 = ZombieNode.init( "noooo! zombie!! 2", engine )
+			vtn1.makeChildConnection( vtn3 )
+			vtn2.makeChildConnection( vtn4 )
+			vtn3.makeChildConnection( zn1 )
+			vtn4.makeChildConnection( zn2 )
+			vtne1 = VariableTestNodeExecutor.init( engine, [ vtn1, vtn2 ], "vtne1" )
+			vtne2 = VariableTestNodeExecutor.init( engine, [ vtn3, vtn4 ], "vtne2" )
+			#[ vtn1, vtn2, vtn3, vtn4, vtne1, vtne2 ].each { |v| v.debug = true }
+			########################################################################################################################################
+
+			###### Object Creation #################################################################################################################
+			token1 = Token.init( ObjectGraphWrapper.init( object1 ), 0, Time.now )
+			token2 = Token.init( ObjectGraphWrapper.init( object2 ), 1, Time.now )
+			########################################################################################################################################
+
+			clusterManager = engine.clusterManager
+			cluster1 = clusterManager.createCluster( [ token1 ], TokenCluster )
+			cluster2 = clusterManager.createCluster( [ token2 ], TokenCluster )
+			
+			#print "I 1\n"
+			vtn1.registerToken( token1 )
+			#print "I 2\n"
+			vtn2.registerToken( token2 )
+			vtn1.execute
+			
+			# First make sure that each zombie has no tokens
+			assert( zn1.tokens.size == 0, "Zombie 1 has #{zn1.tokens.size} token(s) but shouldn't have any" )
+			assert( zn2.tokens.size == 0, "Zombie 2 has #{zn1.tokens.size} token(s) but shouldn't have any" )
+			
+			# By now, the tokens have joined into a cluster and then separated (since object2.val2 != object1.val2). Thus they have new clusters... or should!
+			assert( !token1.cluster.equal?( cluster1 ), "Token1 should have a new cluster!" )
+			assert( !token2.cluster.equal?( cluster2 ), "Token2 should have a new cluster!" )
+			assert( !token1.cluster.equal?( token2.cluster ), "Token1's cluster shouldn't equal? token2's" )
+		end
+
+		def test_broken_cluster3
+			engine = Engine.new
+			object1 = self.objectA
+			object1.val3 = 1024
+			object2 = self.objectA
+			object2.val2 = 1098
+			object3 = self.objectA
+			object3.val3 = 1024
+			#print "object1: #{object1}\nobject2: #{object2}\nobject3: #{object3}\n"
+			
+			###### Graph Creation ##################################################################################################################
+			# variable level 0
+			vtn1 =	VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::EqualityTest.new ], "@val1", true, "X" ), nil, engine, nil, 0 )
+			vtn2 =	VariableTestNode.init( "1", VariableObjectOperation.init( [ MK::EqualityTest.new ], "@val1", true, "X" ), nil, engine, nil, 0 )
+			# variable level 1
+			vtn3 =	VariableTestNode.init( "2", VariableObjectOperation.init( [ MK::EqualityTest.new ], "@val2", true, "Y" ), nil, engine, nil, 1 )
+			vtn4 =	VariableTestNode.init( "3", VariableObjectOperation.init( [ MK::EqualityTest.new ], "@val2", true, "Y" ), nil, engine, nil, 1 )
+			# variable level 2
+			vtn5 =	VariableTestNode.init( "4", VariableObjectOperation.init( [ MK::EqualityTest.new ], "@val3", true, "Z" ), nil, engine, nil, 2 )
+			vtn6 =	VariableTestNode.init( "5", VariableObjectOperation.init( [ MK::EqualityTest.new ], "@val3", true, "Z" ), nil, engine, nil, 2 )
+
+			#engine.setDebugging( true )
+			zn1 = ZombieNode.init( "zombie!! 1", engine )
+			zn2 = ZombieNode.init( "noooo! zombie!! 2", engine )
+			vtn1.makeChildConnection( vtn3 )
+			vtn2.makeChildConnection( vtn4 )
+			vtn3.makeChildConnection( vtn5 )
+			vtn4.makeChildConnection( vtn6 )
+			vtn5.makeChildConnection( zn1 )
+			vtn6.makeChildConnection( zn2 )
+			vtne1 = VariableTestNodeExecutor.init( engine, [ vtn1, vtn2 ] )
+			vtne2 = VariableTestNodeExecutor.init( engine, [ vtn3, vtn4 ] )
+			vtne3 = VariableTestNodeExecutor.init( engine, [ vtn5, vtn6 ] )
+			#[ vtn1, vtn2, vtn3, vtn4, vtn5, vtn6, vtne1, vtne2 ].each { |v| v.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 )
+			########################################################################################################################################
+
+			clusterManager = engine.clusterManager
+			cluster1 = clusterManager.createCluster( [ token1 ], TokenCluster )
+			cluster2 = clusterManager.createCluster( [ token2 ], TokenCluster )
+			cluster3 = clusterManager.createCluster( [ token3 ], TokenCluster )
+			
+			vtn1.registerToken( token1 )
+			vtn2.registerToken( token2 )
+			vtn2.registerToken( token3 )
+			vtn1.execute
+
+			# First make sure that each zombie has no tokens
+			assert( zn1.tokens.size == 1, "Zombie 1 has #{zn1.tokens.size} token(s) but needs 1" )
+			assert( zn2.tokens.size == 1, "Zombie 2 has #{zn1.tokens.size} token(s) but needs 1" )
+			assert( vtn2.tokens.size == 1, "vtn2 should have 1 token, but has #{vtn2.tokens.size}" )
+			
+			# By now, the tokens have joined into a cluster and then separated (since object2.val2 != object1.val2). Thus they have new clusters... or should!
+			assert( !token1.cluster.equal?( cluster1 ), "Token1 should have a new cluster!" )
+			assert( !token2.cluster.equal?( cluster2 ), "Token2 should have a new cluster!" )
+			assert( !token1.cluster.equal?( token2.cluster ), "Token1's cluster shouldn't equal? token2's" )
+		end
+
+		# A cluster with 4 elements with various tests is mached against a token that matches
+		def test_complicated_cluster
+			engine = Engine.new
+			object1 = self.objectA
+			object2 = self.objectA
+			object3 = self.objectA
+			object4 = self.objectA
+			object5 = self.objectA
+			object1.val2 = 1
+			object2.val2 = 2
+			object3.val2 = 2
+			object4.val2 = 3
+			object5.val2 = 4
+			
+			###### 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 )
+			############################################################################################################
+			
+			###### 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 )
+			vtn1.registerToken( token1 )
+			vtn2.registerToken( token2 )
+			vtn3.registerToken( token3 )
+			vtn4.registerToken( token4 )
+			vtn5.registerToken( token5 )
+			############################################################################################################
+			
+			clusterManager = ClusterManager.new
+			cluster = clusterManager.createCluster( [ token1, token2, token3, token4 ], TokenCluster )
+		
+			retval = cluster.matchesWith?( token5 ).first
+			assert( retval.include?( TokenCluster.matchValue ), "It doesn't match, but it should. retval is: #{retval.join( " " )}" )
+		end	
+
+		# This method creates two VariableTestNode's and incorporates a VariableTestNodeExecutor
+		def test_cluster_with_graph1
+			engine = Engine.new
+			object1 = self.objectA
+			object2 = self.objectA
+
+			###### Graph Creation ######################################################################################
+			vtne = VariableTestNodeExecutor.init( engine )
+			vtn1 = VariableTestNode.init( "0", VariableObjectOperation.init( [ MK::EqualityTest.new ], "@val2", true, "X" ), vtne, engine, nil, 0 )
+			vtn2 = VariableTestNode.init( "1", VariableObjectOperation.init( [ MK::EqualityTest.new ], "@val2", true, "X" ), vtne, engine, nil, 1 )
+			gnj  = GraphNodeJoiner.init( "2", vtn1, vtn2, engine )
+			zn   = ZombieNode.init( "3", engine )
+			vtn1.addChild( gnj )
+			vtn2.addChild( gnj )
+			gnj.setChild( zn )
+			vtne.setVariableTestNodes( [ vtn1, vtn2 ] )
+			############################################################################################################
+			
+			###### Object Creation #####################################################################################
+			token1 = Token.init( ObjectGraphWrapper.init( object1 ), 0, Time.now )
+			token2 = Token.init( ObjectGraphWrapper.init( object2 ), 1, Time.now )
+			clusterManager = ClusterManager.new
+			engine.clusterManager = clusterManager
+			cluster1 = clusterManager.createCluster( token1, TokenCluster ) 
+			cluster2 = clusterManager.createCluster( token2, TokenCluster )
+
+			vtn1.registerToken( token1 )
+			vtn2.registerToken( token2 )
+			############################################################################################################
+
+			assert( cluster1.size == 1, "Cluster1's size isn't 1" )
+			assert( cluster2.size == 1, "Cluster2's size isn't 1" )
+			assert( vtn1.tokens.size == 1, "vtn1's tokens size isn't right" )
+			assert( vtn2.tokens.size == 1, "vtn2's tokens size isn't right" )
+			assert( token1.owner != nil, "Token 1's owner is nil but shouldn't be" )
+			assert( token2.owner != nil, "Token 2's owner is nil but shouldn't be" )
+
+			vtn1.execute
+			
+			assert( zn.tokens.size == 1, "Zombie's token size isn't right. It is: #{zn.tokens.size} but should be 1" )
+		end
+		
+		# This method creates a single VariableTestNode and incorporates a VariableTestNodeExecutor
+		def test_cluster_with_graph0
+			engine = Engine.new
+			object = self.objectA
+
+			###### Graph Creation ######################################################################################
+			vtne = VariableTestNodeExecutor.init( engine )
+			vtn = VariableTestNode.init( "1", VariableObjectOperation.init( [ MK::EqualityTest.new ], "@val2", true, "X" ), vtne, engine, nil )
+			zn   = ZombieNode.init( "3", engine )
+			vtn.addChild( zn )
+			vtne.setVariableTestNodes( [ vtn ] )
+			############################################################################################################
+			
+			###### Object Creation #####################################################################################
+			clusterManager = ClusterManager.new
+			engine.clusterManager = clusterManager
+			token = Token.init( ObjectGraphWrapper.init( object ), 0, Time.now, 0 )
+			cluster = clusterManager.createCluster( [ token ], TokenCluster )
+
+			vtn.registerToken( token )
+			############################################################################################################
+
+			assert( token.owner != nil, "Token's owner is nil but shouldn't be" )
+			vtn.execute
+			assert( zn.tokens.size == 1, "Zombie's token size isn't right. It is: #{zn.tokens.size} but should be 1" )
+		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_cluster_with_graph1' )
+			suite << self.new( 'test_cluster_with_graph0' )
+			suite << self.new( 'test_broken_cluster' )
+			suite << self.new( 'test_broken_cluster2' )
+			suite << self.new( 'test_broken_cluster3' )
+      suite
+    end
+
+  end
+
+  require 'test/unit/ui/console/testrunner'
+
+  Test::Unit::UI::Console::TestRunner.run( Test_Graph )
+
+end