testgenie-py 0.1.0__tar.gz → 0.1.1__tar.gz

{testgenie_py-0.1.0 → testgenie_py-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: testgenie-py
-Version: 0.1.0
+Version: 0.1.1
 Summary: 
 Author: cjseitz
 Author-email: charlesjseitz@gmail.com

{testgenie_py-0.1.0 → testgenie_py-0.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "testgenie-py"
-version = "0.1.0"
+version = "0.1.1"
 description = ""
 authors = ["cjseitz <charlesjseitz@gmail.com>"]
 readme = "README.md"
@@ -9,7 +9,7 @@ readme = "README.md"
 include = "testgen" 
 
 [tool.poetry.scripts]
-testgenie = "main:main"
+testgenie = "testgen.main:main"
 
 [tool.poetry.dependencies]
 python = "^3.10"

testgenie_py-0.1.1/testgen/code_to_test/boolean.py

@@ -0,0 +1,146 @@
+from typing import List
+
+
+def bin_and(a: bool, b: bool) ->bool:
+    """
+    >>> bin_and(True, False)
+    False
+
+    >>> bin_and(False, True)
+    False
+
+    >>> bin_and(False, False)
+    False
+
+    >>> bin_and(True, True)
+    True
+    """
+    if a == True:
+        if b == True:
+            return True
+        else:
+            return False
+    else:
+        return False
+
+
+def bin_xor(a: bool, b: bool) ->bool:
+    """
+    >>> bin_xor(True, True)
+    False
+
+    >>> bin_xor(True, False)
+    True
+
+    >>> bin_xor(False, False)
+    False
+
+    >>> bin_xor(False, True)
+    True
+    """
+    if a == True:
+        if b == True:
+            return False
+        else:
+            return True
+    elif b == True:
+        return True
+    else:
+        return False
+
+
+def status_flags(active: bool, verified: bool, admin: bool) ->str:
+    """
+    >>> status_flags(False, False, False)
+    'inactive'
+
+    >>> status_flags(False, False, True)
+    'admin-unverified'
+
+    >>> status_flags(True, True, False)
+    'user-verified'
+
+    >>> status_flags(True, True, True)
+    'admin-verified'
+
+    >>> status_flags(True, False, False)
+    'user-unverified'
+
+    >>> status_flags(False, True, True)
+    'admin-verified'
+
+    >>> status_flags(False, True, False)
+    'inactive'
+
+    >>> status_flags(True, False, True)
+    'admin-unverified'
+    """
+    if admin:
+        if verified:
+            return 'admin-verified'
+        else:
+            return 'admin-unverified'
+    elif active:
+        if verified:
+            return 'user-verified'
+        else:
+            return 'user-unverified'
+    else:
+        return 'inactive'
+
+
+"""def half_adder(a: bool, b: bool) ->tuple:
+    sum: bool = bin_xor(a, b)
+    carry: bool = bin_and(a, b)
+    return sum, carry
+
+
+def full_adder(a: bool, b: bool, carry_in: bool) ->tuple:
+    sum1, carry = half_adder(a, b)
+    sum2, carry_out = half_adder(sum1, carry_in)
+    return sum2, carry or carry_out
+
+
+def thirty_two_bit_adder_excep(x: int, y: int) ->List[int]:
+    x_bits: List[int] = bit_converter(x)
+    y_bits: List[int] = bit_converter(y)
+    result: List[int] = [0] * 32
+    carry: bool = False
+    for i in range(32):
+        try:
+            sum_bit, carry = 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(x: int, y: int) ->List[int]:
+    print(x.bit_length() - 1)
+    print(y.bit_length() - 1)
+    x_bits: List[int] = bit_converter(x)
+    y_bits: List[int] = bit_converter(y)
+    result: List[int] = [0] * 32
+    carry: bool = False
+    for i in range(32):
+        sum_bit, carry = full_adder(x_bits[i], y_bits[i], carry)
+        result[i] = sum_bit
+    return result
+
+def bit_converter(num: int) ->List[int]:
+    binary_str: str = bin(num)[2:]
+    print(bin(num)[2:])
+    return [int(digit) for digit in binary_str]
+
+def thirty_two_bit_adder_excep(x: int, y: int) ->List[int]:
+    x_bits: List[int] = bit_converter(x)
+    y_bits: List[int] = bit_converter(y)
+    result: List[int] = [0] * 32
+    carry: bool = False
+    for i in range(32):
+        sum_bit, carry = full_adder(x_bits[i], y_bits[i], carry)
+        result[i] = sum_bit
+    return result"""

testgenie_py-0.1.1/testgen/code_to_test/calculator.py

@@ -0,0 +1,29 @@
+class AdvancedCalculator:
+
+    def evaluate(self, a: int, b: int, op: str) ->(int | float | str):
+        """>>> AdvancedCalculator().evaluate(16, 56, 'abc')
+'invalid'"""
+        if op == 'add':
+            return a + b
+        elif op == 'sub':
+            return a - b
+        elif op == 'mul':
+            return a * b
+        elif op == 'div':
+            if b == 0:
+                return 'undefined'
+            return a / b
+        else:
+            return 'invalid'
+
+    def is_in_range(self, val: float) ->str:
+        """>>> AdvancedCalculator().is_in_range(0.4023417704905361)
+'fractional'"""
+        if val < 0.0:
+            return 'below zero'
+        elif 0.0 <= val < 1.0:
+            return 'fractional'
+        elif 1.0 <= val <= 100.0:
+            return 'valid'
+        else:
+            return 'out of range'

testgenie_py-0.1.1/testgen/code_to_test/code_to_fuzz.py

@@ -0,0 +1,234 @@
+from typing import List
+
+
+def bin_and(a: bool, b: bool) ->bool:
+    """"
+    >>> bin_and(True, True)
+    True
+    >>> bin_and(True, False)
+    False
+    >>> bin_and(False, True)
+    False
+    >>> bin_and(False, False)
+    False
+
+    Examples:
+    >>> bin_and(True, False)
+    False"""
+    if a == True:
+        if b == True:
+            return True
+        else:
+            return False
+    else:
+        return False
+
+
+def bin_or(a: bool, b: bool) ->bool:
+    """"
+>>> bin_or(True, True)
+True
+>>> bin_or(True, False)
+True
+>>> bin_or(False, True)
+True
+>>> bin_or(False, False)
+False
+
+Examples:
+>>> bin_or(False, True)
+True"""
+    return a | b
+
+
+def bin_xor(a: bool, b: bool) ->bool:
+    """>>> bin_xor(True, True)
+False
+>>> bin_xor(True, False)
+True
+>>> bin_xor(False, True)
+True
+>>> bin_xor(False, False)
+False
+
+Examples:
+>>> bin_xor(True, True)
+False"""
+    return a ^ b
+
+
+def bin_nand(a: bool, b: bool) ->bool:
+    """>>> bin_nand(True, True)
+False
+>>> bin_nand(True, False)
+True
+>>> bin_nand(False, True)
+True
+>>> bin_nand(False, False)
+True
+
+Examples:
+>>> bin_nand(True, False)
+True"""
+    return not (a and b)
+
+
+def bin_nor(a: bool, b: bool) ->bool:
+    """>>> bin_nor(True, True)
+False
+>>> bin_nor(True, False)
+False
+>>> bin_nor(False, True)
+False
+>>> bin_nor(False, False)
+True
+
+Examples:
+>>> bin_nor(False, True)
+False"""
+    return not a | b
+
+
+def mux(c1: bool, c2: bool, x0: bool, x1: bool, x2: bool, x3: bool) ->bool:
+    """"
+>>> mux(1, 1, True, False, False, False)
+True
+>>> mux(1, 0, False, True, False, False)
+True
+>>> mux(0, 1, False, False, True, False)
+True
+>>> mux(0, 0, False, False, False, True)
+True
+>>> mux(0, 0, False, False, False, False)
+False
+
+Examples:
+>>> mux(False, False, False, False, False, True)
+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(a: bool, b: bool) ->bool:
+    """"
+>>> bin_and(True, True)
+True
+>>> bin_and(True, False)
+False
+>>> bin_and(False, True)
+False
+>>> bin_and(False, False)
+False
+
+Examples:
+>>> bin_and_bad(False, True)
+True"""
+    if a == True and b == True:
+        return a and b
+    return a or b
+
+
+def bin_or_bad(a: bool, b: bool) ->bool:
+    """"
+>>> bin_or(True, True)
+True
+>>> bin_or(True, False)
+True
+>>> bin_or(False, True)
+True
+>>> bin_or(False, False)
+False
+
+Examples:
+>>> bin_or_bad(True, True)
+False"""
+    return not a | b
+
+
+def bit_converter_excep(num: int) ->List[int]:
+    """>>> bit_converter_excep(30)
+[1, 1, 1, 1, 0]"""
+    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(num: int) ->List[int]:
+    """
+    >>> bit_converter(25)
+    [1, 1, 0, 0, 1]
+    """
+    binary_str: str = bin(num)[2:]
+    print(bin(num)[2:])
+    return [int(digit) for digit in binary_str]
+
+
+def half_adder(a: bool, b: bool) ->tuple:
+    """>>> half_adder(True, True)
+(False, True)"""
+    sum: bool = bin_xor(a, b)
+    carry: bool = bin_and(a, b)
+    return sum, carry
+
+
+def full_adder(a: bool, b: bool, carry_in: bool) ->tuple:
+    """>>> full_adder(True, False, False)
+(True, False)"""
+    sum1, carry = half_adder(a, b)
+    sum2, carry_out = half_adder(sum1, carry_in)
+    return sum2, carry or carry_out
+
+
+def thirty_two_bit_adder_excep(x: int, y: int) ->List[int]:
+    """>>> thirty_two_bit_adder_excep(9, 3)
+None
+
+Examples:
+>>> thirty_two_bit_adder_excep(34, 1)
+None"""
+    x_bits: List[int] = bit_converter(x)
+    y_bits: List[int] = bit_converter(y)
+    result: List[int] = [0] * 32
+    carry: bool = False
+    for i in range(32):
+        try:
+            sum_bit, carry = 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(x: int, y: int) ->List[int]:
+    """>>> thirty_two_bit_adder(8, 45)
+None"""
+    print(x.bit_length() - 1)
+    print(y.bit_length() - 1)
+    x_bits: List[int] = bit_converter(x)
+    y_bits: List[int] = bit_converter(y)
+    result: List[int] = [0] * 32
+    carry: bool = False
+    for i in range(32):
+        sum_bit, carry = full_adder(x_bits[i], y_bits[i], carry)
+        result[i] = sum_bit
+    return result
+
+
+def thirty_two_bit_adder_excep(x: int, y: int) ->List[int]:
+    x_bits: List[int] = bit_converter(x)
+    y_bits: List[int] = bit_converter(y)
+    result: List[int] = [0] * 32
+    carry: bool = False
+    for i in range(32):
+        sum_bit, carry = full_adder(x_bits[i], y_bits[i], carry)
+        result[i] = sum_bit
+    return result

testgenie_py-0.1.1/testgen/code_to_test/code_to_fuzz_lite.py

@@ -0,0 +1,397 @@
+def random_fuzz_code(x: int, y: int) -> int:
+    """
+    >>> random_fuzz_code(-2130231320, -1191318765)
+		-3321550085
+    >>> random_fuzz_code(-339569712, -1002922858)
+		663353146
+    """
+
+    result = x
+    if x < y:
+        result += y
+    else:
+        result -= y
+    return result
+
+
+def bin_and(a: bool, b: bool) -> bool:
+    """
+    >>> bin_and(False, False)
+		False
+    >>> bin_and(True, True)
+		True
+    >>> bin_and(True, False)
+		False
+    """
+    if a == True:
+        if b == True:
+            return True
+        else:
+            return False
+    else:
+        return False
+
+
+def pos_or_neg(i: int):
+    """
+    >>> pos_or_neg(1846918201)
+		1
+    >>> pos_or_neg(-1651100677)
+		-1
+    """
+
+    if i > 0:
+        sgn = 1
+    else:
+        sgn = -1
+    if sgn > 0:
+        return 1
+    elif sgn < 0:
+        return -1
+    # else sgn == 0
+    # no return here
+
+
+def int_even(x: int):
+    """
+    >>> int_even(-629738975)
+		False
+    >>> int_even(-418984868)
+		True
+    """
+
+    if x % 2 == 0:
+        return True
+    else:
+        return False
+
+
+def bin_and_bad_generated_function(a: bool, b: bool):
+    """
+    >>> bin_and_bad_generated_function(False, False)
+		False
+    >>> bin_and_bad_generated_function(True, True)
+		True
+    >>> bin_and_bad_generated_function(True, False)
+		True
+    >>> bin_and_bad_generated_function(False, True)
+		True
+    """
+
+    if a == True:
+        if b == True:
+            return True
+        else:
+            return True
+    else:
+        if b == True:
+            return True
+        else:
+            return False
+
+
+def bin_nand_generated_function(a: bool, b: bool):
+    """
+    >>> bin_nand_generated_function(True, False)
+		True
+    >>> bin_nand_generated_function(False, False)
+		True
+    >>> bin_nand_generated_function(False, True)
+		True
+    >>> bin_nand_generated_function(True, True)
+		False
+    """
+
+    if a == True:
+        if b == True:
+            return False
+        else:
+            return True
+    else:
+        if b == True:
+            return True
+        else:
+            return True
+
+
+def bin_nor_generated_function(a: bool, b: bool):
+    """
+    >>> bin_nor_generated_function(False, False)
+		True
+    >>> bin_nor_generated_function(True, False)
+		False
+    >>> bin_nor_generated_function(False, True)
+		False
+    """
+
+    if a == True:
+        if b == True:
+            return False
+        else:
+            return False
+    else:
+        if b == True:
+            return False
+        else:
+            return True
+
+
+def bin_or_generated_function(a: bool, b: bool):
+    """
+    >>> bin_or_generated_function(False, False)
+		False
+    >>> bin_or_generated_function(False, True)
+		True
+    >>> bin_or_generated_function(True, False)
+		True
+    """
+
+    if a == True:
+        if b == True:
+            return True
+        else:
+            return True
+    else:
+        if b == True:
+            return True
+        else:
+            return False
+
+
+def bin_or_bad_generated_function(a: bool, b: bool):
+    """
+    >>> bin_or_bad_generated_function(False, False)
+		True
+    >>> bin_or_bad_generated_function(True, True)
+		False
+    >>> bin_or_bad_generated_function(True, False)
+		False
+    >>> bin_or_bad_generated_function(False, True)
+		False
+    """
+
+    if a == True:
+        if b == True:
+            return False
+        else:
+            return False
+    else:
+        if b == True:
+            return False
+        else:
+            return True
+
+
+def bin_xor_generated_function(a: bool, b: bool):
+    """
+    >>> bin_xor_generated_function(False, False)
+		False
+    >>> bin_xor_generated_function(False, True)
+		True
+    >>> bin_xor_generated_function(True, True)
+		False
+    """
+
+    if a == True:
+        if b == True:
+            return False
+        else:
+            return True
+    else:
+        if b == True:
+            return True
+        else:
+            return False
+
+
+def mux_generated_function(c1: bool, c2: bool, x0: bool, x1: bool, x2: bool, x3: bool):
+    if c1 == True:
+        if c2 == True:
+            if x0 == True:
+                if x1 == True:
+                    if x2 == True:
+                        if x3 == True:
+                            return True
+                        else:
+                            return True
+                    else:
+                        if x3 == True:
+                            return True
+                        else:
+                            return True
+                else:
+                    if x2 == True:
+                        if x3 == True:
+                            return True
+                        else:
+                            return True
+                    else:
+                        if x3 == True:
+                            return True
+                        else:
+                            return True
+            else:
+                if x1 == True:
+                    if x2 == True:
+                        if x3 == True:
+                            return False
+                        else:
+                            return False
+                    else:
+                        if x3 == True:
+                            return False
+                        else:
+                            return False
+                else:
+                    if x2 == True:
+                        if x3 == True:
+                            return False
+                        else:
+                            return False
+                    else:
+                        if x3 == True:
+                            return False
+                        else:
+                            return False
+        else:
+            if x0 == True:
+                if x1 == True:
+                    if x2 == True:
+                        if x3 == True:
+                            return True
+                        else:
+                            return True
+                    else:
+                        if x3 == True:
+                            return True
+                        else:
+                            return True
+                else:
+                    if x2 == True:
+                        if x3 == True:
+                            return False
+                        else:
+                            return False
+                    else:
+                        if x3 == True:
+                            return False
+                        else:
+                            return False
+            else:
+                if x1 == True:
+                    if x2 == True:
+                        if x3 == True:
+                            return True
+                        else:
+                            return True
+                    else:
+                        if x3 == True:
+                            return True
+                        else:
+                            return True
+                else:
+                    if x2 == True:
+                        if x3 == True:
+                            return False
+                        else:
+                            return False
+                    else:
+                        if x3 == True:
+                            return False
+                        else:
+                            return False
+    else:
+        if c2 == True:
+            if x0 == True:
+                if x1 == True:
+                    if x2 == True:
+                        if x3 == True:
+                            return True
+                        else:
+                            return True
+                    else:
+                        if x3 == True:
+                            return False
+                        else:
+                            return False
+                else:
+                    if x2 == True:
+                        if x3 == True:
+                            return True
+                        else:
+                            return True
+                    else:
+                        if x3 == True:
+                            return False
+                        else:
+                            return False
+            else:
+                if x1 == True:
+                    if x2 == True:
+                        if x3 == True:
+                            return True
+                        else:
+                            return True
+                    else:
+                        if x3 == True:
+                            return False
+                        else:
+                            return False
+                else:
+                    if x2 == True:
+                        if x3 == True:
+                            return True
+                        else:
+                            return True
+                    else:
+                        if x3 == True:
+                            return False
+                        else:
+                            return False
+        else:
+            if x0 == True:
+                if x1 == True:
+                    if x2 == True:
+                        if x3 == True:
+                            return True
+                        else:
+                            return False
+                    else:
+                        if x3 == True:
+                            return True
+                        else:
+                            return False
+                else:
+                    if x2 == True:
+                        if x3 == True:
+                            return True
+                        else:
+                            return False
+                    else:
+                        if x3 == True:
+                            return True
+                        else:
+                            return False
+            else:
+                if x1 == True:
+                    if x2 == True:
+                        if x3 == True:
+                            return True
+                        else:
+                            return False
+                    else:
+                        if x3 == True:
+                            return True
+                        else:
+                            return False
+                else:
+                    if x2 == True:
+                        if x3 == True:
+                            return True
+                        else:
+                            return False
+                    else:
+                        if x3 == True:
+                            return True
+                        else:
+                            return False

testgenie_py-0.1.1/testgen/code_to_test/decisions.py

@@ -0,0 +1,57 @@
+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

testgenie_py-0.1.1/testgen/code_to_test/math_utils.py

@@ -0,0 +1,47 @@
+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
+    
+

testgenie_py-0.1.1/testgen/code_to_test/sample_code_bin.py

@@ -0,0 +1,141 @@
+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"""