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}")