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

testgen/service/service.py

@@ -1,12 +1,18 @@
+import doctest
+import importlib
 import inspect
 import json
 import os
 import re
 import sqlite3
+import sys
 import time
 import subprocess
+import testgen.util.coverage_utils as coverage_utils
 from types import ModuleType
 from typing import List
+
+import testgen
 import testgen.util.file_utils as file_utils
 
 from testgen.models.test_case import TestCase
@@ -50,11 +56,6 @@ class Service:
             # Create a dummy DB service that doesn't do anything
             self.db_service = None
 
-    def select_all_from_db(self) -> None:
-        rows = self.db_service.get_test_suites()
-        for row in rows:
-            print(repr(dict(row)))
-
     def generate_test_cases(self) -> List[TestCase] | None:
         module = file_utils.load_module(self.file_path)
         class_name = self.analysis_service.get_class_name(module)
@@ -155,36 +156,22 @@ class Service:
         
         try:
             if self.test_format == UNITTEST_FORMAT:
-                subprocess.run(["python", "-m", "coverage", "run", "--source=.", "-m", "unittest", test_file], check=True)
-                result = subprocess.run(
-                    ["python", "-m", "coverage", "report", file_path_to_use], 
-                    check=True, 
-                    capture_output=True, 
-                    text=True
-                )
-                coverage_output = result.stdout
+                self.execute_and_store_unittest(file_path_to_use, test_file)
             elif self.test_format == PYTEST_FORMAT:
-                subprocess.run(["python", "-m", "coverage", "run", "--source=.", "-m", "pytest", test_file], check=True)
-                result = subprocess.run(
-                    ["python", "-m", "coverage", "report", file_path_to_use], 
-                    check=True,
-                    capture_output=True,
-                    text=True
-                )
-                coverage_output = result.stdout
+                self.execute_and_store_pytest(test_file)
             elif self.test_format == DOCTEST_FORMAT:
-                result = subprocess.run(
-                    ["python", "-m", "coverage", "run", "--source=.", "-m", "doctest", "-v", test_file], 
-                    check=True,
-                    capture_output=True,
-                    text=True
-                )
-                coverage_output = result.stdout
+                self.execute_and_store_doctest(test_file)
             else:
-                raise ValueError("Unsupported test format for coverage analysis.")
-                
+                raise ValueError("Unsupported test format for test results.")
+
+            #Run coverage analysis
+            subprocess.run(["python", "-m", "coverage", "run", "--source=.", test_file], check=True)
+            result = subprocess.run(["python", "-m", "coverage", "report", file_path_to_use], check=True, capture_output=True, text=True)
             self._save_coverage_data(coverage_output, file_path_to_use)
-            
+            coverage_output = result.stdout
+
+            self._save_coverage_data(coverage_output, file_path_to_use)
+
         except subprocess.CalledProcessError as e:
             raise RuntimeError(f"Error running coverage subprocess: {e}")
 
@@ -426,4 +413,109 @@ class Service:
 
     def debug(self, message: str):
         if self.debug_mode:
-            self.logger.debug(message)
+            self.logger.debug(message)
+
+    def _get_test_case_id(self, test_case_name: str) -> int:
+        """
+        Retrieve the test case ID from the database based on the test case name.
+        Insert the test case if it does not exist.
+        """
+        if self.db_service is None:
+            raise RuntimeError("Database service is not initialized.")
+
+        # Query the database for the test case ID
+        self.db_service.cursor.execute(
+            "SELECT id FROM TestCase WHERE name = ?",
+            (test_case_name,)
+        )
+        result = self.db_service.cursor.fetchone()
+
+        if result:
+            return result[0]  # Return the test case ID
+        else:
+            # Insert the test case into the database
+            self.db_service.cursor.execute(
+                "INSERT INTO TestCase (name) VALUES (?)",
+                (test_case_name,)
+            )
+            self.db_service.conn.commit()
+            return self.db_service.cursor.lastrowid
+
+    def execute_and_store_pytest(self, test_file):
+        import pytest
+        from _pytest.reports import TestReport
+
+        class PytestResultPlugin:
+            def __init__(self, db_service, get_test_case_id):
+                self.db_service = db_service
+                self.get_test_case_id = get_test_case_id
+
+            def pytest_runtest_logreport(self, report: TestReport):
+                if report.when == "call":
+                    test_case_id = self.get_test_case_id(report.nodeid)
+                    status = report.outcome == "passed"
+                    error_message = report.longreprtext if report.outcome == "failed" else None
+                    self.db_service.insert_test_result(test_case_id, status, error_message)
+
+        pytest.main([test_file], plugins=[PytestResultPlugin(self.db_service, self._get_test_case_id)])
+
+        pytest.main([test_file])
+
+    def execute_and_store_unittest(self, file_path_to_use, test_file):
+        import unittest
+        loader = unittest.TestLoader()
+        print(f"Discovering tests in: {os.path.dirname(file_path_to_use)} with pattern: {os.path.basename(test_file)}")
+        test_module = os.path.relpath(test_file,
+                                      start=os.getcwd())  # Get relative path from the current working directory
+        test_module = test_module.replace("/", ".").replace("\\", ".").rstrip(".py")  # Convert to module name
+        if test_module.startswith("."):
+            test_module = test_module[1:]  # Remove leading dot if present
+        print(f"Test module: {test_module}")
+        suite = loader.loadTestsFromName(test_module)
+        runner = unittest.TextTestRunner()
+        result = runner.run(suite)
+
+        for test_case, traceback in result.failures + result.errors:
+            test_case_id = self._get_test_case_id(str(test_case))
+            self.db_service.insert_test_result(test_case_id, status=False, error=traceback)
+
+        successful_tests = set(str(test) for test in suite) - set(
+            str(test) for test, _ in result.failures + result.errors)
+        for test_case in successful_tests:
+            test_case_id = self._get_test_case_id(str(test_case))
+            self.db_service.insert_test_result(test_case_id, status=True, error=None)
+
+    def execute_and_store_doctest(self, test_file):
+        module_name = os.path.splitext(os.path.basename(test_file))[0]
+        spec = importlib.util.spec_from_file_location(module_name, test_file)
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[module_name] = module
+        spec.loader.exec_module(module)
+
+        # Now run doctests on the loaded module
+        result = doctest.testmod(module)
+
+        test_case_id = self._get_test_case_id(test_file)
+        status = result.failed == 0
+        error_message = f"{result.failed} of {result.attempted} tests failed" if result.failed > 0 else None
+        self.db_service.insert_test_result(test_case_id, status, error_message)
+
+    def query_test_file_data(self, test_file_name: str):
+        if self.db_service is None:
+            raise RuntimeError("Database service is not initialized.")
+
+        results = self.db_service.get_test_file_data(test_file_name)
+        if not results:
+            print(f"No data found for file: {test_file_name}")
+            return
+
+        from tabulate import tabulate
+        rows = [dict(row) for row in results]
+
+        print(f"Results for file: {test_file_name}")
+        print(tabulate(rows, headers="keys", tablefmt="grid"))
+
+    def select_all_from_db(self) -> None:
+        rows = self.db_service.get_test_suites()
+        for row in rows:
+            print(repr(dict(row)))

testgen/sqlite/db_service.py

@@ -11,7 +11,6 @@ from testgen.sqlite.db import create_database
 
 class DBService:
     def __init__(self, db_name="testgen.db"):
-        """Initialize database service with connection to specified database."""
         self.db_name = db_name
         self.conn = None
         self.cursor = None
@@ -111,7 +110,7 @@ class DBService:
         self.conn.commit()
         return self.cursor.lastrowid
 
-    def insert_coverage_data(self, file_name: str, executed_lines: int, missed_lines: int, 
+    def insert_coverage_data(self, file_name: str, executed_lines: str, missed_lines: str,
                            branch_coverage: float, source_file_id: int) -> int:
         """Insert coverage data and return its ID."""
         self.cursor.execute(
@@ -217,3 +216,24 @@ class DBService:
             (file_path,)
         )
         return self.cursor.fetchall()
+
+    def get_test_file_data(self, file_path: str):
+        """
+        Retrieve all test cases, coverage data, and test results for a specific file.
+        """
+        query = """
+            SELECT
+                tc.id AS test_case_id,
+                tc.name AS test_case_name,
+                tc.test_function AS test_case_test_function,
+                tc.test_method_type AS test_case_method_type,
+                COALESCE(cd.missed_lines, 'None') AS coverage_data_missed_lines
+            FROM SourceFile sf
+            LEFT JOIN Function f ON sf.id = f.source_file_id
+            LEFT JOIN TestCase tc ON f.id = tc.function_id
+            LEFT JOIN TestResult tr ON tc.id = tr.test_case_id
+            LEFT JOIN CoverageData cd ON sf.id = cd.source_file_id
+            WHERE sf.path = ?;
+        """
+        self.cursor.execute(query, (file_path,))
+        return self.cursor.fetchall()

testgen/util/coverage_utils.py

@@ -3,6 +3,8 @@ from typing import List
 
 import coverage
 
+from testgen.models.analysis_context import AnalysisContext
+from testgen.models.function_metadata import FunctionMetadata
 from testgen.models.test_case import TestCase
 from testgen.util.file_utils import load_and_parse_file_for_tree, load_module
 from testgen.util.utils import get_function_boundaries
@@ -193,3 +195,36 @@ def get_uncovered_lines_for_func(file_name: str, class_name: str | None, func_no
             uncovered_branch_lines.append(line)
 
     return uncovered_branch_lines
+
+def get_all_executable_statements(analysis_context: AnalysisContext, func: FunctionMetadata, test_cases):
+    import ast
+
+    if not test_cases:
+        print("Warning: No test cases available to determine executable statements")
+    else:
+        analysis = get_coverage_analysis(analysis_context.filepath, analysis_context.class_name, func.function_name, test_cases[0].inputs)
+
+    executable_lines = list(analysis[1])
+
+    with open(analysis_context.filepath, 'r') as f:
+        source = f.read()
+
+    tree = ast.parse(source)
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef) and node.name == func.func_def.name:
+            for if_node in ast.walk(node):
+                if isinstance(if_node, ast.If) and if_node.orelse:
+                    if isinstance(if_node.orelse[0], ast.If):
+                        continue
+                    else_line = if_node.orelse[0].lineno - 1
+
+                    with open(analysis_context.filepath, 'r') as f:
+                        lines = f.readlines()
+                        if else_line <= len(lines):
+                            line_content = lines[else_line - 1].strip()
+                            if line_content == "else:":
+                                if else_line not in executable_lines:
+                                    executable_lines.append(else_line)
+
+    return sorted(executable_lines)

testgen/util/randomizer.py

@@ -1,6 +1,7 @@
 import ast
 import random
 import string
+from types import ModuleType
 from typing import List
 
 import testgen.util.coverage_utils
@@ -67,22 +68,38 @@ def new_random_test_case(file_name: str, class_name: str | None, func_node: ast.
         print(f"Error generating test case for {func_name}: {e}")
         raise
 
-# Should combining test cases preserve the parent cases or entirely replace them?
-def combine_cases(test_cases: List[TestCase]) -> TestCase:
-    # TODO: Research Genetic Algorithms
-
+def combine_cases(module: ModuleType, test_cases: List[TestCase]) -> TestCase:
+    """Combine two test cases by mixing their inputs and calculating the new expected output."""
+    if not test_cases:
+        raise ValueError("Cannot combine cases with empty test case list")
+    
     random_index1 = random.randint(0, len(test_cases) - 1)
     test_case1 = test_cases[random_index1]
-
+    
     test_cases_of_the_same_function = [tc for tc in test_cases if tc.func_name == test_case1.func_name]
-    random_index2 = random.randint(0, len(test_cases) - 1)
-
-    test_case2 = test_cases_of_the_same_function[random_index2]
-
+    if len(test_cases_of_the_same_function) <= 1:
+        return test_case1  # Not enough cases to combine
+    
+    filtered_cases = [tc for tc in test_cases_of_the_same_function if tc != test_case1]
+    if not filtered_cases:
+        random_index2 = random.randint(0, len(test_cases_of_the_same_function) - 1)
+        test_case2 = test_cases_of_the_same_function[random_index2]
+    else:
+        test_case2 = random.choice(filtered_cases)
+    
     mixed_inputs = mix_inputs(test_case1, test_case2)
-
-    # Calculate the new expected value??
-    return TestCase(test_case1.func_name, mixed_inputs, test_case1.expected)
+    
+    try:
+        
+        func = getattr(module, test_case1.func_name)
+        
+        new_expected = func(*mixed_inputs)
+        
+        return TestCase(test_case1.func_name, mixed_inputs, new_expected)
+    
+    except Exception as e:
+        print(f"Error calculating expected output for combined test case: {e}")
+        return test_case1 if random.choice([True, False]) else test_case2
 
 def remove_case(test_cases: List[TestCase]) -> List[TestCase]:
     random_index = random.randint(0, len(test_cases) - 1)

{testgenie_py-0.2.1.dist-info → testgenie_py-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: testgenie-py
-Version: 0.2.1
+Version: 0.2.2
 Summary: 
 Author: cjseitz
 Author-email: charlesjseitz@gmail.com
@@ -19,6 +19,7 @@ Requires-Dist: klara (==0.6.3)
 Requires-Dist: pygraphviz (>=1.14,<2.0)
 Requires-Dist: pytest (>=8.3.5,<9.0.0)
 Requires-Dist: staticfg (>=0.9.5,<0.10.0)
+Requires-Dist: tabulate (>=0.9.0,<0.10.0)
 Requires-Dist: typed-ast (==1.5.5)
 Requires-Dist: z3-solver (==4.13.3.0)
 Description-Content-Type: text/markdown

{testgenie_py-0.2.1.dist-info → testgenie_py-0.2.2.dist-info}/RECORD

@@ -1,4 +1,3 @@
-testgen/.coverage,sha256=NvtMmi3OL9j4U8zNqffRWADmGX-9ygDEiHlCgjhbRjk,69632
 testgen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 testgen/analyzer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 testgen/analyzer/ast_analyzer.py,sha256=JmqiosxgZJm2fhNDr5VUBpKKHmf8S2HP9Jm0Xl7NnnI,6783
@@ -7,25 +6,17 @@ testgen/analyzer/contracts/contract.py,sha256=6rNYJOy_2GrOhGtaXTDIOX6pTEOqo856Fx
 testgen/analyzer/contracts/no_exception_contract.py,sha256=rTWTuu5XKmvzBPD6yNAqiNehk9lbWn_Z8zFj-_djZ_w,512
 testgen/analyzer/contracts/nonnull_contract.py,sha256=uurnrVptImYTVpSnu8ckdlU6c94AbiOWFoH1YnAQU0w,508
 testgen/analyzer/fuzz_analyzer.py,sha256=ktkDdh3mgHjcC4ZitGo9fa9RjnGqkdehaYJeSKssWss,4299
-testgen/analyzer/random_feedback_analyzer.py,sha256=tQkYwrYCH1xeSU5j1aoh0vUMyZwFC-1dFWf5eIlhcH8,13219
+testgen/analyzer/random_feedback_analyzer.py,sha256=TCF4rBEU22YtBMBefNfuKNJRjHo5U-a6Qn-mEr1bH10,23959
 testgen/analyzer/reinforcement_analyzer.py,sha256=U6W7g-xDFS_P0aqxjPRnaXjGp2gOC9TMdfWaetFV7eE,3568
 testgen/analyzer/test_case_analyzer.py,sha256=foHRbz9K6WAn711sXbp-smJHDjI8GTG8F2TpovLZVEo,1530
 testgen/analyzer/test_case_analyzer_context.py,sha256=7umDPHBjoTaCRvZOdNynpnWsr14Gy0E2hpMBPK8mz3Q,2128
-testgen/code_to_test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-testgen/code_to_test/boolean.py,sha256=RM2byJDKFTx1FFrxnPG_uZWb24OcOH20Uh-D1Z-yPcE,3373
-testgen/code_to_test/calculator.py,sha256=j7lw21BYg_vxaQVCrjOlhQOpObjSe5gu9xzthmdGphk,830
-testgen/code_to_test/code_to_fuzz.py,sha256=cwgRpUdXjTlrUHSHMtA2TAj8Y-ddAn6CaUdXPM4MRmo,4826
-testgen/code_to_test/code_to_fuzz_lite.py,sha256=EjS4GB5klnJrvZIDDpS9iIt0iZETVJI0ez9DmihMiYc,10429
-testgen/code_to_test/decisions.py,sha256=ZiW-EF1yTOWeQVZ7Xh0oIPHK2NSNPUzVxCY0E2GbYvQ,1376
-testgen/code_to_test/math_utils.py,sha256=FqPQz5-e1oklzGyTVYNO8JMKDg5ob8z05VOlpKfKvvw,853
-testgen/code_to_test/no_types.py,sha256=kD8CGjVAxVeCjQC45abO773sRNIjiZ4jvhwPRV8-kt0,675
-testgen/code_to_test/sample_code_bin.py,sha256=kMvV_-oFeAkxUmDx41Pw0iTTmMG1pvX31TezXPWMOkE,4225
 testgen/controller/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-testgen/controller/cli_controller.py,sha256=jSwT6Cy3JQhxFPRXaODdZ1md5uXO83Q0IrYh86sIdiE,8832
+testgen/controller/cli_controller.py,sha256=7zDm0hPcTLQXap8Sw_s9SPYcbY0nbfvP1wW8zUqdv-8,8783
 testgen/controller/docker_controller.py,sha256=LK3aV-n_J0YMRRcWNNinz-Z0FrKo-4qzEIYZSFht0Yc,8687
 testgen/docker/Dockerfile,sha256=6mutzP0ZkVueuvMLCOy2bsyGxWjLHU-cq7RFkuC8r5Y,781
+testgen/generated_samplecodebin.py,sha256=pf_aYtcfpjZzgiZ_FiBOxfug_ii3dRX0jnozBgQm7Xw,17030
 testgen/generator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-testgen/generator/code_generator.py,sha256=V5Donxz3r3ZW56xyyldJwOuDBaX6e8NOyPc8UzllQs8,2467
+testgen/generator/code_generator.py,sha256=-Nh5Jt4my29YWA_LKWn98I4jvDA-fNi6AGuw-vJhRV0,3171
 testgen/generator/doctest_generator.py,sha256=Dkaf2l72ENk1mqNP3WkOnIY-iqrTHh-443AWtxzRWGY,8806
 testgen/generator/generator.py,sha256=9M9zg8DO0uU5W5s9hsz2oPCL7bz7sAD087M5TYottSs,2007
 testgen/generator/pytest_generator.py,sha256=ZjQKPHlizFK2yx9WabAxkW9sM-xa64d08IIQibnvwuk,3369
@@ -41,33 +32,28 @@ testgen/models/generator_context.py,sha256=V-T9i-3Ar-gdBzQqidyqBb05PTmOu2LtdQdAI
 testgen/models/test_case.py,sha256=jwodn-6fKHCh4SO2qycbrFyggCb9UlwTZ8k3RdTObDQ,216
 testgen/presentation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 testgen/presentation/cli_view.py,sha256=2fZrsvZ-Wi4j37UvogsK9_yQV5o3A20jowIr6iFRu-s,296
-testgen/q_table/global_q_table.json,sha256=xSMRf5ddtLJAogE_RXleAbkmujgAYU3uiblBJmKqc5w,12059
 testgen/reinforcement/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 testgen/reinforcement/abstract_state.py,sha256=M9Kp8fyJzsTzpyL3ca4HjjYpGXy9DRMw-IG7OgFVisY,154
 testgen/reinforcement/agent.py,sha256=wvgbi-OVoVJMwhasGgsP2y1TKLiC5qjjTwZBNqKNRns,6098
-testgen/reinforcement/environment.py,sha256=bNsk9ejPo2ICY-FM6lwGD2W6YEuoE_N70DKazvjfrqU,10825
+testgen/reinforcement/environment.py,sha256=gW-Chh_c31AXlYR5GjTKybg4iNWSuZLeujB6Q7TdKPI,10838
 testgen/reinforcement/statement_coverage_state.py,sha256=mTZ0uiFnyiIoHcQXlJv9FDSH4y1r3rxltYEdZcMaSSg,1552
 testgen/service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 testgen/service/analysis_service.py,sha256=LPvsb6XwFQIOn05niamDiJx_HqCyTX2UznREvKjfvWo,10973
 testgen/service/cfg_service.py,sha256=ejgwbFlwla9Mfy4OJ-hsLAxo0TV3jO06hkldeEU-akQ,2236
-testgen/service/generator_service.py,sha256=MOkojB4ipp-fRF0buW-rIgFJLlBaRQKzoRxyJksylao,7382
+testgen/service/generator_service.py,sha256=rDwE1mGQdshr_yaDANcCPtgKhcx5sDWxQi8myxkOKhk,8088
 testgen/service/logging_service.py,sha256=vEQsluxwO-dAxWY4Xkwt8v5XeaXEv3GZh3ZYAsFCOEs,3116
-testgen/service/service.py,sha256=HDHm5NS_qC5EvFCcdOJAR6B3lQb8fPEmwRfZz1dV4j0,17001
+testgen/service/service.py,sha256=aT6F8TxxBNLX8LIK3bVPvnohts2ssLkrr3dz-RK0L_c,20994
 testgen/sqlite/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 testgen/sqlite/db.py,sha256=RUt88ndT4CQRo9aZzLGXPHRK1iw0LyDEGnoWlOLzKGM,2390
-testgen/sqlite/db_service.py,sha256=i87YkhMP0VNyug5p1tWUvnzHB8isFcSIRe9vJJTmFLA,8954
-testgen/testgen.db,sha256=iyQiDqur-JoS70QD-VYkJFkgjb_YcK2jBAP2aZvvAhY,106496
-testgen/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-testgen/tests/test_boolean.py,sha256=WzZPPdTLoWHEMnqopimm0g-lbJCp1ExlK_w6KN3Si1s,1636
-testgen/tests/test_decisions.py,sha256=NF3sTscRMHHTsaV0NzwNsQ4zW2WkPyyTp1C1Sw3rNbQ,4437
+testgen/sqlite/db_service.py,sha256=F2ug_FBrYOQtJwM2cMkvQrTS54_VhWGDAHXndnTi-c8,9768
 testgen/tree/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 testgen/tree/node.py,sha256=ONJtbACShN4yNj1X-UslFRgLyBP6mrbg7qZr3c6dWyA,165
 testgen/tree/tree_utils.py,sha256=gT7jucky6_GWVOlDI6jpv6RMeWCkntGOHIYLvHxD85k,2122
 testgen/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-testgen/util/coverage_utils.py,sha256=Le5kC02gZewJEzzIE_Jfw17qOoPIZa9p3UTDWfwxUi0,7578
+testgen/util/coverage_utils.py,sha256=xKaFpgLEZLAgDWzugxJPKVwfd0nYZnP5oHLnFzYuRPE,9084
 testgen/util/coverage_visualizer.py,sha256=Jp9d7SJaGKD38g4GWSOI4TusXtMYgMgQNPGrUnuVynk,5704
 testgen/util/file_utils.py,sha256=IO239ZQB2DoZN1URrFlPq0fv73Xn5wQUQVEWk7g4gl4,7066
-testgen/util/randomizer.py,sha256=J_M24XYxkPjD6wVCr8PmP_Iasc4CgwRJngxZOO6zofc,5039
+testgen/util/randomizer.py,sha256=1WTPjCjgQxfHw9UPhvjRWJCKtcE3gCG4nmLn7HJtrac,5767
 testgen/util/utils.py,sha256=_TPXveAcI_TR9XLU8qaDx63CrZJDvpzSWl_gfYchJz0,5665
 testgen/util/z3_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 testgen/util/z3_utils/ast_to_z3.py,sha256=V87cvlH2OlO7_owuVTqygymMmK_FyesBovi6qe-BUcg,3180
@@ -75,7 +61,7 @@ testgen/util/z3_utils/branch_condition.py,sha256=N9FNR-iJmxIC62NpDQNVZ1OP14rXXqY
 testgen/util/z3_utils/constraint_extractor.py,sha256=RXJLpmk6dAvHZ27839VXKXNtdy9St1F-17-pSEFu4bM,1285
 testgen/util/z3_utils/variable_finder.py,sha256=dUh3F9_L_BDMz1ybiGss09LLcM_egbitgj0FT5Nh9u4,245
 testgen/util/z3_utils/z3_test_case.py,sha256=yF4oJOrXMLzOwDUqXdoeg83MOTl3pvc_lYaZcS01CuQ,4983
-testgenie_py-0.2.1.dist-info/METADATA,sha256=arzD3EpQ9AnK8STIuvazvbZ7Gdoj3rgzLoMVdqQ6zkg,843
-testgenie_py-0.2.1.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-testgenie_py-0.2.1.dist-info/entry_points.txt,sha256=OUN4GqB4zHlHWwWGjwIPbur4E_ZqQgkeeqaCLhzRZgg,47
-testgenie_py-0.2.1.dist-info/RECORD,,
+testgenie_py-0.2.2.dist-info/METADATA,sha256=gqB_l7Y9ELHsTmydKcJDaTeVKbEmgNltEhL7Si0Ll18,885
+testgenie_py-0.2.2.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+testgenie_py-0.2.2.dist-info/entry_points.txt,sha256=OUN4GqB4zHlHWwWGjwIPbur4E_ZqQgkeeqaCLhzRZgg,47
+testgenie_py-0.2.2.dist-info/RECORD,,

testgen/code_to_test/boolean.py

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

testgen/code_to_test/calculator.py

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