def testMethod():
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, -.45, -.15), info
def testMethod():
outcome = lib.getFunction("simulate_monopoly_games", _fileName)(10000, 1500, 1500)
if assertlib.sameType(outcome, None):
info = "Make sure that the function simulate_monopoly_games only returns the difference in the number of streets owned"
elif assertlib.between(outcome, -99999999, 0):
info = "Are you sure you are subtracting player 2s values from player 1 and not the other way around?"
else:
info = "When starting both with 1500, the difference in street ownership is not that big, it should be somewhere between .15 and .55."
return assertlib.between(outcome, .15, .55), info
def testMethod():
montecarlo = lib.getFunction("montecarlo", _fileName)
tanCosSin = lib.documentFunction(
lambda x: math.tan(math.cos(math.sin(x))),
"f(x) = tan(cos(sin(x)))")
outcome = montecarlo(tanCosSin, 0.2, 0, 2.2, 1.5)
return assertlib.between(outcome, 1.69, 1.73)
def correctAverageTrump(test):
def testMethod():
student_func = lib.getFunction("simulate_monopoly_games", _fileName)
nArguments = len(student_func.arguments)
# Trump
if nArguments == 1:
testInput = student_func(10000)
test.success = lambda info: "The code works without starting_money, you can now proceed with starting_money!"
if assertlib.sameType(testInput, None):
test.fail = lambda info: "Make sure that the function simulate_monopoly_games returns the average required number of throws and nothing else"
# starting money, 1 player
elif nArguments == 2:
testInput = student_func(10000, 1000000)
if assertlib.sameType(testInput, None):
test.fail = lambda info: "Make sure that the function simulate_monopoly_games returns the average required number of throws and nothing else"
else:
testInput = False
test.fail = lambda info: "Make sure that the function simulate_monopoly_games with Trumpmode uses 1 argument and with starting_money 2 arguments"
return testInput
test.test = lambda: assertlib.between(testMethod(), 145, 149)
test.description = lambda: "Monopoly works for Trumpmode"
test.timeout = lambda: 60
def testMethod():
reproduce = lib.getFunction("reproduce", _fileName)
viruses = ["GGGG", "AAAA", "TTTT", "GGGG", "ATGC"] * 20
n = 1000
avgPopSize = sum(
len(reproduce(viruses[:], 0.25, 0.50)) for _ in range(n)) / n
return asserts.between(avgPopSize, 145, 155)
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)
except:
testInput = lib.getFunction(
"simuleer_groot_aantal_potjes_Monopoly", _fileName)(1000000)
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)
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
def correctAverageStartingMoney(test):
def testMethod():
nArguments = len(
lib.getFunction("simulate_monopoly_games", _fileName).arguments)
if nArguments == 2:
testInput = lib.getFunction("simulate_monopoly_games",
_fileName)(10000, 1500)
if assertlib.sameType(
lib.getFunction("simulate_monopoly_games",
_fileName)(10000, 1500), None):
test.fail = lambda info: "Make sure that the function simulate_monopoly_games returns the average required number of throws and nothing else"
return testInput
elif nArguments == 3:
testInput = lib.getFunction("simulate_monopoly_games",
_fileName)(10000, 1500, 0)
if assertlib.sameType(
lib.getFunction("simulate_monopoly_games",
_fileName)(10000, 1500, 0), None):
test.fail = lambda info: "Make sure that the function simulate_monopoly_games returns the average required number of throws and nothing else"
return testInput
else:
return 0
test.test = lambda: assertlib.between(testMethod(), 184, 189)
test.description = lambda: "Monopoly works with 1500 euro starting_money"
test.timeout = lambda: 60
def correctAverageTrump(test):
def try_run():
try:
testInput = lib.getFunction("simuleer_groot_aantal_potjes_Monopoly", _fileName)()
test.fail = lambda info : "Zorg dat de functie simuleer_groot_aantal_potjes_Monopoly als argument het aantal potjes heeft"
return False
except:
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
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
def testMethod():
simulate = lib.getFunction("simulate", _fileName)
viruses = ["GGGG", "AAAA", "TTTT", "GGGG", "ATGC"] * 20
n = 100
timesteps = 1000
avg = sum(
sum(simulate(viruses[:], 0.25, 0.1, 0.5, 100, timesteps)) /
timesteps for i in range(n)) / n
return asserts.between(avg, 40, 45)
def testMethod2():
_fn = lib.getFunction("simulate_apple2", _fileName)
try:
_t = apply_function(_fn, (0.01, ), (float, ))
except InvalidFunctionApplication as e:
return False, e.message
if assertlib.between(_t, 2.82, 2.86):
return True, ""
return False, f"Did not expect output {_t} (with input: 0.01)"
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"
else:
info = "Het verschil is niet erg groot, gemiddeld zelfs minder dan 1 straat"
return assertlib.between(outcome, .15, 0.45), info
def correctAverageStartgeld(test):
def try_run():
try:
return lib.getFunction("simuleer_groot_aantal_potjes_Monopoly",
_fileName)(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
def correctAverageStartingMoney(test):
def testMethod():
student_func = lib.getFunction("simulate_monopoly_games", _fileName)
nArguments = len(student_func.arguments)
if nArguments == 2:
testInput = student_func(10000, 1500)
if assertlib.sameType(testInput, None):
test.fail = lambda info: "Make sure that the function simulate_monopoly_games returns the average required number of throws and nothing else"
return testInput
else:
test.fail = lambda info: "Did you implement starting money yet? If not, ignore this frowny."
return 0
test.test = lambda: assertlib.between(testMethod(), 184, 189)
test.description = lambda: "Monopoly works with 1500 euro starting_money"
test.timeout = lambda: 60
def correctAverageStartgeld(test):
def testMethod():
nArguments = len(
lib.getFunction("simuleer_groot_aantal_potjes_monopoly",
_fileName).arguments)
if nArguments == 2:
testInput = lib.getFunction(
"simuleer_groot_aantal_potjes_monopoly", _fileName)(10000,
1500)
if assertlib.sameType(
lib.getFunction("simuleer_groot_aantal_potjes_monopoly",
_fileName)(10000, 1500), 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
else:
return 0
test.test = lambda: assertlib.between(testMethod(), 184, 189)
test.description = lambda: "Monopoly werkt met 1500 euro startgeld"
test.timeout = lambda: 60
def correctAverageTrump(test):
def testMethod():
nArguments = len(
lib.getFunction("simuleer_groot_aantal_potjes_monopoly",
_fileName).arguments)
# Trump
if nArguments == 1:
testInput = lib.getFunction(
"simuleer_groot_aantal_potjes_monopoly", _fileName)(1000)
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"
# Stargeld, 1 speler
elif nArguments == 2:
twoArguments = True
testInput = lib.getFunction(
"simuleer_groot_aantal_potjes_monopoly", _fileName)(1000,
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"
else:
testInput = False
test.fail = lambda info: "Zorg er voor dat de functie simuleer_groot_aantal_potjes_monopoly bij Trumpmode 1 argument heeft en bij starggeld 2 argumenten"
return testInput
test.test = lambda: assertlib.between(testMethod(), 145, 149)
test.test = lambda: testMethod()
test.description = lambda: "Monopoly werkt voor Trumpmode"
test.timeout = lambda: 120
def correctFunc2(test):
test.test = lambda: assertlib.between(
lib.getFunction("montecarlo", _fileName)(lambda x: math.tan(
math.cos(math.sin(x))), 0.2, 0, 2.2, 1.5), 1.69, 1.73)
test.description = lambda: "montecarlo werkt correct wanneer het beginpunt niet gelijk is aan 0"
test.timeout = lambda: 90
def correctFunc1(test):
test.test = lambda: assertlib.between(
lib.getFunction("montecarlo", _fileName)
(lambda x: x**(x + 0.5), 0, 0, 1, 1), 0.51, 0.54)
test.description = lambda: "montecarlo werkt correct voor een simpele functie"
test.timeout = lambda: 90
def correctFunc3(test):
riemann = lib.getFunction("riemann", _fileName)
test.test = lambda: assertlib.between(riemann(1, 0, -2, -1, 1, 1000),
-3.34, -3.33)
test.description = lambda: "riemann() yields the correct value when a function goes below the x-axis"
def correctDice(test):
test.test = lambda: assertlib.between(
lib.getFunction("throw_two_dice", _fileName)(), 2, 12)
test.description = lambda: "returns a correct value for a throw with two dice"
test.timeout = lambda: 200
def correctFunc3(test):
test.test = lambda: assertlib.between(
lib.getFunction("riemann", _fileName)
(lambda x: math.sin(x**2), 0, math.pi, 10000), 0.77, 0.78)
test.description = lambda: "riemann werkt correct voor een functie die onder de x-as komt"
test.timeout = lambda: 90
def testMethod():
montecarlo = lib.getFunction("montecarlo", _fileName)
sin_squared = lib.documentFunction(lambda x: math.sin(x**2),
"f(x) = sin(x**2)")
outcome = montecarlo(sin_squared, 0, -1, math.pi, 1)
return assertlib.between(outcome, 0.75, 0.79)
def testMethod():
montecarlo = lib.getFunction("montecarlo", _fileName)
power = lib.documentFunction(lambda x: x**(x + 0.5),
"f(x) = x**(x + 0.5)")
outcome = montecarlo(power, 0, 0, 1, 1)
return assertlib.between(outcome, 0.51, 0.54)
def correctFunc4(test):
riemann = lib.getFunction("riemann", _fileName)
test.test = lambda: assertlib.between(riemann(-1, 4, 15, -2, 3, 10), 73, 74
)
test.description = lambda: "riemann() yields the correct value of an integral on [-2, 3], with n = 10, for the function -x^2 + 4x + 15"
def correctFunc1(test):
test.test = lambda: assertlib.between(
lib.getFunction("twitter", _fileName)(), 0.82, 0.83)
test.description = lambda: "twitter geeft het juiste antwoord"
test.timeout = lambda: 90
def correctFunc1(test):
test.test = lambda: assertlib.between(
lib.getFunction("riemann", _fileName)
(lambda x: x**(x + 0.5), 0, 1, 10000), 0.52, 0.53)
test.description = lambda: "riemann werkt correct voor een simpele functie"
test.timeout = lambda: 90
def correctFunc2(test):
test.test = lambda: assertlib.between(
lib.getFunction("riemann", _fileName)(lambda x: math.tan(
math.cos(math.sin(x))), 0.2, 2.2, 10000), 1.70, 1.71)
test.description = lambda: "riemann werkt correct wanneer het beginpunt niet gelijk is aan 0"
test.timeout = lambda: 90
def correctFunc3(test):
test.test = lambda: assertlib.between(
lib.getFunction("montecarlo", _fileName)
(lambda x: math.sin(x**2), 0, -1, math.pi, 1), 0.75, 0.79)
test.description = lambda: "montecarlo werkt correct voor een functie die onder de x-as komt"
test.timeout = lambda: 90
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
def correctVierkant(test):
test.test = lambda : assertlib.between(lib.getFunction("vierkant", _fileName)(), 0.51, 0.54)
test.description = lambda : "vierkant geeft de goede afstand terug"
def testMethod():
throw = lib.getFunction("throw", test.fileName)
n = 10000
s = sum(throw() for i in range(n))
return asserts.between(s / n, 6.5, 7.5)
