def test_2_lisatestit(self):
testset = [
['5', '3.5', '43.75', '8.75', '61.25'],
['1', '2.25', '15.25', '2.5', '17.5'],
['0', '0', '0', '0.0', '0.0'],
]
for a, b, c, d, w in testset:
with patch('builtins.input',
side_effect=[
a, b, c,
AssertionError(
"Syötettä pyydetään liian monta kertaa.")
]) as prompt:
reload_module(self.module)
output = get_stdout()
inputs = f"{a}, {b}, ja {c}"
self.assertFalse(prompt.call_count < 3,
'Ohjelman tulee pyytää kolmea syötettä.')
expected = f"Päivässä {d} euroa"
self.assertTrue(
sanitize(expected) in sanitize(output),
f"Ohjelman tulisi syötteillä {inputs} tulostaa rivi\n{expected}\nohjelmasi tulostus oli\n{output}"
)
expected = f"Viikossa {w} euroa"
self.assertTrue(
sanitize(expected) in sanitize(output),
f"Ohjelman tulisi syötteillä {inputs} tulostaa rivi\n{expected}\nohjelmasi tulostus oli\n{output}"
)
def test_1_nolla(self):
test_input = 32
correct = (test_input - 32) * 5 / 9
with patch('builtins.input', return_value=str(test_input)):
reload_module(self.module)
output = get_stdout().lower().split("\n")
self.assertFalse(
output[-1].find("paleltaa") > -1,
"Ohjelmasi tulosti viestin 'Paleltaa!' vaikka lämpötila celsiuksina ei ole alle nollan."
)
self.assertEqual(
len(output), 1,
"Ohjelmasi tulosti useamman kuin yhden rivin kun syöte on 32")
out = output[0]
e = "32 fahrenheit-astetta on 0.0 celsius-astetta"
e2 = "32.0 fahrenheit-astetta on 0.0 celsius-astetta"
self.assertTrue(
sanitize(out) == sanitize(e) or sanitize(out) == sanitize(e2),
f"Ohjelmasi pitäisi tulostaa\n{e}\nkun syöte on {32}, mutta se tulostaa\n{out}"
)
tulos = float(remove_extra_whitespace(out).split(' ')[-2])
self.assertTrue(
close(tulos, 0.0),
"Ohjelma ei muuntanut lämpötilaa oikein: lopputuloksen pitäisi olla 0.0, mutta ohjelmasi tulostaa "
+ output[0])
def test_lisatestit(self):
testset = [['0', '0'], ['0', '1'], ['13', '4'], ['7', '191'],
['716', '28213']]
for a, b in testset:
with patch('builtins.input',
side_effect=[
a, b,
AssertionError(
"Syötettä pyydetään liian monta kertaa.")
]) as prompt:
reload_module(self.module)
output = get_stdout()
summ = int(a) + int(b)
prod = int(a) * int(b)
inputs = f"{a} ja {b}"
self.assertTrue(
str(summ) in output,
'Syötteillä {} summa laskettu väärin. Odotettiin: {}'.
format(inputs, summ))
self.assertTrue(
str(prod) in output,
'Syötteillä {} tulo laskettu väärin. Odotettiin: {}'.
format(inputs, prod))
expected = f"Lukujen summa {summ}"
self.assertTrue(
sanitize(expected) in sanitize(output),
"Syötteillä {} ohjelmasi tulisi tulostaa: {}".format(
inputs, expected))
expected = f"Lukujen tulo {prod}"
self.assertTrue(
sanitize(expected) in sanitize(output),
"Syötteillä {} ohjelmasi tulisi tulostaa: {}".format(
inputs, expected))
def test_4_lukuja_epakelpo_ja_lopetus(self):
values = "9 4 16 -1 0".split(" ")
correct = "3.0\n2.0\n4.0\nEpäkelpo luku\nLopetetaan..."
with patch('builtins.input', side_effect=values):
try:
reload_module(self.module)
except:
self.assertTrue(
False,
"Varmista, että ohjelmasi toimii syötteellä\n:{}".format(
p(values)))
output = get_stdout()
self.assertTrue(
len(output) > 0,
f"Ohjelmasi ei tulosta mitään syötteellä\n:{p(values)}")
self.assertTrue(
len(output.split("\n")) == 5,
"Ohjelmasi tulostaa kyselyjen lisäksi viiden sijasta {} riviä:\n{}\nkun syöte on\n{}"
.format(len(output.split("\n")), output, p(values)))
self.assertTrue(
sanitize(output) == sanitize(correct),
"Tulostus \n{} \nei vastaa oikeaa tulostetta \n{} \nkun syöte on\n{}"
.format(output, correct, p(values)))
def test_tulostus_1(self):
pieces = "Jarmo,1340"
plist = pieces.split(",")
with patch('builtins.input', side_effect=plist):
reload_module(self.module)
output = get_stdout().strip()
self.assertTrue(
len(output) > 0,
"Ohjelmasi ei tulosta mitään kun syöte on:\nJarmo\n1340")
for piece in plist:
self.assertTrue(
output.find(piece) > -1,
"Tulostuksesta ei löytynyt ollenkaan syötettä " + piece +
" kun syöte on\nJarmo\n1340")
story = plist[0] + " on urhea ritari, syntynyt vuonna " + plist[
1] + "."
story += " Eräänä aamuna " + plist[
0] + " heräsi kovaan meluun: lohikäärme lähestyi kylää. "
story += "Vain " + plist[0] + " voisi pelastaa kylän asukkaat."
output = output.replace("\n", " ")
self.assertTrue(
sanitize(output) == sanitize(story),
"Tulostus ei ole esimerkin mukainen syötteellä\nJarmo\n1340\nTulostit:\n{}\nOotettiin:\n{}"
.format(output, story))
def test_kolme_ja_seitseman(self):
with patch('builtins.input',
side_effect=[
'3', '7',
AssertionError("Syötettä pyydetään liian monta kertaa.")
]) as prompt:
reload_module(self.module)
output = get_stdout()
self.failIf(prompt.call_count < 2,
'Ohjelman tulee pyytää kahta syötettä.')
self.assertTrue(len(output) > 0, 'Ohjelmasi ei tulosta mitään')
self.assertTrue(
'10' in output,
'Ohjelmasi ei tulosta lukujen 3 ja 7 summaa oikein. Odotettiin: 10'
+ '\nohjelmasi tulostus oli\n' + str(output))
self.assertTrue(
'21' in output,
'Ohjelmasi ei tulosta lukujen 3 ja 7 tuloa oikein. Odotettiin: 21'
+ '\nohjelmasi tulostus oli\n' + str(output))
expected = f"Lukujen summa 10"
self.assertTrue(
sanitize(expected) in sanitize(output),
"Syötteillä 3 ja 7 ohjelmasi tulostuksessa pitäisi olla rivi\n{}\nohjelmasi tulostus oli\n{}"
.format(expected, output))
expected = f"Lukujen tulo 21"
self.assertTrue(
sanitize(expected) in sanitize(output),
"Syötteillä 3 ja 7 ohjelmasi tulostuksessa pitäisi olla rivi\n{}\nohjelmasi tulostus oli\n{}"
.format(expected, output))
def test_lisatestit(self):
testset = [
['3', '7', '2', '8'],
['8', '-22', '75', '5'],
['0', '0', '0', '0'],
]
for a, b, c, d in testset:
with patch('builtins.input',
side_effect=[
a, b, c, d,
AssertionError(
"Syötettä pyydetään liian monta kertaa.")
]) as prompt:
reload_module(self.module)
output = get_stdout()
summ = int(a) + int(b) + int(c) + int(d)
avg = summ / 4
inputs = f"{a}, {b}, {c} ja {d}"
self.assertTrue(
str(summ) in output,
'Syötteillä {} summa laskettu väärin. Odotettiin: {}'.
format(inputs, summ))
self.assertTrue(
str(avg) in output,
'Syötteillä {} keskiarvo laskettu väärin. Odotettiin: {}'.
format(inputs, avg))
expected = f"Lukujen summa on {summ} ja keskiarvo {avg}"
self.assertTrue(
sanitize(expected) in sanitize(output),
"Syötteillä {} ohjelmasi tulisi tulostaa\n{}".format(
inputs, expected))
def test_2020(self):
with patch('builtins.input', side_effect= ["2020", AssertionError("Syötettä pyydetään liian monta kertaa.") ], ) as prompt:
reload_module(self.module)
output = get_stdout()
self.assertFalse(len(output) == 0 , f"Ohjelmasi ei tulostanut mitään syötteellä 2024" )
expected = 'Vuotta 2020 seuraava karkausvuosi on 2024'
self.assertEqual(sanitize(expected), sanitize(output), f"Syötteellä\n2020\1ohjelmasi pitäisi tulostaa \n{expected}\nohjelmasi tulosti\n{output}" )
def test_tulostus_2(self):
inputs = "7,2,14"
with patch('builtins.input', side_effect = inputs.split(",")):
reload_module(self.module)
output = get_stdout().strip()
ilist = [int(x) for x in inputs.split(",")]
correct = "Tulo on " + str(reduce(lambda x,y: x * y, ilist))
self.assertTrue(len(output.split("\n")) == 1, "Ohjelmasi ei tulostanut yhtä riviä, vaan " + str(len(output.split("\n"))) + " riviä.")
self.assertEqual(sanitize(output), sanitize(correct), "Ohjelmasi tulosti\n{}\nkun oikea tuloste olisi ollut\n{}\nsyötteillä {}".format(output, correct, inputs))
def test_sadalla_ei_400_jaolliset(self):
values = "500 700 1100 1300 1900".split(" ")
for value in values:
acual_value = int(value) - 2
with patch('builtins.input', return_value = str(acual_value)):
reload_module(self.module)
output = get_stdout()
expected = f'Vuotta {acual_value} seuraava karkausvuosi on {acual_value+6}'
self.assertEqual(sanitize(expected), sanitize(output), f"Syötteellä\n{acual_value}\nohjelmasi pitäisi tulostaa \n{expected}\nohjelmasi tulosti\n{output}" )
def test_yhta_pitkat(self):
values = [("tik", "tok"), ("pekka", "liisa"), ("abcd", "abcd"), ("pupuankka", "apupunkka")]
for test_case in values:
with patch('builtins.input', side_effect = test_case):
reload_module(self.module)
out = get_stdout()
output = out.split("\n")
corr = "Jonot ovat yhtä pitkät"
self.assertTrue(len(out) > 0, "Ohjelmasi ei tulosta mitään syötteillä {}".format(test_case))
self.assertTrue(len(output) == 1, f"Ohjelmasi tulisi tulostaa vain yksi rivi syötteiden lisäksi, nyt se tulostaa {len(output)} riviä.")
self.assertTrue(sanitize(corr) == sanitize(out), f"Tuloste ei ole oikea syötteillä {test_case}: ohjelmasi tulostaa\n{out}\nkun oikea tuloste on\n{corr}")
def test_alle_sata_2(self):
value = randint(1,99)
with patch('builtins.input', return_value = str(value)):
reload_module(self.module)
output = get_stdout().split("\n")
self.assertTrue(len(output) == 2, "Ohjelmasi tulostaa kahden rivin sijasta {} riviä syötteellä {}".format(len(output), value))
self.assertTrue(output[0].find(str(value)) > -1, "Tulosteesta ei löydy oikeaa lukua {} syötteellä {}".format(value, value))
malli = str(value) + " taitaa olla onnenlukuni!"
self.assertEqual(sanitize(output[0]), malli, "Tulosteen 1. rivi ei vastaa mallivastausta {} syötteellä {}. Ohjelmasi tulosti\n{}".format(malli, value,p(output)))
malli = "Hyvää päivänjatkoa!"
self.assertEqual(sanitize(output[1]), malli, "Tulosteen 2. rivi ei vastaa mallivastausta syötteellä {} syötteellä {}. Ohjelmasi tulosti\n{}".format(malli, value, p(output)))
def test_yli_sata_2(self):
value = randint(100,10000)
with patch('builtins.input', return_value = str(value)):
reload_module(self.module)
output = get_stdout().split("\n")
self.assertTrue(len(output) == 5, "Ohjelmasi tulostaa viiden rivin sijasta {} riviä syötteellä {}".format(len(output), value))
self.assertTrue(output[2].find(str(value - 100)) > -1, "Tulosteesta ei löydy pienennettyä lukua {} syötteellä {}. Ohjelmasi tulosti\n{}".format(value - 100, value, p(output)))
self.assertEqual(sanitize(output[0]), "Luku oli suurempi kuin sata", "Tulosteen 1. rivi ei vastaa mallivastausta syötteellä {}. Ohjelmasi tulosti\n{}".format(value, p(output)))
self.assertEqual(sanitize(output[1]), "Nyt luvun arvo on pienentynyt sadalla", "Tulosteen 2. rivi ei vastaa mallivastausta syötteellä {}. Ohjelmasi tulosti\n{}".format(value, p(output)))
self.assertEqual(sanitize(output[3]), str(value - 100) + " taitaa olla onnenlukuni!", "Tulosteen 4. rivi ei vastaa mallivastausta syötteellä {}. Ohjelmasi tulosti\n{}".format(value, p(output)))
self.assertEqual(sanitize(output[4]), "Hyvää päivänjatkoa!", "Tulosteen 5. rivi ei vastaa mallivastausta syötteellä {}. Ohjelmasi tulosti\n{}".format(value, p(output)))
def test_D_53_ja_11(self):
with patch('builtins.input',
side_effect=[
'53', '11',
AssertionError("Syötettä pyydetään liian monta kertaa.")
]) as prompt:
reload_module(self.module)
output = get_stdout()
expected = "Ryhmien määrä: 5"
self.assertTrue(
sanitize(expected) in sanitize(output),
"Syötteillä 53 ja 11 ohjelmasi tulisi tulostaa:\n{}\nohjelmasi tulostus oli\n{}"
.format(expected, output))
def test_toka_pidempi(self):
values = [("eka", "toka"), ("lyhyt", "pidempi"), ("testi", "testaus"), ("xyz", "abcd")]
for test_case in values:
with patch('builtins.input', side_effect = test_case):
try:
reload_module(self.module)
except:
self.assertTrue(False, f"varmista että ohjelmasi toimii syötteellä {test_case}")
out = get_stdout()
output = out.split("\n")
corr = test_case[1] + " on pidempi"
self.assertTrue(len(out) > 0, "Ohjelmasi ei tulosta mitään syötteillä {}".format(test_case))
self.assertTrue(len(output) == 1, f"Ohjelmasi tulisi tulostaa vain yksi rivi syötteiden lisäksi, nyt se tulostaa {len(output)} riviä.")
self.assertTrue(sanitize(corr) == sanitize(out), f"Tuloste ei ole oikea syötteillä {test_case}: ohjelmasi tulostaa\n{out}\nkun oikea tuloste on\n{corr}")
def test_A_8_ja_4(self):
with patch('builtins.input',
side_effect=[
'8', '4',
AssertionError("Syötettä pyydetään liian monta kertaa.")
]) as prompt:
reload_module(self.module)
output = get_stdout()
self.assertFalse(prompt.call_count < 2,
'Ohjelman tulee pyytää kahta syötettä.')
expected = "Ryhmien määrä: 2"
self.assertTrue(len(output) > 0, "Ohjelmasi ei tulosta mitään")
self.assertTrue(
sanitize(expected) in sanitize(output),
"Syötteillä 8 ja 4 ohjelmasi tulisi tulostaa:\n{}\nohjelmasi tulostus oli\n{}"
.format(expected, output))
def test_3_summa(self):
for *inpt, lkm, summa, ka, p, n in testset:
with patch(
'builtins.input',
side_effect=[
*inpt,
AssertionError(
"Syötettä pyydetään liian monta kertaa.")
],
) as prompt:
reload_module(self.module)
output = get_stdout()
expected = f'Lukujen summa {summa}'
self.assertTrue(
sanitize(expected) in sanitize(output),
f"Syötteellä \n{pp(inpt)}\nohjelmasi pitäisi tulostaa\n{expected}\nohjelmasi tulosti\n{output}"
)
def test_5_pelkka_lopetus(self):
values = "0".split(" ")
correct = "Lopetetaan..."
with patch('builtins.input', side_effect=values):
reload_module(self.module)
output = get_stdout()
self.assertTrue(
len(output) > 0,
f"Ohjelmasi ei tulosta mitään syötteellä {p(values)}")
self.assertTrue(
len(output.split("\n")) == 1,
"Ohjelmasi tulostaa kyselyjen lisäksi yhden sijasta {} riviä:\n{}\nkun syöte on\n{}"
.format(len(output.split("\n")), output, p(values)))
self.assertTrue(
sanitize(output) == sanitize(correct),
"Tulostus \n{} \nei vastaa oikeaa tulostetta \n{} \nkun syöte on\n{}"
.format(output, correct, p(values)))
def test_2(self):
with patch(
'builtins.input',
side_effect=[
"1234", "4321",
AssertionError("Syötettä pyydetään liian monta kertaa.")
],
) as prompt:
reload_module(self.module)
output = get_stdout()
inpt = '\n'.join(["1234", "4321"])
expected = 'Väärin\nOikein, tarvitsit 2 yritystä'
self.assertEqual(
sanitize(expected), sanitize(output),
f"Syötteellä\n{inpt}\nohjelmasi pitäisi tulostaa:\n{expected}\nohjelmasi tulosti:\n{output}"
)
def test_2(self):
with patch(
'builtins.input',
side_effect=[
"sekred", "wrong", "sekred",
AssertionError("Syötettä pyydetään liian monta kertaa.")
],
) as prompt:
reload_module(self.module)
output = get_stdout()
inpt = '\n'.join(["sekred", "wrong", "sekred"])
expected = 'Ei ollut sama!\nKäyttäjätunnus luotu!'
self.assertEqual(
sanitize(expected), sanitize(output),
f"Syötteellä \n{inpt}\nohjelmasi pitäisi tulostaa:\n{expected}\nohjelmasi tulosti:\n{output}"
)
def test_tulostus_3(self):
test_input = "Maija Marjukka,Mielikuvitushahmo,Mielikuja 555 as. 234,12121,Tampere"
test_output = "Maija Marjukka Mielikuvitushahmo,Mielikuja 555 as. 234,12121,Tampere".split(
",")
with patch('builtins.input', side_effect=test_input.split(",")):
reload_module(self.module)
output = get_stdout().split("\n")
self.assertTrue(
len(output) == 3,
"Ohjelmasi ei tulostanut 3 riviä vaan " + str(len(output)))
self.assertTrue(
sanitize(output[0]) == sanitize(test_output[0]),
f"Ensimmäinen rivi ei tulostunut oikein.\nOdotettiin\n{test_output[0]}\nrivi oli\n{output[0]}\nOhjelman syöte oli\n{test_input}"
)
for i in range(1, 3):
self.assertEqual(
output[i], test_output[i],
'{}. rivi ei tulostunut oikein oikein syötteillä {}'.
format((i + 1), test_input))
def test_tulostus_2(self):
test_input = "Keijo,Keksitty,Keksikuja 123 A 1,98765,Keksilä"
test_output = "Keijo Keksitty,Keksikuja 123 A 1,98765,Keksilä".split(
",")
with patch('builtins.input', side_effect=test_input.split(",")):
reload_module(self.module)
output = get_stdout().split("\n")
self.assertTrue(
len(output) == 3,
"Ohjelmasi ei tulostanut 3 riviä vaan " + str(len(output)))
self.assertTrue(
sanitize(output[0]) == sanitize(test_output[0]),
f"Ensimmäinen rivi ei tulostunut oikein.\nOdotettiin\n{test_output[0]}\nrivi oli\n{output[0]}\nOhjelman syöte oli\n{test_input}"
)
for i in range(1, 3):
self.assertEqual(
output[i], test_output[i],
'{}. rivi ei tulostunut oikein oikein syötteillä {}'.
format((i + 1), test_input))
def test_3_kolme_ja_ei(self):
values = "jatka joo kyllä ei".split(" ")
with patch('builtins.input', side_effect=values):
reload_module(self.module)
output = get_stdout()
self.assertTrue(
len(output) > 0,
"Ohjelmasi ei tulosta mitään syötteellä:\n{}".format(
p(values)))
correct = "moi\nmoi\nmoi\nmoi\nei sitten"
self.assertTrue(
len(output.split("\n")) == 5,
"Ohjelmasi tulostaa kyselyjen lisäksi viiden sijasta {} riviä: \n{}\nsyötteellä:\n{}"
.format(len(output.split("\n")), output, p(values)))
self.assertTrue(
sanitize(output) == sanitize(correct),
"Tulostus\n{}\nei vastaa oikeaa tulostetta\n{}\nkun syöte on:\n{}"
.format(output, correct, p(values)))
def test_tulostus_1(self):
test_input = "Pekka,Python,Pythonpolku 1,12345 Pythonila"
test_output = "Pekka Python,Pythonpolku 1,12345 Pythonila".split(",")
with patch('builtins.input', side_effect=test_input.split(",")):
reload_module(self.module)
out = get_stdout()
self.assertTrue(len(out) > 0, "Ohjelmasi ei tulosta mitään")
output = out.split("\n")
self.assertTrue(
len(output) == 3,
"Ohjelmasi ei tulostanut 3 riviä vaan " + str(len(output)))
self.assertTrue(
sanitize(output[0]) == sanitize(test_output[0]),
f"Ensimmäinen rivi ei tulostunut oikein.\nOdotettiin\n{test_output[0]}\nrivi oli\n{output[0]}\nOhjelman syöte oli\n{test_input}"
)
for i in range(1, 3):
self.assertEqual(
output[i], test_output[i],
'{}. rivi ei tulostunut oikein oikein syötteillä {}'.
format((i + 1), test_input))
def test_yksittainen_merkki(self):
words = "a X z".split(" ")
for word in words:
with patch('builtins.input', return_value = word):
reload_module(self.module)
output_all = get_stdout()
output = output_all.split("\n")
self.assertFalse(len(output_all)==0, "Ohjelmasi ei tulosta mitään syötteellä " +word)
self.assertTrue(len(output) == 1, "Ohjelmasi tulostaa syötteellä {} yhden rivin sijasta riviä sijasta {} riviä".format(word, len(output)))
self.assertEqual(sanitize(output[0]), "Kiitos!", "Ohjelmasi ei tulosta lopuksi Kiitos! syötteellä " +word)
def test_4_heti_ei(self):
values = ["ei"]
with patch('builtins.input', side_effect=values):
reload_module(self.module)
output = get_stdout()
self.assertTrue(
len(output) > 0,
"Ohjelmasi ei tulosta mitään syötteellä:\n{}".format(
p(values)))
correct = "moi\nei sitten"
self.assertTrue(
len(output.split("\n")) == 2,
"Ohjelmasi tulostaa kahden rivin sijasta {} riviä: \n{}\nkun syöte on:\n{}"
.format(len(output.split("\n")), output, p(values)))
self.assertTrue(
sanitize(output) == sanitize(correct),
"Tulostus\n{}\nei vastaa oikeaa tulostetta\n{}\nkun syöte on:\n{}"
.format(output, correct, p(values)))
def test_1(self):
with patch('builtins.input',
side_effect=[
'4', '2.5', '21.5',
AssertionError("Syötettä pyydetään liian monta kertaa.")
]) as prompt:
reload_module(self.module)
output = get_stdout()
self.assertFalse(prompt.call_count < 2,
'Ohjelman tulee pyytää kolmea syötettä.')
expected = "Päivässä 4.5 euroa"
self.assertTrue(
sanitize(expected) in sanitize(output),
f"Ohjelman tulisi syötteillä 4, 2.5 ja 21.5 tulostaa rivi \n{expected}\nohjelmasi tulostus oli\n{output}"
)
expected = "Viikossa 31.5 euroa"
self.assertTrue(
sanitize(expected) in sanitize(output),
f"Ohjelman tulisi syötteillä 4, 2.5 ja 21.5 tulostaa rivi\n{expected}\nohjelmasi tulostus oli\n{output}"
)
def test_pitkat_sanat(self):
words = "auto helikopteri lentokone mopedi fillari".split(" ")
for word in words:
with patch('builtins.input', return_value = word):
reload_module(self.module)
output_all = get_stdout()
output = output_all.split("\n")
self.assertFalse(len(output_all)==0, "Ohjelmasi ei tulosta mitään syötteellä " +word)
self.assertTrue(len(output) == 2, "Ohjelmasi tulostaa syötteellä {} kahden rivin sijasta {} riviä".format(word, len(output)))
self.assertTrue(output[0].find(str(len(word))) > -1, "Ohjelmasi tulosteesta\n{}\nei löydy oikeaa pituutta {} syötteellä {}".format(output[0], len(word), word))
self.assertEqual(sanitize(output[1]), "Kiitos!", "Ohjelmasi ei tulosta lopuksi Kiitos! syötteellä " +word)
def test3_testaa_str2(self):
test_case = ("South Park", 24, ["Animation", "Comedy"])
try:
from src.sarja import Sarja
koodi = f'Sarja("{test_case[0]}", {test_case[1]}, {test_case[2]})'
sarja = Sarja(test_case[0], test_case[1], test_case[2])
genret = ", ".join(test_case[2])
corr = f'{test_case[0]} ({test_case[1]} esityskautta)\ngenret: {genret}\nei arvosteluja'
val = str(sarja)
self.assertEqual(
sanitize(corr), sanitize(val),
f"Metodin __str__ pitäisi palauttaa merkkijono\n{corr}\nkun olio kutsulla\n"
+ f"{koodi}\nNyt metodi palauttaa merkkijonon\n{val}")
except Exception as e:
self.assertTrue(
False,
f'Metodin __str__ kutsuminen palautti virheen: {e}\nkun olio luotiin kutsulla\n{koodi}'
)
def test_1(self):
with patch(
'builtins.input',
side_effect=[
"4321",
AssertionError("Syötettä pyydetään liian monta kertaa.")
],
) as prompt:
reload_module(self.module)
output = get_stdout()
inpt = '\n'.join(["4321"])
expected = 'Oikein, tarvitsit vain yhden yrityksen!'
self.assertFalse(
len(output) == 0,
f"Syötteellä\n{inpt}\nohjelmasi pitäisi tulostaa:\n{expected}\nohjelmasi ei tulostanut mitään"
)
self.assertEqual(
sanitize(expected), sanitize(output),
f"Syötteellä\n{inpt}\nohjelmasi pitäisi tulostaa:\n{expected}\nohjelmasi tulosti:\n{output}"
)
