khammurabi 0.2

data/khammurabi-0.2/tests/test_graph_node_joiner.rb

@@ -0,0 +1,94 @@
+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_Graph_Node_Joiner < Test::Unit::TestCase
+
+    attr_accessor :graphA
+
+    def objectA
+      t = Tester.new
+      t.val1 = 5
+      t.val2 = 10
+      #t.val3 = 15
+      t
+    end
+    
+		# The GraphNodeJoiner joins two rootNodes and passes the tokens from the two RootNode's onto a zombie
+    def test_pass
+			engine = Engine.new
+			rootNode1 = RootNode.init( "root", engine, false )
+			rootNode2 = RootNode.init( "root", engine, false )
+			gnj = GraphNodeJoiner.init( "gnj", rootNode1, rootNode2, engine )
+			zn = ZombieNode.init( "zombie", engine )
+			gnj.setChild( zn )
+			zn.setParent( gnj )
+			
+			rootNode1.setChild( gnj )
+			rootNode2.setChild( gnj )
+			
+			assert( zn.tokens.size == 0, "Zombie should have 0 tokens but has #{zn.tokens.size}" )
+			tokens = Array.new
+			token1 = Token.init( ObjectGraphWrapper.init( Tester.new ), 0, Time.now )
+			token2 = Token.init( ObjectGraphWrapper.init( Tester.new ), 1, Time.now )
+			
+			rootNode1.registerToken( token1 )
+			rootNode2.registerToken( token2 )
+			rootNode1.execute
+			rootNode2.execute
+
+			assert( zn.tokens.size == 1, "ZombieNode's token size should be 1 but is #{zn.tokens.size}" )
+			assert( zn.tokens.first.objectGraphWrappers.size == 2, "The ObjectGraphWrapper size should be 2 but is #{zn.tokens.first.objectGraphWrappers.size}" )
+		end
+    
+    def self.suite
+      suite = Test::Unit::TestSuite.new 
+      suite << self.new( 'test_pass' )
+      suite
+    end
+
+  end
+
+  require 'test/unit/ui/console/testrunner'
+
+  Test::Unit::UI::Console::TestRunner.run( Test_Graph_Node_Joiner )
+
+end

data/khammurabi-0.2/tests/test_hash_addon.rb

@@ -0,0 +1,90 @@
+module MK
+
+  require 'test/unit'
+  require 'stringio'
+	require 'nist/khammurabi/HashAddon'
+
+	class Tester
+    attr :val1, true
+    attr :val2, true
+    attr :val3, true
+
+    def initialize
+      @val1 = @val2 = @val3 = nil
+    end
+		def setValues( a, b, c )
+			@val1 = a
+			@val2 = b
+			@val3 = c
+		end
+		def to_s 
+      "val1: #{self.val1} val2: #{self.val2} val3: #{self.val3}"
+		end
+  end
+
+  class Tester2
+    attr :val0, true
+    attr :val1, true
+    attr :val2, true
+    attr :val3, true
+
+    def initialize
+      @val0 = @val1 = @val2 = @val3 = nil
+    end
+		def setValues( a, b, c, d )
+			@val0 = a
+			@val1 = b
+			@val2 = c
+			@val3 = d
+		end
+  end
+
+	class Test_Hash_Addon < Test::Unit::TestCase
+    
+		def objectA
+      t = Tester.new
+      t.val1 = 5
+      t.val2 = 10
+      #t.val3 = 15
+      t
+    end
+
+		def objectB
+      t = Tester2.new
+      t.val1 = 5
+      t.val2 = 10
+      t.val3 = 15
+      t
+    end
+
+		def objectC
+      t = Tester2.new
+      t.val1 = 50
+      t.val2 = 100
+      t.val3 = 150
+      t
+    end
+
+		def test_join
+			h = Hash.new
+			h[ "one" ] = 1
+			h[ "two" ] = 2
+			h[ "three" ] = 3
+			
+			str = h.join( " => ", ", " )
+			assert( str.eql?( "three => 3, two => 2, one => 1" ), "str isn't right" )
+		end
+		
+    def self.suite
+      suite = Test::Unit::TestSuite.new 
+			suite << self.new( 'test_join' )
+			suite
+    end
+
+  end
+
+  require 'test/unit/ui/console/testrunner'
+
+  Test::Unit::UI::Console::TestRunner.run( Test_Hash_Addon )
+
+end

data/khammurabi-0.2/tests/test_insurance_with_variables.rb

@@ -0,0 +1,143 @@
+module MK
+
+  require 'test/unit'
+  require 'stringio'
+
+	require 'nist/khammurabi/Engine'
+	require 'nist/khammurabi/Message'
+	require 'nist/khammurabi/XiaccEngine'
+	require 'nist/khammurabi/ActionObjectInsert'
+	require 'nist/khammurabi/ReteParseTreePrinter'
+	require 'nist/khammurabi/XiaccParseInput'
+	require 'nist/khammurabi/XiaccParseSpecification'
+
+	class Family
+		attr :members, true # Array( Person )
+		def Family.init( members )
+			family = Family.new
+			family.members = members
+		end
+		def ==( other ); ( self.members == other.members ); end
+	end
+
+	class PersonID
+
+		attr :age, true # Float
+		attr :sex, true # String  m/f
+		attr :income, true # Float
+		attr :smoker, true # Boolean
+		attr :familyID, true # Fixnum
+
+		def PersonID.init( _age, _sex, _income, _smoker, _familyID )
+			person = PersonID.new
+			person.age = _age
+			person.sex = _sex
+			person.income = _income
+			person.smoker = _smoker
+			person.familyID = _familyID
+			person
+		end
+
+		def printOn( stream ); stream << "<Person> age: <#{self.age}> sex: <#{self.sex}> income: <#{self.income}> smoker: <#{self.smoker}> </Person>"; stream; end
+		def to_s; self.printOn( StringIO.new ).string; end
+
+	end
+
+	class Person_V
+
+		attr :age, true # Float
+		attr :sex, true # String  m/f
+		attr :income, true # Float
+		attr :smoker, true # Boolean
+		attr :family, true # Family
+		
+		def Person_V.init( _age, _sex, _income, _smoker, _family )
+			person = Person_V.new
+			person.age = _age
+			person.sex = _sex
+			person.income = _income
+			person.smoker = _smoker
+			person.family = _family
+			person
+		end
+
+		def printOn( stream ); stream << "<Person> age: <#{self.age}> sex: <#{self.sex}> income: <#{self.income}> smoker: <#{self.smoker}> </Person>"; stream; end
+		def to_s; self.printOn( StringIO.new ).string; end
+
+	end
+
+	class Test_Root_Node < Test::Unit::TestCase
+
+    attr_accessor :graphA
+
+		def test_family_with_id
+			engine = MK::XiaccEngine.new
+
+			xpi = XiaccParseInput.init( Array.new( 3 ) { XiaccParseSpecification.new }, \
+																	MK::ActionObjectInsert.init( MK::Message.init( "f2" ), engine ) )
+			xpi.specifications.each { |spec| spec.klass = PersonID }
+			xpi.specifications[ 0 ].parseString = "( age >= 18 and age <= 32 and sex = m and familyID = $FID )"
+			xpi.specifications[ 1 ].parseString = "( age >= 18 and age <= 32 and sex = f and familyID = $FID )"
+			xpi.specifications[ 2 ].parseString = "( age >= 0 and age <= 18 and familyID = $FID )"
+
+			engine + xpi
+			engine.compile
+
+			#printer = MK::ReteParseTreePrinter.init( engine.root )
+			#print "\n\n" + printer.printOn( StringIO.new ).string + "\n\n"
+			#exit
+
+			engine.addObject( PersonID.init( 32, "m", 0, false, 3 ) )
+			engine.addObject( PersonID.init( 32, "f", 0, false, 3 ) )
+			assert( engine.messages.size == 0, "(0) engine shouldn't have any messages!" )
+			engine.addObject( PersonID.init( 12, "f", 0, false, 2 ) )
+			assert( engine.messages.size == 0, "(0) engine shouldn't have any messages .. it has #{engine.messages.size} messages" )
+			engine.addObject( PersonID.init( 12, "f", 0, false, 3 ) )
+			assert( engine.messages.size == 1, "(0) engine doesn't have enough messages! it only has #{engine.messages.size} messages" )
+		end
+
+		def test_family_with_class
+			engine = MK::XiaccEngine.new
+
+			family = Family.new
+			person1 = Person_V.init( 23, "m", 0, false, family )
+			person2 = Person_V.init( 21, "f", 0, false, family )
+			person3 = Person_V.init( 14, "f", 0, false, Family.new )
+			family.members = [ person1, person2 ]
+			
+			xpi = XiaccParseInput.init( Array.new( 3 ) { XiaccParseSpecification.new }, \
+																	MK::ActionObjectInsert.init( MK::Message.init( "Cost: $1,000,000,000 a year" ), engine ) )
+			xpi.specifications.each { |spec| spec.klass = Person_V }
+			xpi.specifications[ 0 ].parseString = "( age >= 18 and age <= 32 and sex = m and family ~ $FID )"
+			xpi.specifications[ 1 ].parseString = "( age >= 18 and age <= 32 and sex = f and family ~ $FID )"
+			xpi.specifications[ 2 ].parseString = "( age >= 9  and age <= 15 and sex = f and family !~ $FID )"
+
+			engine + xpi
+			engine.compile
+
+			#printer = MK::ReteParseTreePrinter.init( engine.root )
+			#print "\n\n" + printer.printOn( StringIO.new ).string + "\n\n"
+			#exit
+
+			engine.addObject( person1 ) 
+			assert( engine.messages.size == 0, "(0) engine shouldn't have any messages, but has #{engine.messages.size}" )
+			engine.addObject( person2 )
+			assert( engine.messages.size == 0, "(1) engine shouldn't have any messages, but has #{engine.messages.size}" )
+			engine.addObject( person3 )
+			assert( engine.messages.size == 1, "(2) engine has #{engine.messages.size} message(s), but should have 1" )
+		end
+
+    def self.suite
+      suite = Test::Unit::TestSuite.new 
+      suite << self.new( 'test_family_with_id' )
+      suite << self.new( 'test_family_with_class' )
+      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_multi_children_arbitrator_node.rb

@@ -0,0 +1,149 @@
+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/MultiChildrenArbitratorNode'
+	require 'nist/khammurabi/ObjectGraphWrapper'
+	
+  class Tester
+    attr :val1, true
+    attr :val2, true
+    attr :val3, true
+		attr :cluster, true # Array
+    def initialize
+      self.val1 = self.val2 = self.val3 = nil
+			self.cluster = nil
+    end
+		def to_s 
+      "val1: #{self.val1} val2: #{self.val2} val3: #{self.val3}"
+		end
+  end
+
+  class Test_Multi_Children_Arbitrator_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 = 1
+      t.val2 = 10
+      #t.val3 = 15
+      t
+    end
+
+		# Test to make sure that each child of the MultiChildrenArbitratorNode gets a single token
+		def test_arbitrate1
+			engine = Engine.new
+			mcan = MultiChildrenArbitratorNode.init( engine )
+			zns = Array.new
+			tokens = Array.new
+			size = 100
+			size.times do |a|
+				zns.push( ZombieNode.init( "ZombieNode #{a}", engine ) )
+				mcan.addChild( zns[ a ] )
+				zns[ a ].setParent( mcan )
+				tokens.push( Token.init( ObjectGraphWrapper.init( Tester.new ), "Token #{a}", Time.now ) )
+			end
+
+			size.times do |a|
+				mcan.registerToken( tokens[ a ] )
+				mcan.execute
+			end
+			
+			size.times do |a|
+				assert( zns[ a ].tokens.size == 1, "ZombieNode #{a}'s tokens size is #{zns[a].tokens.size} while it should be 1" )
+			end
+		end
+
+		# Same as arbitrate1 but with different order of execution (execute comes after the loop)
+		def test_arbitrate2
+			engine = Engine.new
+			mcan = MultiChildrenArbitratorNode.init( engine )
+			zns = Array.new
+			tokens = Array.new
+			size = 100
+			size.times do |a|
+				zns.push( ZombieNode.init( "ZombieNode #{a}", engine ) )
+				mcan.addChild( zns[ a ] )
+				zns[ a ].setParent( mcan )
+				tokens.push( Token.init( ObjectGraphWrapper.init( Tester.new ), "Token #{a}", Time.now ) )
+			end
+
+			size.times do |a|
+				mcan.registerToken( tokens[ a ] )
+			end
+			mcan.execute
+
+			size.times do |a|
+				assert( zns[ a ].tokens.size == 1, "ZombieNode #{a}'s tokens size is #{zns[a].tokens.size} while it should be 1" )
+			end
+		end
+
+		# Makes sure that the arbitrator doesn't choose the next node if the token fails
+		def test_fail
+			engine = Engine.new
+			mcan = MultiChildrenArbitratorNode.init( engine )
+			
+			ctn1 = ConstantTestNode.init( "ctn1", MK::ConstantObjectOperation.init( MK::EqualityTest.init( 1 ), "@val1", true ), engine, mcan )
+			zn1 = ZombieNode.init( "zombie1", engine )
+			zn1.setParent( ctn1 )
+			ctn1.setChild( zn1 )
+			
+			ctn2 = ConstantTestNode.init( "ctn2", MK::ConstantObjectOperation.init( MK::EqualityTest.init( 1 ), "@val1", true ), engine, mcan )
+			zn2 = ZombieNode.init( "zombie2", engine )
+			zn2.setParent( ctn2 )
+			ctn2.setChild( zn2 )
+			
+			mcan.setChildren( [ ctn1, ctn2 ] )
+			#[ ctn1, ctn2, zn1, zn2, mcan ].each { |node| node.debug = true }
+			
+			token1 = Token.init( ObjectGraphWrapper.init( objectA ), "+", Time.now, 0 )
+			token2 = Token.init( ObjectGraphWrapper.init( objectB ), "+", Time.now, 1 )
+			
+			#print "I\n"
+			mcan.registerToken( token1 )
+			mcan.execute
+			
+			#print "I\n"
+			mcan.registerToken( token2 )
+			mcan.execute
+			
+			assert( zn1.tokens.size == 1, "zn1.tokens.size != 1, it is: #{zn1.tokens.size}" )
+			assert( zn2.tokens.size == 0, "zn2.tokens.size != 0, it is: #{zn2.tokens.size}" )
+		end
+
+    def self.suite
+      suite = Test::Unit::TestSuite.new
+			suite << self.new( 'test_arbitrate1' )
+			suite << self.new( 'test_arbitrate2' )
+			suite << self.new( 'test_fail' )
+			suite
+    end
+
+  end
+
+  require 'test/unit/ui/console/testrunner'
+
+  Test::Unit::UI::Console::TestRunner.run( Test_Multi_Children_Arbitrator_Node )
+
+end