def test_CreateTokenExpressions(self):
saproling_description = MgDescriptionExpression(
#1/1
MgPTExpression(
MgNumberValue(1, MgNumberValue.NumberTypeEnum.Literal),
MgNumberValue(1, MgNumberValue.NumberTypeEnum.Literal)),
#green
MgColorExpression(MgColorTerm(MgColorTerm.ColorTermEnum.Green)),
#saproling creature
MgTypeExpression(
MgSubtype(MgSubtype.CreatureSubtypeEnum.Saproling),
MgType(MgType.TypeEnum.Creature)),
#token
MgQualifier(MgQualifier.QualifierEnum.Token))
three_of_them = MgNumberValue(3, MgNumberValue.NumberTypeEnum.Quantity)
create_three_saprolings = MgCreateTokenExpression(
descriptor=saproling_description, quantity=three_of_them)
self.assertTrue(create_three_saprolings.isTraversable())
self.assertEqual(len(create_three_saprolings.getTraversalSuccessors()),
2)
self.assertTrue(create_three_saprolings.isChild(saproling_description))
self.assertEqual(saproling_description.getParent(),
create_three_saprolings)
self.assertTrue(create_three_saprolings.isChild(three_of_them))
self.assertEqual(three_of_them.getParent(), create_three_saprolings)
self.assertEqual(create_three_saprolings.unparseToString().lower(),
"create three 1/1 green saproling creature token")
def test_PowerToughnessExpressions(self):
one_power = MgNumberValue(1,MgNumberValue.NumberTypeEnum.Literal)
three_toughness = MgNumberValue(3,MgNumberValue.NumberTypeEnum.Literal)
one_three = MgPTExpression(one_power,three_toughness)
self.assertTrue(one_three.isTraversable())
self.assertEqual(len(one_three.getTraversalSuccessors()),2)
self.assertTrue(one_three.isChild(one_power))
self.assertEqual(three_toughness.getParent(),one_three)
self.assertEqual(one_three.unparseToString().lower(),"1/3")
def test_CrypticCommand(self):
#Card name: Cryptic Command
cardName = MgName("Cryptic Command")
#Mana cost: 1UUU.
s0 = MgManaSymbol(cvalue=1)
s1 = MgManaSymbol(colorv=MgManaSymbol.ManaType.Blue)
s2 = MgManaSymbol(colorv=MgManaSymbol.ManaType.Blue)
s3 = MgManaSymbol(colorv=MgManaSymbol.ManaType.Blue)
manaExpr = MgManaExpression(s0,s1,s2,s3)
#Instant.
t_instant = MgTypeExpression(MgType(MgType.TypeEnum.Instant))
typeLine = MgTypeLine(types=t_instant)
#counter target spell
choice_counterspell = MgStatementSequence(MgStatement(MgUncastExpression(MgTargetExpression(MgDescriptionExpression(
MgQualifier(MgQualifier.QualifierEnum.Spell)
)))))
#Return target permanent to its owner's hand.
choice_bounce = MgStatementSequence(MgStatement(MgReturnExpression(
subject = MgTargetExpression(MgDescriptionExpression(MgQualifier(MgQualifier.QualifierEnum.Permanent))),
destination = MgPossessiveExpression(possessive=MgPossessiveExpression.PossessiveEnum.Owner,owned=MgZone(MgZone.ZoneEnum.Hand))
)))
#Tap all creatures your opponents control.
choice_tap = MgStatementSequence(MgStatement(MgTapUntapExpression(
MgAllExpression(MgDescriptionExpression(MgTypeExpression(MgType(MgType.TypeEnum.Creature)),MgControlExpression("your opponents")))
,tap=True
)))
#Draw a card.
choice_draw = MgStatementSequence(MgStatement(MgCardDrawExpression(MgNumberValue(value=1,ntype=MgNumberValue.NumberTypeEnum.Quantity))))
#Choose two
modalExpr = MgModalExpression(
MgNumberValue(value=2,ntype=MgNumberValue.NumberTypeEnum.Quantity),
choice_counterspell,choice_bounce,choice_tap,choice_draw
)
instructions = MgStatementSequence(MgStatement(modalExpr,periodTerminated=False))
ability = MgSpellAbility(instructions)
textBox = MgTextBox(ability)
card = MgCard(**{
"name" : cardName,
"manaCost" : manaExpr,
"typeLine" : typeLine,
"textBox" : textBox
})
print(card.unparseToString().lower())
visitor = SimpleGraphingVisitor()
visitor.traverse(card)
def test_DealsDamageExpressions(self):
nameref = MgNameReference(None)
one = MgNumberValue(1, MgNumberValue.NumberTypeEnum.Literal)
any_target = MgTargetExpression(isAny=True)
damageexpr_0 = MgDealsDamageExpression(origin=nameref,
damageExpression=one,
subject=any_target)
self.assertTrue(damageexpr_0.isTraversable())
self.assertEqual(len(damageexpr_0.getTraversalSuccessors()), 3)
self.assertTrue(damageexpr_0.isChild(any_target))
self.assertEqual(any_target.getParent(), damageexpr_0)
self.assertEqual(damageexpr_0.getOrigin(), nameref)
self.assertTrue(damageexpr_0.hasDamageExpression())
self.assertEqual(damageexpr_0.getDamageExpression(), one)
self.assertTrue(damageexpr_0.hasSubject())
self.assertEqual(damageexpr_0.getSubject(), any_target)
self.assertEqual(damageexpr_0.unparseToString().lower(),
"~ deals 1 damage to any target")
def test_Amplify(self):
five = MgNumberValue(5, MgNumberValue.NumberTypeEnum.Literal)
Amplify = MgAmplifyAbility(five)
self.assertTrue(Amplify.isTraversable())
self.assertEqual(len(Amplify.getTraversalSuccessors()), 1)
self.assertTrue(Amplify.isChild(five))
self.assertEqual(five.getParent(), Amplify)
self.assertEqual(Amplify.getCaliber(), five)
self.assertEqual(Amplify.unparseToString().lower(), "amplify 5")
four = MgNumberValue(4, MgNumberValue.NumberTypeEnum.Literal)
Amplify.setCaliber(four)
self.assertEqual(Amplify.getCaliber(), four)
self.assertTrue(Amplify.isChild(four))
self.assertEqual(four.getParent(), Amplify)
self.assertEqual(Amplify.unparseToString().lower(), "amplify 4")
def test_Bushido(self):
five = MgNumberValue(5, MgNumberValue.NumberTypeEnum.Literal)
Bushido = MgBushidoAbility(five)
self.assertTrue(Bushido.isTraversable())
self.assertEqual(len(Bushido.getTraversalSuccessors()), 1)
self.assertTrue(Bushido.isChild(five))
self.assertEqual(five.getParent(), Bushido)
self.assertEqual(Bushido.getCaliber(), five)
self.assertEqual(Bushido.unparseToString().lower(), "bushido 5")
four = MgNumberValue(4, MgNumberValue.NumberTypeEnum.Literal)
Bushido.setCaliber(four)
self.assertEqual(Bushido.getCaliber(), four)
self.assertTrue(Bushido.isChild(four))
self.assertEqual(four.getParent(), Bushido)
self.assertEqual(Bushido.unparseToString().lower(), "bushido 4")
def test_Absorb(self):
five = MgNumberValue(5, MgNumberValue.NumberTypeEnum.Literal)
Absorb = MgAbsorbAbility(five)
self.assertTrue(Absorb.isTraversable())
self.assertEqual(len(Absorb.getTraversalSuccessors()), 1)
self.assertTrue(Absorb.isChild(five))
self.assertEqual(five.getParent(), Absorb)
self.assertEqual(Absorb.getCaliber(), five)
self.assertEqual(Absorb.unparseToString().lower(), "absorb 5")
four = MgNumberValue(4, MgNumberValue.NumberTypeEnum.Literal)
Absorb.setCaliber(four)
self.assertEqual(Absorb.getCaliber(), four)
self.assertTrue(Absorb.isChild(four))
self.assertEqual(four.getParent(), Absorb)
self.assertEqual(Absorb.unparseToString().lower(), "absorb 4")
def test_Poisonous(self):
five = MgNumberValue(5, MgNumberValue.NumberTypeEnum.Literal)
Poisonous = MgPoisonousAbility(five)
self.assertTrue(Poisonous.isTraversable())
self.assertEqual(len(Poisonous.getTraversalSuccessors()), 1)
self.assertTrue(Poisonous.isChild(five))
self.assertEqual(five.getParent(), Poisonous)
self.assertEqual(Poisonous.getCaliber(), five)
self.assertEqual(Poisonous.unparseToString().lower(), "poisonous 5")
four = MgNumberValue(4, MgNumberValue.NumberTypeEnum.Literal)
Poisonous.setCaliber(four)
self.assertEqual(Poisonous.getCaliber(), four)
self.assertTrue(Poisonous.isChild(four))
self.assertEqual(four.getParent(), Poisonous)
self.assertEqual(Poisonous.unparseToString().lower(), "poisonous 4")
def test_Afflict(self):
five = MgNumberValue(5, MgNumberValue.NumberTypeEnum.Literal)
Afflict = MgAfflictAbility(five)
self.assertTrue(Afflict.isTraversable())
self.assertEqual(len(Afflict.getTraversalSuccessors()), 1)
self.assertTrue(Afflict.isChild(five))
self.assertEqual(five.getParent(), Afflict)
self.assertEqual(Afflict.getCaliber(), five)
self.assertEqual(Afflict.unparseToString().lower(), "afflict 5")
four = MgNumberValue(4, MgNumberValue.NumberTypeEnum.Literal)
Afflict.setCaliber(four)
self.assertEqual(Afflict.getCaliber(), four)
self.assertTrue(Afflict.isChild(four))
self.assertEqual(four.getParent(), Afflict)
self.assertEqual(Afflict.unparseToString().lower(), "afflict 4")
def test_Surveil(self):
five = MgNumberValue(5, MgNumberValue.NumberTypeEnum.Literal)
Surveil = MgSurveilAbility(five)
self.assertTrue(Surveil.isTraversable())
self.assertEqual(len(Surveil.getTraversalSuccessors()), 1)
self.assertTrue(Surveil.isChild(five))
self.assertEqual(five.getParent(), Surveil)
self.assertEqual(Surveil.getCaliber(), five)
self.assertEqual(Surveil.unparseToString().lower(), "surveil 5")
four = MgNumberValue(4, MgNumberValue.NumberTypeEnum.Literal)
Surveil.setCaliber(four)
self.assertEqual(Surveil.getCaliber(), four)
self.assertTrue(Surveil.isChild(four))
self.assertEqual(four.getParent(), Surveil)
self.assertEqual(Surveil.unparseToString().lower(), "surveil 4")
def test_Crew(self):
five = MgNumberValue(5, MgNumberValue.NumberTypeEnum.Literal)
Crew = MgCrewAbility(five)
self.assertTrue(Crew.isTraversable())
self.assertEqual(len(Crew.getTraversalSuccessors()), 1)
self.assertTrue(Crew.isChild(five))
self.assertEqual(five.getParent(), Crew)
self.assertEqual(Crew.getCaliber(), five)
self.assertEqual(Crew.unparseToString().lower(), "crew 5")
four = MgNumberValue(4, MgNumberValue.NumberTypeEnum.Literal)
Crew.setCaliber(four)
self.assertEqual(Crew.getCaliber(), four)
self.assertTrue(Crew.isChild(four))
self.assertEqual(four.getParent(), Crew)
self.assertEqual(Crew.unparseToString().lower(), "crew 4")
def test_Fabricate(self):
five = MgNumberValue(5, MgNumberValue.NumberTypeEnum.Literal)
Fabricate = MgFabricateAbility(five)
self.assertTrue(Fabricate.isTraversable())
self.assertEqual(len(Fabricate.getTraversalSuccessors()), 1)
self.assertTrue(Fabricate.isChild(five))
self.assertEqual(five.getParent(), Fabricate)
self.assertEqual(Fabricate.getCaliber(), five)
self.assertEqual(Fabricate.unparseToString().lower(), "fabricate 5")
four = MgNumberValue(4, MgNumberValue.NumberTypeEnum.Literal)
Fabricate.setCaliber(four)
self.assertEqual(Fabricate.getCaliber(), four)
self.assertTrue(Fabricate.isChild(four))
self.assertEqual(four.getParent(), Fabricate)
self.assertEqual(Fabricate.unparseToString().lower(), "fabricate 4")
def test_Rampage(self):
five = MgNumberValue(5, MgNumberValue.NumberTypeEnum.Literal)
Rampage = MgRampageAbility(five)
self.assertTrue(Rampage.isTraversable())
self.assertEqual(len(Rampage.getTraversalSuccessors()), 1)
self.assertTrue(Rampage.isChild(five))
self.assertEqual(five.getParent(), Rampage)
self.assertEqual(Rampage.getCaliber(), five)
self.assertEqual(Rampage.unparseToString().lower(), "rampage 5")
four = MgNumberValue(4, MgNumberValue.NumberTypeEnum.Literal)
Rampage.setCaliber(four)
self.assertEqual(Rampage.getCaliber(), four)
self.assertTrue(Rampage.isChild(four))
self.assertEqual(four.getParent(), Rampage)
self.assertEqual(Rampage.unparseToString().lower(), "rampage 4")
def test_Renown(self):
five = MgNumberValue(5, MgNumberValue.NumberTypeEnum.Literal)
Renown = MgRenownAbility(five)
self.assertTrue(Renown.isTraversable())
self.assertEqual(len(Renown.getTraversalSuccessors()), 1)
self.assertTrue(Renown.isChild(five))
self.assertEqual(five.getParent(), Renown)
self.assertEqual(Renown.getCaliber(), five)
self.assertEqual(Renown.unparseToString().lower(), "renown 5")
four = MgNumberValue(4, MgNumberValue.NumberTypeEnum.Literal)
Renown.setCaliber(four)
self.assertEqual(Renown.getCaliber(), four)
self.assertTrue(Renown.isChild(four))
self.assertEqual(four.getParent(), Renown)
self.assertEqual(Renown.unparseToString().lower(), "renown 4")
def test_Devour(self):
five = MgNumberValue(5, MgNumberValue.NumberTypeEnum.Literal)
Devour = MgDevourAbility(five)
self.assertTrue(Devour.isTraversable())
self.assertEqual(len(Devour.getTraversalSuccessors()), 1)
self.assertTrue(Devour.isChild(five))
self.assertEqual(five.getParent(), Devour)
self.assertEqual(Devour.getCaliber(), five)
self.assertEqual(Devour.unparseToString().lower(), "devour 5")
four = MgNumberValue(4, MgNumberValue.NumberTypeEnum.Literal)
Devour.setCaliber(four)
self.assertEqual(Devour.getCaliber(), four)
self.assertTrue(Devour.isChild(four))
self.assertEqual(four.getParent(), Devour)
self.assertEqual(Devour.unparseToString().lower(), "devour 4")
def test_Frenzy(self):
five = MgNumberValue(5, MgNumberValue.NumberTypeEnum.Literal)
Frenzy = MgFrenzyAbility(five)
self.assertTrue(Frenzy.isTraversable())
self.assertEqual(len(Frenzy.getTraversalSuccessors()), 1)
self.assertTrue(Frenzy.isChild(five))
self.assertEqual(five.getParent(), Frenzy)
self.assertEqual(Frenzy.getCaliber(), five)
self.assertEqual(Frenzy.unparseToString().lower(), "frenzy 5")
four = MgNumberValue(4, MgNumberValue.NumberTypeEnum.Literal)
Frenzy.setCaliber(four)
self.assertEqual(Frenzy.getCaliber(), four)
self.assertTrue(Frenzy.isChild(four))
self.assertEqual(four.getParent(), Frenzy)
self.assertEqual(Frenzy.unparseToString().lower(), "frenzy 4")
def test_Vanishing(self):
five = MgNumberValue(5, MgNumberValue.NumberTypeEnum.Literal)
Vanishing = MgVanishingAbility(five)
self.assertTrue(Vanishing.isTraversable())
self.assertEqual(len(Vanishing.getTraversalSuccessors()), 1)
self.assertTrue(Vanishing.isChild(five))
self.assertEqual(five.getParent(), Vanishing)
self.assertEqual(Vanishing.getCaliber(), five)
self.assertEqual(Vanishing.unparseToString().lower(), "vanishing 5")
four = MgNumberValue(4, MgNumberValue.NumberTypeEnum.Literal)
Vanishing.setCaliber(four)
self.assertEqual(Vanishing.getCaliber(), four)
self.assertTrue(Vanishing.isChild(four))
self.assertEqual(four.getParent(), Vanishing)
self.assertEqual(Vanishing.unparseToString().lower(), "vanishing 4")
def test_Graft(self):
five = MgNumberValue(5, MgNumberValue.NumberTypeEnum.Literal)
Graft = MgGraftAbility(five)
self.assertTrue(Graft.isTraversable())
self.assertEqual(len(Graft.getTraversalSuccessors()), 1)
self.assertTrue(Graft.isChild(five))
self.assertEqual(five.getParent(), Graft)
self.assertEqual(Graft.getCaliber(), five)
self.assertEqual(Graft.unparseToString().lower(), "graft 5")
four = MgNumberValue(4, MgNumberValue.NumberTypeEnum.Literal)
Graft.setCaliber(four)
self.assertEqual(Graft.getCaliber(), four)
self.assertTrue(Graft.isChild(four))
self.assertEqual(four.getParent(), Graft)
self.assertEqual(Graft.unparseToString().lower(), "graft 4")
def test_Annihilator(self):
five = MgNumberValue(5, MgNumberValue.NumberTypeEnum.Literal)
Annihilator = MgAnnihilatorAbility(five)
self.assertTrue(Annihilator.isTraversable())
self.assertEqual(len(Annihilator.getTraversalSuccessors()), 1)
self.assertTrue(Annihilator.isChild(five))
self.assertEqual(five.getParent(), Annihilator)
self.assertEqual(Annihilator.getCaliber(), five)
self.assertEqual(Annihilator.unparseToString().lower(),
"annihilator 5")
four = MgNumberValue(4, MgNumberValue.NumberTypeEnum.Literal)
Annihilator.setCaliber(four)
self.assertEqual(Annihilator.getCaliber(), four)
self.assertTrue(Annihilator.isChild(four))
self.assertEqual(four.getParent(), Annihilator)
self.assertEqual(Annihilator.unparseToString().lower(),
"annihilator 4")
def test_Bloodthirst(self):
five = MgNumberValue(5, MgNumberValue.NumberTypeEnum.Literal)
Bloodthirst = MgBloodthirstAbility(five)
self.assertTrue(Bloodthirst.isTraversable())
self.assertEqual(len(Bloodthirst.getTraversalSuccessors()), 1)
self.assertTrue(Bloodthirst.isChild(five))
self.assertEqual(five.getParent(), Bloodthirst)
self.assertEqual(Bloodthirst.getCaliber(), five)
self.assertEqual(Bloodthirst.unparseToString().lower(),
"bloodthirst 5")
four = MgNumberValue(4, MgNumberValue.NumberTypeEnum.Literal)
Bloodthirst.setCaliber(four)
self.assertEqual(Bloodthirst.getCaliber(), four)
self.assertTrue(Bloodthirst.isChild(four))
self.assertEqual(four.getParent(), Bloodthirst)
self.assertEqual(Bloodthirst.unparseToString().lower(),
"bloodthirst 4")
def test_NumberValues(self):
five_literal = MgNumberValue(5,MgNumberValue.NumberTypeEnum.Literal)
self.assertTrue(five_literal.isLiteral())
self.assertTrue(five_literal.isTraversable())
self.assertEqual(len(five_literal.getTraversalSuccessors()),0)
self.assertEqual(five_literal.unparseToString().lower(),"5")
seventytwo_quantity = MgNumberValue(72,MgNumberValue.NumberTypeEnum.Cardinal)
self.assertTrue(seventytwo_quantity.isQuantity())
self.assertEqual(seventytwo_quantity.unparseToString().lower(),"seventy-two")
one_frequency = MgNumberValue(1,MgNumberValue.NumberTypeEnum.Frequency)
self.assertTrue(one_frequency.isFrequency())
self.assertEqual(one_frequency.unparseToString().lower(),"once")
two_frequency = MgNumberValue(2,MgNumberValue.NumberTypeEnum.Frequency)
self.assertTrue(two_frequency.isFrequency())
self.assertEqual(two_frequency.unparseToString().lower(),"twice")
three_frequency = MgNumberValue(3,MgNumberValue.NumberTypeEnum.Frequency)
self.assertTrue(three_frequency.isFrequency())
self.assertEqual(three_frequency.unparseToString().lower(),"three times")
four_ordinal = MgNumberValue(4,MgNumberValue.NumberTypeEnum.Ordinal)
self.assertTrue(four_ordinal.isOrdinal())
self.assertEqual(four_ordinal.unparseToString().lower(),"fourth")
seventytwo_quantity.setFrequency()
self.assertTrue(seventytwo_quantity.isFrequency())
self.assertEqual(seventytwo_quantity.getValue(),72)
seventytwo_quantity.setValue(73)
self.assertEqual(seventytwo_quantity.unparseToString().lower(),"seventy-three times")
star_custom = MgNumberValue("*",MgNumberValue.NumberTypeEnum.Custom)
self.assertTrue(star_custom.isCustom())
self.assertEqual(star_custom.unparseToString().lower(),"*")
