Skip to content

Commit

Permalink
Monopolytest
Browse files Browse the repository at this point in the history
  • Loading branch information
VeraSchild committed Aug 19, 2018
1 parent 84153e1 commit 58d63cf
Show file tree
Hide file tree
Showing 2 changed files with 79 additions and 93 deletions.
95 changes: 45 additions & 50 deletions tests/module3/monopoly_opdracht1Test.py
Original file line number Diff line number Diff line change
@@ -1,39 +1,35 @@
import checkpy.tests as t
import checkpy.lib as lib
import checkpy.assertlib as assertlib
import importlib



def before():
try:
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
plt.switch_backend("Agg")
lib.neutralizeFunction(plt.pause)
except ImportError:
pass
import matplotlib.pyplot as plt
plt.switch_backend("Agg")
lib.neutralizeFunction(plt.pause)

def after():
try:
import matplotlib.pyplot as plt
plt.switch_backend("TkAgg")
importlib.reload(plt)
except ImportError:
pass


# @t.test(0)
# def hasworp_met_twee_dobbelstenen(test):
# test.test = lambda : assertlib.fileContainsFunctionDefinitions(_fileName, "worp_met_twee_dobbelstenen")
# test.description = lambda : "definieert de functie worp_met_twee_dobbelstenen"
# test.timeout = lambda : 60

# @t.test(10)
# def correctDice(test):
# test.test = lambda : assertlib.between(lib.getFunction("worp_met_twee_dobbelstenen", _fileName)(), 2, 12)
# test.description = lambda : "returnt een correcte waarde voor een worp van twee dobbelstenen"
# test.timeout = lambda : 60
import matplotlib.pyplot as plt
plt.switch_backend("TkAgg")
reload(plt)

@t.test(0)
def hasworp_met_twee_dobbelstenen(test):
test.test = lambda : assertlib.fileContainsFunctionDefinitions(_fileName, "worp_met_twee_dobbelstenen")
test.description = lambda : "definieert de functie worp_met_twee_dobbelstenen"
test.timeout = lambda : 60


@t.passed(hasworp_met_twee_dobbelstenen)
@t.test(10)
def correctDice(test):
test.test = lambda : assertlib.between(lib.getFunction("worp_met_twee_dobbelstenen", _fileName)(), 2, 12)
test.description = lambda : "returnt een correcte waarde voor een worp van twee dobbelstenen"
test.timeout = lambda : 60


@t.passed(correctDice)
@t.test(20)
def hassimuleer_potjeAndsimuleer_groot_aantal_potjes_Monopoly(test):

Expand All @@ -52,52 +48,51 @@ def testMethod():
test.timeout = lambda : 60


# @t.passed(hassimuleer_potjeAndsimuleer_groot_aantal_potjes_Monopoly)
@t.passed(hassimuleer_potjeAndsimuleer_groot_aantal_potjes_Monopoly)
@t.test(30)
def correctAverageTrump(test):

def try_run():

fail_type = ""
pos = {type(None): "niks, zorg dat deze het gemiddeld aan benodigde worpen returnt",\
str: "een woord of zin, zorg dat de functie een getal returnt", \
tuple: "meerdere waarden, zorg dat deze alleen het gemiddeld aan benodigde worpen returnt"}

try:
testInput = lib.getFunction("simuleer_groot_aantal_potjes_Monopoly", _fileName)()
type_output = type(testInput)

if type_output != int:
fail_type = pos[type_output]
test.fail = lambda info : "De functie simuleer_groot_aantal_potjes_Monopoly returnt nu %s" %(fail_type)

test.fail = lambda info : "Zorg dat de functie simuleer_groot_aantal_potjes_Monopoly als argument het aantal potjes heeft"
return False
except:
testInput = lib.getFunction("simuleer_groot_aantal_potjes_Monopoly", _fileName)(1000000)
type_output = type(testInput)
try:
testInput = lib.getFunction("simuleer_groot_aantal_potjes_Monopoly", _fileName)(10000)
test.success = lambda info : "De code werkt zonder startgeld, je kunt nu startgeld invoeren!"
if assertlib.sameType(lib.getFunction("simuleer_groot_aantal_potjes_Monopoly", _fileName)(10000), None):
test.fail = lambda info : "Zorg er voor dat de functie simuleer_groot_aantal_potjes_Monopoly het gemiddeld aan benodigde worpen returnt en ook alleen deze waarde returnt"
return testInput
except:
testInput = lib.getFunction("simuleer_groot_aantal_potjes_Monopoly", _fileName)(10000, 1000000)
if assertlib.sameType(lib.getFunction("simuleer_groot_aantal_potjes_Monopoly", _fileName)(10000, 1000000), None):
test.fail = lambda info : "Zorg er voor dat de functie simuleer_groot_aantal_potjes_Monopoly het gemiddeld aan benodigde worpen returnt en ook alleen deze waarde returnt"
return testInput

if type_output != int:
fail_type = pos[type_output]
test.fail = lambda info : "De functie simuleer_groot_aantal_potjes_Monopoly returnt nu %s" %(fail_type)

return testInput if type(testInput) == int else 0

test.fail = lambda info : "de correcte waarde is ongeveer 147"
test.test = lambda : assertlib.between(try_run(), 145, 149)
test.description = lambda : "Monopoly werkt in Trump-Mode"
test.timeout = lambda : 60


# @t.passed(correctAverageTrump)
@t.passed(correctAverageTrump)
@t.test(40)
def correctAverageStartgeld(test):

def try_run():
try:
return lib.getFunction("simuleer_groot_aantal_potjes_Monopoly", _fileName)(1500)
return lib.getFunction("simuleer_groot_aantal_potjes_Monopoly", _fileName)(10000, 1500)
except:
return False

test.fail = lambda info : "de correcte waarde is ongeveer 187"
test.test = lambda : assertlib.between(try_run(), 184, 189)
test.description = lambda : "Monopoly werkt met 1500 euro startgeld"
test.timeout = lambda : 60





77 changes: 34 additions & 43 deletions tests/module3/monopoly_realistischTest.py
Original file line number Diff line number Diff line change
@@ -1,88 +1,79 @@
import checkpy.tests as t
import checkpy.lib as lib
import checkpy.assertlib as assertlib
import importlib


def before():
try:
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
plt.switch_backend("Agg")
lib.neutralizeFunction(plt.pause)
except ImportError:
pass
import matplotlib.pyplot as plt
plt.switch_backend("Agg")
lib.neutralizeFunction(plt.pause)

def after():
try:
import matplotlib.pyplot as plt
plt.switch_backend("TkAgg")
importlib.reload(plt)
except ImportError:
pass
import matplotlib.pyplot as plt
plt.switch_backend("TkAgg")
reload(plt)

@t.test(0)
def hassimuleer_groot_aantal_potjes_Monopoly(test):
def try_run():
if assertlib.fileContainsFunctionDefinitions(_fileName, "simuleer_groot_aantal_potjes_Monopoly"):
try:
testInput = lib.getFunction("simuleer_groot_aantal_potjes_Monopoly", _fileName)(1000000, 1000000)
testInput = lib.getFunction("simuleer_groot_aantal_potjes_Monopoly", _fileName)(10000, 1000000, 1000000)
return True
except:
return False
return False

test.test = try_run
test.fail = lambda info : "Zorg dat de functie twee argumenten heeft, startgeld voor speler 1 en startgeld voor speler 2"
test.description = lambda : "Definieert de functie simuleer_potje en simuleer_groot_aanal_potjes_Monopoly met twee argumenten"
test.fail = lambda info : "zorg dat de functie drie argumenten heeft, het aantal potjes, startgeld voor speler 1 en startgeld voor speler 2"
test.description = lambda : "definieert de functie simuleer_potje en simuleer_groot_aanal_potjes_Monopoly met drie argumenten"
test.timeout = lambda : 90


# @t.passed(hassimuleer_groot_aantal_potjes_Monopoly)
@t.passed(hassimuleer_groot_aantal_potjes_Monopoly)
@t.test(10)
def correctAverageDiv(test):
def testMethod():
outcome = lib.getFunction("simuleer_groot_aantal_potjes_Monopoly", _fileName)(1500, 1500)

type_output = type(outcome)
fail_type = ""
pos = {type(None): "niks, zorg dat deze het gemiddeld aan benodigde worpen returnt",\
str: "een woord of zin, zorg dat de functie een getal returnt", \
tuple: "meerdere waarden, zorg dat deze alleen het gemiddeld aan benodigde worpen returnt"}

if type_output != int:
fail_type = pos[type_output]
info = "De functie simuleer_groot_aantal_potjes_Monopoly returnt nu %s" %(fail_type)
elif assertlib.between(outcome, -99999999, 0):
info = "Als speler 1 meer straten heeft dan speler 2 is het verschil positief"
outcome = lib.getFunction("simuleer_groot_aantal_potjes_Monopoly", _fileName)(10000, 1500, 1500)
if assertlib.sameType(outcome, None):
info = "Zorg er voor dat de functie simuleer_groot_aantal_potjes_Monopoly het verschil in het bezit van straten returnt en alleen deze waarde returnt"
elif assertlib.between(outcome, 0, 99999999):
info = "Als speler 1 meer straten heeft dan speler 2 is het verschil negatief"
else:
info = "Het verschil is niet erg groot, gemiddeld zelfs minder dan 1 straat"
return assertlib.between(outcome, .15, 0.45), info
return assertlib.between(outcome, -.45, -.15), info

test.test = testMethod
test.description = lambda : "Monopoly met twee spelers geeft de het correcte gemiddelde verschil in gekochten straten"
test.timeout = lambda : 90



# @t.passed(correctAverageDiv)
@t.passed(correctAverageDiv)
@t.test(20)
def correctAverageDiv(test):
def testMethod():
def findline(outputOf):
tsts = ['startgeld', 'evenveel', 'straten']
for line in outputOf.split("\n"):
if all([assertlib.contains(line, tst) for tst in tsts]):
return line
return ""

def findline(outputOf):
tsts = ['startgeld', 'evenveel', 'straten']
for line in outputOf.split("\n"):
if all([assertlib.contains(line, tst) for tst in tsts]):
return line
return ""

line = findline(lib.outputOf(_fileName))
line = findline(lib.outputOf(_fileName))

info = ""
if assertlib.numberOnLine(75, line):
info = "De gevonden waarde is 75 euro. Checkpy het programma nog een keer."

test.test = lambda : assertlib.numberOnLine(115, line, deviation = 15)
return assertlib.numberOnLine(125, line), info

test.test = testMethod
test.description = lambda : "Monopoly met twee spelers vindt het correcte extra startgeld voor speler 2"
test.timeout = lambda : 90






0 comments on commit 58d63cf

Please sign in to comment.