class cantHandle(unittest.TestCase):
""" Test cases of cantHandle """
def setUp(self):
""" Build the FaintDelegate for the test """
self.handler = AffectUserFaintDelegate()
self.user = BuildPokemonBattleWrapper()
self.target = BuildPokemonBattleWrapper()
self.effect = BuildEffectDelegate()
def userFainted(self):
""" Test that it can't handle the user fainting """
self.user.faint()
self.effect.affectUser = 1
cantHandle = self.handler.cantHandle(user = self.user, effect = self.effect)
assert cantHandle, "Shouldn't handle when the user is fainted"
def userNotFainted(self):
""" Test that it can handle when the user is not fainted """
self.effect.affectUser = 1
cantHandle = self.handler.cantHandle(user = self.user, effect = self.effect)
assert not cantHandle, "Should handle when the user is not fainted"
def targetFainted(self):
""" Test that it can't handle the target fainting """
self.target.faint()
self.effect.affectUser = 0
cantHandle = self.handler.cantHandle(target = self.target, effect = self.effect)
assert cantHandle, "Shouldn't handle when the target is fainted"
def targetNotFainted(self):
""" Test that it can handle when the target is not fainted """
self.effect.affectUser = 0
cantHandle = self.handler.cantHandle(target = self.target, effect = self.effect)
assert not cantHandle, "Should handle when the target is not fainted"
class hit(unittest.TestCase):
""" Test cases of hit """
def setUp(self):
""" Build the Pkmn and Delegate for the test """
self.attack = BuildAttack()
self.user = BuildPokemonBattleWrapper()
self.target = BuildPokemonBattleWrapper()
self.environment = BattleEnvironment()
self.toHit = 100.0
self.delegate = HitDelegate(self.attack, self.toHit)
def fainted(self):
""" Test that if the target is fainted the attack misses """
self.target.faint()
hit, message = self.delegate.hit(self.user, self.target, self.environment)
assert not hit, "Should miss if the target is fainted"
def dodging(self):
""" Test that if the target is dodging the attack misses """
self.target.dodge = "DIG"
hit, message = self.delegate.hit(self.user, self.target, self.environment)
assert not hit, "Should miss if the target is dodging"
def otherwise(self):
""" Test that the attack hits if the target is not dodging or fainted """
hit, message = self.delegate.hit(self.user, self.target, self.environment)
assert hit, "Should hit otherwise"
class checkFaint(unittest.TestCase):
""" Test cases of checkFaint """
def setUp(self):
""" Build the Pkmn, Lock, and Precondition Checker for the test """
self.user = BuildPokemonBattleWrapper()
self.target = BuildPokemonBattleWrapper()
self.environment = BattleEnvironment()
self.actionLock = BuildActionLock(user = self.user)
self.attack = AttackFactory.getAttackAsNew("TACKLE")
self.preconditionChecker = PreconditionChecker(self.user, self.target, self.environment, self.attack)
def fainted(self):
""" Test that check faint returns correctly when the user has fainted """
self.user.faint()
stop, messages = self.preconditionChecker.checkFaint()
assert stop, "Should stop if the user is fainted"
assert messages == [], "Should receive the messages for the actual attack"
def notFainted(self):
""" Test that check faint returns correctly when the user has not fainted """
stop, messages = self.preconditionChecker.checkFaint()
assert not stop, "Should not stop if the user is using its lock"
assert messages == [], "Should not receive any messages"
class tryToApplyEffect(unittest.TestCase):
""" Test cases of tryToApplyEffect """
def setUp(self):
""" Build the Pkmn and Effect for the test """
self.delegate = EffectDelegate()
self.delegate.faintHandler = BuildFaintHandler("EITHER")
self.user = BuildPokemonBattleWrapper()
self.target = BuildPokemonBattleWrapper()
def userFainted(self):
""" Test that if the user is fainted the effect does nothing """
self.user.faint()
messages = self.delegate.tryToApplyEffect(self.user, self.target, None)
assert messages == [], "Effect should do nothing if the user has fainted"
def targetFainted(self):
""" Test that if the target is fainted the effect does nothing """
self.target.faint()
messages = self.delegate.tryToApplyEffect(self.user, self.target, None)
assert messages == [], "Effect should do nothing if the target has fainted"
def applyEffectCalled(self):
""" Test that applyEffect is called otherwise """
messages = self.delegate.tryToApplyEffect(self.user, self.target, None)
assert messages == [EffectDelegate.message], "Effect should call applyEffect"
class cantHandle(unittest.TestCase):
""" Test cases of cantHandle """
def setUp(self):
""" Build the FaintDelegate for the test """
self.handler = EitherFaintDelegate()
self.user = BuildPokemonBattleWrapper()
self.target = BuildPokemonBattleWrapper()
def user(self):
""" Test that it can handle the user fainting """
self.user.faint()
cantHandle = self.handler.cantHandle(user=self.user,
target=self.target)
assert cantHandle, "Shouldn't handle when the user faints"
def target(self):
""" Test that it can't handle the target fainting """
self.target.faint()
cantHandle = self.handler.cantHandle(user=self.user,
target=self.target)
assert cantHandle, "Shouldn't handle when the target faints"
def both(self):
""" Test that it can't handle both pkmn fainting """
self.user.faint()
self.target.faint()
cantHandle = self.handler.cantHandle(user=self.user,
target=self.target)
assert cantHandle, "Shouldn't handle when both pkmn faints"
def neither(self):
""" Test that it can handle neither pkmn fainting """
cantHandle = self.handler.cantHandle(user=self.user,
target=self.target)
assert not cantHandle, "Should handle when neither faints"
class cantHandle(unittest.TestCase):
""" Test cases of cantHandle """
def setUp(self):
""" Build the FaintDelegate for the test """
self.handler = EitherFaintDelegate()
self.user = BuildPokemonBattleWrapper()
self.target = BuildPokemonBattleWrapper()
def user(self):
""" Test that it can handle the user fainting """
self.user.faint()
cantHandle = self.handler.cantHandle(user = self.user, target = self.target)
assert cantHandle, "Shouldn't handle when the user faints"
def target(self):
""" Test that it can't handle the target fainting """
self.target.faint()
cantHandle = self.handler.cantHandle(user = self.user, target = self.target)
assert cantHandle, "Shouldn't handle when the target faints"
def both(self):
""" Test that it can't handle both pkmn fainting """
self.user.faint()
self.target.faint()
cantHandle = self.handler.cantHandle(user = self.user, target = self.target)
assert cantHandle, "Shouldn't handle when both pkmn faints"
def neither(self):
""" Test that it can handle neither pkmn fainting """
cantHandle = self.handler.cantHandle(user = self.user, target = self.target)
assert not cantHandle, "Should handle when neither faints"
class cantHandle(unittest.TestCase):
""" Test cases of cantHandle """
def setUp(self):
""" Build the FaintDelegate for the test """
self.handler = UserFaintDelegate()
self.user = BuildPokemonBattleWrapper()
def userFainted(self):
""" Test that it can't handle the user fainting """
self.user.faint()
cantHandle = self.handler.cantHandle(user=self.user)
assert cantHandle, "Shouldn't handle when the user is fainted"
def userNotFainted(self):
""" Test that it can handle when the user is not fainted """
cantHandle = self.handler.cantHandle(user=self.user)
assert not cantHandle, "Should handle when the user is not fainted"
class cantHandle(unittest.TestCase):
""" Test cases of cantHandle """
def setUp(self):
""" Build the FaintDelegate for the test """
self.handler = UserFaintDelegate()
self.user = BuildPokemonBattleWrapper()
def userFainted(self):
""" Test that it can't handle the user fainting """
self.user.faint()
cantHandle = self.handler.cantHandle(user = self.user)
assert cantHandle, "Shouldn't handle when the user is fainted"
def userNotFainted(self):
""" Test that it can handle when the user is not fainted """
cantHandle = self.handler.cantHandle(user = self.user)
assert not cantHandle, "Should handle when the user is not fainted"
class attemptAfterTurn(unittest.TestCase):
""" Test cases of attemptAfterTurn """
def setUp(self):
""" Build the Pkmn and AfterTurnEffect for the test """
self.effect = AfterTurnEffect()
self.effect.faintHandler = BuildFaintHandler("USER")
self.pkmn = BuildPokemonBattleWrapper()
def fainted(self):
""" Test that the Effect is not performed when the pkmn has fainted """
self.pkmn.faint()
messages = self.effect.attemptAfterTurn(self.pkmn)
assert messages == [], "Should receive no messages since nothing was performed"
def notFainted(self):
""" Test that the Effect is performed when the pkmn has fainted """
messages = self.effect.attemptAfterTurn(self.pkmn)
assert messages == [AfterTurnEffect.message], "Should receive messages from afterTurn function"
class attemptAfterTurn(unittest.TestCase):
""" Test cases of attemptAfterTurn """
def setUp(self):
""" Build the Pkmn and AfterTurnEffect for the test """
self.effect = AfterTurnEffect()
self.effect.faintHandler = BuildFaintHandler("USER")
self.pkmn = BuildPokemonBattleWrapper()
def fainted(self):
""" Test that the Effect is not performed when the pkmn has fainted """
self.pkmn.faint()
messages = self.effect.attemptAfterTurn(self.pkmn)
assert messages == [], "Should receive no messages since nothing was performed"
def notFainted(self):
""" Test that the Effect is performed when the pkmn has fainted """
messages = self.effect.attemptAfterTurn(self.pkmn)
assert messages == [
AfterTurnEffect.message
], "Should receive messages from afterTurn function"
class cantHandle(unittest.TestCase):
""" Test cases of cantHandle """
def setUp(self):
""" Build the FaintDelegate for the test """
self.handler = AffectUserFaintDelegate()
self.user = BuildPokemonBattleWrapper()
self.target = BuildPokemonBattleWrapper()
self.effect = BuildEffectDelegate()
def userFainted(self):
""" Test that it can't handle the user fainting """
self.user.faint()
self.effect.affectUser = 1
cantHandle = self.handler.cantHandle(user=self.user,
effect=self.effect)
assert cantHandle, "Shouldn't handle when the user is fainted"
def userNotFainted(self):
""" Test that it can handle when the user is not fainted """
self.effect.affectUser = 1
cantHandle = self.handler.cantHandle(user=self.user,
effect=self.effect)
assert not cantHandle, "Should handle when the user is not fainted"
def targetFainted(self):
""" Test that it can't handle the target fainting """
self.target.faint()
self.effect.affectUser = 0
cantHandle = self.handler.cantHandle(target=self.target,
effect=self.effect)
assert cantHandle, "Shouldn't handle when the target is fainted"
def targetNotFainted(self):
""" Test that it can handle when the target is not fainted """
self.effect.affectUser = 0
cantHandle = self.handler.cantHandle(target=self.target,
effect=self.effect)
assert not cantHandle, "Should handle when the target is not fainted"
class cantHandle(unittest.TestCase):
""" Test cases of cantHandle """
def setUp(self):
""" Build the FaintDelegate for the test """
self.handler = SourceFaintDelegate()
self.source = BuildPokemonBattleWrapper()
self.user = BuildPokemonBattleWrapper()
self.effect = BuildEffectDelegate()
self.effect.source = self.source
self.user.secondaryEffects.append(self.effect)
def userFainted(self):
""" Test that it can't handle the user fainting """
self.user.faint()
cantHandle = self.handler.cantHandle(user = self.user, effect = self.effect)
assert cantHandle, "Shouldn't handle when the user is fainted"
assert self.effect in self.user.secondaryEffects, "The effect shouldnot be removed from the user"
def userNotFainted(self):
""" Test that it can handle when the user is not fainted """
cantHandle = self.handler.cantHandle(user = self.user, effect = self.effect)
assert not cantHandle, "Should handle when the user is not fainted"
assert self.effect in self.user.secondaryEffects, "The effect should not be removed from the user"
def sourceFainted(self):
""" Test that it can't handle the source fainting """
self.source.faint()
cantHandle = self.handler.cantHandle(user = self.user, effect = self.effect)
assert cantHandle, "Shouldn't handle when the source is fainted"
assert not self.effect in self.user.secondaryEffects, "The effect should be removed from the user"
def sourceNotFainted(self):
""" Test that it can handle when the user is not fainted """
cantHandle = self.handler.cantHandle(user = self.user, effect = self.effect)
assert not cantHandle, "Should handle when the source is not fainted"
assert self.effect in self.user.secondaryEffects, "The effect should not be removed from the user"
class diverge(unittest.TestCase):
""" Test cases of diverge """
def setUp(self):
""" Build the Pkmn and Effects for the test """
self.user = BuildPokemonBattleWrapper()
self.target = BuildPokemonBattleWrapper()
self.divergeEffects = [BuildEffectDelegate(), BuildEffectDelegate()]
self.normalEffects = [BuildEffectDelegate()]
self.message = BuildEffectDelegate().message
self.delegate = DivergeOnFaintDelegate(self.divergeEffects,
self.normalEffects)
def fainted(self):
""" Test that the diverge effects are called when the target has fainted """
self.target.faint()
diverge = self.delegate.diverge(self.user, self.target)
assert diverge, "Should diverge"
def notFainted(self):
""" Test that the regular effects are called when the target is not fainted """
diverge = self.delegate.diverge(self.user, self.target)
assert not diverge, "Should not diverge when the target is not fainted"
class diverge(unittest.TestCase):
""" Test cases of diverge """
def setUp(self):
""" Build the Pkmn and Effects for the test """
self.user = BuildPokemonBattleWrapper()
self.target = BuildPokemonBattleWrapper()
self.divergeEffects = [BuildEffectDelegate(), BuildEffectDelegate()]
self.normalEffects = [BuildEffectDelegate()]
self.message = BuildEffectDelegate().message
self.delegate = DivergeOnFaintDelegate(self.divergeEffects, self.normalEffects)
def fainted(self):
""" Test that the diverge effects are called when the target has fainted """
self.target.faint()
diverge = self.delegate.diverge(self.user, self.target)
assert diverge, "Should diverge"
def notFainted(self):
""" Test that the regular effects are called when the target is not fainted """
diverge = self.delegate.diverge(self.user, self.target)
assert not diverge, "Should not diverge when the target is not fainted"
