def testIdentityCriterion(self):
ob = object()
i = Pointer(ob)
validateCriterion(i,
strategy.make_node_type(strategy.dispatch_by_identity))
i = ISeededCriterion(i)
self.assertEqual(list(i.seeds()),[None,id(ob)&maxint])
def testIdentityCriterion(self):
ob = object()
i = Pointer(ob)
validateCriterion(
i, strategy.make_node_type(strategy.dispatch_by_identity))
i = ISeededCriterion(i)
self.assertEqual(list(i.seeds()), [None, id(ob) & maxint])
def testClassCriteriaSeedsAndDispatchFunctions(self):
for klass in (Vehicle,LandVehicle,WaterVehicle,HumanPowered,GasPowered):
seeds = list(ISeededCriterion(klass).seeds())
self.failUnless(klass in seeds)
self.failUnless(object in seeds)
self.failIf(len(seeds)!=2)
validateCriterion(klass,
strategy.make_node_type(strategy.dispatch_by_mro),
parents=[ICriterion(cls) for cls in getMRO(klass,True)])
def testClassCriteriaSeedsAndDispatchFunctions(self):
for klass in (Vehicle, LandVehicle, WaterVehicle, HumanPowered,
GasPowered):
seeds = list(ISeededCriterion(klass).seeds())
self.failUnless(klass in seeds)
self.failUnless(object in seeds)
self.failIf(len(seeds) != 2)
validateCriterion(
klass,
strategy.make_node_type(strategy.dispatch_by_mro),
parents=[ICriterion(cls) for cls in getMRO(klass, True)])
def testHasParentCriterion(self):
from dispatch import strategy, predicates, functions
from peak.binding.components import HasParentCriterion as HPC
from peak.binding.components import dispatch_by_hierarchy
data = HPC(self.data)
svc = HPC(self.data.aService)
table = {data.ptr:"pass", None:"fail"}
strategy.validateCriterion(data,
strategy.make_node_type(dispatch_by_hierarchy), # XXX
parents=[HPC(p) for p in binding.iterParents(self.data)]
)
self.failUnless(svc.implies(data))
for item in self.data, self.data.aService.thing5, self.data.thing8:
self.failUnless(strategy.Pointer(item) in data)
self.assertEqual(dispatch_by_hierarchy(table, item),"pass")
for item in self.data.getParentComponent(), self.data.thing1, None:
self.failIf(strategy.Pointer(item) in data)
self.assertEqual(dispatch_by_hierarchy(table, item),"fail")
table[svc.ptr] = "pass"
self.assertEqual(Set(data.matches(table)), Set([svc.ptr,data.ptr]))
gf = functions.GenericFunction(lambda x:None)
d = locals()
parse = gf.parse
pe = lambda e: parse(e,d,globals())
self.assertEqual(pe('binding.hasParent(x,self.data)'),
strategy.Signature(x=data))
[gf.when("binding.hasParent(x,self.data)")]
def gf(x): return "in data"
[gf.when("binding.hasParent(x,self.data.aService)")]
def gf(x): return "in service"
self.assertEqual(gf(self.data),"in data")
self.assertEqual(gf(self.data.thing8),"in service")
self.assertEqual(gf(self.data.aService.thing5),"in data")
self.assertEqual(gf(self.data.aService.nestedService),"in service")
def testSubclassCriterion(self):
s = SubclassCriterion(Vehicle)
validateCriterion(
s,
strategy.make_node_type(strategy.dispatch_by_subclass),
parents=[SubclassCriterion(c) for c in getMRO(Vehicle, True)])
# seeds()
self.assertEqual(s.seeds(), [Vehicle, None])
# __contains__
for klass in Vehicle, LandVehicle, WaterVehicle:
self.failUnless(klass in s)
for klass in None, GasPowered, object, Wheeled:
self.failUnless(klass not in s)
# implies()
self.failUnless(s.implies(SubclassCriterion(object)))
self.failUnless(SubclassCriterion(LandVehicle).implies(s))
self.failIf(s.implies(SubclassCriterion(LandVehicle)))
self.failIf(SubclassCriterion(object).implies(s))
# eq/ne/invert
self.assertEqual(s, SubclassCriterion(Vehicle))
self.assertNotEqual(s, SubclassCriterion(LandVehicle))
# matches()
table = {LandVehicle: 1, object: 2, None: 3}
items = list(s.matches(table))
self.assertEqual(items, [LandVehicle])
# dispatch
table = {Vehicle: 1, object: 2, None: 3}
self.assertEqual(strategy.dispatch_by_subclass(table, Vehicle), 1)
self.assertEqual(strategy.dispatch_by_subclass(table, LandVehicle), 1)
self.assertEqual(strategy.dispatch_by_subclass(table, object), 2)
self.assertEqual(strategy.dispatch_by_subclass(table, None), 3)
self.assertRaises(AttributeError, strategy.dispatch_by_subclass, table,
Bicycle)
def testSubclassCriterion(self):
s = SubclassCriterion(Vehicle)
validateCriterion(s,
strategy.make_node_type(strategy.dispatch_by_subclass),
parents=[SubclassCriterion(c) for c in getMRO(Vehicle,True)]
)
# seeds()
self.assertEqual( s.seeds(), [Vehicle,None])
# __contains__
for klass in Vehicle,LandVehicle,WaterVehicle:
self.failUnless(klass in s)
for klass in None,GasPowered,object,Wheeled:
self.failUnless(klass not in s)
# implies()
self.failUnless( s.implies(SubclassCriterion(object)) )
self.failUnless( SubclassCriterion(LandVehicle).implies(s) )
self.failIf( s.implies(SubclassCriterion(LandVehicle)) )
self.failIf( SubclassCriterion(object).implies(s) )
# eq/ne/invert
self.assertEqual( s, SubclassCriterion(Vehicle))
self.assertNotEqual( s, SubclassCriterion(LandVehicle))
# matches()
table = {LandVehicle:1,object:2,None:3}
items = list(s.matches(table))
self.assertEqual(items,[LandVehicle])
# dispatch
table = {Vehicle:1,object:2,None:3}
self.assertEqual(strategy.dispatch_by_subclass(table, Vehicle), 1)
self.assertEqual(strategy.dispatch_by_subclass(table, LandVehicle), 1)
self.assertEqual(strategy.dispatch_by_subclass(table, object), 2)
self.assertEqual(strategy.dispatch_by_subclass(table, None), 3)
self.assertRaises(AttributeError,
strategy.dispatch_by_subclass, table, Bicycle)
def testTruth(self):
for t in True, False:
validateCriterion(
TruthCriterion(t),
strategy.make_node_type(strategy.dispatch_by_truth))
def testTruth(self):
for t in True,False:
validateCriterion(TruthCriterion(t),
strategy.make_node_type(strategy.dispatch_by_truth))
