testgenie-py 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

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/no_types.py

@@ -1,35 +0,0 @@
-def bin_and(a, b):
-    if a == True:
-        if b == True:
-            return True
-        else:
-            return False
-    else:
-        return False
-
-
-def bin_xor(a, b):
-    if a == True:
-        if b == True:
-            return False
-        else:
-            return True
-    elif b == True:
-        return True
-    else:
-        return False
-
-
-def status_flags(active, verified, admin):
-    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'

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"""