testgenie-py 0.3.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

testgen/code_to_test/decisions.py

@@ -1,57 +0,0 @@
-def password_strength(pwd: str) ->str:
-    """>>> password_strength('abc')
-'weak'"""
-    if len(pwd) < 6:
-        return 'weak'
-    elif len(pwd) < 10:
-        if any(c.isdigit() for c in pwd):
-            return 'medium'
-        else:
-            return 'weak'
-    elif any(c.isdigit() for c in pwd) and any(c.isupper() for c in pwd):
-        return 'strong'
-    else:
-        return 'medium'
-
-
-def email_type(email: str) ->str:
-    """>>> email_type('abc')
-'invalid'"""
-    if not email or '@' not in email:
-        return 'invalid'
-    elif email.endswith('@school.edu'):
-        return 'school'
-    elif email.endswith('@company.com'):
-        return 'work'
-    elif email.endswith('@gmail.com') or email.endswith('@yahoo.com'):
-        return 'personal'
-    else:
-        return 'unknown'
-
-
-def http_code(code: int) ->str:
-    """>>> http_code(85)
-'invalid'"""
-    if code < 100 or code > 599:
-        return 'invalid'
-    elif 100 <= code < 200:
-        return 'informational'
-    elif 200 <= code < 300:
-        return 'success'
-    elif 300 <= code < 400:
-        return 'redirection'
-    elif 400 <= code < 500:
-        return 'client error'
-    else:
-        return 'server error'
-
-
-def add_or_subtract(x: int, y: int) ->int:
-    """>>> add_or_subtract(87, 100)
-187"""
-    result = x
-    if x < y:
-        result += y
-    else:
-        result -= y
-    return result

testgen/code_to_test/math_utils.py

@@ -1,47 +0,0 @@
-def categorize_number(n: int) -> str:
-    if n < 0:
-        return "negative"
-    elif n == 0:
-        return "zero"
-    elif 0 < n < 10:
-        return "small"
-    elif 10 <= n < 100:
-        return "medium"
-    else:
-        return "large"
-
-def complex_divide(a: int, b: int) -> float:
-    if b == 0:
-        return float("inf")
-    elif a == 0:
-        return 0.0
-    elif a == b:
-        return 1.0
-    elif a > b:
-        return a / b
-    else:
-        return -1 * (a / b)
-    
-def pos_or_neg(i: int) -> int:
-    if i > 0:
-        sgn = 1
-    else:
-        sgn = -1
-    if sgn > 0:
-        return 1
-    elif sgn < 0:
-        return -1
-    
-def is_even(x: int) -> bool:
-    if x % 2 == 0:
-        return True
-    else:
-        return False
-    
-def is_odd(x: int) -> bool:
-    if x % 2 != 0:
-        return True
-    else:
-        return False
-    
-

testgen/code_to_test/sample_code_bin.py

@@ -1,141 +0,0 @@
-from typing import List
-
-class SampleCodeBin:
-    def bin_and(self, a: bool, b: bool) -> bool:
-        """
-        >>> SampleCodeBin().bin_and(False, False)
-        False
-        """
-        return a and b
-
-    def bin_or(self, a: bool, b: bool) -> bool:
-        """
-        >>> SampleCodeBin().bin_or(False, False)
-        False
-        """
-        return a | b
-
-    def bin_xor(self, a: bool, b: bool) -> bool:
-        """
-        >>> SampleCodeBin().bin_xor(True, True)
-        False
-        """
-        return a ^ b
-
-    def bin_nand(self, a: bool, b: bool) -> bool:
-        """
-        >>> SampleCodeBin().bin_nand(True, False)
-        True
-        """
-        return not(a and b)
-
-    def bin_nor(self, a: bool, b:bool) -> bool:
-        """
-        >>> SampleCodeBin().bin_nor(True, False)
-        False
-        """
-        return not(a | b)
-
-    def mux(self, c1: bool, c2: bool, x0: bool, x1: bool, x2: bool, x3: bool) -> bool:
-        """
-        >>> SampleCodeBin().mux(True, True, True, False, True, False)
-        True
-        """
-        return (c1 and c2 and x0) | (c1 and (not(c2)) and x1) | (not(c1) and c2 and x2) | (not(c1) and not(c2) and x3)
-
-    def bin_and_bad(self, a: bool, b: bool) -> bool:
-        """
-        >>> SampleCodeBin().bin_and_bad(True, True)
-        True
-        >>> SampleCodeBin().bin_and_bad(False, True)
-        True
-        """
-        if(a == True and b == True):
-            return a and b
-        return a or b
-
-    def bin_or_bad(self, a: bool, b: bool) -> bool:
-        """
-        >>> SampleCodeBin().bin_or_bad(False, False)
-        True
-        """
-        return not(a | b)
-
-    """def bit_converter_excep(self, num: int) -> List[int]:
-        # binary_str: str = bin(num)[2:]
-        bs = bin(num)
-        binary_str = bs[2:]
-        try:
-            return [int(digit) for digit in binary_str]
-        except Exception as e:
-            print(binary_str)
-            print(bs)
-            print(f"Invalid Literal Exception in Bit Converter: {e}")
-            return
-
-    def bit_converter(self, num: int) -> List[int]:
-        binary_str: str = bin(num)[2:]
-        return [int(digit) for digit in binary_str]
-
-    def half_adder(self, a: bool, b: bool) -> tuple:
-        sum: bool = self.bin_xor(a, b)
-        carry: bool = self.bin_and(a, b)
-        return (sum, carry)
-
-    def full_adder(self, a: bool, b: bool, carry_in: bool) -> tuple:
-        sum1, carry = self.half_adder(a, b)
-        sum2, carry_out = self.half_adder(sum1, carry_in)
-        return (sum2, carry or carry_out)
-
-    def thirty_two_bit_adder_excep(self, x: int, y: int) -> List[int]:
-        x_bits: List[int] = self.bit_converter(x)
-        y_bits: List[int] = self.bit_converter(y)
-        result: List[int] = [0] * 32
-        carry: bool = False
-
-        for i in range(32):
-            try: 
-                sum_bit, carry = self.full_adder(x_bits[i], y_bits[i], carry)
-                result[i] = sum_bit
-            except IndexError as e:
-                print(f"Index Out of Bounds Error In ThirtyTwoBitAdder: {e}")
-                result = [1] * 32
-
-            if carry:
-                return OverflowError("Sum exceeds 32 bits")
-
-        return result
-
-    def thirty_two_bit_adder(self, x: int, y: int) -> List[int]:
-        print(x.bit_length() - 1)
-        print(y.bit_length() -1)
-        x_bits: List[int] = self.bit_converter(x)
-        y_bits: List[int] = self.bit_converter(y)
-
-        #if(len(x_bits) > 32 or len(y_bits) >= 32):
-        #    print(f"Length of bit list greater than 32")
-
-        result: List[int] = [0] * 32
-        carry: bool = False
-
-        for i in range(32):
-            sum_bit, carry = self.full_adder(x_bits[i], y_bits[i], carry)
-            result[i] = sum_bit
-
-        return result
-
-
-    def thirty_two_bit_adder_excep(self, x: int, y: int) -> List[int]:
-        #print(x.bit_length - 1)
-        #peint(x.bit_length - 1)
-        x_bits: List[int] = self.bit_converter(x)
-        y_bits: List[int] = self.bit_converter(y)
-
-        result: List[int] = [0] * 32
-        carry: bool = False
-
-        for i in range(32):
-            sum_bit, carry = self.full_adder(x_bits[i], y_bits[i], carry)
-            result[i] = sum_bit
-
-        return result"""

testgen/tests/test_code_to_fuzz.py

@@ -1,263 +0,0 @@
-import unittest
-
-import testgen.code_to_test.code_to_fuzz as code_to_fuzz
-
-class TestNone(unittest.TestCase):  
-
-   def test_random_fuzz_code_0(self):
-      args = (1927227313, 775789320)
-      expected = 1151437993
-      result = code_to_fuzz.random_fuzz_code(*args)
-      self.assertEqual(result, expected)
-
-   def test_random_fuzz_code_1(self):
-      args = (1359311181, 1603562853)
-      expected = 2962874034
-      result = code_to_fuzz.random_fuzz_code(*args)
-      self.assertEqual(result, expected)
-
-   def test_bin_and_2(self):
-      args = (False, False)
-      expected = False
-      result = code_to_fuzz.bin_and(*args)
-      self.assertEqual(result, expected)
-
-   def test_bin_and_3(self):
-      args = (True, True)
-      expected = True
-      result = code_to_fuzz.bin_and(*args)
-      self.assertEqual(result, expected)
-
-   def test_bin_and_4(self):
-      args = (True, False)
-      expected = False
-      result = code_to_fuzz.bin_and(*args)
-      self.assertEqual(result, expected)
-
-   def test_pos_or_neg_5(self):
-      args = 1381971091
-      expected = 1
-      result = code_to_fuzz.pos_or_neg(args)
-      self.assertEqual(result, expected)
-
-   def test_pos_or_neg_6(self):
-      args = -1792272568
-      expected = -1
-      result = code_to_fuzz.pos_or_neg(args)
-      self.assertEqual(result, expected)
-
-   def test_int_even_7(self):
-      args = 612556544
-      expected = True
-      result = code_to_fuzz.int_even(args)
-      self.assertEqual(result, expected)
-
-   def test_int_even_8(self):
-      args = 1538337835
-      expected = False
-      result = code_to_fuzz.int_even(args)
-      self.assertEqual(result, expected)
-
-   def test_http_code_9(self):
-      args = 1748799535
-      expected = 'invalid'
-      result = code_to_fuzz.http_code(args)
-      self.assertEqual(result, expected)
-
-   def test_add_or_subtract_10(self):
-      args = (1167731537, 1136934405)
-      expected = 30797132
-      result = code_to_fuzz.add_or_subtract(*args)
-      self.assertEqual(result, expected)
-
-   def test_add_or_subtract_11(self):
-      args = (506636609, 1260222214)
-      expected = 1766858823
-      result = code_to_fuzz.add_or_subtract(*args)
-      self.assertEqual(result, expected)
-
-   def test_bin_and_bad_generated_function_12(self):
-      args = (False, False)
-      expected = False
-      result = code_to_fuzz.bin_and_bad_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_bin_and_bad_generated_function_13(self):
-      args = (True, True)
-      expected = True
-      result = code_to_fuzz.bin_and_bad_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_bin_and_bad_generated_function_14(self):
-      args = (False, True)
-      expected = True
-      result = code_to_fuzz.bin_and_bad_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_bin_nand_generated_function_15(self):
-      args = (False, False)
-      expected = True
-      result = code_to_fuzz.bin_nand_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_bin_nand_generated_function_16(self):
-      args = (True, True)
-      expected = False
-      result = code_to_fuzz.bin_nand_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_bin_nand_generated_function_17(self):
-      args = (True, False)
-      expected = True
-      result = code_to_fuzz.bin_nand_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_bin_nand_generated_function_18(self):
-      args = (False, True)
-      expected = True
-      result = code_to_fuzz.bin_nand_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_bin_nor_generated_function_19(self):
-      args = (True, True)
-      expected = False
-      result = code_to_fuzz.bin_nor_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_bin_nor_generated_function_20(self):
-      args = (False, True)
-      expected = False
-      result = code_to_fuzz.bin_nor_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_bin_nor_generated_function_21(self):
-      args = (True, False)
-      expected = False
-      result = code_to_fuzz.bin_nor_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_bin_or_generated_function_22(self):
-      args = (False, True)
-      expected = True
-      result = code_to_fuzz.bin_or_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_bin_or_generated_function_23(self):
-      args = (True, False)
-      expected = True
-      result = code_to_fuzz.bin_or_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_bin_or_generated_function_24(self):
-      args = (True, True)
-      expected = True
-      result = code_to_fuzz.bin_or_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_bin_or_generated_function_25(self):
-      args = (False, False)
-      expected = False
-      result = code_to_fuzz.bin_or_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_bin_or_bad_generated_function_26(self):
-      args = (False, True)
-      expected = False
-      result = code_to_fuzz.bin_or_bad_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_bin_or_bad_generated_function_27(self):
-      args = (True, True)
-      expected = False
-      result = code_to_fuzz.bin_or_bad_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_bin_or_bad_generated_function_28(self):
-      args = (False, False)
-      expected = True
-      result = code_to_fuzz.bin_or_bad_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_bin_or_bad_generated_function_29(self):
-      args = (True, False)
-      expected = False
-      result = code_to_fuzz.bin_or_bad_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_bin_xor_generated_function_30(self):
-      args = (True, True)
-      expected = False
-      result = code_to_fuzz.bin_xor_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_bin_xor_generated_function_31(self):
-      args = (True, False)
-      expected = True
-      result = code_to_fuzz.bin_xor_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_bin_xor_generated_function_32(self):
-      args = (False, True)
-      expected = True
-      result = code_to_fuzz.bin_xor_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_bin_xor_generated_function_33(self):
-      args = (False, False)
-      expected = False
-      result = code_to_fuzz.bin_xor_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_mux_generated_function_34(self):
-      args = (True, False, False, True, False, False)
-      expected = True
-      result = code_to_fuzz.mux_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_mux_generated_function_35(self):
-      args = (False, True, False, False, True, False)
-      expected = True
-      result = code_to_fuzz.mux_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_mux_generated_function_36(self):
-      args = (True, False, False, False, True, True)
-      expected = False
-      result = code_to_fuzz.mux_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_mux_generated_function_37(self):
-      args = (False, True, False, True, False, True)
-      expected = False
-      result = code_to_fuzz.mux_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_mux_generated_function_38(self):
-      args = (False, False, True, False, True, False)
-      expected = False
-      result = code_to_fuzz.mux_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_mux_generated_function_39(self):
-      args = (True, False, False, False, False, False)
-      expected = False
-      result = code_to_fuzz.mux_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_mux_generated_function_40(self):
-      args = (False, True, True, True, True, True)
-      expected = True
-      result = code_to_fuzz.mux_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_mux_generated_function_41(self):
-      args = (False, False, False, True, False, False)
-      expected = False
-      result = code_to_fuzz.mux_generated_function(*args)
-      self.assertEqual(result, expected)
-
-   def test_mux_generated_function_42(self):
-      args = (True, False, True, True, True, False)
-      expected = True
-      result = code_to_fuzz.mux_generated_function(*args)
-      self.assertEqual(result, expected)