From 11be18cf078f12b3e852df6cda995085fd757901 Mon Sep 17 00:00:00 2001 From: Filip Gralinski Date: Sat, 14 Nov 2020 20:44:19 +0100 Subject: [PATCH] up --- intro/Task102Test.py | 2 +- intro/Task103Test.py | 2 +- intro/Task104Test.py | 37 ++++++++++++++++++++++++++ intro/Task105Test.py | 50 +++++++++++++++++++++++++++++++++++ intro/Task106Test.py | 43 ++++++++++++++++++++++++++++++ intro/Task107Test.py | 40 ++++++++++++++++++++++++++++ intro/Task108Test.py | 39 +++++++++++++++++++++++++++ intro/Task109Test.dat.txt | 8 ++++++ intro/Task109Test.py | 31 ++++++++++++++++++++++ intro/Task110Test.dat.in.txt | 6 +++++ intro/Task110Test.dat.out.txt | 6 +++++ intro/Task110Test.py | 46 ++++++++++++++++++++++++++++++++ 12 files changed, 308 insertions(+), 2 deletions(-) create mode 100755 intro/Task104Test.py create mode 100755 intro/Task105Test.py create mode 100755 intro/Task106Test.py create mode 100755 intro/Task107Test.py create mode 100755 intro/Task108Test.py create mode 100644 intro/Task109Test.dat.txt create mode 100755 intro/Task109Test.py create mode 100644 intro/Task110Test.dat.in.txt create mode 100644 intro/Task110Test.dat.out.txt create mode 100755 intro/Task110Test.py diff --git a/intro/Task102Test.py b/intro/Task102Test.py index d067c31..a814690 100755 --- a/intro/Task102Test.py +++ b/intro/Task102Test.py @@ -9,7 +9,7 @@ Napisz funkcję `add_three_numbers` zwracającą sumę trzech liczb całkowitych NAME: add_three_numbers PARAMS: int, int, int RETURN: int -POINTS: 3 +POINTS: 1 """ import unittest diff --git a/intro/Task103Test.py b/intro/Task103Test.py index 3d1e843..fd8633d 100755 --- a/intro/Task103Test.py +++ b/intro/Task103Test.py @@ -12,7 +12,7 @@ liczba 0. NAME: probability PARAMS: double RETURN: double -POINTS: 2 +POINTS: 1 """ diff --git a/intro/Task104Test.py b/intro/Task104Test.py new file mode 100755 index 0000000..58546fe --- /dev/null +++ b/intro/Task104Test.py @@ -0,0 +1,37 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 104 + +Napisz funkcję `sum_from_one_to_n` zwracającą sume kwadratów liczb od 1 do `n`. +Jeśli podany argument jest mniejszy od 1 powinna być zwracana wartość 0. + +NAME: sum_from_one_to_n +PARAMS: int +RETURN: int +POINTS: 1 +""" + +import unittest +from Task104 import sum_from_one_to_n + +class Task104Test(unittest.TestCase): + """Testy do zadania 104""" + + def test_special_cases(self): + """Testy przypadków szczególnych.""" + self.assertEqual(sum_from_one_to_n(-100), 0) + self.assertEqual(sum_from_one_to_n(-1), 0) + self.assertEqual(sum_from_one_to_n(0), 0) + self.assertEqual(sum_from_one_to_n(1), 1) + self.assertEqual(sum_from_one_to_n(2), 5) + + def test_regular(self): + """Testy dla kilku liczb""" + self.assertEqual(sum_from_one_to_n(3), 14) + self.assertEqual(sum_from_one_to_n(4), 30) + + +if __name__ == '__main__': + unittest.main() diff --git a/intro/Task105Test.py b/intro/Task105Test.py new file mode 100755 index 0000000..9f83c31 --- /dev/null +++ b/intro/Task105Test.py @@ -0,0 +1,50 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 105 + +Napisz funkcję `is_almost_prime(number, limit)` sprawdzającą, czy +podana liczba nie dzieli się przez żadną liczbę z zakresu od 2 do +`limit`. Dla liczb ujemnych powinna zostać zwrócona wartość `True`. + +NAME: is_almost_prime +PARAMS: int, int +RETURN: bool +POINTS: 1 +""" + +import unittest +from Task105 import is_almost_prime + +class Task105Test(unittest.TestCase): + """Testy do zadania 105""" + + def test_simple(self): + """Proste testy""" + self.assertTrue(is_almost_prime(35, 4)) + self.assertFalse(is_almost_prime(35, 5)) + self.assertFalse(is_almost_prime(35, 100)) + self.assertTrue(is_almost_prime(17, 4)) + self.assertTrue(is_almost_prime(17, 16)) + self.assertFalse(is_almost_prime(17, 17)) + self.assertFalse(is_almost_prime(17, 100)) + self.assertFalse(is_almost_prime(16, 2)) + self.assertFalse(is_almost_prime(16, 5)) + self.assertFalse(is_almost_prime(16, 13)) + self.assertFalse(is_almost_prime(16, 101)) + + def test_special_cases(self): + """Testy przypadków szczególnych.""" + self.assertTrue(is_almost_prime(-1, 10)) + self.assertFalse(is_almost_prime(0, 8)) + self.assertTrue(is_almost_prime(1, 6)) + self.assertFalse(is_almost_prime(2, 2)) + + def test_negatives(self): + """Testy dla liczb ujemnych.""" + self.assertTrue(is_almost_prime(-5, 100)) + self.assertTrue(is_almost_prime(-13, 5)) + +if __name__ == '__main__': + unittest.main() diff --git a/intro/Task106Test.py b/intro/Task106Test.py new file mode 100755 index 0000000..e1dd63c --- /dev/null +++ b/intro/Task106Test.py @@ -0,0 +1,43 @@ +#!/usr/bin/python2 +# -*- coding: utf-8 -*- + +""" +Zadanie 106 + +Napisz funkcję freq_dic(sequence), która zlicza liczbę wystąpień +elementów dla dowolnego typu sekwencyjnego. Funkcja powinna zwracać +słownik, w którym klucze odpowiadają elementom, a wartości liczbie +elementów. Dla łańcucha "abracadabra" wynikiem jest: + +{"a":5, "b":2, "c":1, "d":1, "r":2} + +NAME: freq_dic +PARAMS: sequence +RETURN: dictionary +POINTS: 1 +""" + +import unittest +from Task106 import freq_dic + +class Task106Test(unittest.TestCase): + """Testy do zadania 106""" + + def test_string(self): + """Test na napisie.""" + self.assertEqual(freq_dic("abracadabra"), {"a": 5, "b": 2, "c": 1, "d": 1, "r": 2}) + + def test_number_list(self): + """Test na liście liczb.""" + self.assertEqual(freq_dic([1, 1, 2, 1, 10, 20, 2]), {1: 3, 2: 2, 10: 1, 20: 1}) + + def test_tuple(self): + """Test na krotce.""" + self.assertEqual(freq_dic((1, 2, 3, 1)), {1: 2, 2: 1, 3: 1}) + + def test_empty(self): + """Test na pustej liście.""" + self.assertEqual(freq_dic([]), { }) + +if __name__ == '__main__': + unittest.main() diff --git a/intro/Task107Test.py b/intro/Task107Test.py new file mode 100755 index 0000000..6a87512 --- /dev/null +++ b/intro/Task107Test.py @@ -0,0 +1,40 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 107 + +Napisz funkcję `list_squared(list)` zwracającą sumę kwadratów +zadanych liczb. Dla listy pustej powinna zostać zwrócona wartość zero. + +NAME: list_squared +PARAMS: list +RETURN: obj +POINTS: 1 +""" + +import unittest +from Task107 import list_squared + +class Task107Test(unittest.TestCase): + """Testy do zadania 107""" + + def test_simple(self): + """Prosty test.""" + self.assertEqual(list_squared([3, 0, -1, 2]), 14), + + def test_empty(self): + """Test na pustej liście.""" + self.assertEqual(list_squared([]), 0), + + def test_singleton(self): + """Test na liście jednoelementowej.""" + self.assertEqual(list_squared([-4]), 16) + + def test_two_elements(self): + """Test na liście dwuelementowej.""" + self.assertEqual(list_squared([100, -100]), 20000) + self.assertEqual(list_squared([2, 10]), 104) + +if __name__ == '__main__': + unittest.main() diff --git a/intro/Task108Test.py b/intro/Task108Test.py new file mode 100755 index 0000000..f3da705 --- /dev/null +++ b/intro/Task108Test.py @@ -0,0 +1,39 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 108 + +Napisz funkcję `leet_speak`, która podmienia w podanym napisie +niektóre litery na podobnie wyglądające cyfry: 'e' na '3', 'l' na '1', +'o' na '0', 't' na '7'. Np. `leet('leet')` powinno zwrócić '1337'. + +NAME: leet_speak +PARAMS: string +RETURN: string +POINTS: 1 +""" + +import unittest +from Task108 import leet_speak + +class Task108Test(unittest.TestCase): + """Testy do zadania 108.""" + + def test_special_cases(self): + """Przypadki szczególne.""" + self.assertEqual(leet_speak(''), '') + self.assertEqual(leet_speak('x'), 'x') + self.assertEqual(leet_speak('o'), '0') + self.assertEqual(leet_speak('banan'), 'banan') + self.assertEqual(leet_speak('1337'), '1337') + self.assertEqual(leet_speak('admin1'), 'admin1') + + def test_standard_cases(self): + """Standardowe przypadki.""" + self.assertEqual(leet_speak('leet'), '1337') + self.assertEqual(leet_speak('mouse'), 'm0us3') + self.assertEqual(leet_speak('do not want'), 'd0 n07 wan7') + +if __name__ == '__main__': + unittest.main() diff --git a/intro/Task109Test.dat.txt b/intro/Task109Test.dat.txt new file mode 100644 index 0000000..89fe8a4 --- /dev/null +++ b/intro/Task109Test.dat.txt @@ -0,0 +1,8 @@ +raz +dwa +YES +cztery +YES +YES +YES +tego YES nie liczyć diff --git a/intro/Task109Test.py b/intro/Task109Test.py new file mode 100755 index 0000000..18bce39 --- /dev/null +++ b/intro/Task109Test.py @@ -0,0 +1,31 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 109 + +Napisz funkcję `count_yes_lines(filename)`, która po podaniu nazwy pliku +tekstowego `filename` zwraca liczbę wierszy w pliku zawierających +(wyłącznie) napis "YES" (i znak końca wiersza). + +NAME: count_yes_lines +PARAMS: string +RETURN: int +POINTS: 1 +""" +import unittest +from Task109 import count_yes_lines + +class Task109Test(unittest.TestCase): + """Testy do zadania 109.""" + + def test_on_self(self): + """Testy na samym sobie.""" + self.failUnlessEqual(count_yes_lines("Task109Test.py"), 0) + + def test_simple(self): + """Testy na prostym pliku.""" + self.failUnlessEqual(count_yes_lines("Task109Test.dat.txt"), 4) + +if __name__ == '__main__': + unittest.main() diff --git a/intro/Task110Test.dat.in.txt b/intro/Task110Test.dat.in.txt new file mode 100644 index 0000000..ce0360c --- /dev/null +++ b/intro/Task110Test.dat.in.txt @@ -0,0 +1,6 @@ +this is a string +Ala ma kota +blablabla + +nic +pies, czyli kot diff --git a/intro/Task110Test.dat.out.txt b/intro/Task110Test.dat.out.txt new file mode 100644 index 0000000..b872e0c --- /dev/null +++ b/intro/Task110Test.dat.out.txt @@ -0,0 +1,6 @@ +4 2 1 6 +3 2 4 +9 + +3 +5 5 3 diff --git a/intro/Task110Test.py b/intro/Task110Test.py new file mode 100755 index 0000000..1b86f8f --- /dev/null +++ b/intro/Task110Test.py @@ -0,0 +1,46 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +""" +Zadanie 110 + +Napisz funkcję `words_to_length(infile, outfile)`, która wczytując +wiersze z pliku `infile` i wypisując je do pliku `outfile`, zamienia +wyrazy na liczbę odpowiadającą długości wyrazu. Np. wiersz `this is a +string` zostanie zamieniony na `4 2 1 6`. Zakładamy, że wyrazy +oddzielone są spacjami (np. dla `pies, czyli kot` powinno wyjść `5 5 +3`). + +NAME: word_to_length +PARAMS: file, file +RETURN: string +POINTS: 1 +""" + +import unittest +from Task110 import word_to_length + +class Task110Test(unittest.TestCase): + """Testy do zadania 110""" + + def test(self): + """Prosty test przez porównanie z oczekiwanym wyjściem.""" + infile = open("Task110Test.dat.in.txt", 'r') + + out1 = open("Task110Test.out.txt", 'w') + word_to_length(infile, out1) + infile.close() + out1.close() + + out1 = open("Task110Test.out.txt", 'r') + out2 = open("Task110Test.dat.out.txt", 'r') + + for line1 in out1: + line2 = out2.readline() + self.assertEqual( line1, line2 ) + + out1.close() + out2.close() + +if __name__ == '__main__': + unittest.main()