New Homework

HNC/Exercises/Prime_Generator/testing_prime_numbers.py

@@ -0,0 +1,93 @@
+def verify(message, expected, actual):
+    a = "========================="
+    print(a)
+    print(message)
+    if type(actual) != type(expected) or actual != expected:
+        print("FAILED!")
+
+        print(f"Expected value: {expected}")
+        print(f"Actual value: {actual}")
+
+        print(a)
+        return False
+    else:
+        print("SUCCESS!")
+        print(a)
+        return True
+    
+
+def verify_all(dataset):
+    summa_success = int()
+    summa_failed = int()
+    for result in dataset:
+        if verify(result[0], result[1], result[2]):
+            summa_success += 1
+        else:
+            summa_failed += 1
+    print("Total:", len(dataset), "\nSuccessful:", summa_success, "\nFailed:", summa_failed)
+    return True
+
+# def prime_generator(n):
+#     primes = []
+#     if type(n) is int and n >= 2:
+#         sieve = [True] * n
+#         for i in range(2, n-1):
+#             if sieve:
+#                 for j in range(2*i, n, i):
+#                     sieve[j] = False
+#         for p in range(2, n):
+#             if sieve[p]:
+#                 primes.append(p)
+#         return primes
+#     else:
+#         return False
+    
+# dataset3 = [
+#     ("genarator1", [2, 3, 5, 7, 11, 13, 17, 19, 23, 29], prime_generator(30)),
+#     ("genarator2", [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47], prime_generator(50)),
+#     ("genarator3", [2, 3, 5, 7, 11, 13], prime_generator(15)),
+#     ("genarator4", [2, 3, 5, 7], prime_generator(10)),
+# ]
+
+# verify_all(dataset3)
+
+def prime_generator(n):
+    primes = []
+    if type(n) is int and n >= 2:
+        sieve = [True] * n
+        for i in range(2, n + 1):
+            if sieve:
+                for j in range(2*i, n, i):
+                    sieve[j] = False
+        for p in range(2, n):
+            if sieve[p]:
+                primes.append(p)
+        return primes
+    else:
+        return []
+
+
+
+dataset = [  # Проверочные тесты, что вообще что-то работает
+    ("prime_generator0", ([]), prime_generator(2)),
+    ("prime_generator1", ([2, 3, 5, 7, 11, 13]), prime_generator(15)),
+    ("prime_generator2", ([2]), prime_generator(3)),
+    ("prime_generator3", ([]), prime_generator(-2)),
+    ("prime_generator4", ([2, 3, 5, 7]), prime_generator(10)),
+
+    # Тесты на пустые значения
+    ("prime_generator5", ([]), prime_generator('')),
+    ("prime_generator6", ([]), prime_generator(None)),
+
+    # Тесты на неверный тип
+    ("prime_generator7", ([]), prime_generator("jvfenfrufrfur")),
+    ("prime_generator8", ([]), prime_generator(True)),
+
+    # Тесты на редкие случаи
+    ("prime_generator_with_float_number", ([]), prime_generator(1.5)),
+    ("prime_generator_with_numbers_in_array", ([]), prime_generator([23])),
+    ("prime_generator11", ([]), prime_generator(' ..,..,,2')),
+]
+
+
+verify_all(dataset)

HNC/Exercises/Selfmade_Testing/testing.py

@@ -1,4 +1,13 @@
+import re
+import numpy as np
+
 def sum_dataset(dataset_number):
+    if dataset_number is None:
+        return -1, -1
+
+    if not isinstance(dataset_number, str):
+        return -1, -1
+    
     sum = 0
 
     for a in dataset_number:
@@ -14,34 +23,89 @@ def upper_letter_count(dataset_sentence):
     return upper
 
 def lower_letter_count(dataset_sentence):
+    if dataset_sentence is None:
+        return -1, -1
+
+    if not isinstance(dataset_sentence, str):
+        return -1, -1
+    
     lower = 0
+
     for count in dataset_sentence:
         if count.islower():
             lower += 1
+
     return lower
 
 def sum_letters_in_sentence(dataset_sentence):
-    lower=0
+
-    upper=0
+    if dataset_sentence is None:
-    result = lower + upper
+        return -1, -1
+
+    if not isinstance(dataset_sentence, str):
+        return -1, -1
+
+    lower = 0
+    upper = 0
+
     for count in dataset_sentence:
-        if(count.islower()):
+        if count.isalpha():
-            lower+=1
+            if count.islower():
-        else:
+                lower += 1
-            upper+=1
+            else:
-    return result 
+                upper += 1
+
+    return upper, lower 
+
+def word_count(text):
+
+    if text is None:
+        return []
+
+    if not isinstance(text, str):
+        return []
+
+    c = []
+    final = {}
+    a = re.sub("[^А-Яа-я-A-Z-a-z ]", " ", text).lower()
+    b = str(a).split()
+    c = list(b)
+    unique_array, count_array = np.unique(c, return_counts=True)
+    final = zip(unique_array, count_array)
+    final2 = list(final)
+    return final2
 
 ########################################################################################################################
 
-def verify(message, actual, expected):
+def verify(message, expected, actual):
+    a = "========================="
+    print(a)
     print(message)
-    if actual != expected:
+    if type(actual) != type(expected) or actual != expected:
-        print("=======> FAILED! <=======")
+        print("FAILED!")
-        print(f"Got value <{actual}>")
+
-        print(f"Expected value is <{expected}>")
+        print(f"Expected value: {expected}")
+        print(f"Actual value: {actual}")
+
+        print(a)
+        return False
     else:
         print("SUCCESS!")
-    print()
+        print(a)
+        return True
+    
+
+def verify_all(dataset):
+    summa_success = int()
+    summa_failed = int()
+    for result in dataset:
+        if verify(result[0], result[1], result[2]):
+            summa_success += 1
+        else:
+            summa_failed += 1
+    print("Total:", len(dataset), "\nSuccessful:", summa_success, "\nFailed:", summa_failed)
+    return True
+
 
 dataset_sentence1 = ["My Year was so Great, but it was hard!"]
 dataset_sentence2 = ["HeakfhZUWmvbhfPEHFHT123"]
@@ -57,39 +121,50 @@ dataset_number1 = [23, 34, 89, 12, -12, 92, 123, 9, 204, -34, -100, 34, 19, 67,
 dataset_number2 = [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
 dataset_number3 = [927, 142, -816, 682, -6599, 1000, -8, 334, 0, 6654, -8361, 555, 121, 680]
 
-sum_dataset_test = [dataset_number1, dataset_number2, dataset_number3, [], [0]]
-upper_letter_count_test = [dataset_sentence1, dataset_sentence2, dataset_sentence3, '']
-lower_letter_count_test = [dataset_sentence4, dataset_sentence5, dataset_sentence6, '']
-sum_letters_in_sentence_test = [dataset_sentence7, dataset_sentence8, dataset_sentence9, '']
-
 ########################################################################################################################
 
-for i in range(len(sum_dataset_test)):
+dataset = [# Проверочные тесты, что вообще что-то работает
-    result = sum_dataset(sum_dataset_test[i])
+            ("slis0", (4, 6), sum_letters_in_sentence("АаБбВвГгдд")),
-    expected = sum(sum_dataset_test[i])
+            ("slis1", (6, 4), sum_letters_in_sentence("AaBbCcDdEE")),
-    verify(f"SUM_DATASET TEST {i+1}", result, expected)
+            ("slis2", (10, 10), sum_letters_in_sentence("AaBbCcDdEEАаБбВвГгдд")),
-
+            ("slis3", (10, 10), sum_letters_in_sentence("A aBbC cDdEE АаБб ВвГг дд")),
-########################################################################################################################
+            ("slis4", (10, 10), sum_letters_in_sentence("Aa,.BbCc%&§DdEEА&/(аБбВвГгдд")),
-
+
-for i in range(len(upper_letter_count_test)):
+            # Тесты на пустые значения
-    sentence = upper_letter_count_test[i]
+            ("slis5", (0, 0), sum_letters_in_sentence('')),
-    expected_result = sum(1 for letter in sentence if letter.isupper()) if isinstance(sentence, str) else 0
+            ("slis6", (-1, -1), sum_letters_in_sentence(None)),
-    verify(f"UPPER_LETTER_COUNT TEST {i+1}", upper_letter_count(sentence), expected_result)
+
-
+            # Тесты на неверный тип
-########################################################################################################################
+            ("slis7", (-1, -1), sum_letters_in_sentence(123)),
-
+            ("slis8", (-1, -1), sum_letters_in_sentence(True)),
-for i in range(len(lower_letter_count_test)):
+
-    sentence = lower_letter_count_test[i]
+            # Тесты на редкие случаи
-    expected_result = sum(1 for letter in sentence if letter.islower()) if isinstance(sentence, str) else 0
+            ("slis9", (0, 0), sum_letters_in_sentence('123')),
-    verify(f"LOWER_LETTER_COUNT TEST {i+1}", lower_letter_count(sentence), expected_result)
+            ("slis10", (0, 1), sum_letters_in_sentence('a')),
-
+            ("slis11", (1, 0), sum_letters_in_sentence('B')),
-########################################################################################################################        
+            ("slis12", (0, 0), sum_letters_in_sentence(' ')),
-
+        ]
-for i in range(len(sum_letters_in_sentence_test)):
+
-    sentence = sum_letters_in_sentence_test[i]
+dataset2 = [# Проверочные тесты, что вообще что-то работает
-    expected_upper = sum(1 for letter in sentence if letter.isupper()) if isinstance(sentence, str) else 0
+            ("word_count0", [('нашел', 1), ('пришел', 1), ('ушел', 1), ('я', 3)], word_count('Я пришел, я ушел, я нашел')),
-    expected_lower = sum(1 for letter in sentence if letter.islower()) if isinstance(sentence, str) else 0
+            ("word_count1", [('слово', 4), ('точно', 1)], word_count("Слово: Слово! Точно слово? Слово...")),
-    expected_result = expected_upper + expected_lower
+
-    verify(f"SUM_LETTERS_IN_SENTENCE TEST {i+1}", sum_letters_in_sentence(sentence), expected_result)
+            # Тесты на пустые значения
+            ("word_count2", [], word_count('')),
+            ("word_count3", [], word_count(None)),
+
+            # Тесты на неверный тип
+            ("word_count4", [], word_count(123)),
+            ("word_count5", [], word_count(True)),
+
+            # Тесты на редкие случаи
+            ("word_count6", [('слово', 1)], word_count("Слово")),
+            ("word_count7", [('слово', 1)], word_count("Слово ")),
+            ("word_count8", [('слово', 1)], word_count(" Слово")),
+            ("word_count9", [('слово', 2)], word_count("Слово.Слово")),
+           ]
+
+# verify_all(dataset)
+# verify_all(dataset2)
 
 ########################################################################################################################