Improve primelib.py test coverage #9943

maths/primelib.py

@@ -46,6 +46,19 @@ def is_prime(number: int) -> bool:
     """
     input: positive integer 'number'
     returns true if 'number' is prime otherwise false.
+
+    >>> is_prime(3)
+    True
+    >>> is_prime(10)
+    False
+    >>> is_prime(-1)
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'number' must been an int and positive
+    >>> is_prime("test")
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'number' must been an int and positive
     """
 
     # precondition
@@ -83,6 +96,16 @@ def sieve_er(n):
     This function implements the algorithm called
     sieve of erathostenes.
 
+    >>> sieve_er(8)
+    [2, 3, 5, 7]
+    >>> sieve_er(-1)
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'N' must been an int and > 2
+    >>> sieve_er("test")
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'N' must been an int and > 2
     """
 
     # precondition
@@ -116,6 +139,17 @@ def get_prime_numbers(n):
     input: positive integer 'N' > 2
     returns a list of prime numbers from 2 up to N (inclusive)
     This function is more efficient as function 'sieveEr(...)'
+
+    >>> get_prime_numbers(8)
+    [2, 3, 5, 7]
+    >>> get_prime_numbers(-1)
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'N' must been an int and > 2
+    >>> get_prime_numbers("test")
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'N' must been an int and > 2
     """
 
     # precondition
@@ -142,6 +176,21 @@ def prime_factorization(number):
     """
     input: positive integer 'number'
     returns a list of the prime number factors of 'number'
+
+    >>> prime_factorization(0)
+    [0]
+    >>> prime_factorization(8)
+    [2, 2, 2]
+    >>> prime_factorization(287)
+    [7, 41]
+    >>> prime_factorization(-1)
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'number' must been an int and >= 0
+    >>> prime_factorization("test")
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'number' must been an int and >= 0
     """
 
     # precondition
@@ -183,12 +232,27 @@ def greatest_prime_factor(number):
     """
     input: positive integer 'number' >= 0
     returns the greatest prime number factor of 'number'
+
+    >>> greatest_prime_factor(0)
+    0
+    >>> greatest_prime_factor(8)
+    2
+    >>> greatest_prime_factor(287)
+    41
+    >>> greatest_prime_factor(-1)
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'number' must been an int and >= 0
+    >>> greatest_prime_factor("test")
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'number' must been an int and >= 0
     """
 
     # precondition
     assert isinstance(number, int) and (
         number >= 0
-    ), "'number' bust been an int and >= 0"
+    ), "'number' must been an int and >= 0"
 
     ans = 0
 
@@ -210,12 +274,27 @@ def smallest_prime_factor(number):
     """
     input: integer 'number' >= 0
     returns the smallest prime number factor of 'number'
+
+    >>> smallest_prime_factor(0)
+    0
+    >>> smallest_prime_factor(8)
+    2
+    >>> smallest_prime_factor(287)
+    7
+    >>> smallest_prime_factor(-1)
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'number' must been an int and >= 0
+    >>> smallest_prime_factor("test")
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'number' must been an int and >= 0
     """
 
     # precondition
     assert isinstance(number, int) and (
         number >= 0
-    ), "'number' bust been an int and >= 0"
+    ), "'number' must been an int and >= 0"
 
     ans = 0
 
@@ -237,11 +316,24 @@ def is_even(number):
     """
     input: integer 'number'
     returns true if 'number' is even, otherwise false.
+
+    >>> is_even(0)
+    True
+    >>> is_even(8)
+    True
+    >>> is_even(287)
+    False
+    >>> is_even(-1)
+    False
+    >>> is_even("test")
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'number' must been an int
     """
 
     # precondition
     assert isinstance(number, int), "'number' must been an int"
-    assert isinstance(number % 2 == 0, bool), "compare bust been from type bool"
+    assert isinstance(number % 2 == 0, bool), "compare must been from type bool"
 
     return number % 2 == 0
 
@@ -253,11 +345,24 @@ def is_odd(number):
     """
     input: integer 'number'
     returns true if 'number' is odd, otherwise false.
+
+    >>> is_odd(0)
+    False
+    >>> is_odd(8)
+    False
+    >>> is_odd(287)
+    True
+    >>> is_odd(-1)
+    True
+    >>> is_odd("test")
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'number' must been an int
     """
 
     # precondition
     assert isinstance(number, int), "'number' must been an int"
-    assert isinstance(number % 2 != 0, bool), "compare bust been from type bool"
+    assert isinstance(number % 2 != 0, bool), "compare must been from type bool"
 
     return number % 2 != 0
 
@@ -270,6 +375,23 @@ def goldbach(number):
     Goldbach's assumption
     input: a even positive integer 'number' > 2
     returns a list of two prime numbers whose sum is equal to 'number'
+
+    >>> goldbach(8)
+    [3, 5]
+    >>> goldbach(824)
+    [3, 821]
+    >>> goldbach(0)
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'number' must been an int, even and > 2
+    >>> goldbach(-1)
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'number' must been an int, even and > 2
+    >>> goldbach("test")
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'number' must been an int, even and > 2
     """
 
     # precondition
@@ -323,6 +445,23 @@ def kg_v(number1, number2):
     Least common multiple
     input: two positive integer 'number1' and 'number2'
     returns the least common multiple of 'number1' and 'number2'
+
+    >>> kg_v(8,10)
+    40
+    >>> kg_v(824,67)
+    55208
+    >>> kg_v(0)
+    Traceback (most recent call last):
+        ...
+    TypeError: kg_v() missing 1 required positional argument: 'number2'
+    >>> kg_v(10,-1)
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'number1' and 'number2' must been positive integer.
+    >>> kg_v("test","test2")
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'number1' and 'number2' must been positive integer.
     """
 
     # precondition
@@ -395,6 +534,21 @@ def get_prime(n):
     Gets the n-th prime number.
     input: positive integer 'n' >= 0
     returns the n-th prime number, beginning at index 0
+
+    >>> get_prime(0)
+    2
+    >>> get_prime(8)
+    23
+    >>> get_prime(824)
+    6337
+    >>> get_prime(-1)
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'number' must been a positive int
+    >>> get_prime("test")
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'number' must been a positive int
     """
 
     # precondition
@@ -430,6 +584,25 @@ def get_primes_between(p_number_1, p_number_2):
             pNumber1 < pNumber2
     returns a list of all prime numbers between 'pNumber1' (exclusive)
             and 'pNumber2' (exclusive)
+
+    >>> get_primes_between(3, 67)
+    [5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61]
+    >>> get_primes_between(0)
+    Traceback (most recent call last):
+        ...
+    TypeError: get_primes_between() missing 1 required positional argument: 'p_number_2'
+    >>> get_primes_between(0, 1)
+    Traceback (most recent call last):
+        ...
+    AssertionError: The arguments must been prime numbers and 'pNumber1' < 'pNumber2'
+    >>> get_primes_between(-1, 3)
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'number' must been an int and positive
+    >>> get_primes_between("test","test")
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'number' must been an int and positive
     """
 
     # precondition
@@ -473,6 +646,19 @@ def get_divisors(n):
     """
     input: positive integer 'n' >= 1
     returns all divisors of n (inclusive 1 and 'n')
+
+    >>> get_divisors(8)
+    [1, 2, 4, 8]
+    >>> get_divisors(824)
+    [1, 2, 4, 8, 103, 206, 412, 824]
+    >>> get_divisors(-1)
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'n' must been int and >= 1
+    >>> get_divisors("test")
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'n' must been int and >= 1
     """
 
     # precondition
@@ -497,6 +683,19 @@ def is_perfect_number(number):
     """
     input: positive integer 'number' > 1
     returns true if 'number' is a perfect number otherwise false.
+
+    >>> is_perfect_number(28)
+    True
+    >>> is_perfect_number(824)
+    False
+    >>> is_perfect_number(-1)
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'number' must been an int and >= 1
+    >>> is_perfect_number("test")
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'number' must been an int and >= 1
     """
 
     # precondition
@@ -525,6 +724,15 @@ def simplify_fraction(numerator, denominator):
     input: two integer 'numerator' and 'denominator'
     assumes: 'denominator' != 0
     returns: a tuple with simplify numerator and denominator.
+
+    >>> simplify_fraction(10, 20)
+    (1, 2)
+    >>> simplify_fraction(10, -1)
+    (10, -1)
+    >>> simplify_fraction("test","test")
+    Traceback (most recent call last):
+        ...
+    AssertionError: The arguments must been from type int and 'denominator' != 0
     """
 
     # precondition
@@ -554,6 +762,19 @@ def factorial(n):
     """
     input: positive integer 'n'
     returns the factorial of 'n' (n!)
+
+    >>> factorial(0)
+    1
+    >>> factorial(20)
+    2432902008176640000
+    >>> factorial(-1)
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'n' must been a int and >= 0
+    >>> factorial("test")
+    Traceback (most recent call last):
+        ...
+    AssertionError: 'n' must been a int and >= 0
     """
 
     # precondition
@@ -570,15 +791,27 @@ def factorial(n):
 # -------------------------------------------------------------------
 
 
-def fib(n):
+def fib(n: int) -> int:
     """
     input: positive integer 'n'
     returns the n-th fibonacci term , indexing by 0
 
+    >>> fib(0)
+    1
     >>> fib(5)
     8
+    >>> fib(20)
+    10946
     >>> fib(99)
     354224848179261915075
+    >>> fib(-1)
+    Traceback (most recent call last):
+    ...
+    AssertionError: 'n' must been an int and >= 0
+    >>> fib("test")
+    Traceback (most recent call last):
+    ...
+    AssertionError: 'n' must been an int and >= 0
     """
 
     # precondition