| #!/usr/bin/env python3 |
| # Copyright 2021 The Chromium Authors |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| """Graph analysis functions for the testing framework. |
| """ |
| |
| import logging |
| from typing import List, Optional, Tuple |
| |
| from models import ActionCoverage |
| from models import ActionType |
| from models import Action |
| from models import ActionNode |
| from models import CoverageTest |
| from models import TestPlatform |
| |
| |
| def build_action_node_graph(root_node: ActionNode, |
| tests: List[CoverageTest]) -> None: |
| """ |
| Builds a graph of ActionNodes on the given `root_node`. The graph is |
| generated by iterating the `tests`, starting at the `root_node` for each |
| test, and adding ActionNodes to the graph for each state-change action |
| (following the graph for every state-change action). State-check actions are |
| added to the previous state-change action ActionNode. |
| """ |
| assert root_node is not None |
| assert isinstance(root_node, ActionNode) |
| assert isinstance(tests, list) |
| for test in tests: |
| assert isinstance(test, CoverageTest) |
| parent = root_node |
| for action in test.actions: |
| assert isinstance(action, Action) |
| assert action.type is not ActionType.PARAMETERIZED |
| if action.is_state_check(): |
| parent.add_state_check_action(action) |
| else: |
| node = None |
| if action.name in parent.children: |
| node = parent.children[action.name] |
| else: |
| node = ActionNode(action) |
| parent.add_child(node) |
| parent = node |
| |
| |
| def generage_graphviz_dot_file(root_node: ActionNode, |
| platform: Optional[TestPlatform]) -> str: |
| def get_all_nodes_and_assign_graph_ids(root: ActionNode |
| ) -> List[ActionNode]: |
| current_graph_id = 0 |
| |
| def get_all_nodes_helper(node: ActionNode, nodes: List[ActionNode]): |
| nonlocal current_graph_id |
| if node.graph_id is not None: |
| return |
| node.graph_id = current_graph_id |
| current_graph_id += 1 |
| nodes.append(node) |
| if not node.children: |
| return |
| for child in node.children.values(): |
| get_all_nodes_helper(child, nodes) |
| |
| # Skip the root node, as it is only there for the algorithm to work. |
| all_nodes = [] |
| for child in root.children.values(): |
| get_all_nodes_helper(child, all_nodes) |
| return all_nodes |
| |
| def print_graph(node: ActionNode) -> List[str]: |
| assert node.graph_id is not None, node.action.name |
| if not node.children: |
| return [] |
| lines = [] |
| for child in node.children.values(): |
| assert child.graph_id is not None, child.action.name |
| edge_str = str(node.graph_id) + " -> " + str(child.graph_id) |
| lines.append(edge_str) |
| lines.extend(print_graph(child)) |
| return lines |
| |
| lines = [] |
| lines.append("strict digraph {") |
| nodes = get_all_nodes_and_assign_graph_ids(root_node) |
| for node in nodes: |
| color_str = ("seagreen" if platform is None |
| or platform in node.action.full_coverage_platforms else |
| "sandybrown") |
| label_str = node.get_graphviz_label() |
| lines.append(f"{node.graph_id}[label={label_str} color={color_str}]") |
| # Skip the root node, as it is only there for the algorithm to work. |
| for child in root_node.children.values(): |
| lines.extend(print_graph(child)) |
| lines.append("}") |
| return "\n".join(lines) |
| |
| |
| # Removes any nodes and actions from the graph that are not supported by the |
| # given platform. |
| def trim_graph_to_platform_actions(root_node: ActionNode, |
| platform: TestPlatform) -> None: |
| """ |
| Removes any nodes and actions from the graph that are not supported by the |
| given platform. |
| """ |
| new_children = {} |
| for child in root_node.children.values(): |
| if child.action.supported_for_platform(platform): |
| new_children[child.action.name] = child |
| root_node.children = new_children |
| new_state_check_actions = {} |
| for action in root_node.state_check_actions.values(): |
| if action.supported_for_platform(platform): |
| new_state_check_actions[action.name] = action |
| root_node.state_check_actions = new_state_check_actions |
| for child in root_node.children.values(): |
| trim_graph_to_platform_actions(child, platform) |
| |
| |
| def generate_framework_tests(root_node: ActionNode, |
| platform: TestPlatform) -> List[CoverageTest]: |
| assert isinstance(root_node, ActionNode) |
| |
| def GetAllPaths(node: ActionNode) -> List[List[ActionNode]]: |
| assert node is not None |
| assert isinstance(node, ActionNode) |
| paths = [] |
| for child in node.children.values(): |
| for path in GetAllPaths(child): |
| assert path is not None |
| assert isinstance(path, list) |
| assert bool(path) |
| paths.append([node] + path) |
| if len(paths) == 0: |
| paths = [[node]] |
| return paths |
| |
| all_paths = GetAllPaths(root_node) |
| result = [] |
| for path in all_paths: |
| all_actions_in_path = [] |
| for node in path[1:]: # Skip the root node |
| all_actions_in_path.append(node.action) |
| all_actions_in_path.extend(node.state_check_actions.values()) |
| result.append(CoverageTest(all_actions_in_path, {platform})) |
| return result |
| |
| |
| def generate_coverage_file_and_percents( |
| required_coverage_tests: List[CoverageTest], |
| tested_graph_root: ActionNode, |
| platform: TestPlatform) -> Tuple[str, float, float]: |
| lines = [] |
| total_actions = 0.0 |
| actions_fully_covered = 0.0 |
| actions_partially_covered = 0.0 |
| for coverage_test in required_coverage_tests: |
| action_strings = [] |
| last_action_node = tested_graph_root |
| for action in coverage_test.actions: |
| total_actions += 1 |
| coverage = None |
| if last_action_node is not None: |
| if action.name in last_action_node.children: |
| coverage = action.get_coverage_for_platform(platform) |
| if (action.is_state_check() |
| and last_action_node.has_state_check_action(action)): |
| coverage = action.get_coverage_for_platform(platform) |
| if coverage is None: |
| last_action_node = None |
| action_strings.append(action.name + '🌑') |
| continue |
| elif (coverage == ActionCoverage.FULL): |
| actions_fully_covered += 1 |
| action_strings.append(action.name + '🌕') |
| elif (coverage == ActionCoverage.PARTIAL): |
| action_strings.append(action.name + '🌓') |
| actions_partially_covered += 1 |
| # Only proceed if the action was in the children. If not, then it |
| # was in the stateless action list and we stay at the same node. |
| if action.name in last_action_node.children: |
| last_action_node = last_action_node.children[action.name] |
| lines.append(action_strings) |
| |
| full_coverage = actions_fully_covered / total_actions |
| partial_coverage = ((actions_fully_covered + actions_partially_covered) / |
| total_actions) |
| logging.info(f"Coverage for {platform}:") |
| logging.info(f"Full coverage: {full_coverage:.0%}, " |
| f", with partial coverage: {partial_coverage:.0%}") |
| return ("\n".join(["\t".join(line) |
| for line in lines]), full_coverage, partial_coverage) |
