def testError_checkCombination(self):
sud = Validator(4, 8)
#numbers and dimension to low
for startValueOfCombi in range(-1, 4):
for endValueOfCombi in range(-1, 4):
combi = list(range(startValueOfCombi, endValueOfCombi))
with self.assertRaises(ValueError):
#print(str(startValueOfCombi) +" "+ str(endValueOfCombi) +" "+ str(combi) +" "+ str(len(combi)))
sud.validateCombination(Colorcombination(combi))
#numbers and dimension to high
for startValueOfCombi in range(4, 6):
for endValueOfCombi in range(4, 6):
combi = list(range(startValueOfCombi, endValueOfCombi))
with self.assertRaises(ValueError):
#print(str(startValueOfCombi) +" "+ str(endValueOfCombi) +" "+ str(combi) +" "+ str(len(combi)))
sud.validateCombination(Colorcombination(combi))
combi = [1, 1, 1, 1]
with self.assertRaises(ValueError):
sud.validateCombination(Colorcombination(combi))
combi = [1, 1, 2, 1]
with self.assertRaises(ValueError):
sud.validateCombination(Colorcombination(combi))
combi = [1, 2, 1, 3]
with self.assertRaises(ValueError):
sud.validateCombination(Colorcombination(combi))
def testFunction_checkCombination(self):
sud = Validator(4, 8)
#valid combination
for startValueOfCombi in range(0, 5):
combi = list(range(startValueOfCombi, startValueOfCombi + 4))
#print(str(startValueOfCombi) +" "+ str(startValueOfCombi + 4) +" "+ str(combi) +" "+ str(len(combi)))
sud.validateCombination(Colorcombination(combi))
def testAllNPCs():
masterCombination = Colorcombination(random.sample(range(0, numberOfColors), lengthOfGuess))
gameCoordinator = GameCoordinator(lengthOfGuess, numberOfColors, masterCombination, maximumNumberOfGuesses)
print("\nStart all performance tests.\n")
print("NPC_random performance test")
npc = NPC_random(lengthOfGuess, numberOfColors, gameCoordinator.attempts)
npc.strategy = npc.strategy_automaticRandom
gameCoordinator.player = npc
startPerformanceTests(gameCoordinator)
print("NPC_hardCoded performance test")
npc = NPC_hardCoded(lengthOfGuess, numberOfColors, gameCoordinator.attempts)
npc.strategy = npc.strategy_automaticImprovedRandom
gameCoordinator.player = npc
startPerformanceTests(gameCoordinator)
print("NPC_csp performance test ")
npc = NPC_csp(lengthOfGuess, numberOfColors, gameCoordinator.attempts)
npc.strategy = npc.strategy_getNextPossibleCombination
npc.cspSolvingStrategy = constraint.BacktrackingSolver()
gameCoordinator.player = npc
startPerformanceTests(gameCoordinator, npc.resetProblems)
print("\nSucessfully performed all performance tests.")
def testError_playGame(self):
sud = GameCoordinator(4, 8, Colorcombination([0, 1, 2, 3]), 4)
tp = TestPlayer([[0, 1, 2, 3]])
sud.player = tp
finalScore = sud.playGame()
self.assertEqual(finalScore == FinalScore(True, 1, False), True)
tp = TestPlayer([[0, 1, 2, 4], [0, 1, 2, 3]])
sud.player = tp
finalScore = sud.playGame()
self.assertEqual(finalScore == FinalScore(True, 2, False), True)
tp = TestPlayer([[0, 1, 2, 44], [0, 1, 2, 7], [0, 1, 2, 3]])
sud.player = tp
finalScore = sud.playGame()
self.assertEqual(finalScore == FinalScore(True, 2, False), True)
tp = TestPlayer([[0, 1, 2, 44], [0, 1, 2, 7], [0, -1, 2, 7],
[0, 6, 2, 6], [0, 1, 2, 3]])
sud.player = tp
finalScore = sud.playGame()
self.assertEqual(finalScore == FinalScore(True, 2, False), True)
tp = TestPlayer([[0, 1, 2, 7], [0, 4, 2, 6], [0, 4, 1, 6],
[0, 1, 2, 3]])
sud.player = tp
finalScore = sud.playGame()
self.assertEqual(finalScore == FinalScore(True, 4, False), True)
tp = TestPlayer([[0, 1, 2, 7], [0, 4, 2, 6], [0, 4, 1, 6],
[0, 1, 2, 6]])
sud.player = tp
finalScore = sud.playGame()
self.assertEqual(finalScore == FinalScore(False, 4, False), True)
def __checkForDeadLoss(self, combination):
try:
allWrongCombinations = self.__attempts.getCombinationsWithNoRightColor(
)
for wrongCombination in allWrongCombinations:
if Colorcombination(combination).hasAnyColorInCommon(
wrongCombination):
#print("__checkForDeadLoss "+ str(combination))
return True
except ValueError:
pass
return False
def __getNewUserCombination(self):
while (True):
try:
userCmbi = Colorcombination(self.player.readInputIn())
self.__validator.validateCombination(userCmbi)
break
except ValueError as e:
print(
str(e) +
". Combination not valid, do it again. Just write the color values seperated by a whitespace and hit enter."
)
return userCmbi
def testFunction_getLastAttempt(self):
evaluator = Evaluator(Colorcombination([0, 1, 2, 3]))
attempts = Attempts()
evaluatedCombi = EvaluatedCombination(Colorcombination([4, 5, 6, 7]),
Evaluation(0, 0, False))
attempts.addEvaluatedCombination(evaluatedCombi)
self.assertEqual(attempts.getLastAttempt() == evaluatedCombi, True)
evaluatedCombi = EvaluatedCombination(Colorcombination([5, 6, 7, 0]),
Evaluation(1, 0, False))
attempts.addEvaluatedCombination(evaluatedCombi)
self.assertEqual(attempts.getLastAttempt() == evaluatedCombi, True)
evaluatedCombi = EvaluatedCombination(Colorcombination([5, 1, 7, 0]),
Evaluation(1, 1, False))
attempts.addEvaluatedCombination(evaluatedCombi)
self.assertEqual(attempts.getLastAttempt() == evaluatedCombi, True)
evaluatedCombi = EvaluatedCombination(Colorcombination([5, 6, 7, 0]),
Evaluation(1, 0, False))
attempts.addEvaluatedCombination(evaluatedCombi)
self.assertEqual(attempts.getLastAttempt() == evaluatedCombi, True)
evaluatedCombi = EvaluatedCombination(Colorcombination([5, 1, 2, 0]),
Evaluation(1, 2, False))
attempts.addEvaluatedCombination(evaluatedCombi)
self.assertEqual(attempts.getLastAttempt() == evaluatedCombi, True)
def testFunction_addEvaluatedCombination(self):
evaluator = Evaluator(Colorcombination([0, 1, 2, 3]))
attempts = Attempts()
evaluatedCombi = EvaluatedCombination(Colorcombination([4, 5, 6, 7]),
Evaluation(0, 0, False))
attempts.addEvaluatedCombination(evaluatedCombi)
self.assertEqual(attempts.getNumberOfAttempts() == 1, True)
evaluatedCombi = EvaluatedCombination(Colorcombination([5, 6, 7, 0]),
Evaluation(1, 0, False))
attempts.addEvaluatedCombination(evaluatedCombi)
self.assertEqual(attempts.getNumberOfAttempts() == 2, True)
evaluatedCombi = EvaluatedCombination(Colorcombination([5, 1, 7, 0]),
Evaluation(1, 1, False))
attempts.addEvaluatedCombination(evaluatedCombi)
self.assertEqual(attempts.getNumberOfAttempts() == 3, True)
evaluatedCombi = EvaluatedCombination(Colorcombination([5, 6, 7, 0]),
Evaluation(1, 0, False))
attempts.addEvaluatedCombination(evaluatedCombi)
self.assertEqual(attempts.getNumberOfAttempts() == 4, True)
evaluatedCombi = EvaluatedCombination(Colorcombination([5, 1, 2, 0]),
Evaluation(1, 2, False))
attempts.addEvaluatedCombination(evaluatedCombi)
self.assertEqual(attempts.getNumberOfAttempts() == 5, True)
attempts.clearAttempts()
self.assertEqual(attempts.getNumberOfAttempts() == 0, True)
def strategy_getNextPossibleCombination(self):
lastAttempt = None
try:
lastAttempt = self.__attempts.getLastAttempt()
except ValueError:
return random.sample(range(0, self.__numberOfColors),
self.__lengthOfGuess)
if self.__lengthOfGuess == 1:
lambdaConstraint = lambda c_0: self.__validateWithTemporaryMastercombination(
Colorcombination([c_0]), lastAttempt.colorCombination
) == lastAttempt.evaluation
elif self.__lengthOfGuess == 2:
lambdaConstraint = lambda c_0, c_1: self.__validateWithTemporaryMastercombination(
Colorcombination([c_0, c_1]), lastAttempt.colorCombination
) == lastAttempt.evaluation
elif self.__lengthOfGuess == 3:
lambdaConstraint = lambda c_0, c_1, c_2: self.__validateWithTemporaryMastercombination(
Colorcombination([c_0, c_1, c_2]), lastAttempt.colorCombination
) == lastAttempt.evaluation
elif self.__lengthOfGuess == 4:
lambdaConstraint = lambda c_0, c_1, c_2, c_3: self.__validateWithTemporaryMastercombination(
Colorcombination([c_0, c_1, c_2, c_3]), lastAttempt.
colorCombination) == lastAttempt.evaluation
elif self.__lengthOfGuess == 5:
lambdaConstraint = lambda c_0, c_1, c_2, c_3, c_4: self.__validateWithTemporaryMastercombination(
Colorcombination([c_0, c_1, c_2, c_3, c_4]), lastAttempt.
colorCombination) == lastAttempt.evaluation
elif self.__lengthOfGuess == 6:
lambdaConstraint = lambda c_0, c_1, c_2, c_3, c_4, c_5: self.__validateWithTemporaryMastercombination(
Colorcombination([c_0, c_1, c_2, c_3, c_4, c_5]), lastAttempt.
colorCombination) == lastAttempt.evaluation
else:
raise NotImplementedError(
"This lenght of Guess is not supported yet")
self.__cspProblem.addConstraint(lambdaConstraint,
self.__cspVariablesStrings)
newCombination = []
for value in self.__cspProblem.getSolution().values():
newCombination.append(value)
return newCombination
def testFunction_Constructor(self):
#valid construcotrs
sud = GameCoordinator(1, 2, Colorcombination([0]), 1)
sud = GameCoordinator(2, 2, Colorcombination([0, 1]), 2)
sud = GameCoordinator(1, 1, Colorcombination([0]), 1)
sud = GameCoordinator(1, 2, Colorcombination([0]), 1)
sud = GameCoordinator(1, 2, Colorcombination([0]), 1)
sud = GameCoordinator(1, 2, Colorcombination([1]), 1)
sud = GameCoordinator(2, 2, Colorcombination([0, 1]), 1)
sud = GameCoordinator(2, 2, Colorcombination([1, 0]), 1)
sud = GameCoordinator(1, 2, Colorcombination([0]), 2)
sud = GameCoordinator(4, 8, Colorcombination([0, 1, 2, 3]), 10)
sud = GameCoordinator(4, 8, Colorcombination([7, 6, 5, 4]), 10)
sud = GameCoordinator(1, 8, Colorcombination([7]), 1)
sud = GameCoordinator(1, 3, Colorcombination([2]), 55)
def test_hasAllColorsInCommon(self):
self.assertEqual(
Colorcombination([]).hasAllColorsInCommon(Colorcombination([])),
True)
self.assertEqual(
Colorcombination([1]).hasAllColorsInCommon(Colorcombination([1])),
True)
self.assertEqual(
Colorcombination([1,
2]).hasAllColorsInCommon(Colorcombination([1,
2])),
True)
self.assertEqual(
Colorcombination([2,
1]).hasAllColorsInCommon(Colorcombination([1,
2])),
True)
self.assertEqual(
Colorcombination([1,
2]).hasAllColorsInCommon(Colorcombination([2,
1])),
True)
self.assertEqual(
Colorcombination([1, 2, 3, 4]).hasAllColorsInCommon(
Colorcombination([1, 2, 4, 3])), True)
self.assertEqual(
Colorcombination([1, 2, 3, 4]).hasAllColorsInCommon(
Colorcombination([4, 3, 1, 2])), True)
self.assertEqual(
Colorcombination([1, 2, 3, 4]).hasAllColorsInCommon(
Colorcombination([2, 4, 1, 3])), True)
self.assertEqual(
Colorcombination([1]).hasAllColorsInCommon(Colorcombination([])),
False)
self.assertEqual(
Colorcombination([]).hasAllColorsInCommon(Colorcombination([1])),
False)
self.assertEqual(
Colorcombination([1, 2]).hasAllColorsInCommon(
Colorcombination([1, 2, 3])), False)
self.assertEqual(
Colorcombination([2, 1]).hasAllColorsInCommon(
Colorcombination([3, 1, 2])), False)
self.assertEqual(
Colorcombination([3, 1,
2]).hasAllColorsInCommon(Colorcombination([2,
1])),
False)
self.assertEqual(
Colorcombination([1, 2, 3, 4]).hasAllColorsInCommon(
Colorcombination([1, 5, 4, 3])), False)
self.assertEqual(
Colorcombination([1, 2, 3, 5]).hasAllColorsInCommon(
Colorcombination([4, 3, 1, 2])), False)
self.assertEqual(
Colorcombination([1, 2, 3, 4]).hasAllColorsInCommon(
Colorcombination([2, 4, 1, 3, 0])), False)
self.assertEqual(
Colorcombination([1, 2, 3, 6, 4]).hasAllColorsInCommon(
Colorcombination([2, 4, 1, 3])), False)
def test_eq(self):
#equal evaluations
self.assertEqual(Colorcombination([]) == Colorcombination([]), True)
self.assertEqual(Colorcombination([1]) == Colorcombination([1]), True)
self.assertEqual(
Colorcombination([1, 2]) == Colorcombination([1, 2]), True)
self.assertEqual(
Colorcombination([1, 5, 8]) == Colorcombination([1, 5, 8]), True)
self.assertEqual(
Colorcombination([9, 3, 1, 0]) == Colorcombination([9, 3, 1, 0]),
True)
#unequal evaluations
self.assertEqual(Colorcombination([]) == Colorcombination([1]), False)
self.assertEqual(Colorcombination([2]) == Colorcombination([1]), False)
self.assertEqual(
Colorcombination([-1]) == Colorcombination([1]), False)
self.assertEqual(
Colorcombination([2, 1]) == Colorcombination([1, 2]), False)
self.assertEqual(
Colorcombination([2, 1]) == Colorcombination([2, 1, 9]), False)
self.assertEqual(
Colorcombination([2, 1, 9]) == Colorcombination([2, 1]), False)
def testError_validateForNoObviousRrrors(self):
sud = Validator(4, 8)
attempts = Attempts()
evaluatedCombi = EvaluatedCombination(Colorcombination([4, 5, 6, 7]),
Evaluation(0, 0, False))
attempts.addEvaluatedCombination(evaluatedCombi)
debriefing = sud.validateForNoObviousErrors(attempts)
if debriefing:
self.fail()
evaluatedCombi = EvaluatedCombination(Colorcombination([5, 6, 7, 0]),
Evaluation(1, 0, False))
attempts.addEvaluatedCombination(evaluatedCombi)
debriefing = sud.validateForNoObviousErrors(attempts)
if not debriefing:
self.fail()
attempts.clearAttempts()
evaluatedCombi = EvaluatedCombination(Colorcombination([5, 1, 7, 0]),
Evaluation(1, 1, False))
attempts.addEvaluatedCombination(evaluatedCombi)
debriefing = sud.validateForNoObviousErrors(attempts)
if debriefing:
self.fail()
evaluatedCombi = EvaluatedCombination(Colorcombination([5, 6, 7, 0]),
Evaluation(1, 0, False))
attempts.addEvaluatedCombination(evaluatedCombi)
debriefing = sud.validateForNoObviousErrors(attempts)
if debriefing:
self.fail()
evaluatedCombi = EvaluatedCombination(Colorcombination([5, 1, 2, 0]),
Evaluation(1, 2, False))
attempts.addEvaluatedCombination(evaluatedCombi)
debriefing = sud.validateForNoObviousErrors(attempts)
if debriefing:
self.fail()
evaluatedCombi = EvaluatedCombination(Colorcombination([4, 5, 6, 7]),
Evaluation(0, 0, False))
attempts.addEvaluatedCombination(evaluatedCombi)
debriefing = sud.validateForNoObviousErrors(attempts)
if debriefing:
self.fail()
evaluatedCombi = EvaluatedCombination(Colorcombination([1, 2, 5, 0]),
Evaluation(3, 0, False))
attempts.addEvaluatedCombination(evaluatedCombi)
debriefing = sud.validateForNoObviousErrors(attempts)
if not debriefing:
self.fail()
attempts.clearAttempts()
evaluatedCombi = EvaluatedCombination(Colorcombination([5, 1, 7, 0]),
Evaluation(1, 1, False))
attempts.addEvaluatedCombination(evaluatedCombi)
debriefing = sud.validateForNoObviousErrors(attempts)
if debriefing:
self.fail()
evaluatedCombi = EvaluatedCombination(Colorcombination([1, 3, 2, 0]),
Evaluation(3, 1, False))
attempts.addEvaluatedCombination(evaluatedCombi)
debriefing = sud.validateForNoObviousErrors(attempts)
if debriefing:
self.fail()
evaluatedCombi = EvaluatedCombination(Colorcombination([5, 1, 2, 0]),
Evaluation(1, 2, False))
attempts.addEvaluatedCombination(evaluatedCombi)
debriefing = sud.validateForNoObviousErrors(attempts)
if not debriefing:
self.fail()
def test_hasAnyColorInCommon(self):
self.assertEqual(
Colorcombination([1]).hasAnyColorInCommon(Colorcombination([1])),
True)
self.assertEqual(
Colorcombination([1]).hasAnyColorInCommon(
Colorcombination([1, 2, 3, 45])), True)
self.assertEqual(
Colorcombination([1]).hasAnyColorInCommon(
Colorcombination([2, 4, -1, 1])), True)
self.assertEqual(
Colorcombination([1, 5]).hasAnyColorInCommon(
Colorcombination([1, 4, 7, 2, 5, 6])), True)
self.assertEqual(
Colorcombination([1]).hasAnyColorInCommon(Colorcombination([])),
False)
self.assertEqual(
Colorcombination([]).hasAnyColorInCommon(Colorcombination([])),
False)
self.assertEqual(
Colorcombination([]).hasAnyColorInCommon(Colorcombination([1])),
False)
self.assertEqual(
Colorcombination([1]).hasAnyColorInCommon(Colorcombination([])),
False)
self.assertEqual(
Colorcombination([]).hasAnyColorInCommon(Colorcombination([1])),
False)
self.assertEqual(
Colorcombination([1]).hasAnyColorInCommon(Colorcombination([2])),
False)
self.assertEqual(
Colorcombination([1]).hasAnyColorInCommon(
Colorcombination([2, 3, 45])), False)
self.assertEqual(
Colorcombination([5]).hasAnyColorInCommon(
Colorcombination([2, 4, -1, 1])), False)
self.assertEqual(
Colorcombination([1, 5]).hasAnyColorInCommon(
Colorcombination([0, 4, 7, 2, 9, 6])), False)
def testFunction_checkIfCombinationExist(self):
attempts = Attempts()
self.assertEqual(
attempts.checkIfCombinationExist(Colorcombination([0, 0, 1])),
False)
attempts.addEvaluatedCombination(
EvaluatedCombination(Colorcombination([0, 0, 1]),
Evaluation(0, 0, False)))
self.assertEqual(
attempts.checkIfCombinationExist(Colorcombination([0, 0, 1])),
True)
self.assertEqual(
attempts.checkIfCombinationExist(Colorcombination([0, 1, 0])),
False)
attempts.addEvaluatedCombination(
EvaluatedCombination(Colorcombination([0, 1, 0]),
Evaluation(1, 0, False)))
self.assertEqual(
attempts.checkIfCombinationExist(Colorcombination([0, 1, 0])),
True)
self.assertEqual(
attempts.checkIfCombinationExist(Colorcombination([0, 1, 1])),
False)
attempts.addEvaluatedCombination(
EvaluatedCombination(Colorcombination([0, 1, 1]),
Evaluation(1, 1, False)))
self.assertEqual(
attempts.checkIfCombinationExist(Colorcombination([0, 1, 1])),
True)
self.assertEqual(
attempts.checkIfCombinationExist(Colorcombination([1, 0, 0])),
False)
attempts.addEvaluatedCombination(
EvaluatedCombination(Colorcombination([1, 0, 0]),
Evaluation(1, 0, False)))
self.assertEqual(
attempts.checkIfCombinationExist(Colorcombination([1, 0, 0])),
True)
self.assertEqual(
attempts.checkIfCombinationExist(Colorcombination([0, 0, 0])),
False)
self.assertEqual(
attempts.checkIfCombinationExist(Colorcombination([0, 0, 1])),
True)
self.assertEqual(
attempts.checkIfCombinationExist(Colorcombination([0, 1, 0])),
True)
self.assertEqual(
attempts.checkIfCombinationExist(Colorcombination([0, 1, 1])),
True)
self.assertEqual(
attempts.checkIfCombinationExist(Colorcombination([1, 0, 0])),
True)
self.assertEqual(
attempts.checkIfCombinationExist(Colorcombination([1, 0, 1])),
False)
self.assertEqual(
attempts.checkIfCombinationExist(Colorcombination([1, 1, 0])),
False)
self.assertEqual(
attempts.checkIfCombinationExist(Colorcombination([1, 1, 1])),
False)
attempts.clearAttempts()
attempts.addEvaluatedCombination(
EvaluatedCombination(Colorcombination([0, 2, 3, 1]),
Evaluation(1, 0, False)))
self.assertEqual(
attempts.checkIfCombinationExist(Colorcombination([0, 2, 3, 1])),
True)
self.assertEqual(
attempts.checkIfCombinationExist(Colorcombination([0, 2, 1, 3])),
False)
self.assertEqual(
attempts.checkIfCombinationExist(Colorcombination([0, 3, 2, 1])),
False)
self.assertEqual(
attempts.checkIfCombinationExist(Colorcombination([0, 3, 1, 2])),
False)
self.assertEqual(
attempts.checkIfCombinationExist(Colorcombination([0, 1, 2, 3])),
False)
self.assertEqual(
attempts.checkIfCombinationExist(Colorcombination([0, 1, 3, 2])),
False)
self.assertEqual(
attempts.checkIfCombinationExist(Colorcombination([2, 0, 3, 1])),
False)
def setNewRandomMasterCombination(sud):
masterCombination = Colorcombination(random.sample(range(0, numberOfColors), lengthOfGuess))
sud.setMasterCombination(masterCombination)
def testFunction_getCombinationsWithNoRightColor(self):
evaluator = Evaluator(Colorcombination([0, 1, 2, 3]))
attempts = Attempts()
evaluatedCombi = EvaluatedCombination(Colorcombination([5, 6, 7, 0]),
Evaluation(1, 0, False))
attempts.addEvaluatedCombination(evaluatedCombi)
self.assertEqual(attempts.getCombinationsWithNoRightColor() == [],
True)
evaluatedCombi = EvaluatedCombination(Colorcombination([4, 5, 6, 7]),
Evaluation(0, 0, False))
attempts.addEvaluatedCombination(evaluatedCombi)
self.assertEqual(
attempts.getCombinationsWithNoRightColor() == [
Colorcombination([4, 5, 6, 7])
], True)
evaluatedCombi = EvaluatedCombination(Colorcombination([5, 1, 7, 0]),
Evaluation(1, 1, False))
attempts.addEvaluatedCombination(evaluatedCombi)
self.assertEqual(
attempts.getCombinationsWithNoRightColor() == [
Colorcombination([4, 5, 6, 7])
], True)
evaluatedCombi = EvaluatedCombination(Colorcombination([5, 6, 7, 0]),
Evaluation(1, 0, False))
attempts.addEvaluatedCombination(evaluatedCombi)
self.assertEqual(
attempts.getCombinationsWithNoRightColor() == [
Colorcombination([4, 5, 6, 7])
], True)
evaluatedCombi = EvaluatedCombination(Colorcombination([0, 1, 2, 5]),
Evaluation(0, 1, False))
attempts.addEvaluatedCombination(evaluatedCombi)
self.assertEqual(
attempts.getCombinationsWithNoRightColor() == [
Colorcombination([4, 5, 6, 7])
], True)
evaluatedCombi = EvaluatedCombination(Colorcombination([4, 6, 5, 7]),
Evaluation(0, 0, False))
attempts.addEvaluatedCombination(evaluatedCombi)
self.assertEqual(
attempts.getCombinationsWithNoRightColor() == [
Colorcombination([4, 5, 6, 7]),
Colorcombination([4, 6, 5, 7])
], True)
evaluatedCombi = EvaluatedCombination(Colorcombination([4, 6, 5, 7]),
Evaluation(0, 0, False))
attempts.addEvaluatedCombination(evaluatedCombi)
self.assertEqual(
attempts.getCombinationsWithNoRightColor() == [
Colorcombination([4, 5, 6, 7]),
Colorcombination([4, 6, 5, 7])
], True)
evaluatedCombi = EvaluatedCombination(Colorcombination([0, 1, 2, 3]),
Evaluation(0, 4, True))
attempts.addEvaluatedCombination(evaluatedCombi)
self.assertEqual(
attempts.getCombinationsWithNoRightColor() == [
Colorcombination([4, 5, 6, 7]),
Colorcombination([4, 6, 5, 7])
], True)
def testFunction_getCombinationsWithAllRightColor(self):
evaluator = Evaluator(Colorcombination([0, 1, 2, 3]))
attempts = Attempts()
evaluatedCombi = EvaluatedCombination(Colorcombination([5, 6, 7, 0]),
Evaluation(1, 0, False))
attempts.addEvaluatedCombination(evaluatedCombi)
with self.assertRaises(ValueError):
attempts.getCombinationWithAllRightColors()
evaluatedCombi = EvaluatedCombination(Colorcombination([0, 1, 2, 3]),
Evaluation(1, 3, True))
attempts.addEvaluatedCombination(evaluatedCombi)
self.assertEqual(
attempts.getCombinationWithAllRightColors() == Colorcombination(
[0, 1, 2, 3]), True)
evaluatedCombi = EvaluatedCombination(Colorcombination([4, 6, 5, 7]),
Evaluation(0, 0, False))
attempts.addEvaluatedCombination(evaluatedCombi)
self.assertEqual(
attempts.getCombinationWithAllRightColors() == Colorcombination(
[0, 1, 2, 3]), True)
evaluatedCombi = EvaluatedCombination(Colorcombination([0, 1, 3, 2]),
Evaluation(0, 4, True))
attempts.addEvaluatedCombination(evaluatedCombi)
self.assertEqual(
attempts.getCombinationWithAllRightColors() == Colorcombination(
[0, 1, 2, 3]), True)
attempts.clearAttempts()
evaluatedCombi = EvaluatedCombination(Colorcombination([0, 1, 3, 2]),
Evaluation(0, 4, True))
attempts.addEvaluatedCombination(evaluatedCombi)
self.assertEqual(
attempts.getCombinationWithAllRightColors() == Colorcombination(
[0, 1, 3, 2]), True)
evaluatedCombi = EvaluatedCombination(Colorcombination([5, 6, 7, 0]),
Evaluation(1, 0, False))
attempts.addEvaluatedCombination(evaluatedCombi)
self.assertEqual(
attempts.getCombinationWithAllRightColors() == Colorcombination(
[0, 1, 3, 2]), True)
evaluatedCombi = EvaluatedCombination(Colorcombination([0, 1, 2, 3]),
Evaluation(1, 3, True))
attempts.addEvaluatedCombination(evaluatedCombi)
self.assertEqual(
attempts.getCombinationWithAllRightColors() == Colorcombination(
[0, 1, 3, 2]), True)
evaluatedCombi = EvaluatedCombination(Colorcombination([4, 6, 5, 7]),
Evaluation(0, 0, False))
attempts.addEvaluatedCombination(evaluatedCombi)
self.assertEqual(
attempts.getCombinationWithAllRightColors() == Colorcombination(
[0, 1, 3, 2]), True)
def __checkForDuplicate(self, combination):
if self.__attempts.checkIfCombinationExist(
Colorcombination(combination)):
#print("__checkForDuplicate " + str(combination))
return True
return False
def testFunction_eq(self):
#equal evaluations
evaluatedCombi = EvaluatedCombination(Colorcombination([0, 1, 2, 3]),
Evaluation(0, 0, False))
self.assertEqual(evaluatedCombi == evaluatedCombi, True)
evaluatedCombi = EvaluatedCombination(Colorcombination([0, 1, 2, 7]),
Evaluation(1, 0, False))
self.assertEqual(evaluatedCombi == evaluatedCombi, True)
evaluatedCombi = EvaluatedCombination(Colorcombination([4, 1, 2, 7]),
Evaluation(1, 1, False))
self.assertEqual(evaluatedCombi == evaluatedCombi, True)
evaluatedCombi = EvaluatedCombination(Colorcombination([4, 1, 5, 7]),
Evaluation(1, 2, False))
self.assertEqual(evaluatedCombi == evaluatedCombi, True)
#unequal evaluations
evaluatedCombi = EvaluatedCombination(Colorcombination([0, 1, 2, 3]),
Evaluation(0, 0, True))
self.assertEqual(
evaluatedCombi == EvaluatedCombination(
Colorcombination([0, 1, 2, 3]), Evaluation(0, 1, True)), False)
self.assertEqual(
evaluatedCombi == EvaluatedCombination(
Colorcombination([0, 1, 2, 3]), Evaluation(0, 1, False)),
False)
evaluatedCombi = EvaluatedCombination(Colorcombination([0, 1, 2, 3]),
Evaluation(0, 0, True))
self.assertEqual(
evaluatedCombi == EvaluatedCombination(
Colorcombination([0, 1, 5, 3]), Evaluation(0, 0, True)), False)
self.assertEqual(
evaluatedCombi == EvaluatedCombination(
Colorcombination([0, 1, 5, 3]), Evaluation(0, 0, False)),
False)
evaluatedCombi = EvaluatedCombination(Colorcombination([0, 1, 2, 3]),
Evaluation(0, 0, True))
self.assertEqual(
evaluatedCombi == EvaluatedCombination(
Colorcombination([0, 1, 5, 3]), Evaluation(1, 0, True)), False)
self.assertEqual(
evaluatedCombi == EvaluatedCombination(
Colorcombination([0, 1, 5, 3]), Evaluation(1, 0, False)),
False)
evaluatedCombi = EvaluatedCombination(Colorcombination([0, 1, 2, 3]),
Evaluation(0, 0, True))
self.assertEqual(
evaluatedCombi == EvaluatedCombination(
Colorcombination([7, 5, 6, 4]), Evaluation(1, 6, True)), False)
self.assertEqual(
evaluatedCombi == EvaluatedCombination(
Colorcombination([7, 5, 6, 4]), Evaluation(1, 6, False)),
False)
def testError_Constructor(self):
#invalid construcotrs
with self.assertRaises(ValueError):
sud = GameCoordinator(-1, 1, Colorcombination([0]), 1)
with self.assertRaises(ValueError):
sud = GameCoordinator(0, 1, Colorcombination([0]), 1)
with self.assertRaises(ValueError):
sud = GameCoordinator(2, 1, Colorcombination([0]), 1)
with self.assertRaises(ValueError):
sud = GameCoordinator(1, -1, Colorcombination([0]), 1)
with self.assertRaises(ValueError):
sud = GameCoordinator(1, 0, Colorcombination([0]), 1)
with self.assertRaises(AttributeError):
sud = GameCoordinator(1, 1, 0, 1)
with self.assertRaises(AttributeError):
sud = GameCoordinator(1, 1, 'v', 1)
with self.assertRaises(AttributeError):
sud = GameCoordinator(1, 1, 0, 1)
with self.assertRaises(AttributeError):
sud = GameCoordinator(1, 1, 'v', 1)
with self.assertRaises(AttributeError):
sud = GameCoordinator(1, 1, [], 1)
with self.assertRaises(ValueError):
sud = GameCoordinator(1, 1, Colorcombination([]), 1)
with self.assertRaises(ValueError):
sud = GameCoordinator(1, 1, Colorcombination([-1]), 1)
with self.assertRaises(ValueError):
sud = GameCoordinator(1, 1, Colorcombination([1]), 1)
with self.assertRaises(ValueError):
sud = GameCoordinator(1, 1, Colorcombination([0, 0]), 1)
with self.assertRaises(ValueError):
sud = GameCoordinator(1, 1, Colorcombination([0, 1]), 1)
with self.assertRaises(ValueError):
sud = GameCoordinator(1, 2, Colorcombination([0]), -1)
with self.assertRaises(ValueError):
sud = GameCoordinator(1, 2, Colorcombination([0]), 0)
def testFunction_evaluateCombination(self):
sud = Evaluator(Colorcombination([0, 1, 2, 3]))
#calculate right colors on the right place evaluations
self.assertEqual(
sud.evaluateCombination(Colorcombination([0, 1, 2, 3])),
Evaluation(0, 4, True))
self.assertEqual(
sud.evaluateCombination(Colorcombination([4, 1, 2, 3])),
Evaluation(0, 3, False))
self.assertEqual(
sud.evaluateCombination(Colorcombination([4, 5, 2, 3])),
Evaluation(0, 2, False))
self.assertEqual(
sud.evaluateCombination(Colorcombination([4, 5, 6, 3])),
Evaluation(0, 1, False))
self.assertEqual(
sud.evaluateCombination(Colorcombination([4, 5, 6, 7])),
Evaluation(0, 0, False))
#calculate right colors on the wrong place evaluations
self.assertEqual(
sud.evaluateCombination(Colorcombination([3, 2, 1, 0])),
Evaluation(4, 0, False))
self.assertEqual(
sud.evaluateCombination(Colorcombination([3, 2, 1, 7])),
Evaluation(3, 0, False))
self.assertEqual(
sud.evaluateCombination(Colorcombination([3, 2, 6, 7])),
Evaluation(2, 0, False))
self.assertEqual(
sud.evaluateCombination(Colorcombination([3, 5, 6, 7])),
Evaluation(1, 0, False))
self.assertEqual(
sud.evaluateCombination(Colorcombination([4, 5, 6, 7])),
Evaluation(0, 0, False))
#calculate mixed evaluations
self.assertEqual(
sud.evaluateCombination(Colorcombination([2, 1, 7, 4])),
Evaluation(1, 1, False))
self.assertEqual(
sud.evaluateCombination(Colorcombination([2, 1, 0, 4])),
Evaluation(2, 1, False))
self.assertEqual(
sud.evaluateCombination(Colorcombination([2, 1, 0, 3])),
Evaluation(2, 2, False))
self.assertEqual(
sud.evaluateCombination(Colorcombination([2, 1, 6, 3])),
Evaluation(1, 2, False))
import random
from ManagementFunctions.GameCoordinator import GameCoordinator
from GameLogic.Colorcombination import Colorcombination
numberOfColors = 8
lengthOfGuess = 4
maximumNumberOfGuesses = 100
masterCombination = Colorcombination(
random.sample(range(0, numberOfColors), lengthOfGuess))
#masterCombination = Colorcombination([0, 1, 2, 3])
gc = GameCoordinator(lengthOfGuess, numberOfColors, masterCombination,
maximumNumberOfGuesses)
gc.playGame()
