testgenie-py 0.1.0__py3-none-any.whl

testgen/models/generator_context.py

@@ -0,0 +1,63 @@
+from types import ModuleType
+from typing import List
+
+from testgen.models.test_case import TestCase
+
+
+class GeneratorContext:
+    def __init__(self, filepath: str, filename: str, class_name:str | None, module: ModuleType, output_path: str, test_cases: List[TestCase]):
+        self._filepath: str = filepath
+        self._filename: str = filename
+        self._class_name: str = class_name
+        self._module: ModuleType = module
+        self._output_path: str = output_path
+        self._test_cases: List[TestCase] = test_cases
+    
+    @property
+    def filepath(self) -> str:
+        return self._filepath
+    
+    @filepath.setter
+    def filepath(self, value: str) -> None:
+        self._filepath = value
+    
+    @property
+    def filename(self) -> str:
+        return self._filename
+    
+    @filename.setter
+    def filename(self, value: str) -> None:
+        self._filename = value
+    
+    @property
+    def class_name(self) -> str | None:
+        return self._class_name
+    
+    @class_name.setter
+    def class_name(self, value: str | None) -> None:
+        self._class_name = value
+    
+    @property
+    def module(self) -> ModuleType:
+        return self._module
+    
+    @module.setter
+    def module(self, value: ModuleType) -> None:
+        self._module = value
+    
+    @property
+    def output_path(self) -> str:
+        return self._output_path
+    
+    @output_path.setter
+    def output_path(self, value: str) -> None:
+        self._output_path = value
+    
+    @property
+    def test_cases(self) -> List[TestCase]:
+        return self._test_cases
+    
+    @test_cases.setter
+    def test_cases(self, value: List[TestCase]) -> None:
+        self._test_cases = value
+

testgen/models/test_case.py

@@ -0,0 +1,8 @@
+import string
+from typing import List
+
+class TestCase:
+    def __init__(self, func_name, inputs: tuple, expected: any):
+        self.func_name = func_name
+        self.inputs = inputs
+        self.expected = expected

testgen/presentation/cli_view.py

@@ -0,0 +1,12 @@
+class CLIView:
+    def __init__(self):
+        "pass"
+
+    def display_message(self, message: str):
+        print(f"[INFO] {message}")
+
+    def display_error(self, error: str):
+        print(f"[ERROR] {error}")
+
+    def prompt_input(self, prompt: str) -> str:
+        return input(f"{prompt}:> ")

testgen/q_table/global_q_table.json

@@ -0,0 +1 @@
+{"(0.0, 0)|add": 1.0147553256632154, "(62.5, 1)|z3": -0.020000000000000004, "(62.5, 3)|add": -0.010000000000000002, "(62.5, 4)|add": 0.18000000000000002, "(87.5, 5)|add": 0.07100000000000001, "(75.0, 1)|add": 0.6092791100000001, "(87.5, 2)|add": 0.18509310000000004, "(87.5, 3)|z3": 0.0, "(87.5, 3)|add": -0.010000000000000002, "(87.5, 4)|add": 0.26100000000000007, "(87.5, 2)|remove": -0.09000000000000001, "(62.5, 1)|add": -0.019000000000000003, "(62.5, 2)|add": -0.010000000000000002, "(62.5, 3)|z3": -0.020000000000000004, "(62.5, 5)|add": -0.010000000000000002, "(62.5, 6)|add": -0.010000000000000002, "(62.5, 7)|add": 0.07100000000000001, "(87.5, 8)|add": -0.010000000000000002, "(87.5, 9)|z3": -0.010000000000000002, "(87.5, 3)|remove": -0.09000000000000001, "(62.5, 2)|z3": -0.020900000000000002, "(62.5, 4)|merge": -0.010000000000000002, "(62.5, 5)|merge": -0.010000000000000002, "(62.5, 6)|remove": 0.010000000000000002, "(62.5, 5)|z3": -0.011000000000000001, "(87.5, 3)|merge": 0.08000000000000002, "(62.5, 4)|remove": 0.010000000000000002, "(62.5, 3)|merge": -0.0009999999999999996, "(87.5, 6)|z3": 0.0, "(87.5, 6)|merge": 0.09000000000000001, "(87.5, 2)|z3": -0.0009999999999999996, "(75.0, 1)|z3": 0.10056590000000001, "(60.0, 1)|add": 0.18917349, "(60.0, 2)|add": 0.17900000000000002, "(70.0, 3)|add": 0.23680000000000007, "(90.0, 4)|add": -0.010000000000000002, "(90.0, 5)|add": 0.1629, "(90.0, 6)|add": -0.01929, "(90.0, 7)|z3": -0.0046099999999999995, "(90.0, 7)|merge": -0.010000000000000002, "(90.0, 8)|add": -0.010000000000000002, "(0.0, 0)|z3": 0.20518, "(60.0, 4)|add": 0.24390000000000006, "(70.0, 5)|add": -0.010000000000000002, "(70.0, 6)|remove": 0.019000000000000003, "(70.0, 5)|z3": -0.020000000000000004, "(70.0, 7)|add": -0.010000000000000002, "(70.0, 8)|z3": -0.020000000000000004, "(70.0, 10)|add": 0.09000000000000001, "(60.0, 2)|z3": 0.08000000000000002, "(70.0, 4)|add": 0.06100000000000001, "(90.0, 5)|z3": -0.010000000000000002, "(90.0, 6)|z3": -0.0029, "(90.0, 6)|merge": -0.010000000000000002, "(90.0, 7)|add": 0.05390000000000001, "(60.0, 1)|z3": 0.26273490000000005, "(70.0, 5)|merge": -0.009, "(70.0, 5)|remove": -0.08100000000000002, "(80.0, 5)|z3": -0.010000000000000002, "(80.0, 6)|add": 0.18449000000000004, "(80.0, 2)|add": -0.010000000000000002, "(80.0, 3)|add": -0.010000000000000002, "(80.0, 4)|z3": 0.053800000000000014, "(90.0, 8)|z3": -0.010000000000000002, "(90.0, 9)|add": -0.010000000000000002, "(80.0, 3)|remove": -0.08100000000000002, "(90.0, 4)|z3": 0.0, "(90.0, 4)|remove": 0.054200000000000005, "(90.0, 3)|add": 0.09000000000000001, "(90.0, 3)|z3": -0.0072000000000000015, "(80.0, 2)|z3": -0.010000000000000002, "(80.0, 3)|z3": -0.0009999999999999996, "(60.0, 4)|remove": 0.010000000000000002, "(60.0, 3)|add": 0.09710000000000002, "(80.0, 5)|add": 0.08944900000000001, "(90.0, 6)|remove": -0.08100000000000002, "(53.84615384615385, 1)|add": 0.3104837900000001, "(76.92307692307693, 2)|remove": -0.09000000000000001, "(61.53846153846154, 1)|add": 0.17100000000000004, "(76.92307692307693, 2)|add": -0.010000000000000002, "(76.92307692307693, 3)|add": 0.081, "(76.92307692307693, 4)|remove": -0.0719, "(76.92307692307693, 3)|z3": 0.0, "(84.61538461538461, 4)|z3": 0.0, "(53.84615384615385, 2)|z3": -0.04000000000000001, "(53.84615384615385, 6)|add": 0.09000000000000001, "(69.23076923076923, 7)|merge": -0.010000000000000002, "(69.23076923076923, 8)|add": 0.15390000000000004, "(76.92307692307693, 9)|add": -0.010000000000000002, "(76.92307692307693, 10)|add": 0.09000000000000001, "(61.53846153846154, 2)|add": -0.010000000000000002, "(61.53846153846154, 3)|add": -0.010000000000000002, "(61.53846153846154, 4)|add": 0.07100000000000001, "(84.61538461538461, 5)|add": -0.010000000000000002, "(84.61538461538461, 6)|add": 0.17100000000000004, "(92.3076923076923, 7)|add": -0.010000000000000002, "(92.3076923076923, 8)|add": -0.010000000000000002, "(69.23076923076923, 2)|add": 0.171, "(69.23076923076923, 3)|merge": -0.010000000000000002, "(69.23076923076923, 4)|add": -0.010000000000000002, "(69.23076923076923, 5)|add": -0.010000000000000002, "(69.23076923076923, 6)|z3": -0.011000000000000001, "(69.23076923076923, 9)|add": -0.010000000000000002, "(69.23076923076923, 2)|z3": -0.030000000000000006, "(69.23076923076923, 5)|remove": 0.019000000000000003, "(69.23076923076923, 4)|z3": -0.030000000000000006, "(69.23076923076923, 7)|add": -0.0029, "(84.61538461538461, 9)|add": 0.09000000000000001, "(92.3076923076923, 10)|add": 0.07100000000000001, "(53.84615384615385, 2)|merge": -0.010000000000000002, "(53.84615384615385, 3)|add": -0.010000000000000002, "(53.84615384615385, 4)|add": 0.09100000000000001, "(69.23076923076923, 4)|remove": 0.010000000000000002, "(69.23076923076923, 3)|add": 0.23471000000000006, "(76.92307692307693, 4)|add": -0.010000000000000002, "(53.84615384615385, 1)|z3": -0.04000000000000001, "(53.84615384615385, 5)|z3": -0.04000000000000001, "(53.84615384615385, 9)|add": 0.09000000000000001, "(69.23076923076923, 10)|add": -0.010000000000000002, "(69.23076923076923, 11)|add": -0.010000000000000002, "(69.23076923076923, 12)|add": -0.010000000000000002, "(76.92307692307693, 2)|z3": 0.09000000000000001, "(84.61538461538461, 3)|add": -0.010000000000000002, "(84.61538461538461, 4)|add": -0.010000000000000002, "(84.61538461538461, 5)|z3": -0.0009999999999999996, "(92.3076923076923, 7)|z3": -0.010000000000000002, "(92.3076923076923, 8)|z3": -0.010000000000000002, "(76.92307692307693, 4)|z3": -0.020000000000000004, "(76.92307692307693, 6)|add": 0.05904900000000002, "(92.3076923076923, 7)|merge": -0.010000000000000002, "(92.3076923076923, 8)|merge": -0.010000000000000002, "(92.3076923076923, 9)|merge": -0.0009999999999999996, "(53.84615384615385, 2)|add": 0.09000000000000001, "(61.53846153846154, 3)|merge": -0.0009999999999999996, "(61.53846153846154, 5)|z3": 0.08000000000000002, "(76.92307692307693, 7)|remove": 0.034390000000000004, "(75.0, 2)|add": -0.010000000000000002, "(75.0, 3)|merge": -0.010000000000000002, "(87.5, 5)|merge": -0.0029, "(100.0, 6)|add": 0.09000000000000001, "(70.0, 3)|z3": 0.10368000000000002, "(70.0, 3)|remove": -0.06632, "(70.0, 4)|merge": -0.0038999999999999994, "(100.0, 8)|add": 0.09000000000000001, "(53.84615384615385, 1)|remove": -0.058951621, "(69.23076923076923, 4)|merge": -0.009, "(69.23076923076923, 7)|z3": -0.030000000000000006, "(69.23076923076923, 6)|remove": 0.010000000000000002, "(69.23076923076923, 9)|z3": -0.030000000000000006, "(84.61538461538461, 10)|add": 0.09000000000000001}

testgen/reinforcement/abstract_state.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+from typing import Tuple
+
+class AbstractState(ABC):
+    @abstractmethod
+    def get_state(self) -> Tuple:
+        pass

testgen/reinforcement/agent.py

@@ -0,0 +1,153 @@
+import random
+import time
+from typing import List
+
+from testgen.models.test_case import TestCase
+from testgen.reinforcement.environment import ReinforcementEnvironment
+
+
+class ReinforcementAgent:
+    def __init__(self, file_name: str, environment: ReinforcementEnvironment, test_cases: List[TestCase], q_table=None):
+        self.learning_rate = 0.1
+        self.file_name = file_name
+        self.env = environment
+        self.q_table = q_table if q_table else {}
+        self.actions = ["add", "merge", "remove", "z3"]
+
+    def collect_test_cases(self) -> List[TestCase]:
+        max_time = 30
+        if not self.q_table:
+            print("Q_TABLE IS EMPTY, RUN TRAIN FIRST")
+            return []
+        else:
+            current_state = self.env.get_state()
+
+            goal_state: float = 100.0
+
+            start_time = time.time()
+
+            while current_state[0] != goal_state and time.time() - start_time < max_time:
+                action = self.choose_action(current_state)
+                next_state, reward = self.env.step(action)
+
+                if not isinstance(next_state, tuple) or len(next_state) != 2:
+                    raise ValueError(f"Expected new_state to be a tuple (covered_statements, coverage_percentage, len(test_cases)), but got: {next_state}")
+
+                self.update_q_table(next_state, action, next_state, reward)
+
+                current_state = next_state
+
+            return self.env.test_cases
+
+
+    def do_q_learning(self, episodes=10):
+        max_time = 30
+        best_coverage = 0.0
+        best_test_cases = []
+
+        for episode in range(episodes):
+            print(f"\nNEW EPISODE {episode}")
+            self.env.reset()
+
+            current_state = self.env.get_state()
+            print(f"Current state after reset: {current_state}")
+
+            goal_state: float = 100.0
+            steps_in_episode = 1
+            max_steps_per_episode = 100
+
+            start_time = time.time()
+
+            while current_state[0] != goal_state and steps_in_episode < max_steps_per_episode and time.time() - start_time < max_time:
+                print(f"Step {steps_in_episode} in episode {episode}")
+
+                action = self.choose_action(current_state)
+                next_state, reward = self.env.step(action)
+
+                if not isinstance(next_state, tuple) or len(next_state) != 2:
+                    raise ValueError(f"Expected new_state to be a tuple (covered_statements, coverage_percentage, len(test_cases)), but got: {next_state}")
+
+                print(f"AFTER NEW STATE, REWARD: {reward}")
+
+                # Update q_table
+                self.update_q_table(current_state, action, next_state, reward)
+                current_state = next_state
+
+                steps_in_episode += 1
+                if current_state[0] > best_coverage:
+                    best_coverage = current_state[0]
+                    best_test_cases = self.env.test_cases.copy()
+                    print(f"New best coverage: {best_coverage}% with {len(best_test_cases)} test cases")
+                elif current_state[0] == best_coverage and len(best_test_cases) > len(self.env.test_cases):
+                    best_test_cases = self.env.test_cases.copy()
+                    print(f"New best coverage: {best_coverage}% with {len(best_test_cases)} test cases")
+
+        return best_test_cases
+
+
+    def choose_action(self, state):
+        EXPLORATION = 0
+        EXPLOITATION = 1
+
+        weights = [0.33, 0.67]
+        
+        choice = random.choices([EXPLORATION, EXPLOITATION], weights=weights, k=1)[0]
+        action_list = self.get_action_list(state[1])
+
+        if not isinstance(state, tuple) or len(state) != 2:
+            raise ValueError(f"Expected state to be a tuple (covered_statements, coverage_percentage, len(test_cases)), but got: {state}")
+
+        if choice == EXPLORATION:
+            chosen_action = random.choice(action_list)
+            print(f"CHOSEN EXPLORATION ACTION: {chosen_action}")
+            return chosen_action
+        else:
+            chosen_action = max(action_list, key=lambda action: self.q_table.get((state, action), 0), default=random.choice(action_list))
+            print(f"CHOSEN EXPLOITATION ACTION: {chosen_action}")
+            return chosen_action
+
+    def optimize_test_suit(self, current_state, executable_statements):
+        # Try to optimize test cases by repeatedly performing remove actions if reached full coverage
+        test_case_count = current_state[1]
+        optimization_attempts = min(10, test_case_count - 1)
+
+        for _ in range(optimization_attempts):
+            if test_case_count <= 1:
+                break
+
+            action = "remove"
+            next_state, reward = self.env.step(action)
+
+            new_covered = next_state[0]
+            new_uncovered = [stmt for stmt in executable_statements if stmt not in new_covered]
+
+            if len(new_uncovered) == 0:
+                current_state = next_state
+                test_case_count = current_state[2]
+                print(f"Optimized to {test_case_count} test cases.")
+            else:
+                # Add a test case back if removing broke coverage
+                self.env.step("add")
+                break
+
+        return current_state
+
+    @staticmethod
+    def get_action_list(test_case_length: int) -> List[str]:
+        action_list = ["add", "z3"]
+        if test_case_length >= 2:
+            action_list.extend(["merge", "remove"])
+        return action_list
+
+    def update_q_table(self, state: tuple, action: str, new_state:tuple, reward:float):
+        current_q = self.q_table.get((state, action), 0)
+        print(f"CURRENT Q: {current_q}")
+        valid_actions = self.get_action_list(new_state[1])
+
+        max_next_q = max(self.q_table.get((new_state, a), 0) for a in valid_actions)
+        print(f"MAX NEXT Q: {max_next_q}")
+
+        print(f"UPDATING Q TABLE FOR STATE: {state}, ACTION: {action} WITH REWARD: {reward}")
+        new_q = (1 - self.learning_rate) * current_q + self.learning_rate * (reward + max_next_q)
+        
+        self.q_table[(state, action)] = new_q

testgen/reinforcement/environment.py

@@ -0,0 +1,215 @@
+import ast
+import io
+from typing import List, Tuple
+
+import coverage
+
+import testgen.util.coverage_utils
+import testgen.util.file_utils
+from testgen.reinforcement.abstract_state import AbstractState
+import testgen.util.randomizer as randomizer
+from testgen.models.test_case import TestCase
+
+
+class ReinforcementEnvironment:
+    def __init__(self, file_name, fut: ast.FunctionDef, module, initial_test_cases: List[TestCase], state: AbstractState):
+        self.file_name = file_name
+        self.fut = fut
+        self.module = module
+        self.initial_test_cases = initial_test_cases
+        self.test_cases = initial_test_cases.copy()
+        self.state = state
+        self.cov = coverage.Coverage()
+
+    # State represented by covered_statements, test_count
+    def get_state(self) -> Tuple:
+        return self.state.get_state()
+
+    def step(self, action) -> Tuple[Tuple, float]:
+        prev_coverage = self.state.get_state()[0]  # Get actual coverage before action
+        prev_test_cases = self.state.get_state()[1]
+        print(f"STEP: Previous coverage: {prev_coverage} before action: {action}")
+
+        # Execute action
+        if action == "add":
+            self.test_cases.append(randomizer.new_random_test_case(self.file_name, self.fut))
+        elif action == "merge" and len(self.test_cases) > 1:
+            self.test_cases.append(randomizer.combine_cases(self.test_cases))
+        elif action == "remove" and len(self.test_cases) > 1:
+            self.test_cases = randomizer.remove_case(self.test_cases)
+        elif action == "z3":
+            self.test_cases = randomizer.get_z3_test_cases(self.file_name, self.fut, self.test_cases)
+        else:
+            raise ValueError("Invalid action")
+
+        # Update state with new coverage
+        new_coverage = self.state.get_state()[0]
+        num_test_cases = self.state.get_state()[1]
+
+        # Calculate reward
+        coverage_delta = new_coverage - prev_coverage
+        num_test_cases_delta = num_test_cases - prev_test_cases
+        reward = self.get_reward(coverage_delta, num_test_cases_delta)
+
+        print(f"Action: {action}, Previous coverage: {prev_coverage}, New coverage: {new_coverage}, Reward: {reward}")
+
+        return self.get_state(), reward
+
+    def reset(self) -> None:
+        self.test_cases = self.initial_test_cases.copy()
+
+    def render(self):
+        pass
+
+    @staticmethod
+    def get_reward(coverage_delta, num_test_cases_delta) -> float:
+        reward: float
+        """
+        Reward of 1.0 for increasing coverage
+        No reward for no change
+        Penalty of -1.0 for decreasing coverage
+        """
+        if coverage_delta > 0:
+            reward = 1.0
+        elif coverage_delta == 0:
+            reward = 0.0
+        else:
+            reward = -1.0
+
+        print(f"Coverage delta reward: {reward}")
+
+        """
+        If new test cases are added, subtract a small penalty
+        If test cases are removed, add a small bonus
+        If test cases are the same, no change
+        """
+        test_cases_factor = (num_test_cases_delta * -0.1)
+        reward = reward + test_cases_factor
+        print(f"Reward or penalty added to coverage delta reward: {test_cases_factor}")
+
+        print(f"Final reward {reward}")
+        return reward
+
+    
+    def get_all_executable_statements(self):
+        """Get all executable statements including else branches"""
+        import ast
+
+        test_cases = [tc for tc in self.test_cases if tc.func_name == self.fut.name]
+
+        if not test_cases:
+            print("Warning: No test cases available to determine executable statements")
+            from testgen.util.randomizer import new_random_test_case
+            temp_case = new_random_test_case(self.file_name, self.fut)
+            analysis = testgen.util.coverage_utils.get_coverage_analysis(self.file_name, self.fut.name, temp_case.inputs)
+        else:
+            analysis = testgen.util.coverage_utils.get_coverage_analysis(self.file_name, self.fut.name, test_cases[0].inputs)
+        
+        # Get standard executable lines from coverage.py
+        executable_lines = list(analysis[1])
+        
+        # Parse the source file to find else branches
+        with open(self.file_name, 'r') as f:
+            source = f.read()
+        
+        # Parse the code
+        tree = ast.parse(source)
+        
+        # Find our specific function
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef) and node.name == self.fut.name:
+                # Find all if statements in this function
+                for if_node in ast.walk(node):
+                    if isinstance(if_node, ast.If) and if_node.orelse:
+                        # There's an else branch
+                        if isinstance(if_node.orelse[0], ast.If):
+                            # This is an elif - already counted
+                            continue
+                        
+                        # Get the line number of the first statement in the else block
+                        # and subtract 1 to get the 'else:' line
+                        else_line = if_node.orelse[0].lineno - 1
+                        
+                        # Check if this is actually an else line (not a nested if)
+                        with open(self.file_name, '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)
+    
+    def run_tests(self) -> float:
+        """Run all tests and calculate coverage with branch awareness"""
+        import os
+        
+        # Create a coverage object with branch tracking
+        self.cov = coverage.Coverage(branch=True)
+        self.cov.start()
+        
+        # Execute all test cases
+        for test_case in self.test_cases:
+            try:
+                module = testgen.util.file_utils.load_module(self.file_name)
+                func = getattr(module, self.fut.name)
+                _ = func(*test_case.inputs)
+            except Exception as e:
+                import traceback
+                print(f"[ERROR]: {traceback.format_exc()}")
+        
+        self.cov.stop()
+        
+        # Get detailed coverage data including branches
+        file_path = os.path.abspath(self.file_name)
+        data = self.cov.get_data()
+        
+        # Extract function-specific coverage
+        function_range = self._get_function_line_range()
+        if function_range:
+            start_line, end_line = function_range
+            
+            # Calculate function-specific coverage
+            analysis = self.cov.analysis2(file_path)
+            
+            if len(analysis) >= 4:
+                executable_in_func = [line for line in analysis[1] if start_line <= line <= end_line]
+                missed_in_func = [line for line in analysis[3] if start_line <= line <= end_line]
+                
+                if executable_in_func:
+                    func_coverage = (len(executable_in_func) - len(missed_in_func)) / len(executable_in_func) * 100
+                    return func_coverage
+        
+        # Fall back to standard coverage calculation
+        fake_file = io.StringIO()
+        total_coverage = self.cov.report(file=fake_file)
+        self.cov.save()
+        return total_coverage
+
+    def _get_function_line_range(self):
+        """Get the line range of the current function"""
+        import ast
+        
+        try:
+            with open(self.file_name, 'r') as f:
+                source = f.read()
+            
+            tree = ast.parse(source)
+            
+            for node in ast.walk(tree):
+                if isinstance(node, ast.FunctionDef) and node.name == self.fut.name:
+                    # Find the first line of the function
+                    start_line = node.lineno
+                    
+                    # Find the last line by getting the maximum line number of any node in this function
+                    max_line = start_line
+                    for child in ast.walk(node):
+                        if hasattr(child, 'lineno'):
+                            max_line = max(max_line, child.lineno)
+                    
+                    return (start_line, max_line)
+        except Exception as e:
+            print(f"Error getting function range: {e}")
+        
+        return None

testgen/reinforcement/statement_coverage_state.py

@@ -0,0 +1,33 @@
+from typing import Tuple
+
+import testgen.util.coverage_utils
+from testgen.reinforcement.abstract_state import AbstractState
+from testgen.util import utils
+
+class StatementCoverageState(AbstractState):
+    def __init__(self, environment):
+        self.environment = environment
+
+    def get_state(self) -> Tuple[float, int]:
+        """Returns calculated coverage and length of test cases in a tuple"""
+        all_covered_statements = set()
+        for test_case in self.environment.test_cases:
+            analysis = testgen.util.coverage_utils.get_coverage_analysis(self.environment.file_name, self.environment.fut.name, test_case.inputs)
+            covered = testgen.util.coverage_utils.get_list_of_covered_statements(analysis)
+            all_covered_statements.update(covered)
+
+        executable_statements = self.environment.get_all_executable_statements()
+
+        if not executable_statements or executable_statements == 0:
+            calc_coverage = 0.0
+        else:
+            calc_coverage: float = (len(all_covered_statements) / len(executable_statements)) * 100
+
+        print(f"GET STATE ALL COVERED STATEMENTS: {all_covered_statements}")
+        print(f"GET STATE ALL EXECUTABLE STATEMENTS: {self.environment.get_all_executable_statements()}")
+        print(f"GET STATE FLOAT COVERAGE: {calc_coverage}")
+
+        if calc_coverage >= 100:
+            print(f"!!!!!!!!FULLY COVERED FUNCTION: {self.environment.fut.name}!!!!!!!!")
+        return calc_coverage, len(self.environment.test_cases)
+