def testPerFess(self):
shield = blazon.Field()
shield.tincture = blazon.PerPale(color1="argent", color2="gules")
# Ditto
self.assertTrue(shield.tincture.pieces is 2)
self.assertTrue(HasOnlyTheColors(shield, ["white", "red"]))
self.assertTrue(repr(shield) is not None)
def testInOrle(self):
shield = blazon.Field("gules")
bezants = blazon.ChargeGroup(9, blazon.Roundel("or"))
bezants.arrangement = arrangement.InOrle()
shield.charges.append(bezants)
for charge in shield.charges:
charge.arrange()
def testBogusByNumbers(self):
shield = blazon.Field("vert")
chargegroup = blazon.ChargeGroup(6, blazon.Roundel("argent"))
chargegroup.arrangement = arrangement.ByNumbers()
chargegroup.arrangement.setRows([1, 2, 3, 4])
shield.charges.append(chargegroup)
for charge in shield.charges:
self.assertRaises(blazon.ArrangementError, charge.arrange)
def test2by4(self):
shield = blazon.Field("sable")
chargegroup = blazon.ChargeGroup(8, blazon.Annulet("or"))
chargegroup.arrangement = arrangement.ByNumbers()
chargegroup.arrangement.setRows([2, 2, 2, 2])
shield.charges.append(chargegroup)
for charge in shield.charges:
charge.arrange()
def testPerPale(self):
shield = blazon.Field()
shield.tincture = blazon.PerPale(color1="vert", color2="sable")
# Maybe it's silly to test for number of pieces, since it's used
# only internally
self.assertTrue(shield.tincture.pieces is 2)
self.assertTrue(HasOnlyTheColors(shield, ["green", "black"]))
self.assertTrue(repr(shield) is not None)
def testPily(self):
shield = blazon.Field()
# Not according to the Rule of Tincture, but who cares?
shield.tincture = blazon.Chevronny(color1="azure", color2="vert")
self.assertTrue(HasOnlyTheColors(shield, ["blue", "green"]))
# Chevronny has 8 pieces like everything else, but is not
# used in a very sensible way.
self.assertTrue(shield.tincture.pieces is 8)
self.assertTrue(repr(shield) is not None)
def test10Charges(self):
"""Test for ability to add *two* group of ten charges without errors."""
shield = blazon.Field("sable")
# Currently, this looks wrong, because the annulets end up
# *on top of* the lozenges.
shield.charges.append(blazon.ChargeGroup(10, blazon.Lozenge("argent")))
shield.charges.append(blazon.ChargeGroup(10, blazon.Annulet("or")))
for charge in shield.charges:
charge.arrange()
def p_blazon_2(p):
"blazon : fulltreatment optcharges bordure chief"
# sys.stderr.write("top: %s %s %s %s\n"%
# tuple(map(str,p[1:])))
shield = blazon.Field()
shield.tincture = p[1]
if p[2]:
shield.extendCharges(p[2])
if p[3]:
shield.addBordure(p[3])
if p[4]:
shield.addChief(p[4])
p[0] = shield
Globals.shield = shield
return shield
def p_blazon_2(p):
"blazon : multitreatment optcharges"
# sys.stderr.write("top: %s %s %s %s\n"%
# tuple(map(str,p[1:])))
shield = blazon.Field()
shield.tincture = p[1]
if p[2]:
# shield.extendCharges(p[2])
## The following should also be done for Chiefs, doesn't quite work yet
justcharges = [i for i in p[2] if not isinstance(i, blazon.Bordure)]
shield.extendCharges(justcharges)
bord = [i for i in p[2] if isinstance(i, blazon.Bordure)]
if bord:
shield.addBordure(bord[0])
p[0] = shield
Globals.shield = shield
return shield
def testInChief(self):
shield = blazon.Field("gules")
lozenge = blazon.Lozenge("or")
lozenge.arrangement = arrangement.InChief()
for charge in shield.charges:
charge.arrange()
def testPily(self):
shield = blazon.Field()
shield.tincture = blazon.Pily(color1="or", color2="purpure")
self.assertTrue(HasOnlyTheColors(shield, ["yellow", "purple"]))
self.assertTrue(shield.tincture.pieces is 8)
self.assertTrue(repr(shield) is not None)
def testPaly(self):
shield = blazon.Field()
shield.tincture = blazon.Paly(color1="sable", color2="or")
self.assertTrue(HasOnlyTheColors(shield, ["black", "yellow"]))
self.assertTrue(shield.tincture.pieces is 8)
self.assertTrue(repr(shield) is not None)
def testTiercedInPairle(self):
shield = blazon.Field()
shield.tincture = blazon.PerPall(color1="vert", color2="azure", color3="gules")
self.assertTrue(HasOnlyTheColors(shield, ["green", "blue", "red"]))
self.assertTrue(repr(shield) is not None)
def testPerSaltire(self):
shield = blazon.Field()
shield.tincture = blazon.PerSaltire(color1="azure", color2="argent")
self.assertTrue(HasOnlyTheColors(shield, ["blue", "white"]))
self.assertTrue(repr(shield) is not None)
def testQuartered(self):
shield = blazon.Field()
shield.tincture = blazon.PerCross(color1="vert", color2="sable")
self.assertTrue(HasOnlyTheColors(shield, ["green", "black"]))
self.assertTrue(repr(shield) is not None)
def test10Charges(self):
"""Test for ability to add a group of ten charges without errors."""
shield = blazon.Field("sable")
shield.charges.append(blazon.ChargeGroup(10, blazon.Lozenge("argent")))
for charge in shield.charges:
charge.arrange()
def testAppend(self):
"""Test for correct behaviour when appending a charge to a field."""
shield = blazon.Field("vert")
shield.charges.append(blazon.Saltire("or", "plain"))
self.assertEqual(len(shield.charges), 1)
self.assertTrue(shield.charges[0].tincture.color is 'yellow')
def testGyronny(self):
shield = blazon.Field()
shield.tincture = blazon.Gyronny(color1="purpure", color2="argent")
self.assertTrue(HasOnlyTheColors(shield, ["purple", "white"]))
self.assertTrue(shield.tincture.pieces is 8)
self.assertTrue(repr(shield) is not None)
