def test_pitkat_sanat(self):
words = "keinutuolikauppa tosipitkayhdistelma abcdefghijkl melkein20merkkia!!!".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")
correct = get_correct(word)
self.assertFalse(
len(output_all) == 0,
"Ohjelmasi ei tulosta mitään syötteellä " + word)
self.assertTrue(
len(output) == 1,
"Ohjelmasi tulostaa syötteellä {} {} rivin sijasta {} riviä"
.format(word, 1, len(output)))
self.assertTrue(
output_all.count("*") == 20 - len(word),
"Ohjelmasi tulostaa {} tähteä oikean määrän {} sijasta syötteellä {}: \n{}"
.format(output_all.count("*"), (20 - len(word)), word,
output_all))
self.assertTrue(
len(output_all) == 20,
"Tulosteesi pituus on {} merkkiä 20 sijasta. Tulostit\n{}\nOdotettin\n{}"
.format(len(output_all), output_all, correct))
self.assertTrue(
outputs_equal(output_all, correct),
"Ohjelmasi tuloste\n{}\nei vastaa oikeaa tulostetta \n{} \nsyötteellä {}"
.format(output_all, correct, word))
def test_15(self):
with patch('builtins.input',
side_effect=[
'15', 'ei',
AssertionError("Syötettä pyydetään liian monta kertaa.")
]) as prompt:
reload_module(self.module)
output = get_stdout()
syote = "15, ei"
self.assertFalse(prompt.call_count < 1,
'Ohjelman tulee pyytää kahta syötettä.')
self.assertTrue(
housut_tpaita in output,
f"Syötteellä:\n{syote}\nohjelman pitäisi tulostaa rivi\n" +
housut_tpaita + "\nohjelmasi tulostaa\n" + output)
self.assertTrue(
pitkahih in output,
f"Syötteellä:\n{syote}\nohjelman pitäisi tulostaa rivi\n" +
pitkahih + "\nohjelmasi tulostaa\n" + output)
self.assertFalse(
takki in output,
f"Syötteellä:\n{syote}\nohjelman EI pitäisi tulostaa riviä\n" +
takki + "\nohjelmasi tulostaa\n" + output)
self.assertFalse(
lammin_takki in output,
f"Syötteellä:\n{syote}\nohjelman EI pitäisi tulostaa riviä\n" +
lammin_takki + "\nohjelmasi tulostaa\n" + output)
self.assertFalse(
hanskat in output,
f"Syötteellä:\n{syote}\nohjelman EI pitäisi tulostaa riviä\n" +
hanskat + "\nohjelmasi tulostaa\n" + output)
self.assertFalse(
sateenvarjo in output,
f"Syötteellä:\n{syote}\nohjelman EI pitäisi tulostaa riviä\n" +
sateenvarjo + "\nohjelmasi tulostaa\n" + output)
def test_4_toimii_tiedostoilla_4(self):
words = ['opiskelijat4.csv', 'tehtavat4.csv', 'koepisteet4.csv', 'kurssi4.txt']
with patch('builtins.input', side_effect =words + [ AssertionError("Syötettä pyydetään liian monta kertaa.")]):
try:
reload_module(self.module)
output_all = get_stdout()
except:
self.assertTrue(False, f"Varmista, että ohjelmasi voidaan suorittaa syötteellä\n{f(words)}")
exp = """Tietokoneen toiminnan perusteet, 2 opintopistettä
=================================================
nimi teht_lkm teht_pist koe_pist yht_pist arvosana
pekka pelokas 25 6 6 12 0
mirja virtanen 30 7 8 15 1
jane doe 33 8 14 22 3
donald frump 35 8 16 24 4
john doe 36 9 20 29 5
kalle paakkola 16 4 9 13 0
eila kaisla 29 7 19 26 4
antti tuuri 18 4 8 12 0
leena lempinen 26 6 10 16 1
eero honkela 21 5 11 16 1 """
expRows = exp.split('\n')
try:
txt_file = get_content_1()
except:
self.assertTrue(False, f"Ohjelmasi pitää luoda tiedosto tulos.txt syötteellä\n{f(words)}")
for i in range(3):
line = txt_file[i]
self.assertEqual(line.strip(), expRows[i], f"Ohjelmasi luoma tiedosto tulos.txt ei ole kunnossa syötteellä\n{f(words)}\nRivi:\n{line}\nei ole odotetun kaltainen\nSen pitäisi olla:\n{exp}")
self.assertEqual(len(txt_file), len(expRows), f"Ohjelmasi luoma tiedosto tulos.txt ei ole kunnossa syötteellä\n{f(words)}\tiedostossa pitäisi olla {len(expRows)} riviä, riveja on {len(txt_file)}")
for i in range(3, len(expRows)):
line = txt_file[i]
self.assertTrue(line.strip() in exp, f"Ohjelmasi luoma tiedosto tulos.txt ei ole kunnossa syötteellä\n{f(words)}\nrivi\n{line}\nei ole odotetun kaltainen\nTiedoston pitäisi sisältää seuraavat rivit:\n{exp}")
try:
csv_file = get_content_2()
except:
self.assertTrue(False, f"Ohjelmasi pitää luoda tiedosto tulos.csv syötteellä\n{f(words)}")
exp = """12345678;pekka pelokas;0
12345687;mirja virtanen;1
12345699;jane doe;3
12345688;donald frump;4
12345698;john doe;5
12345700;kalle paakkola;0
12345701;eila kaisla;4
12345702;antti tuuri;0
12345704;leena lempinen;1
12345709;eero honkela;1"""
expRows = exp.split('\n')
self.assertEqual(len(csv_file), len(expRows), f"Ohjelmasi luoma tiedosto tulos.csv ei ole kunnossa syötteellä\n{f(words)}\ntiedostossa pitäisi olla {len(expRows)} riviä, riveja on {len(csv_file)}")
for i in range(0, len(expRows)):
line = csv_file[i]
self.assertTrue(line.strip() in exp, f"Ohjelmasi luoma tiedosto tulos.csv ei ole kunnossa syötteellä\n{f(words)}\nrivi\n{line}\nei ole odotetun kaltainen\nTiedoston pitäisi sisältää seuraavat rivit:\n{exp}")
def test_jonot(self):
values = [("moi", "1"), ("abc", 4), ("xyx", 7), ("hei", 2),
("testi", 6)]
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[0] * int(test_case[1])
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.assertEqual(
out.strip(), corr,
f"Tuloste ei ole oikea syötteillä {test_case}: ohjelmasi tulostaa\n{out}\nkun oikea tuloste on\n{corr}"
)
def test_syotteet1(self):
values = (0, 100, -1)
with patch('builtins.input', side_effect=[str(x) for x in values]):
reload_module(self.module)
output = get_stdout()
output_list = output.split("\n")
cor = getcor(values)
mssage = """\nHuomaa, että tässä tehtävässä mitään koodia EI TULE SIJOITTAA lohkon
if __name__ == "__main__":
sisälle
"""
#\n{mssage}")
self.assertTrue(
len(output) > 0,
f"Ohjelmasi ei tulosta mitään kun syöte on {values}\n{mssage}")
self.assertEqual(
len(output_list), len(cor),
f"Ohjelmasi tulisi tulostaa {len(cor)} riviä, nyt se tulostaa {len(output_list)} riviä kun syöte on: {values}"
)
r = 1
for l1, l2 in zip(cor, output_list):
self.assertEqual(
l1.strip(), l2.strip(),
f"Tulostus väärin rivillä {r}: ohjelman pitäisi tulostaa\n{l1}\nmutta se tulostaa\n{l2}\nkun syöte on {values}"
)
r += 1
def test_2_toimii_jos_osoite_ja_numero(self):
syote = [
"3", "Emilia", "Mannerheimintie 100", "1", "Emilia", "044-121212",
"2", "Emilia", "0"
]
with patch('builtins.input', side_effect=syote):
try:
reload_module(self.module)
except:
self.fail(
f"varmista että ohjelma toimii syötteellä\n{s(syote)}")
output = get_stdout()
odotettu = "044-121212"
self.assertTrue(
odotettu in output,
f"Ohjelmasi tulostuksessa pitäisi olla\n{odotettu}\nsyötteellä\n{s(syote)}\nTulostus oli\n{output}"
)
odotettu = "Mannerheimintie 100"
self.assertTrue(
odotettu in output,
f"Ohjelmasi tulostuksessa pitäisi olla\n{odotettu}\nsyötteellä\n{s(syote)}\nTulostus oli\n{output}"
)
odotettu = "numero ei tiedossa"
self.assertFalse(
odotettu in output,
f"Ohjelmasi tulostuksessa EI pitäisi olla\n{odotettu}\nsyötteellä\n{s(syote)}\nTulostus oli\n{output}"
)
odotettu = "osoite ei tiedossa"
self.assertFalse(
odotettu in output,
f"Ohjelmasi tulostuksessa EI pitäisi olla\n{odotettu}\nsyötteellä\n{s(syote)}\nTulostus oli\n{output}"
)
def test_2(self):
luku = 2
with patch(
'builtins.input',
side_effect=[
str(luku),
AssertionError("Syötettä pyydetään liian monta kertaa.")
],
) as prompt:
reload_module(self.module)
output_all = get_stdout()
output = output_all.split('\n')
expected = ["BBB", "BAB", "BBB"]
mssage = """\nHuomaa, että tässä tehtävässä mitään koodia EI TULE SIJOITTAA lohkon
if __name__ == "__main__":
sisälle
"""
#{mssage}")
self.assertTrue(
len(output_all) > 0,
f"Ohjelmasi ei tulosta mitään syötteellä {luku}\n{mssage}")
self.assertEqual(
len(expected), len(output),
f"Ohjelmasi tulisi tulostaa {len(expected)} riviä lukuja syötteellä {luku}, nyt se tulostaa {len(output)} riviä:\n{output_all}"
)
for i in range(0, len(expected)):
self.assertEqual(
expected[i], output[i].strip(),
f"rivin {i+1} tulostus väärin kun syöte on {luku}, rivin pitäisi olla\n{expected[i]}\ntulostit\n{output[0]}"
)
def test4_testaa_attribuuttien_tyypit(self):
with patch('builtins.input',
side_effect=[
AssertionError("Syötteen pyytämistä ei odotettu")
]):
reload_module(self.module)
from src.kirja import Kirja
attributes = (("nimi", str), ("kirjoittaja", str), ("genre", str),
("kirjoitusvuosi", int))
for attr in attributes:
ref = reflect.Reflect()
ref.set_object(
Kirja("Python 1", "Pekka Python", "Tietokirja", 2010))
name, taip = attr
taip_name = str(taip).replace("<class '", "").replace("'>", "")
taip2 = str(type(ref.get_attribute(name))).replace(
"<class '", "").replace("'>", "")
self.assertTrue(
type(ref.get_attribute(name)) == taip,
f"Attribuutin {name} tyypin pitäisi olla {taip_name}, nyt se on {taip2}"
)
def test_lyhyet(self):
words = "auto pallo karkki kone moi se lakki nakki rakki".split(" ")
for word in words:
with patch('builtins.input', return_value=word):
try:
reload_module(self.module)
except:
self.assertTrue(
False,
f"varmista että ohjelmasi toimii syötteellä {word}")
output_all = get_stdout()
output = [
line.strip() for line in output_all.split("\n")
if len(line) > 0
]
correct = get_correct(word)
self.assertFalse(
len(output_all) == 0,
"Ohjelmasi ei tulosta mitään syötteellä " + word)
self.assertTrue(
len(output) == len(word),
"Ohjelmasi tulostaa syötteellä {} {} rivin sijasta {} riviä"
.format(word, len(word), len(output)))
self.assertTrue(
outputs_equal(output_all, correct),
"Ohjelmasi tuloste\n{}\nei vastaa oikeaa tulostetta \n{} \nsyötteellä {}"
.format(output_all, correct, word))
def test_0_arvosanat(self):
values = "50 55 59 60 67 69 70 79 80 89 90 99 100".split(" ")
for value in values:
with patch('builtins.input', return_value=value):
reload_module(self.module)
out = get_stdout()
output = out.split("\n")
self.assertTrue(
len(out) > 0,
"Ohjelmasi ei tulosta mitään syötteellä {}".format(value))
self.assertTrue(
len(output) == 1,
"Ohjelmasi tulostaa yhden rivin sijasta {} riviä: {} kun syöte on {}"
.format(len(output), output, value))
correct = "Arvosana: " + get_grade(int(value))
self.assertTrue(
len(output) == 1,
"Ohjelmasi tulostaa yhden rivin sijasta {} riviä: {} kun syöte on {}"
.format(len(output), output, value))
self.assertEqual(
output[0].strip(), correct,
"Tuloste\n{}\nei vastaa oikeaa tulostetta\n{}\nkun syöte on {}"
.format(output[0], correct, value))
def test5_testaa_attribuuttien_arvot(self):
test_cases = [("Seitsemän veljestä", "Aleksis Kivi", "Romaani", 1870),
("Sinuhe egyptiläinen", "Mika Waltari", "Romaani", 1945),
("Kyberias", "Stanislaw Lem", "Sci-fi", 1965),
("Kotona maailmankaikkeudessa", "Esko Valtaoja", "Tiede",
2001)]
for test_case in test_cases:
with patch('builtins.input',
side_effect=[
AssertionError("Syötteen pyytämistä ei odotettu")
]):
reload_module(self.module)
from src.kirja import Kirja
kirja = Kirja(test_case[0], test_case[1], test_case[2],
test_case[3])
attributes = ("nimi", "kirjoittaja", "genre", "kirjoitusvuosi")
ref = reflect.Reflect()
ref.set_object(kirja)
for i in range(len(attributes)):
value = ref.get_attribute(attributes[i])
self.assertEqual(
value, test_case[i],
f'Attribuutin {attributes[i]} arvon pitäisi olla {test_case[i]}, nyt se on {value},\n kun parametrit olivat \n{test_case}'
)
def test_lauta(self):
with patch('builtins.input', side_effect=["2"] * 100):
for koko in range(3, 60):
reload_module(self.module)
output_alussa = get_stdout()
clear_stdout()
self.module.shakkilauta(koko)
output_all = get_stdout().replace(output_alussa, '', 1)
output = [
l for l in output_all.split("\n") if len(l.strip()) > 0
]
self.assertTrue(
len(output_all) > 0,
f"Funktiokutsu shakkilauta({koko}) ei tulosta mitään")
acual = '\n'.join(output)
self.assertEqual(
koko, len(output),
f"Funktiokutsun shakkilauta({koko}) pitäisi tulostaa {koko} riviä, nyt se tulosti {len(output)} riviä, tulostus oli\n{acual}"
)
for i in range(koko):
rivi = "10" * koko if i % 2 == 0 else "01" * koko
rivi = rivi[0:koko]
self.assertEqual(
rivi, output[i].strip(),
f"Funktiokutsun shakkilauta({koko}) rivin {i} pitäisi olla {rivi}, nyt se on\n{output[i]}\nfunktion koko tulostus oli\n{acual}"
)
def test_4_syotteet(self):
test_cases = "okei ei moikka moido mom".split()
correct = ["ei ollut palindromi"] * 4
correct.append("mom on palindromi!")
with patch('builtins.input', side_effect=test_cases):
reload_module(self.module)
output = [
x.strip().replace(" ", " ") for x in get_stdout().split("\n")
if len(x.strip()) > 0
]
ncorrect = '\n'.join(correct)
noutput = '\n'.join(output)
ntest_cases = '\n'.join(test_cases)
mssage = """\nHuomaa, että tässä tehtävässä mitään koodia EI TULE SIJOITTAA lohkon
if __name__ == "__main__":
sisälle
"""
#\n{mssage}")
self.assertFalse(
len(noutput) == 0,
f"Ohjelmasi ei tulosta mitään testisyötteellä\n{ntest_cases}\n{mssage}"
)
self.assertTrue(
correct == output,
f"Tuloste\n{noutput}\nei vastaa mallivastausta:\n{ncorrect}\nseuraavalla testisyötteellä:\n{ntest_cases}"
)
def test3_testaa_lista1(self):
test_case = [("Seitsemän veljestä", "Aleksis Kivi", "Romaani", 1870),
("Sinuhe egyptiläinen", "Mika Waltari", "Romaani", 1945),
("Kyberias", "Stanislaw Lem", "Sci-fi", 1965),
("Kotona maailmankaikkeudessa", "Esko Valtaoja", "Tiede",
2001)]
genre = "Romaani"
with patch('builtins.input',
side_effect=[
AssertionError("Syötteen pyytämistä ei odotettu")
]):
reload_module(self.module)
genren_kirjat = load(exercise, function, 'fi')
from src.genren_kirjat import Kirja
lista = [Kirja(x[0], x[1], x[2], x[3]) for x in test_case]
corr = sorted([x for x in lista if x.genre == genre],
key=lambda x: x.nimi)
val = sorted(genren_kirjat(lista, genre), key=lambda x: x.nimi)
self.assertEqual(
corr, val,
f"Funktion tulisi palauttaa listassa arvot\n{corr}\n,nyt se palauttaa listan\n{val}\nkun kirjat olivat\n{test_case}"
)
def test_lukuja(self):
values = "0.1 1.34 101.001 12.474747".split(" ")
for value in values:
with patch('builtins.input', return_value=value):
intpart = value[:value.find(".")]
decpart = "0" + value[value.find("."):]
reload_module(self.module)
acual_output = get_stdout()
output = acual_output.split("\n")
self.assertTrue(
len(acual_output) > 0,
"Ohjelmasi ei tulosta mitään syötteellä {}".format(value))
self.assertTrue(
len(output) == 2,
"Ohjelmasi tulostaa kahden rivin sijasta {} riviä syötteellä {}"
.format(len(output), value))
self.assertTrue(
output[0].find(str(intpart)) > -1,
"Tulosteesta {} ei löydy oikeaa kokonaisosaa {} syötteellä {}"
.format(output[0], intpart, value))
self.assertTrue(
output[1].find(str(decpart)) > -1,
"Tulosteesta {} ei löydy oikeaa desimaalisosaa {} syötteellä {}"
.format(output[1], decpart, value))
def test_pitkat(self):
words = "automaattinen superlatiivi ehdottomasti supercalifragilisticexpialidocus".split(
" ")
for word in words:
with patch('builtins.input', return_value=word):
try:
reload_module(self.module)
except:
self.assertTrue(
False,
f"varmista että ohjelmasi toimii syötteellä {word}")
output_all = get_stdout()
output = [
line.strip() for line in output_all.split("\n")
if len(line) > 0
]
correct = get_correct(word)
self.assertFalse(
len(output_all) == 0,
"Ohjelmasi ei tulosta mitään syötteellä " + word)
self.assertTrue(
len(output) == len(word),
"Ohjelmasi tulostaa syötteellä {} {} rivin sijasta {} riviä"
.format(word, len(word), len(output)))
self.assertTrue(
outputs_equal(output_all, correct),
"Ohjelmasi tuloste\n{}\nei vastaa oikeaa tulostetta \n{} \nsyötteellä {}"
.format(output_all, correct, word))
def test_parilliset(self):
testcases = "2 6 8 12 4 18".split()
for testcase in testcases:
with patch('builtins.input', return_value=testcase):
reload_module(self.module)
output_all = get_stdout()
output = [
x.strip() for x in output_all.split("\n")
if len(x.strip()) > 0
]
correct = get_correct(int(testcase))
len_correct = len(correct.split("\n"))
self.assertFalse(
len(output_all) == 0,
"Ohjelmasi ei tulosta mitään syötteellä " + testcase)
self.assertTrue(
len(output) == len_correct,
"Ohjelmasi tulostaa syötteellä ({}) {} rivin sijasta {} riviä: \n{}"
.format(testcase, len_correct, len(output), output_all))
self.assertTrue(
outputs_equal(output_all, correct),
"Ohjelmasi tuloste\n{}\nei vastaa oikeaa tulostetta \n{} \nsyötteellä ({})"
.format(output_all, correct, testcase))
def test_3_listat_1(self):
test_cases = {
(1, 2, 3, 5, 6, 9, 10): 3,
(0, 2, 4, 5, 6, 7, 10, 11, 12, 100, 101): 4,
(1, 3, 5, 7, 10, 11, 14, 15, 19, 20, 21, 22, 23, 24, 25, 30): 7
}
for test_case in test_cases:
with patch('builtins.input',
side_effect=[
AssertionError("Syötteen pyytämistä ei odotettu")
]):
reload_module(self.module)
output_alussa = get_stdout()
pisin_naapurijono = load(exercise, function, 'fi')
correct = test_cases[test_case]
test_case2 = test_case[:]
try:
test_result = pisin_naapurijono(list(test_case))
except:
self.assertTrue(
False,
f"Varmista että metodin suoritus onnistuu parametrilla {test_case2}."
)
self.assertEqual(
correct, test_result,
f"Tulos {test_result} ei vastaa mallivastausta {correct} kutsuttaessa funktiota parametrilla {test_case2}."
)
self.assertEqual(
test_case, test_case2,
f"Funktio ei saa muuttaa alkuperäistä listaa. Arvon pitäisi olla {list(test_case2)} mutta se on {list(test_case)}."
)
def test_lisatestit(self):
testset = ['2020', '1983', '1985']
for vuosi in testset:
with patch('builtins.input', return_value = vuosi):
reload_module(self.module)
output = get_stdout()
self.assertFalse(len(output)>0, f"Syötteellä {vuosi} ohjelman ei pitäisi tulostaa mitään, ohjelmasi kuitenkin tulosti\n"+ output)
def test_2_merkkaa_valmiiksi_poikkeus(self):
reload_module(self.module)
from src.koodi import Tilauskirja, Tehtava
koodi = """
t = Tilauskirja()
t.lisaa_tilaus("koodaa webbikauppa", "Antti", 10)
t.merkkaa_valmiiksi(999)
"""
t = Tilauskirja()
t.lisaa_tilaus("koodaa webbikauppa", "Antti", 10)
til = t.kaikki_tilaukset()
id = til[0].id + 1
koodi += f"\n"
ok = False
try:
t.merkkaa_valmiiksi(id)
except ValueError:
ok = True
except Exception as e:
self.fail(
f'Koodin {koodi}suoritus aiheutti virheen\n{e}\nOnhan metodi merkkaa_valmiiksi(self, id: int) määritelty?'
)
self.assertTrue(
ok,
f'Koodin {koodi}suorituksen pitäisi tuottaa poikkeus ValueError')
def test_4(self):
luku = 4
with patch(
'builtins.input',
side_effect=[
str(luku),
AssertionError(
"Syötettä pyydetään liian monta kertaa.")
],
) as prompt:
reload_module(self.module)
output_all = get_stdout()
output = output_all.split('\n')
expected = [
"DDDDDDD"
"DCCCCCD", "DCBBBCD", "DCBABCD", "DCBBBCD", "DCCCCCD",
"DDDDDDD"
]
self.assertTrue(
len(output_all) > 0,
f"Ohjelmasi ei tulosta mitään syötteellä {luku}")
self.assertEqual(
len(expected), len(output),
f"Ohjelmasi tulisi tulostaa {len(expected)} riviä lukuja syötteellä {luku}, nyt se tulostaa {len(output)} riviä:\n{output_all}"
)
for i in range(0, len(expected)):
self.assertEqual(
expected[i], output[i].strip(),
f"rivin {i+1} tulostus väärin kun syöte on {luku}, rivin pitäisi olla\n{expected[i]}\ntulostit\n{output[0]}"
)
def test_syotteen_tulostus_1(self):
with patch('builtins.input', return_value='Pekka'):
reload_module(self.module)
output = get_stdout()
self.assertTrue(len(output) > 0, "Ohjelmasi ei tulosta mitään!")
assert_ignore_ws(self, output, '!Pekka!Pekka!',
'Ohjelma ei toimi oikein syötteellä: Pekka\n')
def test_3_valmiit_matriisit(self):
test_cases = (([[1, 2, 3], [2, 3, 1],
[4, 5, 6]], 2), ([[1, 5, 5, 3], [2, 5, 2, 5],
[0, 0, 2, 5]], 5), ([[1, 2, 3, 4],
[2, 3, 4, 5],
[3, 4, 6,
5]], 6))
for test_case in test_cases:
with patch('builtins.input',
side_effect=[
AssertionError("Syötteen pyytämistä ei odotettu")
]):
reload_module(self.module)
output_alussa = get_stdout()
laske_alkiot = load(exercise, function, 'fi')
correct = get_correct(test_case[0], test_case[1])
test_case2 = test_case[0][:]
try:
test_result = laske_alkiot(test_case[0], test_case[1])
except:
self.assertTrue(
False,
f"Varmista että funktio toimii kun matriisi on {test_case[0]} ja etsittävä alkio {test_case[1]}"
)
self.assertEqual(
correct, test_result,
f"Tulos {test_result} ei vastaa mallivastausta {correct} kun matriisi on {test_case[0]} ja etsittävä alkio {test_case[1]}"
)
self.assertEqual(
test_case[0], test_case2,
f"Funktio ei saa muuttaa alkuperäistä listaa. Arvon pitäisi olla {test_case2} mutta se on {test_case}."
)
def test3_testaa_listat(self):
test_cases = [[("Mersu", 200), ("Volvo", 180)],
[("Opel", 175), ("Mazda", 185)],
[("Lada", 170), ("Mersu", 155), ("Volvo", 175)],
[("Ferrari", 300), ("Bugatti", 350),
("Lamborghini", 330)],
[("Trabant", 100), ("Lada", 110), ("Skoda", 105),
("Mosse", 95)]]
for test_case in test_cases:
nopeus, maara = -1, 0
for x in test_case:
if x[1] > nopeus:
nopeus = x[1]
maara = 1
elif x[1] == nopeus:
maara += 1
self.assertEqual(
maara, 1, "Virhe testissä: nopein auto ei ole yksikäsitteinen")
with patch('builtins.input',
side_effect=[
AssertionError("Syötteen pyytämistä ei odotettu")
]):
reload_module(self.module)
nopein_auto = load(exercise, function, 'fi')
from src.nopein_auto import Auto
testlist = [Auto(x[0], x[1]) for x in test_case]
val = nopein_auto(testlist)
corr = max(testlist, key=lambda x: x.huippunopeus).merkki
self.assertEqual(
val, corr,
f'Funktion pitäisi palauttaa {corr}, mutta se palauttaa {val} kun testilista on \n{testlist}'
)
def test_3_elokuvat_1(self):
test_cases = (("Linnut", "Alfred Hitchcock", 1963,
119), ("Kummisetä", "Francis Ford Coppola", 1972, 175),
("Tappajahai", "Steven Spielberg", 1975,
124), ("Star Wars", "George Lucas", 1977, 121))
movielist = []
for tc in test_cases:
movielist.append({
x: y
for x, y in zip(("nimi", "ohjaaja", "vuosi", "pituus"), tc)
})
with patch('builtins.input',
side_effect=[
AssertionError("Syötteen pyytämistä ei odotettu")
]):
reload_module(self.module)
output_alussa = get_stdout()
etsi_elokuvat = load(exercise, function, 'fi')
correct = get_correct(movielist, "ta")
answer = etsi_elokuvat(movielist, "ta")
self.assertEqual(
len(correct), len(answer),
f"Tuloksessa pitäisi olla {len(correct)} alkiota;\n{correct}, mutta siinä on {len(answer)} alkiota: \n{answer}\nkun rekisterissä on elokuvat \n{movielist} ja hakusana on 'ta'"
)
self.assertEqual(
correct, answer,
f"Tulos \n{answer}\nei vastaa mallivastausta \n{correct}\nkun rekisterissä on elokuvat \n{movielist}\nja hakusana on 'ta'"
)
def test_3_ei_symmetriset(self):
words = "(5,3) (3,6) (8,4) (5,10)".split(" ")
for word in words:
with patch('builtins.input', side_effect=word[1:-1].split(",")):
reload_module(self.module)
output_all = get_stdout()
output = [
line.strip() for line in output_all.split("\n")
if len(line) > 0
]
correct = get_correct(word)
w, h = [int(x) for x in word[1:-1].split(",")]
self.assertFalse(
len(output_all) == 0,
"Ohjelmasi ei tulosta mitään syötteellä " + word)
self.assertTrue(
len(output[0]) == w,
f"Syötteellä {word} neliön leveyden pitäisi olla {w}, se oli {len(output[0])}. Ohjelmasi tulostus:\n{output_all}"
)
self.assertTrue(
len(output) == h,
f"Syötteellä {word} neliön korkeuden pitäisi olla {h}, se oli {len(output)}. Ohjelmasi tulostus:\n{output_all}"
)
self.assertTrue(
outputs_equal(output_all, correct),
"Ohjelmasi tuloste\n{}\nei vastaa oikeaa tulostetta \n{} \nsyötteellä {}"
.format(output_all, correct, word))
def test_tulostus_3(self):
luku = 451
with patch('builtins.input', return_value=str(luku)):
reload_module(self.module)
output = get_stdout().split("\n")
if luku < 1000:
self.assertEqual(
output[0], "Luku on pienempi kuin 1000",
"Ohjelmasi ei tulostanut, että luku on pienempi kuin 1000 luvulle "
+ str(luku))
if luku < 100:
self.assertTrue(
len(output) > 1,
"Ohjelmasi ei tulostanut\nLuku on pienempi kuin 100\nLuvulle "
+ str(luku))
self.assertEqual(
output[1], "Luku on pienempi kuin 100",
"Ohjelmasi ei tulostanut, että luku on pienempi kuin 100 luvulle "
+ str(luku))
if luku < 10:
self.assertTrue(
len(output) > 2,
"Ohjelmasi ei tulostanut\nLuku on pienempi kuin 10\nLuvulle "
+ str(luku))
self.assertEqual(
output[2], "Luku on pienempi kuin 10",
"Ohjelmasi ei tulostanut, että luku on pienempi kuin 10 luvulle "
+ str(luku))
self.assertEqual(
output[-1], "Kiitos!",
"Ohjelmasi ei tulostanut lopuksi riviä 'Kiitos!'")
def test_syotteet(self):
values = "2 3 7 5".split()
for test_case in values:
with patch('builtins.input', side_effect=[test_case]):
reload_module(self.module)
output = get_stdout()
output_list = output.split("\n")
cor = [
str(x) for x in range(-(int(test_case)),
int(test_case) + 1) if x != 0
]
mssage = """\nHuomaa, että tässä tehtävässä mitään koodia EI TULE SIJOITTAA lohkon
if __name__ == "__main__":
sisälle
"""
#\n{mssage}")
self.assertTrue(
len(output) > 0,
f"Ohjelmasi ei tulosta mitään kun syöte on {test_case}\n{mssage}"
)
self.assertEqual(
len(output_list), len(cor),
f"Ohjelmasi tulisi tulostaa syötteiden kysymisen lisäksi {len(cor)} riviä, nyt se tulostaa {len(output_list)} riviä kun syöte on {test_case}"
)
r = 1
for l1, l2 in zip(output_list, cor):
self.assertEqual(
l1.strip(), l2,
f"Ohjelmasi tulisi tulostaa rivillä {r} \n{l2} \nmutta nyt se tulostaa \n{l1}\nkun syöte on {test_case}"
)
r += 1
def test_2_lukuja(self):
testcases = [
"3 0", "2 4 6 5 -1", "1 2 3 7 6 -10", "5 4 3 8 0", "2 -1",
"9 8 10 11 0"
]
for testcase in testcases:
with patch('builtins.input', side_effect=testcase.split(" ")):
reload_module(self.module)
output_all = get_stdout().replace(" ", " ").replace(
" ", " ").replace(" ", " ").replace(" ", " ")
output = [
x.strip() for x in output_all.split("\n")
if len(x.strip()) > 0
]
correct = get_correct(testcase.split(" "))
len_correct = len(correct.split("\n"))
self.assertFalse(
len(output_all) == 0,
"Ohjelmasi ei tulosta mitään syötteellä:\n" + f(testcase))
self.assertTrue(
len(output) == len_correct,
"Ohjelmasi tulostaa syötteellä {}{} rivin sijasta {} riviä: \n{}"
.format(f(testcase), len_correct, len(output), output_all))
self.assertTrue(
outputs_equal(output_all, correct),
"Ohjelmasi tuloste\n{}\nei vastaa oikeaa tulostetta \n{} \nsyötteellä:{}"
.format(output_all, correct, f(testcase)))
def test_1(self):
for luku in [3, 5, 7, 10, 13, 17, 21, 1001]:
with patch(
'builtins.input',
side_effect=[
str(luku),
AssertionError(
"Syötettä pyydetään liian monta kertaa.")
],
) as prompt:
reload_module(self.module)
output_all = get_stdout()
output = output_all.split('\n')
self.assertTrue(
len(output_all) > 0,
f"Ohjelmasi ei tulosta mitään syötteellä {luku}")
self.assertEqual(
luku - 1, len(output),
f"Ohjelmasi tulisi tulostaa {luku-1} riviä lukuja syötteellä {luku}, nyt se tulostaa {len(output)} riviä:\n{output_all}"
)
inpt = str(luku)
for i in range(1, luku):
expected = str(i)
self.assertEqual(
str(i), output[i - 1],
f"rivin {i} tulostus väärin kun syöte on {luku}")
