Kea2-python 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

kea2/bug_report_generator.py

@@ -1,31 +1,124 @@
 import json
-import datetime
+from datetime import datetime
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Dict, TypedDict, Literal, List
+from typing import Dict, TypedDict, List, Deque, NewType, Union, Optional
 from collections import deque
+from concurrent.futures import ThreadPoolExecutor
 
-from PIL import Image, ImageDraw
+from PIL import Image, ImageDraw, ImageFont
 from jinja2 import Environment, FileSystemLoader, select_autoescape, PackageLoader
-from .utils import getLogger
-
+from kea2.utils import getLogger
 
 logger = getLogger(__name__)
 
 
 class StepData(TypedDict):
+    # The type of the action (Monkey / Script / Script Info)
     Type: str
+    # The steps of monkey event when the action happened
+    # ps: since we insert script actions into monkey actions. Total actions count >= Monkey actions count
     MonkeyStepsCount: int
+    # The time stamp of the action
     Time: str
+    # The execution info of the action
     Info: Dict
+    # The screenshot of the action
     Screenshot: str
 
+
+class CovData(TypedDict):
+    stepsCount: int
+    coverage: float
+    totalActivitiesCount: int
+    testedActivitiesCount: int
+    totalActivities: List[str]
+    testedActivities: List[str]
+    activityCountHistory: Dict[str, int]
+
+
+class ReportData(TypedDict):
+    timestamp: str
+    bugs_found: int
+    executed_events: int
+    total_testing_time: float
+    coverage: float
+    total_activities_count: int
+    tested_activities_count: int
+    total_activities: List
+    tested_activities: List
+    all_properties_count: int
+    executed_properties_count: int
+    property_violations: List[Dict]
+    property_stats: List
+    property_error_details: Dict[str, List[Dict]]  # Support multiple errors per property
+    screenshot_info: Dict
+    coverage_trend: List
+    property_execution_trend: List  # Track executed properties count over steps
+    activity_count_history: Dict[str, int]  # Activity traversal count from final coverage data
+
+
+class PropertyExecResult(TypedDict):
+    precond_satisfied: int
+    executed: int
+    fail: int
+    error: int
+
+
+@dataclass
+class PropertyExecInfo:
+    """Class representing property execution information from property_exec_info file"""
+    prop_name: str
+    state: str  # start, pass, fail, error
+    traceback: str
+    start_steps_count: int
+    occurrence_count: int = 1
+    short_description: str = ""
+    start_steps_count_list: List[int] = None
+    
+    def __post_init__(self):
+        if self.start_steps_count_list is None:
+            self.start_steps_count_list = [self.start_steps_count]
+        if not self.short_description and self.traceback:
+            self.short_description = self._extract_error_summary(self.traceback)
+    
+    def _extract_error_summary(self, traceback: str) -> str:
+        """Extract a short error summary from the full traceback"""
+        try:
+            lines = traceback.strip().split('\n')
+            for line in reversed(lines):
+                line = line.strip()
+                if line and not line.startswith('  '):
+                    return line
+            return "Unknown error"
+        except Exception:
+            return "Error parsing traceback"
+    
+    def get_error_hash(self) -> int:
+        """Generate hash key for error deduplication"""
+        return hash((self.state, self.traceback))
+    
+    def is_error_state(self) -> bool:
+        """Check if this is an error or fail state"""
+        return self.state in ["fail", "error"]
+    
+    def add_occurrence(self, start_steps_count: int):
+        """Add another occurrence of the same error"""
+        self.occurrence_count += 1
+        self.start_steps_count_list.append(start_steps_count)
+
+
+PropertyName = NewType("PropertyName", str)
+TestResult = NewType("TestResult", Dict[PropertyName, PropertyExecResult])
+
+
 @dataclass
 class DataPath:
     steps_log: Path
     result_json: Path
     coverage_log: Path
     screenshots_dir: Path
+    property_exec_info: Path
 
 
 class BugReportGenerator:
@@ -33,26 +126,66 @@ class BugReportGenerator:
     Generate HTML format bug reports
     """
 
-    def __init__(self, result_dir):
+    _cov_trend: Deque[CovData] = None
+    _test_result: TestResult = None
+    _take_screenshots: bool = None
+    _data_path: DataPath = None
+
+    @property
+    def cov_trend(self):
+        if self._cov_trend is not None:
+            return self._cov_trend
+
+        # Parse coverage data
+        if not self.data_path.coverage_log.exists():
+            logger.error(f"{self.data_path.coverage_log} not exists")
+
+        cov_trend = list()
+
+        with open(self.data_path.coverage_log, "r", encoding="utf-8") as f:
+            for line in f:
+                if not line.strip():
+                    continue
+
+                coverage_data = json.loads(line)
+                cov_trend.append(coverage_data)
+        self._cov_trend = cov_trend
+        return self._cov_trend
+
+    @property
+    def take_screenshots(self) -> bool:
+        """Whether the `--take-screenshots` enabled. Should we report the screenshots?
+
+        Returns:
+            bool: Whether the `--take-screenshots` enabled.
+        """
+        if self._take_screenshots is None:
+            self._take_screenshots = self.data_path.screenshots_dir.exists()
+        return self._take_screenshots
+
+    @property
+    def test_result(self) -> TestResult:
+        if self._test_result is not None:
+            return self._test_result
+
+        if not self.data_path.result_json.exists():
+            logger.error(f"{self.data_path.result_json} not found")
+        with open(self.data_path.result_json, "r", encoding="utf-8") as f:
+            self._test_result: TestResult = json.load(f)
+
+        return self._test_result
+
+    def __init__(self, result_dir=None):
         """
         Initialize the bug report generator
 
         Args:
             result_dir: Directory path containing test results
         """
-        self.result_dir = Path(result_dir)
-        self.log_timestamp = self.result_dir.name.split("_", 1)[1]
-
-        self.data_path: DataPath = DataPath(
-            steps_log=self.result_dir / f"output_{self.log_timestamp}" / "steps.log",
-            result_json=self.result_dir / f"result_{self.log_timestamp}.json",
-            coverage_log=self.result_dir / f"output_{self.log_timestamp}" / "coverage.log",
-            screenshots_dir=self.result_dir / f"output_{self.log_timestamp}" / "screenshots"
-        )
+        if result_dir is not None:
+            self._setup_paths(result_dir)
 
-        self.screenshots = deque()
-
-        self.take_screenshots = self._detect_screenshots_setting()
+        self.executor = ThreadPoolExecutor(max_workers=128)
 
         # Set up Jinja2 environment
         # First try to load templates from the package
@@ -75,16 +208,48 @@ class BugReportGenerator:
                 autoescape=select_autoescape(['html', 'xml'])
             )
 
+    def _setup_paths(self, result_dir):
+        """
+        Setup paths for a given result directory
 
-    def generate_report(self):
+        Args:
+            result_dir: Directory path containing test results
+        """
+        self.result_dir = Path(result_dir)
+        self.log_timestamp = self.result_dir.name.split("_", 1)[1]
+
+        self.data_path: DataPath = DataPath(
+            steps_log=self.result_dir / f"output_{self.log_timestamp}" / "steps.log",
+            result_json=self.result_dir / f"result_{self.log_timestamp}.json",
+            coverage_log=self.result_dir / f"output_{self.log_timestamp}" / "coverage.log",
+            screenshots_dir=self.result_dir / f"output_{self.log_timestamp}" / "screenshots",
+            property_exec_info=self.result_dir / f"property_exec_info_{self.log_timestamp}.json"
+        )
+
+        self.screenshots = deque()
+
+    def generate_report(self, result_dir_path=None):
         """
         Generate bug report and save to result directory
+
+        Args:
+            result_dir_path: Directory path containing test results (optional)
+                           If not provided, uses the path from initialization
         """
         try:
+            # Setup paths if result_dir_path is provided
+            if result_dir_path is not None:
+                self._setup_paths(result_dir_path)
+
+            # Check if paths are properly set up
+            if not hasattr(self, 'result_dir') or self.result_dir is None:
+                raise ValueError(
+                    "No result directory specified. Please provide result_dir_path or initialize with a directory.")
+
             logger.debug("Starting bug report generation")
 
             # Collect test data
-            test_data = self._collect_test_data()
+            test_data: ReportData = self._collect_test_data()
 
             # Generate HTML report
             html_content = self._generate_html_report(test_data)
@@ -95,170 +260,206 @@ class BugReportGenerator:
                 f.write(html_content)
 
             logger.debug(f"Bug report saved to: {report_path}")
+            return str(report_path)
 
         except Exception as e:
             logger.error(f"Error generating bug report: {e}")
+        finally:
+            self.executor.shutdown()
 
-    def _collect_test_data(self):
+    def _collect_test_data(self) -> ReportData:
         """
         Collect test data, including results, coverage, etc.
         """
-        data = {
+        data: ReportData = {
             "timestamp": self.log_timestamp,
             "bugs_found": 0,
             "executed_events": 0,
             "total_testing_time": 0,
-            "first_bug_time": 0,
-            "first_precondition_time": 0,
             "coverage": 0,
             "total_activities": [],
             "tested_activities": [],
+            "all_properties_count": 0,
+            "executed_properties_count": 0,
             "property_violations": [],
             "property_stats": [],
-            "screenshot_info": {},  # Store detailed information for each screenshot
-            "coverage_trend": []  # Store coverage trend data
+            "property_error_details": {},
+            "screenshot_info": {},
+            "coverage_trend": [],
+            "property_execution_trend": [],
+            "activity_count_history": {}
         }
 
         # Parse steps.log file to get test step numbers and screenshot mappings
-        steps_log_path = self.data_path.steps_log
         property_violations = {}  # Store multiple violation records for each property
-        relative_path = f"output_{self.log_timestamp}/screenshots"
-
-        if steps_log_path.exists():
-            with open(steps_log_path, "r", encoding="utf-8") as f:
-                # Track current test state
-                current_property = None
-                current_test = {}
-                monkey_events_count = 0
-                step_index = 0
-
-                for line in f:
-                    step_data = self._parse_step_data(line)
-                    if step_data:
-                        step_index += 1  # Count steps starting from 1
-                        step_type = step_data.get("Type", "")
-                        screenshot = step_data.get("Screenshot", "")
-                        info = step_data.get("Info", {})
-
-                        # Count Monkey events
-                        if step_type == "Monkey":
-                            monkey_events_count += 1
-
-                        # If screenshots are enabled, mark the screenshot
-                        if self.take_screenshots and screenshot:
-                            self._mark_screenshot(step_data)
-
-                        # Collect detailed information for each screenshot
-                        if screenshot and screenshot not in data["screenshot_info"]:
-                            self._add_screenshot_info(screenshot, step_type, info, step_index, relative_path, data)
-
-                        # Process ScriptInfo for property violations
-                        if step_type == "ScriptInfo":
-                            try:
-                                property_name = info.get("propName", "")
-                                state = info.get("state", "")
-                                current_property, current_test = self._process_script_info(
-                                    property_name, state, step_index, screenshot,
-                                    current_property, current_test, property_violations
-                                )
-                            except Exception as e:
-                                logger.error(f"Error processing ScriptInfo step {step_index}: {e}")
-
-                        # Store first and last step for time calculation
-                        if step_index == 1:
-                            first_step_time = step_data["Time"]
-                        last_step_time = step_data["Time"]
-
-                # Set the monkey events count
-                data["executed_events"] = monkey_events_count
-
-                # Calculate test time
-                if step_index > 0:
+        executed_properties_by_step = {}  # Track executed properties at each step: {step_count: set()}
+        executed_properties = set()  # Track unique executed properties
+
+        if not self.data_path.steps_log.exists():
+            logger.error(f"{self.data_path.steps_log} not exists")
+            return
+
+        current_property = None
+        current_test = {}
+        step_index = 0
+        monkey_events_count = 0  # Track monkey events separately
+
+        with open(self.data_path.steps_log, "r", encoding="utf-8") as f:
+            # Track current test state
+
+            for step_index, line in enumerate(f, start=1):
+                step_data = self._parse_step_data(line)
+
+                if not step_data:
+                    continue
+
+                step_type = step_data.get("Type", "")
+                screenshot = step_data.get("Screenshot", "")
+                info = step_data.get("Info", {})
+
+                # Count Monkey events separately
+                if step_type == "Monkey":
+                    monkey_events_count += 1
+
+                # If screenshots are enabled, mark the screenshot
+                if self.take_screenshots and step_data["Screenshot"]:
+                    self.executor.submit(self._mark_screenshot, step_data)
+
+                # Collect detailed information for each screenshot
+                if screenshot and screenshot not in data["screenshot_info"]:
+                    self._add_screenshot_info(step_data, step_index, data)
+
+                # Process ScriptInfo for property violations and execution tracking
+                if step_type == "ScriptInfo":
                     try:
-                        data["total_testing_time"] = int((datetime.datetime.strptime(last_step_time,"%Y-%m-%d %H:%M:%S.%f") -
-                                                          datetime.datetime.strptime(first_step_time,"%Y-%m-%d %H:%M:%S.%f")
-                                                         ).total_seconds())
+                        property_name = info.get("propName", "")
+                        state = info.get("state", "")
+                        
+                        # Track executed properties (properties that have been started)
+                        if property_name and state == "start":
+                            executed_properties.add(property_name)
+                            # Record the monkey steps count for this property execution
+                            executed_properties_by_step[monkey_events_count] = executed_properties.copy()
+                        
+                        current_property, current_test = self._process_script_info(
+                            property_name, state, step_index, screenshot,
+                            current_property, current_test, property_violations
+                        )
                     except Exception as e:
-                        logger.error(f"Error calculating test time: {e}")
+                        logger.error(f"Error processing ScriptInfo step {step_index}: {e}")
 
-        # Parse result file
-        result_json_path = self.data_path.result_json
-        
-        if result_json_path.exists():
-            with open(result_json_path, "r", encoding="utf-8") as f:
-                result_data = json.load(f)
+                # Store first and last step for time calculation
+                if step_index == 1:
+                    first_step_time = step_data["Time"]
+                last_step_time = step_data["Time"]
+
+            # Set the monkey events count correctly
+            data["executed_events"] = monkey_events_count
+
+            # Calculate test time
+            if first_step_time and last_step_time:
+                def _get_datetime(raw_datetime) -> datetime:
+                    return datetime.strptime(raw_datetime, r"%Y-%m-%d %H:%M:%S.%f")
+
+                test_time = _get_datetime(last_step_time) - _get_datetime(first_step_time)
 
-            # Calculate bug count directly from result data
-            for property_name, test_result in result_data.items():
-                # Check if failed or error
-                if test_result.get("fail", 0) > 0 or test_result.get("error", 0) > 0:
-                    data["bugs_found"] += 1
+                total_seconds = int(test_time.total_seconds())
+                hours, remainder = divmod(total_seconds, 3600)
+                minutes, seconds = divmod(remainder, 60)
+                data["total_testing_time"] = f"{hours:02d}:{minutes:02d}:{seconds:02d}"
 
-            # Store the raw result data for direct use in HTML template
-            data["property_stats"] = result_data
+        # Calculate bug count directly from result data
+        for property_name, test_result in self.test_result.items():
+            # Check if failed or error
+            if test_result["fail"] > 0 or test_result["error"] > 0:
+                data["bugs_found"] += 1
+
+        # Store the raw result data for direct use in HTML template
+        data["property_stats"] = self.test_result
+
+        # Calculate properties statistics
+        data["all_properties_count"] = len(self.test_result)
+        data["executed_properties_count"] = sum(1 for result in self.test_result.values() if result.get("executed", 0) > 0)
 
         # Process coverage data
-        cov_trend, last_line = self._get_cov_trend()
-        if cov_trend:
-            data["coverage_trend"] = cov_trend
-
-        if last_line:
-            try:
-                coverage_data = json.loads(last_line)
-                if coverage_data:
-                    data["coverage"] = coverage_data.get("coverage", 0)
-                    data["total_activities"] = coverage_data.get("totalActivities", [])
-                    data["tested_activities"] = coverage_data.get("testedActivities", [])
-            except Exception as e:
-                logger.error(f"Error parsing final coverage data: {e}")
+        data["coverage_trend"] = self.cov_trend
+
+        if self.cov_trend:
+            final_trend = self.cov_trend[-1]
+            data["coverage"] = final_trend["coverage"]
+            data["total_activities"] = final_trend["totalActivities"]
+            data["tested_activities"] = final_trend["testedActivities"]
+            data["total_activities_count"] = final_trend["totalActivitiesCount"]
+            data["tested_activities_count"] = final_trend["testedActivitiesCount"]
+            data["activity_count_history"] = final_trend["activityCountHistory"]
+
+        # Generate property execution trend aligned with coverage trend
+        data["property_execution_trend"] = self._generate_property_execution_trend(executed_properties_by_step)
 
         # Generate Property Violations list
         self._generate_property_violations_list(property_violations, data)
 
+        # Load error details for properties with fail/error state
+        data["property_error_details"] = self._load_property_error_details()
+
         return data
 
     def _parse_step_data(self, raw_step_info: str) -> StepData:
-        step_data = json.loads(raw_step_info)
-        step_data["Info"] = json.loads(step_data.get("Info"))
+        step_data: StepData = json.loads(raw_step_info)
+        step_data["Info"] = json.loads(step_data["Info"])
         return step_data
 
     def _mark_screenshot(self, step_data: StepData):
-        if step_data["Type"] == "Monkey":
-            try:
+        try:
+            step_type = step_data["Type"]
+            screenshot_name = step_data["Screenshot"]
+            if not screenshot_name:
+                return
+
+            if step_type == "Monkey":
                 act = step_data["Info"].get("act")
                 pos = step_data["Info"].get("pos")
-                screenshot_name = step_data["Screenshot"]
                 if act in ["CLICK", "LONG_CLICK"] or act.startswith("SCROLL"):
-                    screenshot_path = self.data_path.screenshots_dir / screenshot_name
-                    if screenshot_path.exists():
-                        self._mark_screenshot_interaction(screenshot_path, act, pos)
-            except Exception as e:
-                logger.error(f"Error processing Monkey step: {e}")
+                    self._mark_screenshot_interaction(step_type, screenshot_name, act, pos)
 
+            elif step_type == "Script":
+                act = step_data["Info"].get("method")
+                pos = step_data["Info"].get("params")
+                if act in ["click", "setText", "swipe"]:
+                    self._mark_screenshot_interaction(step_type, screenshot_name, act, pos)
 
-    def _mark_screenshot_interaction(self, screenshot_path, action_type, position):
+        except Exception as e:
+            logger.error(f"Error when marking screenshots: {e}")
+
+
+    def _mark_screenshot_interaction(self, step_type: str, screenshot_name: str, action_type: str, position: Union[List, tuple]) -> bool:
         """
-            Mark interaction on screenshot with colored rectangle
+        Mark interaction on screenshot with colored rectangle
 
-            Args:
-                screenshot_path (Path): Path to the screenshot file
-                action_type (str): Type of action ('CLICK' or 'LONG_CLICK' or 'SCROLL')
-                position (list): Position coordinates [x1, y1, x2, y2]
+        Args:
+            step_type (str): Type of the step (Monkey or Script)
+            screenshot_name (str): Name of the screenshot file
+            action_type (str): Type of action (CLICK/LONG_CLICK/SCROLL for Monkey, click/setText/swipe for Script)
+            position: Position coordinates or parameters (format varies by action type)
 
-            Returns:
-                bool: True if marking was successful, False otherwise
+        Returns:
+            bool: True if marking was successful, False otherwise
         """
-        try:
-            img = Image.open(screenshot_path).convert("RGB")
-            draw = ImageDraw.Draw(img)
+        screenshot_path: Path = self.data_path.screenshots_dir / screenshot_name
+        if not screenshot_path.exists():
+            logger.error(f"Screenshot file {screenshot_path} not exists.")
+            return False
 
-            if not isinstance(position, (list, tuple)) or len(position) != 4:
-                logger.warning(f"Invalid position format: {position}")
-                return False
+        img = Image.open(screenshot_path).convert("RGB")
+        draw = ImageDraw.Draw(img)
+        line_width = 5
 
-            x1, y1, x2, y2 = map(int, position)
+        if step_type == "Monkey":
+            if len(position) < 4:
+                logger.warning(f"Monkey action requires 4 coordinates, got {len(position)}. Skip drawing.")
+                return False
 
-            line_width = 5
+            x1, y1, x2, y2 = map(int, position[:4])
 
             if action_type == "CLICK":
                 for i in range(line_width):
@@ -270,56 +471,64 @@ class BugReportGenerator:
                 for i in range(line_width):
                     draw.rectangle([x1 - i, y1 - i, x2 + i, y2 + i], outline=(0, 255, 0))
 
-            img.save(screenshot_path)
-            return True
+        elif step_type == "Script":
+            if action_type == "click":
 
-        except Exception as e:
-            logger.error(f"Error marking screenshot {screenshot_path}: {e}")
-            return False
-
-
-    def _detect_screenshots_setting(self):
-        """
-            Detect if screenshots were enabled during test run.
-            Returns True if screenshots were taken, False otherwise.
-        """
-        return self.data_path.screenshots_dir.exists()
+                if len(position) < 2:
+                    logger.warning(f"Script click action requires 2 coordinates, got {len(position)}. Skip drawing.")
+                    return False
+                
+                x, y = map(float, position[:2])
+                x1, y1, x2, y2 = x - 50, y - 50, x + 50, y + 50
 
-    def _get_cov_trend(self):
-        # Parse coverage data
-        coverage_log_path = self.data_path.coverage_log
-        cov_trend = []
-        last_line = None
-        if coverage_log_path.exists():
-            with open(coverage_log_path, "r", encoding="utf-8") as f:
-                for line in f:
-                    if not line.strip():
-                        continue
-                    try:
-                        coverage_data = json.loads(line)
-                        cov_trend.append({
-                            "steps": coverage_data.get("stepsCount", 0),
-                            "coverage": coverage_data.get("coverage", 0),
-                            "tested_activities_count": coverage_data.get("testedActivitiesCount", 0)
-                        })
-                        last_line = line
-                    except Exception as e:
-                        logger.error(f"Error parsing coverage data: {e}")
-                        continue
-        return cov_trend, last_line
+                for i in range(line_width):
+                    draw.rectangle([x1 - i, y1 - i, x2 + i, y2 + i], outline=(255, 0, 0))
+                    
+            elif action_type == "swipe":
+
+                if len(position) < 4:
+                    logger.warning(f"Script swipe action requires 4 coordinates, got {len(position)}. Skip drawing.")
+                    return False
+                
+                x1, y1, x2, y2 = map(float, position[:4])
+                
+                # mark start and end positions with rectangles
+                start_x1, start_y1, start_x2, start_y2 = x1 - 50, y1 - 50, x1 + 50, y1 + 50
+                for i in range(line_width):
+                    draw.rectangle([start_x1 - i, start_y1 - i, start_x2 + i, start_y2 + i], outline=(255, 0, 0))
 
-    def _generate_html_report(self, data):
+                end_x1, end_y1, end_x2, end_y2 = x2 - 50, y2 - 50, x2 + 50, y2 + 50
+                for i in range(line_width):
+                    draw.rectangle([end_x1 - i, end_y1 - i, end_x2 + i, end_y2 + i], outline=(255, 0, 0))
+                
+                # draw line between start and end positions
+                draw.line([(x1, y1), (x2, y2)], fill=(255, 0, 0), width=line_width)
+                
+                # add text labels for start and end positions
+                font = ImageFont.truetype("arial.ttf", 80)
+                    
+                # draw "start" at start position
+                draw.text((x1 - 20, y1 - 70), "start", fill=(255, 0, 0), font=font)
+                    
+                # draw "end" at end position
+                draw.text((x2 - 15, y2 - 70), "end", fill=(255, 0, 0), font=font)
+
+        img.save(screenshot_path)
+        return True
+
+    def _generate_html_report(self, data: ReportData):
         """
         Generate HTML format bug report
         """
         try:
             # Format timestamp for display
-            timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 
             # Ensure coverage_trend has data
             if not data["coverage_trend"]:
                 logger.warning("No coverage trend data")
-                data["coverage_trend"] = [{"steps": 0, "coverage": 0, "tested_activities_count": 0}]
+                # Use the same field names as in coverage.log file
+                data["coverage_trend"] = [{"stepsCount": 0, "coverage": 0, "testedActivitiesCount": 0}]
 
             # Convert coverage_trend to JSON string, ensuring all data points are included
             coverage_trend_json = json.dumps(data["coverage_trend"])
@@ -332,18 +541,22 @@ class BugReportGenerator:
                 'total_testing_time': data["total_testing_time"],
                 'executed_events': data["executed_events"],
                 'coverage_percent': round(data["coverage"], 2),
-                'first_bug_time': data["first_bug_time"],
-                'first_precondition_time': data["first_precondition_time"],
-                'total_activities_count': len(data["total_activities"]),
-                'tested_activities_count': len(data["tested_activities"]),
-                'tested_activities': data["tested_activities"],  # Pass list of tested Activities
-                'total_activities': data["total_activities"],  # Pass list of all Activities
+                'total_activities_count': data["total_activities_count"],
+                'tested_activities_count': data["tested_activities_count"],
+                'tested_activities': data["tested_activities"],
+                'total_activities': data["total_activities"],
+                'all_properties_count': data["all_properties_count"],
+                'executed_properties_count': data["executed_properties_count"],
                 'items_per_page': 10,  # Items to display per page
                 'screenshots': self.screenshots,
                 'property_violations': data["property_violations"],
                 'property_stats': data["property_stats"],
+                'property_error_details': data["property_error_details"],
                 'coverage_data': coverage_trend_json,
-                'take_screenshots': self.take_screenshots  # Pass screenshot setting to template
+                'take_screenshots': self.take_screenshots,  # Pass screenshot setting to template
+                'property_execution_trend': data["property_execution_trend"],
+                'property_execution_data': json.dumps(data["property_execution_trend"]),
+                'activity_count_history': data["activity_count_history"]
             }
 
             # Check if template exists, if not create it
@@ -361,66 +574,52 @@ class BugReportGenerator:
             logger.error(f"Error rendering template: {e}")
             raise
 
-    def _add_screenshot_info(self, screenshot: str, step_type: str, info: Dict, step_index: int, relative_path: str, data: Dict):
+    def _add_screenshot_info(self, step_data: StepData, step_index: int, data: Dict):
         """
         Add screenshot information to data structure
-        
+
         Args:
-            screenshot: Screenshot filename
-            step_type: Type of step (Monkey, Script, ScriptInfo)
-            info: Step information dictionary
+            step_data: data for the current step
             step_index: Current step index
-            relative_path: Relative path to screenshots directory
             data: Data dictionary to update
         """
-        try:
-            caption = ""
+        caption = ""
 
-            if step_type == "Monkey":
-                # Extract 'act' attribute for Monkey type and convert to lowercase
-                caption = f"{info.get('act', 'N/A').lower()}"
-            elif step_type == "Script":
-                # Extract 'method' attribute for Script type
-                caption = f"{info.get('method', 'N/A')}"
-            elif step_type == "ScriptInfo":
-                # Extract 'propName' and 'state' attributes for ScriptInfo type
-                prop_name = info.get('propName', '')
-                state = info.get('state', 'N/A')
-                caption = f"{prop_name} {state}" if prop_name else f"{state}"
-
-            data["screenshot_info"][screenshot] = {
-                "type": step_type,
-                "caption": caption,
-                "step_index": step_index
-            }
-            
-            screenshot_caption = data["screenshot_info"][screenshot].get('caption', '')
-            self.screenshots.append({
-                'id': step_index,
-                'path': f"{relative_path}/{screenshot}",
-                'caption': f"{step_index}. {screenshot_caption}"
-            })
-            
-        except Exception as e:
-            logger.error(f"Error parsing screenshot info: {e}")
-            data["screenshot_info"][screenshot] = {
-                "type": step_type,
-                "caption": step_type,
-                "step_index": step_index
-            }
-            
-            screenshot_caption = data["screenshot_info"][screenshot].get('caption', '')
-            self.screenshots.append({
-                'id': step_index,
-                'path': f"{relative_path}/{screenshot}",
-                'caption': f"{step_index}. {screenshot_caption}"
-            })
+        if step_data["Type"] == "Monkey":
+            # Extract 'act' attribute for Monkey type and add MonkeyStepsCount
+            monkey_steps_count = step_data.get('MonkeyStepsCount', 'N/A')
+            action = step_data['Info'].get('act', 'N/A')
+            caption = f"Monkey Step {monkey_steps_count}: {action}"
+        elif step_data["Type"] == "Script":
+            # Extract 'method' attribute for Script type
+            caption = f"{step_data['Info'].get('method', 'N/A')}"
+        elif step_data["Type"] == "ScriptInfo":
+            # Extract 'propName' and 'state' attributes for ScriptInfo type
+            prop_name = step_data["Info"].get('propName', '')
+            state = step_data["Info"].get('state', 'N/A')
+            caption = f"{prop_name}: {state}" if prop_name else f"{state}"
+
+        screenshot_name = step_data["Screenshot"]
+        # Use relative path string instead of Path object
+        relative_screenshot_path = f"output_{self.log_timestamp}/screenshots/{screenshot_name}"
+
+        data["screenshot_info"][screenshot_name] = {
+            "type": step_data["Type"],
+            "caption": caption,
+            "step_index": step_index
+        }
 
-    def _process_script_info(self, property_name: str, state: str, step_index: int, screenshot: str, 
-                           current_property: str, current_test: Dict, property_violations: Dict) -> tuple:
+        self.screenshots.append({
+            'id': step_index,
+            'path': relative_screenshot_path,  # Now using string path
+            'caption': f"{step_index}. {caption}"
+        })
+
+    def _process_script_info(self, property_name: str, state: str, step_index: int, screenshot: str,
+                             current_property: str, current_test: Dict, property_violations: Dict) -> tuple:
         """
         Process ScriptInfo step for property violations tracking
-        
+
         Args:
             property_name: Property name from ScriptInfo
             state: State from ScriptInfo (start, pass, fail, error)
@@ -429,7 +628,7 @@ class BugReportGenerator:
             current_property: Currently tracked property
             current_test: Current test data
             property_violations: Dictionary to store violations
-            
+
         Returns:
             tuple: (updated_current_property, updated_current_test)
         """
@@ -464,13 +663,13 @@ class BugReportGenerator:
                     # Reset current test
                     current_property = None
                     current_test = {}
-        
+
         return current_property, current_test
 
     def _generate_property_violations_list(self, property_violations: Dict, data: Dict):
         """
         Generate property violations list from collected violation data
-        
+
         Args:
             property_violations: Dictionary containing property violations
             data: Data dictionary to update with property violations list
@@ -489,3 +688,141 @@ class BugReportGenerator:
                         "postcondition_page": end_step
                     })
                     index += 1
+
+    def _load_property_error_details(self) -> Dict[str, List[Dict]]:
+        """
+        Load property execution error details from property_exec_info file
+        
+        Returns:
+            Dict[str, List[Dict]]: Mapping of property names to their error tracebacks with context
+        """
+        if not self.data_path.property_exec_info.exists():
+            logger.warning(f"Property exec info file {self.data_path.property_exec_info} not found")
+            return {}
+            
+        try:
+            property_exec_infos = self._parse_property_exec_infos()
+            return self._group_errors_by_property(property_exec_infos)
+            
+        except Exception as e:
+            logger.error(f"Error reading property exec info file: {e}")
+            return {}
+
+    def _parse_property_exec_infos(self) -> List[PropertyExecInfo]:
+        """Parse property execution info from file"""
+        exec_infos = []
+        
+        with open(self.data_path.property_exec_info, "r", encoding="utf-8") as f:
+            for line_number, line in enumerate(f, 1):
+                line = line.strip()
+                if not line:
+                    continue
+                    
+                try:
+                    exec_info_data = json.loads(line)
+                    prop_name = exec_info_data.get("propName", "")
+                    state = exec_info_data.get("state", "")
+                    tb = exec_info_data.get("tb", "")
+                    start_steps_count = exec_info_data.get("startStepsCount", 0)
+                    
+                    exec_info = PropertyExecInfo(
+                        prop_name=prop_name,
+                        state=state,
+                        traceback=tb,
+                        start_steps_count=start_steps_count
+                    )
+                    
+                    if exec_info.is_error_state() and prop_name and tb:
+                        exec_infos.append(exec_info)
+                        
+                except json.JSONDecodeError as e:
+                    logger.warning(f"Failed to parse property exec info line {line_number}: {line[:100]}... Error: {e}")
+                    continue
+                    
+        return exec_infos
+
+    def _group_errors_by_property(self, exec_infos: List[PropertyExecInfo]) -> Dict[str, List[Dict]]:
+        """Group errors by property name and deduplicate"""
+        error_details = {}
+        
+        for exec_info in exec_infos:
+            prop_name = exec_info.prop_name
+            
+            if prop_name not in error_details:
+                error_details[prop_name] = {}
+            
+            error_hash = exec_info.get_error_hash()
+            
+            if error_hash in error_details[prop_name]:
+                # Error already exists, add occurrence
+                error_details[prop_name][error_hash].add_occurrence(exec_info.start_steps_count)
+            else:
+                # New error, create entry
+                error_details[prop_name][error_hash] = exec_info
+        
+        # Convert to template-compatible format
+        result = {}
+        for prop_name, hash_dict in error_details.items():
+            result[prop_name] = []
+            for exec_info in hash_dict.values():
+                result[prop_name].append({
+                    "state": exec_info.state,
+                    "traceback": exec_info.traceback,
+                    "occurrence_count": exec_info.occurrence_count,
+                    "short_description": exec_info.short_description,
+                    "startStepsCountList": exec_info.start_steps_count_list
+                })
+            
+            # Sort by earliest startStepsCount, then by occurrence count (descending)
+            result[prop_name].sort(key=lambda x: (min(x["startStepsCountList"]), -x["occurrence_count"]))
+        
+        return result
+
+    def _generate_property_execution_trend(self, executed_properties_by_step: Dict[int, set]) -> List[Dict]:
+        """
+        Generate property execution trend aligned with coverage trend
+        
+        Args:
+            executed_properties_by_step: Dictionary containing executed properties at each step
+            
+        Returns:
+            List[Dict]: Property execution trend data aligned with coverage trend
+        """
+        property_execution_trend = []
+        
+        # Get step points from coverage trend to ensure alignment
+        coverage_step_points = []
+        if self.cov_trend:
+            coverage_step_points = [cov_data["stepsCount"] for cov_data in self.cov_trend]
+        
+        # If no coverage data, use property execution data points
+        if not coverage_step_points and executed_properties_by_step:
+            coverage_step_points = sorted(executed_properties_by_step.keys())
+        
+        # Generate property execution data for each coverage step point
+        for step_count in coverage_step_points:
+            # Find the latest executed properties count up to this step
+            executed_count = 0
+            latest_step = 0
+            
+            for exec_step in executed_properties_by_step.keys():
+                if exec_step <= step_count and exec_step >= latest_step:
+                    latest_step = exec_step
+                    executed_count = len(executed_properties_by_step[exec_step])
+            
+            property_execution_trend.append({
+                "stepsCount": step_count,
+                "executedPropertiesCount": executed_count
+            })
+        
+        return property_execution_trend
+
+
+if __name__ == "__main__":
+    print("Generating bug report")
+    # OUTPUT_PATH = "<Your output path>"
+    OUTPUT_PATH = "P:/Python/Kea2/output/res_2025070814_4842540549"
+
+    report_generator = BugReportGenerator()
+    report_path = report_generator.generate_report(OUTPUT_PATH)
+    print(f"bug report generated: {report_path}")