khammurabi 0.2

data/khammurabi-0.2/tests/test_cluster_manager.rb

@@ -0,0 +1,204 @@
+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_Manager
+
+		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_Manager < Test::Unit::TestCase
+
+		include Hostilities
+
+    attr_accessor :graphA
+		attr :hostilities, true # Array
+		
+    def objectA
+      t = Tester_Cluster_Manager.new
+      t.val1 = 5
+      t.val2 = 10
+    	self.hostilities = Array.new
+			#t.val3 = 15
+      t
+    end
+
+		def test_create_cluster
+			cm = ClusterManager.new
+			t1, t2 = Tester_Cluster_Manager.new, Tester_Cluster_Manager.new
+			cluster = cm.createCluster( [ t1, t2 ], Cluster )
+			assert( cm.clusters.size == 1, "Manager's clusters doesn't have the correct size" )
+		end
+
+		def test_disband
+			cm = ClusterManager.new
+			t1, t2 = Tester_Cluster_Manager.new, Tester_Cluster_Manager.new
+			cluster = cm.createCluster( [ t1, t2 ], Cluster )
+			assert( cluster.contain?( t1 ), "Cluster should contain t1" )
+			cm.disbandCluster( cluster, Cluster )
+			assert( !t1.cluster.equal?( cluster ), "t1's cluster isn't right" )
+			assert( t1.cluster != nil, "t1's cluster should be nil" )
+			assert( t2.cluster != nil, "t2's cluster shouldn't be nil" )
+			assert( !t1.cluster.equal?( t2.cluster ), "t1 and t2's clusters shouldn't be equal" )
+			assert( cluster.size == 0, "Cluster's size isn't right. Should be 0 but is: #{cluster.size}" )
+		end
+
+		def test_delete_from_cluster
+			cm = ClusterManager.new
+			t1, t2, t3 = Tester_Cluster_Manager.new, Tester_Cluster_Manager.new, Tester_Cluster_Manager.new
+			cluster = cm.createCluster( [ t1, t2, t3 ], Cluster )
+			cm.deleteFromCluster( t1, cluster )
+			assert( t1.cluster != nil, "t1's cluster shouldn't be nil" )
+			assert( !t1.cluster.equal?( cluster ), "t1's cluster shouldn't be equal to cluster" )
+			cm.deleteFromCluster( t2, cluster )
+			cm.deleteFromCluster( t3, cluster )
+			assert( !cm.clusters.includeID?( cluster ), "manager's clusters shouldn't have cluster" )
+		end
+
+		def test_clean_cluster
+			########
+			cm = ClusterManager.new
+			t1, t2, t3, t4 = Tester_Cluster_Manager.new, Tester_Cluster_Manager.new, Tester_Cluster_Manager.new, Tester_Cluster_Manager.new
+			clusters = Array.new
+			3.times do |a|
+				clusters.push( cm.createCluster( [ t1, t2, t3 ], Cluster ) )
+			end
+			cm.cleanClusters( clusters )
+			assert( clusters.size == 1, "clusters.size != 1 but is: #{clusters.size}, which is bad" )
+
+			########
+			clusters = Array.new
+			3.times do |a|
+				clusters.push( cm.createCluster( [ t1, t2, t3 ], Cluster ) )
+			end
+			clusters.push( cm.createCluster( [ t2, t1, t3 ], Cluster ) )
+			cm.cleanClusters( clusters )
+			assert( clusters.size == 1, "clusters.size != 1, but is #{clusters.size} bad" )
+
+			########
+			cm = ClusterManager.new
+			t1, t2, t3, t4 = Tester_Cluster_Manager.new, Tester_Cluster_Manager.new, Tester_Cluster_Manager.new, Tester_Cluster_Manager.new
+			t4.val1 = -99
+			clusters = Array.new
+			3.times do |a|
+				clusters.push( cm.createCluster( [ t1, t2, t3 ], Cluster ) )
+			end
+			clusters.push( cm.createCluster( [ t2, t1, t4 ], Cluster ) )
+			cm.cleanClusters( clusters )
+			assert( clusters.size == 2, "clusters.size != 2, but is #{clusters.size}, bad" )
+			
+			#########
+			size = 8
+			cm = ClusterManager.new
+			ts = Array.new( size ) { Tester_Cluster_Manager.new }
+			clusters = Array.new
+			clusters.push( cm.createCluster( [ ts[ 1 ], ts[ 2 ], ts[ 0 ] ], Cluster ) )
+			clusters.push( cm.createCluster( [ ts[ 0 ], ts[ 1 ], ts[ 2 ] ], Cluster ) )
+			clusters.push( cm.createCluster( [ ts[ 1 ], ts[ 0 ], ts[ 2 ] ], Cluster ) )
+			cm.cleanClusters( clusters )
+			assert( clusters.size == 1, "clusters.size != 1, but is #{clusters.size}, bad" )
+			
+			#########
+			clusters = Array.new
+			clusters.push( cm.createCluster( [ ts[ 1 ], ts[ 2 ], ts[ 0 ] ], Cluster ) )
+			clusters.push( cm.createCluster( [ ts[ 0 ], ts[ 1 ], ts[ 2 ] ], Cluster ) )
+			clusters.push( cm.createCluster( [ ts[ 1 ], ts[ 0 ], ts[ 2 ] ], Cluster ) )
+			clusters.push( cm.createCluster( [ ts[ 1 ], ts[ 0 ], ts[ 2 ], ts[ 3 ] ], Cluster ) )
+			cm.cleanClusters( clusters )
+			assert( clusters.size == 2, "clusters.size != 2, but is #{clusters.size}, bad" )
+
+			## Small one with small adds instead of a big creation ##
+			clusters = Array.new
+			cluster1 = cm.createCluster( [ ts[ 1 ] ], Cluster )
+			clusters.push( cluster1 )
+			cluster1.add( ts[ 2 ] )
+			cluster2 = cm.createCluster
+			cluster2.add( ts[ 1 ] )
+			cluster2.add( ts[ 2 ] )
+			clusters.push( cluster2 )
+			cm.cleanClusters( clusters )
+			assert( clusters.size == 1, "clusters.size != 1, but is #{clusters.size}, bad" )
+		end
+
+		def test_clean_cluster_complex
+			size = 8
+			cm = ClusterManager.new
+			ts = Array.new( size ) { Tester_Cluster_Manager.new }
+			clusters = Array.new
+			clusters.push( cm.createCluster( [ ts[ 0 ] ],                                     Cluster ) )
+			clusters.push( cm.createCluster( [ ts[ 0 ], ts[ 1 ] ],                            Cluster ) ) 
+			clusters.push( cm.createCluster( [ ts[ 0 ], ts[ 1 ], ts[ 2 ] ],                   Cluster ) )
+			clusters.push( cm.createCluster( [ ts[ 0 ], ts[ 1 ], ts[ 2 ] ],                   Cluster ) )
+			clusters.push( cm.createCluster( [ ts[ 0 ] ],                                     Cluster ) )
+			clusters.push( cm.createCluster( [ ts[ 0 ], ts[ 1 ] ],                            Cluster ) )
+			clusters.push( cm.createCluster( [ ts[ 0 ], ts[ 3 ], ts[ 4 ] ],                   Cluster ) )
+			clusters.push( cm.createCluster( [ ts[ 0 ], ts[ 3 ], ts[ 4 ], ts[ 6 ], ts[ 7 ] ], Cluster ) )
+			clusters.push( cm.createCluster( [ ts[ 0 ], ts[ 1 ] ],                            Cluster ) )
+			clusters.push( cm.createCluster( [ ts[ 0 ], ts[ 1 ] ],                            Cluster ) )
+			clusters.push( cm.createCluster( [ ts[ 0 ], ts[ 1 ] ],                            Cluster ) )
+			clusters.push( cm.createCluster( [ ts[ 0 ], ts[ 1 ] ],                            Cluster ) )
+			clusters.push( cm.createCluster( [ ts[ 0 ], ts[ 1 ] ],                            Cluster ) )
+			clusters.push( cm.createCluster( [ ts[ 0 ], ts[ 1 ], ts[ 2 ], ts[ 3 ] ],          Cluster ) )
+			cm.cleanClusters( clusters )
+			assert( clusters.size == 6, "clusters.size != 2, but is #{clusters.size}, bad" )
+		end
+
+		def test_lossy_concat
+			size = 3
+			cm = ClusterManager.new
+			ts = Array.new( size ) { Tester_Cluster_Manager.new }
+			cluster1 = cm.createCluster( [ ts[ 0 ], ts[ 1 ] ], Cluster )
+			cluster2 = cm.createCluster( [ ts[ 2 ] ],          Cluster )
+			cm.lossyConcat( cluster1, cluster2 )
+			assert( cluster2.size == 0, "cluster2's size should be 0 but is #{cluster2.size}" )
+			assert( cluster1.size == 3, "cluster1's size should be 3 but is #{cluster1.size}" )
+		end
+		
+    def self.suite
+      suite = Test::Unit::TestSuite.new
+			suite << self.new( 'test_create_cluster' )
+      suite << self.new( 'test_disband' )
+			suite << self.new( 'test_delete_from_cluster' )
+			suite << self.new( 'test_clean_cluster' )
+			suite << self.new( 'test_clean_cluster_complex' )
+			suite << self.new( 'test_lossy_concat' )
+			suite
+    end
+
+  end
+
+  require 'test/unit/ui/console/testrunner'
+
+  Test::Unit::UI::Console::TestRunner.run( Test_Cluster_Manager )
+
+end

data/khammurabi-0.2/tests/test_constant_object_operation.rb

@@ -0,0 +1,112 @@
+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_Constant_Object_Operation < Test::Unit::TestCase
+
+    attr_accessor :graphA
+
+    def objectA
+      t = Tester.new
+      t.val1 = 5
+      t.val2 = 10
+      #t.val3 = 15
+      t
+    end
+    
+		def test_matching
+			coo = ConstantObjectOperation.init( MK::EqualityTest.init( 5 ), "@val1", true )
+			object1 = objectA
+			assert( coo.match?( object1 ) == true, "coo should have matched but didn't" )
+
+			coo = ConstantObjectOperation.init( MK::EqualityTest.init( 5 ), "@val1", true )
+			object1.val1 = 6
+			assert( coo.match?( object1 ) == false, "coo shouldn't have matched but did" )
+		end
+		
+		def test_equalequal
+			coo1 = ConstantObjectOperation.init( MK::EqualityTest.init( 5 ), "@val1", true )
+			coo2 = ConstantObjectOperation.init( MK::EqualityTest.init( 5 ), "@val1", true )
+			coo3 = ConstantObjectOperation.init( MK::EqualityTest.init( 6 ), "@val1", true )
+			coo4 = ConstantObjectOperation.init( MK::InequalityTest.init( 5 ), "@val1", true )
+			coo5 = ConstantObjectOperation.init( MK::InequalityTest.init( 5 ), "@val2", true )
+			coo6 = ConstantObjectOperation.init( MK::InequalityTest.init( 5 ), "@val2", false )
+			coo7 = ConstantObjectOperation.init( MK::InequalityTest.init( 5 ), "@val2", true )
+
+			coo8  = ConstantObjectOperation.init( [ MK::InequalityTest.init( 5 ), MK::EqualityTest.init( 2 ) ], "@val2", true )
+			coo9  = ConstantObjectOperation.init( [ MK::EqualityTest.init( 2 ),   MK::InequalityTest.init( 5 ) ], "@val2", true )
+			coo10 = ConstantObjectOperation.init( MK::EqualityTest.init( nil ), "@val2", true )
+			coo11 = ConstantObjectOperation.init( MK::EqualityTest.init( "" ), "@val2", true )
+			
+			assert( coo1 == coo2, "coo1 != coo2, bad" )
+			assert( coo2 != coo3, "coo2 == coo3, bad" )
+			assert( coo4 != coo5, "coo4 == coo5, bad" )
+			assert( coo5 != coo6, "coo5 == coo6, bad" )
+			assert( coo5 == coo7, "coo5 != coo7, bad" )
+			assert( coo1 != coo7, "coo1 == coo7, bad" )
+			assert( coo8 == coo9, "coo8 != coo9, bad" )
+			assert( coo7 != coo9, "coo7 == coo9, bad" )
+
+			assert( coo1 != coo10, "coo1 == coo10, not good" )
+			assert( coo4 != coo10, "coo1 == coo10, not good" )
+			assert( coo9 != coo10, "coo9 == coo10, not good" )
+
+			assert( coo1 != coo11, "coo1 == coo11, not good" )
+			assert( coo4 != coo11, "coo1 == coo11, not good" )
+			assert( coo9 != coo11, "coo9 == coo11, not good" )
+		end
+		
+		def test_clone
+			coo1 = ConstantObjectOperation.init( MK::EqualityTest.init( 5 ), "@val1", true )
+			cologne = coo1.clone
+			assert( cologne.class == ConstantObjectOperation )
+			assert( cologne.templateTestValue == [ 5 ] )
+			assert( cologne.testMe == true )
+			assert( cologne.name == "@val1" )
+		end
+		
+		def self.suite
+			suite = Test::Unit::TestSuite.new
+			suite << self.new( 'test_matching' )
+			suite << self.new( 'test_equalequal' )
+			suite << self.new( 'test_clone' )
+			suite
+		end
+	
+  end
+
+  require 'test/unit/ui/console/testrunner'
+
+  Test::Unit::UI::Console::TestRunner.run( Test_Constant_Object_Operation )
+
+end

data/khammurabi-0.2/tests/test_constant_test_node.rb

@@ -0,0 +1,142 @@
+module MK
+
+  require 'test/unit'
+  require 'stringio'
+
+  require 'nist/khammurabi/Engine'
+  require 'nist/khammurabi/TestNode'
+  require 'nist/khammurabi/VariableTestNode'
+  require 'nist/khammurabi/InstantiatorNode'
+  require 'nist/khammurabi/ObjectProduction'
+  require 'nist/khammurabi/ArrayAddon'
+  require 'nist/khammurabi/GraphNode'
+  require 'nist/khammurabi/ValueTestSuite'
+	require 'nist/khammurabi/ReteParseTreePrinter'
+	require 'nist/khammurabi/ZombieNode'
+	
+  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 < 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 = 6
+      t.val2 = 10
+      #t.val3 = 15
+      t
+    end
+    
+		def test_pass
+			engine = Engine.new
+			test = MK::EqualityTest.init( 5 )
+			ctn = ConstantTestNode.init( "coo1", ConstantObjectOperation.init( test, "@val1", true ), engine, nil )
+			zn = ZombieNode.init( "Zombie zombie", engine )
+			ctn.setChild( zn )
+			zn.setParent( ctn )
+
+			token1 = Token.init( ObjectGraphWrapper.init( objectA ), "+", Time.now )
+			token2 = Token.init( ObjectGraphWrapper.init( objectB ), "+", Time.now )
+
+			ctn.registerToken( token1 )
+			ctn.execute
+			
+			assert( zn.tokens.size == 1, "ZombieNode doesn't have any tokens, bad" )
+			
+			ctn.registerToken( token2 )
+			ctn.execute
+			assert( zn.tokens.size == 1, "ZombieNode should still only have 1 token, bad" )
+			assert( ctn.tokens.size == 0, "coo shouldn't have any tokens" )
+		end
+
+		def test_pass2
+			engine = Engine.new
+			test = MK::LessThanOrEqualTest.init( 30 )
+			ctn = ConstantTestNode.init( "coo1", ConstantObjectOperation.init( test, "@val1", true ), engine, nil )
+			zn = ZombieNode.init( "Zombie zombie", engine )
+			ctn.setChild( zn )
+			zn.setParent( ctn )
+
+			token1 = Token.init( ObjectGraphWrapper.init( objectA ), "+", Time.now )
+			token2 = Token.init( ObjectGraphWrapper.init( objectB ), "+", Time.now )
+
+			ctn.registerToken( token1 )
+			ctn.execute
+			
+			assert( zn.tokens.size == 1, "ZombieNode doesn't have any tokens, bad" )
+			
+			ctn.registerToken( token2 )
+			ctn.execute
+			assert( zn.tokens.size == 2, "ZombieNode should have 2 tokens, bad" )
+			assert( ctn.tokens.size == 0, "coo shouldn't have any tokens" )
+		end
+
+		def test_pass3
+			engine = Engine.new
+			test = MK::InequalityTest.init( 50 )
+			ctn = ConstantTestNode.init( "coo1", ConstantObjectOperation.init( test, "@val1", true ), engine, nil )
+			zn = ZombieNode.init( "Zombie zombie", engine )
+			ctn.setChild( zn )
+			zn.setParent( ctn )
+
+			token1 = Token.init( ObjectGraphWrapper.init( objectA ), "+", Time.now )
+			token2 = Token.init( ObjectGraphWrapper.init( objectB ), "+", Time.now )
+
+			ctn.registerToken( token1 )
+			ctn.execute
+			
+			assert( zn.tokens.size == 1, "ZombieNode doesn't have any tokens, bad" )
+			
+			ctn.registerToken( token2 )
+			ctn.execute
+			assert( zn.tokens.size == 2, "ZombieNode should have 2 tokens, bad" )
+			assert( ctn.tokens.size == 0, "coo shouldn't have any tokens" )
+		end
+
+		def self.suite
+      suite = Test::Unit::TestSuite.new 
+      suite << self.new( 'test_pass' )
+      suite << self.new( 'test_pass2' )
+      suite << self.new( 'test_pass3' )
+      suite
+    end
+
+  end
+
+  require 'test/unit/ui/console/testrunner'
+
+  Test::Unit::UI::Console::TestRunner.run( Test_Constant_Test_Node )
+
+end