From 6af5e1e02ca3512487057473bbabfb41d46762f3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E4=BE=9D=E7=91=AA=E8=B2=93?= Date: Thu, 16 Jul 2026 13:43:28 +0800 Subject: [PATCH] Remove redundant tests Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_013dggmjXoVy7JswW68o7M2V --- tests/test_graph.py | 18 ---- tests/test_palm_tree.py | 102 ------------------- tests/test_spqrtree.py | 187 ----------------------------------- tests/test_triconnected.py | 197 ------------------------------------- 4 files changed, 504 deletions(-) diff --git a/tests/test_graph.py b/tests/test_graph.py index 7b68e66..0a21995 100644 --- a/tests/test_graph.py +++ b/tests/test_graph.py @@ -59,11 +59,6 @@ class TestMultiGraphVertices(unittest.TestCase): self.g: MultiGraph = MultiGraph() """The graph under test.""" - def test_add_vertex(self) -> None: - """Test adding a single vertex.""" - self.g.add_vertex(1) - self.assertIn(1, self.g.vertices) - def test_add_multiple_vertices(self) -> None: """Test adding multiple vertices.""" for v in [1, 2, 3, 4]: @@ -110,11 +105,6 @@ class TestMultiGraphEdges(unittest.TestCase): self.assertEqual(e.u, 1) self.assertEqual(e.v, 2) - def test_add_edge_returns_edge(self) -> None: - """Test that add_edge returns an Edge object.""" - e: Edge = self.g.add_edge(1, 2) - self.assertIsInstance(e, Edge) - def test_add_parallel_edges(self) -> None: """Test adding parallel edges between the same pair.""" e1: Edge = self.g.add_edge(1, 2) @@ -151,14 +141,6 @@ class TestMultiGraphEdges(unittest.TestCase): e: Edge = self.g.add_edge(1, 2, virtual=True) self.assertTrue(e.virtual) - def test_edges_property(self) -> None: - """Test that edges property returns all edges.""" - e1: Edge = self.g.add_edge(1, 2) - e2: Edge = self.g.add_edge(2, 3) - ids: set[int] = {e.id for e in self.g.edges} - self.assertIn(e1.id, ids) - self.assertIn(e2.id, ids) - class TestMultiGraphNeighbors(unittest.TestCase): """Tests for neighbor/adjacency operations on MultiGraph.""" diff --git a/tests/test_palm_tree.py b/tests/test_palm_tree.py index f82b725..e8bb422 100644 --- a/tests/test_palm_tree.py +++ b/tests/test_palm_tree.py @@ -71,17 +71,6 @@ def _make_c4() -> tuple[MultiGraph, list[int]]: return g, [e0.id, e1.id, e2.id, e3.id] -class TestPalmTreeType(unittest.TestCase): - """Tests that build_palm_tree returns a PalmTree instance.""" - - def test_returns_palm_tree(self) -> None: - """Test that build_palm_tree returns a PalmTree object.""" - g: MultiGraph - g, _ = _make_k3() - pt: PalmTree = build_palm_tree(g, 1) - self.assertIsInstance(pt, PalmTree) - - class TestPalmTreePath(unittest.TestCase): """Tests for palm tree on a path graph P3 (no back edges).""" @@ -94,15 +83,6 @@ class TestPalmTreePath(unittest.TestCase): self.pt: PalmTree = build_palm_tree(g, 1) """The palm tree for the graph.""" - def test_dfs_num_root(self) -> None: - """Test that the start vertex has DFS number 1.""" - self.assertEqual(self.pt.dfs_num[1], 1) - - def test_dfs_num_order(self) -> None: - """Test that DFS numbers are assigned 1, 2, 3 in traversal order.""" - nums: list[int] = sorted(self.pt.dfs_num.values()) - self.assertEqual(nums, [1, 2, 3]) - def test_tree_edges_count(self) -> None: """Test that there are n-1 = 2 tree edges.""" self.assertEqual(len(self.pt.tree_edges), 2) @@ -117,32 +97,6 @@ class TestPalmTreePath(unittest.TestCase): self.assertIn(e0, self.pt.tree_edges) self.assertIn(e1, self.pt.tree_edges) - def test_parent_root(self) -> None: - """Test that the root has no parent (None).""" - self.assertIsNone(self.pt.parent.get(1)) - - def test_nd_values(self) -> None: - """Test that ND values are correct for P3.""" - # DFS from 1: 1→2→3 (since 2 is first in adj[1]) - self.assertEqual(self.pt.nd[1], 3) - - def test_nd_leaf(self) -> None: - """Test that a leaf vertex has ND = 1.""" - # Vertex 3 is a leaf in P3 - self.assertEqual(self.pt.nd[3], 1) - - def test_lowpt1_values(self) -> None: - """Test lowpt1 values for P3 (all vertices reach only themselves).""" - for v in [1, 2, 3]: - self.assertLessEqual( - self.pt.lowpt1[v], self.pt.dfs_num[v] - ) - - def test_lowpt1_no_fronds(self) -> None: - """Test that lowpt1[v] == dfs_num[v] when no fronds exist.""" - for v in [1, 2, 3]: - self.assertEqual(self.pt.lowpt1[v], self.pt.dfs_num[v]) - class TestPalmTreeTriangle(unittest.TestCase): """Tests for palm tree on the triangle graph K3.""" @@ -189,14 +143,6 @@ class TestPalmTreeTriangle(unittest.TestCase): """Test that the root has nd = 3.""" self.assertEqual(self.pt.nd[1], 3) - def test_nd_leaf(self) -> None: - """Test that the DFS leaf (vertex 3) has nd = 1.""" - # Vertex 3 is visited last in K3 with DFS from 1 - leaf: Hashable = next( - v for v, n in self.pt.nd.items() if n == 1 - ) - self.assertEqual(self.pt.nd[leaf], 1) - def test_first_child_of_root(self) -> None: """Test that root vertex 1 has a first child.""" self.assertIsNotNone(self.pt.first_child.get(1)) @@ -208,11 +154,6 @@ class TestPalmTreeTriangle(unittest.TestCase): ) self.assertIsNone(self.pt.first_child.get(leaf)) - def test_lowpt1_le_dfs_num(self) -> None: - """Test that lowpt1[v] <= dfs_num[v] for all v.""" - for v in [1, 2, 3]: - self.assertLessEqual(self.pt.lowpt1[v], self.pt.dfs_num[v]) - def test_lowpt1_le_lowpt2(self) -> None: """Test that lowpt1[v] <= lowpt2[v] for all v.""" for v in [1, 2, 3]: @@ -374,20 +315,6 @@ class TestPhiKeyP3(unittest.TestCase): # lowpt1[3]=3, case 3: 3*3+2 = 11 self.assertEqual(key, 3 * 3 + 2) - def test_tree_edge_case3_greater_than_case1(self) -> None: - """Test that case-3 phi > case-1 phi for ordering. - - Case 1: phi = 3*lowpt1[w] - Case 3: phi = 3*lowpt1[w]+2 - Case 3 must be strictly greater than case 1 for same lowpt1. - """ - e0: int = self.eids[0] - key_v1: int = phi_key( - v=1, eid=e0, pt=self.pt, graph=self.g, - ) - # Case 3 value (8) > case 1 value (6) for lowpt1[2]=2 - self.assertGreater(key_v1, 3 * 2) - class TestPhiKeyK3Frond(unittest.TestCase): """Tests for phi_key correctness on the triangle K3. @@ -426,35 +353,6 @@ class TestPhiKeyK3Frond(unittest.TestCase): # Correct formula: 3 * dfs_num[w=1] + 1 = 3*1+1 = 4 self.assertEqual(key, 3 * 1 + 1) - def test_frond_phi_different_from_v_formula(self) -> None: - """Test that frond phi uses w (not v) DFS number. - - The buggy formula uses dfs_num[v] (= 3) giving 3*3+2 = 11. - The correct formula uses dfs_num[w] (= 1) giving 3*1+1 = 4. - These must differ. - """ - e2: int = self.eids[2] - key: int = phi_key( - v=3, eid=e2, pt=self.pt, graph=self.g, - ) - # The buggy value would be 3*dfs_num[v=3]+2 = 3*3+2 = 11. - # The correct value is 3*dfs_num[w=1]+1 = 4. - self.assertNotEqual(key, 11) - self.assertEqual(key, 4) - - def test_frond_phi_less_than_tree_edge_case3(self) -> None: - """Test ordering: frond phi < tree-edge case-3 phi. - - The frond phi (4) should be less than a case-3 tree-edge phi - with the same lowpt1 (3*1+2=5), ensuring correct DFS order. - """ - e2: int = self.eids[2] - frond_key: int = phi_key( - v=3, eid=e2, pt=self.pt, graph=self.g, - ) - # Frond phi = 3*1+1=4; case-3 tree-edge phi at lowpt1=1 = 3*1+2=5 - self.assertLess(frond_key, 3 * 1 + 2) - def test_tree_edge_case1_condition(self) -> None: """Test phi_key for tree edge where lowpt2[w] < dfs_num[v]. diff --git a/tests/test_spqrtree.py b/tests/test_spqrtree.py index 6164cb0..d49895f 100644 --- a/tests/test_spqrtree.py +++ b/tests/test_spqrtree.py @@ -120,11 +120,6 @@ def _collect_all_nodes(root: SPQRNode) -> list[SPQRNode]: class TestSPQRNodeStructure(unittest.TestCase): """Tests for SPQRNode structure and attributes.""" - def test_spqrnode_has_type(self) -> None: - """Test that SPQRNode has a type attribute.""" - root: SPQRNode = build_spqr_tree(_make_k3()) - self.assertIsInstance(root.type, NodeType) - def test_spqrnode_has_skeleton(self) -> None: """Test that SPQRNode has a skeleton graph.""" root: SPQRNode = build_spqr_tree(_make_k3()) @@ -146,12 +141,6 @@ class TestSPQRNodeStructure(unittest.TestCase): root: SPQRNode = build_spqr_tree(_make_k3()) self.assertIsNone(root.parent) - def test_children_parent_links(self) -> None: - """Test that children have correct parent links.""" - root: SPQRNode = build_spqr_tree(_make_k3()) - for child in root.children: - self.assertIs(child.parent, root) - class TestSPQRK3(unittest.TestCase): """Tests for the SPQR-tree of the triangle K3.""" @@ -164,20 +153,10 @@ class TestSPQRK3(unittest.TestCase): _collect_all_nodes(self.root) """All SPQR tree nodes.""" - def test_returns_spqrnode(self) -> None: - """Test that build_spqr_tree returns an SPQRNode.""" - self.assertIsInstance(self.root, SPQRNode) - def test_root_is_s_node(self) -> None: """Test that K3 produces an S-node (POLYGON) as root.""" self.assertEqual(self.root.type, NodeType.S) - def test_node_types_are_valid(self) -> None: - """Test that all node types are valid NodeType values.""" - for node in self.all_nodes: - self.assertIsInstance(node.type, NodeType) - self.assertIn(node.type, list(NodeType)) - class TestSPQRK4(unittest.TestCase): """Tests for the SPQR-tree of the complete graph K4.""" @@ -194,10 +173,6 @@ class TestSPQRK4(unittest.TestCase): """Test that K4 produces a single R-node.""" self.assertEqual(self.root.type, NodeType.R) - def test_skeleton_has_vertices(self) -> None: - """Test that the R-node skeleton has vertices.""" - self.assertGreater(self.root.skeleton.num_vertices(), 0) - class TestSPQRC4(unittest.TestCase): """Tests for the SPQR-tree of the 4-cycle C4.""" @@ -214,11 +189,6 @@ class TestSPQRC4(unittest.TestCase): """Test that C4 produces an S-node (POLYGON) as root.""" self.assertEqual(self.root.type, NodeType.S) - def test_node_types_are_valid(self) -> None: - """Test that all node types are valid NodeType values.""" - for node in self.all_nodes: - self.assertIsInstance(node.type, NodeType) - class TestSPQRTwoParallel(unittest.TestCase): """Tests for the SPQR-tree of two parallel edges.""" @@ -258,29 +228,10 @@ class TestSPQRThreeParallel(unittest.TestCase): """Test that 3 parallel edges produce a single P-node.""" self.assertEqual(self.root.type, NodeType.P) - def test_node_types_are_valid(self) -> None: - """Test that all node types are valid NodeType values.""" - for node in self.all_nodes: - self.assertIsInstance(node.type, NodeType) - class TestSPQRInvariants(unittest.TestCase): """Tests for global SPQR-tree invariants across all graphs.""" - def _check_parent_links(self, root: SPQRNode) -> None: - """Check that parent-child links are consistent. - - :param root: The SPQR-tree root. - :return: None - """ - for node in _collect_all_nodes(root): - for child in node.children: - self.assertIs( - child.parent, - node, - f"Child {child.type} has wrong parent", - ) - def _check_skeleton_edges(self, root: SPQRNode) -> None: """Check that each node's skeleton has at least 1 edge. @@ -294,28 +245,6 @@ class TestSPQRInvariants(unittest.TestCase): f"Node {node.type} has empty skeleton", ) - def test_k3_parent_links(self) -> None: - """Test parent link invariant for K3.""" - self._check_parent_links(build_spqr_tree(_make_k3())) - - def test_c4_parent_links(self) -> None: - """Test parent link invariant for C4.""" - self._check_parent_links(build_spqr_tree(_make_c4())) - - def test_k4_parent_links(self) -> None: - """Test parent link invariant for K4.""" - self._check_parent_links(build_spqr_tree(_make_k4())) - - def test_two_parallel_parent_links(self) -> None: - """Test parent link invariant for 2 parallel edges.""" - self._check_parent_links(build_spqr_tree(_make_two_parallel())) - - def test_three_parallel_parent_links(self) -> None: - """Test parent link invariant for 3 parallel edges.""" - self._check_parent_links( - build_spqr_tree(_make_three_parallel()) - ) - def test_k3_skeleton_edges(self) -> None: """Test skeleton edge invariant for K3.""" self._check_skeleton_edges(build_spqr_tree(_make_k3())) @@ -409,20 +338,6 @@ class TestSPQRDiamond(unittest.TestCase): _collect_all_nodes(self.root) """All SPQR tree nodes.""" - def test_at_least_two_nodes(self) -> None: - """Test that diamond produces at least 2 SPQR-tree nodes.""" - self.assertGreaterEqual( - len(self.all_nodes), - 2, - "Diamond has a separation pair, expect >=2 SPQR nodes", - ) - - def test_node_types_are_valid(self) -> None: - """Test that all node types are valid NodeType values.""" - for node in self.all_nodes: - self.assertIsInstance(node.type, NodeType) - self.assertIn(node.type, list(NodeType)) - def test_no_ss_adjacency(self) -> None: """Test that no S-node is adjacent to another S-node.""" _assert_no_ss_pp(self, self.root, NodeType.S) @@ -463,11 +378,6 @@ class TestSPQRTheta(unittest.TestCase): "expect P-node at root", ) - def test_node_types_are_valid(self) -> None: - """Test that all node types are valid NodeType values.""" - for node in self.all_nodes: - self.assertIsInstance(node.type, NodeType) - def test_no_ss_adjacency(self) -> None: """Test that no S-node is adjacent to another S-node.""" _assert_no_ss_pp(self, self.root, NodeType.S) @@ -504,10 +414,6 @@ class TestSPQRPrism(unittest.TestCase): ) self.assertEqual(self.root.type, NodeType.R) - def test_no_children(self) -> None: - """Test that the single R-node has no children.""" - self.assertEqual(len(self.root.children), 0) - def test_skeleton_has_nine_edges(self) -> None: """Test that the R-node skeleton contains 9 edges.""" self.assertEqual(self.root.skeleton.num_edges(), 9) @@ -546,52 +452,6 @@ def _assert_no_ss_pp( ) -class TestSPQRNoSSPPInvariants(unittest.TestCase): - """Tests that no S-S or P-P adjacency occurs for all graphs.""" - - def _check_tree(self, g: MultiGraph) -> None: - """Build SPQR-tree and check S-S and P-P invariants. - - :param g: The input multigraph. - :return: None - """ - root: SPQRNode = build_spqr_tree(g) - _assert_no_ss_pp(self, root, NodeType.S) - _assert_no_ss_pp(self, root, NodeType.P) - - def test_k3_no_ss_pp(self) -> None: - """Test no S-S or P-P adjacency for K3.""" - self._check_tree(_make_k3()) - - def test_c4_no_ss_pp(self) -> None: - """Test no S-S or P-P adjacency for C4.""" - self._check_tree(_make_c4()) - - def test_k4_no_ss_pp(self) -> None: - """Test no S-S or P-P adjacency for K4.""" - self._check_tree(_make_k4()) - - def test_two_parallel_no_ss_pp(self) -> None: - """Test no S-S or P-P adjacency for 2 parallel edges.""" - self._check_tree(_make_two_parallel()) - - def test_three_parallel_no_ss_pp(self) -> None: - """Test no S-S or P-P adjacency for 3 parallel edges.""" - self._check_tree(_make_three_parallel()) - - def test_diamond_no_ss_pp(self) -> None: - """Test no S-S or P-P adjacency for the diamond graph.""" - self._check_tree(_make_diamond()) - - def test_theta_no_ss_pp(self) -> None: - """Test no S-S or P-P adjacency for the theta graph.""" - self._check_tree(_make_theta()) - - def test_prism_no_ss_pp(self) -> None: - """Test no S-S or P-P adjacency for the triangular prism.""" - self._check_tree(_make_prism()) - - def _count_real_edges_in_tree(root: SPQRNode) -> int: """Count real (non-virtual) edges across all SPQR-tree skeletons. @@ -820,28 +680,6 @@ class TestSPQRMultiEdgeComplex(unittest.TestCase): """Test all SPQR-tree invariants for the multi-edge graph.""" _check_spqr_invariants(self, self.g, self.root) - def test_has_p_node(self) -> None: - """Test that multi-edges produce P-nodes in the tree.""" - p_nodes: list[SPQRNode] = [ - n for n in self.all_nodes - if n.type == NodeType.P - ] - self.assertGreaterEqual( - len(p_nodes), 1, - "Multi-edge graph should have at least one P-node", - ) - - def test_has_s_node(self) -> None: - """Test that the cycle backbone produces an S-node.""" - s_nodes: list[SPQRNode] = [ - n for n in self.all_nodes - if n.type == NodeType.S - ] - self.assertGreaterEqual( - len(s_nodes), 1, - "Multi-edge graph should have at least one S-node", - ) - def test_exact_node_structure(self) -> None: """Test exact SPQR-tree node counts: 2 P-nodes, 1 S-node. @@ -1045,10 +883,6 @@ class TestSPQRSingleEdge(unittest.TestCase): """Test that there is exactly 1 node in the tree.""" self.assertEqual(len(self.all_nodes), 1) - def test_no_children(self) -> None: - """Test that the Q-node has no children.""" - self.assertEqual(len(self.root.children), 0) - def test_skeleton_has_one_edge(self) -> None: """Test that the Q-node skeleton has exactly 1 edge.""" self.assertEqual(self.root.skeleton.num_edges(), 1) @@ -1104,10 +938,6 @@ class TestSPQRC6(unittest.TestCase): """Test that C6 yields exactly 1 SPQR node.""" self.assertEqual(len(self.all_nodes), 1) - def test_no_children(self) -> None: - """Test that the root S-node has no children.""" - self.assertEqual(len(self.root.children), 0) - def test_skeleton_has_six_edges(self) -> None: """Test that the S-node skeleton has 6 edges.""" self.assertEqual(self.root.skeleton.num_edges(), 6) @@ -1225,10 +1055,6 @@ class TestSPQRPetersen(unittest.TestCase): """Test that there is exactly 1 node in the tree.""" self.assertEqual(len(self.all_nodes), 1) - def test_no_children(self) -> None: - """Test that the R-node has no children.""" - self.assertEqual(len(self.root.children), 0) - def test_skeleton_has_fifteen_edges(self) -> None: """Test that the R-node skeleton has 15 edges.""" self.assertEqual(self.root.skeleton.num_edges(), 15) @@ -2120,19 +1946,6 @@ class TestSPQRLadder(unittest.TestCase): self.assertEqual(len(s), 3, "Expected 3 S-nodes") self.assertEqual(len(p), 2, "Expected 2 P-nodes") - def test_no_r_or_q_nodes(self) -> None: - """Test that the ladder has no R-nodes or Q-nodes.""" - r: list[SPQRNode] = [ - n for n in self.all_nodes - if n.type == NodeType.R - ] - q: list[SPQRNode] = [ - n for n in self.all_nodes - if n.type == NodeType.Q - ] - self.assertEqual(len(r), 0, "Expected no R-nodes") - self.assertEqual(len(q), 0, "Expected no Q-nodes") - def _make_c7() -> MultiGraph: """Build the 7-cycle C7 (vertices 0-6). diff --git a/tests/test_triconnected.py b/tests/test_triconnected.py index 7c9042a..e4dabb8 100644 --- a/tests/test_triconnected.py +++ b/tests/test_triconnected.py @@ -143,10 +143,6 @@ class TestTriconnectedK3(unittest.TestCase): find_triconnected_components(self.g) """The triconnected split components.""" - def test_returns_list(self) -> None: - """Test that find_triconnected_components returns a list.""" - self.assertIsInstance(self.comps, list) - def test_single_component(self) -> None: """Test that K3 produces exactly 1 triconnected component.""" self.assertEqual(len(self.comps), 1) @@ -306,16 +302,6 @@ class TestTriconnectedThreeParallel(unittest.TestCase): class TestTriconnectedInvariants(unittest.TestCase): """Tests for global invariants across all graphs.""" - def _check_real_edge_count(self, g: MultiGraph) -> None: - """Check that real edge count is preserved across decomposition. - - :param g: The input graph. - :return: None - """ - comps: list[TriconnectedComponent] = \ - find_triconnected_components(g) - self.assertEqual(_count_real_edges(comps), g.num_edges()) - def _check_virtual_edges_in_two_comps( self, comps: list[TriconnectedComponent] ) -> None: @@ -334,26 +320,6 @@ class TestTriconnectedInvariants(unittest.TestCase): f"(expected 2)", ) - def test_k3_real_edge_count(self) -> None: - """Test real edge count invariant for K3.""" - self._check_real_edge_count(_make_k3()) - - def test_c4_real_edge_count(self) -> None: - """Test real edge count invariant for C4.""" - self._check_real_edge_count(_make_c4()) - - def test_k4_real_edge_count(self) -> None: - """Test real edge count invariant for K4.""" - self._check_real_edge_count(_make_k4()) - - def test_two_parallel_real_edge_count(self) -> None: - """Test real edge count invariant for 2 parallel edges.""" - self._check_real_edge_count(_make_two_parallel()) - - def test_three_parallel_real_edge_count(self) -> None: - """Test real edge count invariant for 3 parallel edges.""" - self._check_real_edge_count(_make_three_parallel()) - def test_k3_virtual_edges_in_two_comps(self) -> None: """Test virtual edge invariant for K3.""" comps: list[TriconnectedComponent] = \ @@ -384,40 +350,6 @@ class TestTriconnectedInvariants(unittest.TestCase): find_triconnected_components(_make_three_parallel()) self._check_virtual_edges_in_two_comps(comps) - def test_component_types_are_valid(self) -> None: - """Test that all component types are valid ComponentType values.""" - for g in [ - _make_k3(), _make_c4(), _make_k4(), - _make_two_parallel(), _make_three_parallel(), - ]: - comps: list[TriconnectedComponent] = \ - find_triconnected_components(g) - for comp in comps: - self.assertIsInstance(comp.type, ComponentType) - self.assertIn( - comp.type, - [ - ComponentType.BOND, - ComponentType.POLYGON, - ComponentType.TRICONNECTED, - ], - ) - - def test_each_component_has_edges(self) -> None: - """Test that every component has at least 2 edges.""" - for g in [ - _make_k3(), _make_c4(), _make_k4(), - _make_two_parallel(), _make_three_parallel(), - ]: - comps: list[TriconnectedComponent] = \ - find_triconnected_components(g) - for comp in comps: - self.assertGreaterEqual( - len(comp.edges), - 2, - f"Component {comp.type} has fewer than 2 edges", - ) - def _make_diamond() -> MultiGraph: """Build the diamond graph (K4 minus one edge). @@ -489,14 +421,6 @@ class TestTriconnectedDiamond(unittest.TestCase): find_triconnected_components(self.g) """The triconnected split components.""" - def test_at_least_two_components(self) -> None: - """Test that the diamond produces at least 2 components.""" - self.assertGreaterEqual( - len(self.comps), - 2, - "Diamond has separation pair {2,3}, expect >=2 components", - ) - def test_total_real_edges(self) -> None: """Test that total real edge count equals input edge count (5).""" self.assertEqual( @@ -515,18 +439,6 @@ class TestTriconnectedDiamond(unittest.TestCase): f"(expected 2)", ) - def test_no_ss_adjacency(self) -> None: - """Test that no two S-type components share a virtual edge.""" - _assert_no_same_type_adjacency( - self, self.comps, ComponentType.POLYGON - ) - - def test_no_pp_adjacency(self) -> None: - """Test that no two P-type components share a virtual edge.""" - _assert_no_same_type_adjacency( - self, self.comps, ComponentType.BOND - ) - def test_each_component_has_at_least_two_edges(self) -> None: """Test that every component has at least 2 edges.""" for comp in self.comps: @@ -566,18 +478,6 @@ class TestTriconnectedTheta(unittest.TestCase): f"(expected 2)", ) - def test_no_ss_adjacency(self) -> None: - """Test that no two S-type components share a virtual edge.""" - _assert_no_same_type_adjacency( - self, self.comps, ComponentType.POLYGON - ) - - def test_no_pp_adjacency(self) -> None: - """Test that no two P-type components share a virtual edge.""" - _assert_no_same_type_adjacency( - self, self.comps, ComponentType.BOND - ) - def test_each_component_has_at_least_two_edges(self) -> None: """Test that every component has at least 2 edges.""" for comp in self.comps: @@ -963,29 +863,6 @@ class TestTriconnectedMultiEdgeComplex(unittest.TestCase): """Test all decomposition invariants for the multi-edge graph.""" _check_all_invariants(self, self.g, self.comps) - def test_has_bond_components(self) -> None: - """Test that multi-edges produce BOND components.""" - bond_types: list[TriconnectedComponent] = [ - c for c in self.comps - if c.type == ComponentType.BOND - ] - self.assertGreaterEqual( - len(bond_types), 1, - "Multi-edge graph should have at least one BOND " - "component", - ) - - def test_has_polygon_component(self) -> None: - """Test that the backbone cycle produces a POLYGON component.""" - poly_types: list[TriconnectedComponent] = [ - c for c in self.comps - if c.type == ComponentType.POLYGON - ] - self.assertGreaterEqual( - len(poly_types), 1, - "Multi-edge graph should have at least one POLYGON", - ) - def test_exact_component_structure(self) -> None: """Test exact component counts: 2 BONDs and 1 POLYGON. @@ -1601,12 +1478,6 @@ class TestTriconnectedK33(unittest.TestCase): ] self.assertEqual(len(real), 9) - def test_total_real_edges(self) -> None: - """Test that total real edge count equals input edge count.""" - self.assertEqual( - _count_real_edges(self.comps), self.g.num_edges() - ) - class TestTriconnectedW4(unittest.TestCase): """Tests for triconnected decomposition of the wheel graph W4. @@ -1642,12 +1513,6 @@ class TestTriconnectedW4(unittest.TestCase): ] self.assertEqual(len(real), 8) - def test_total_real_edges(self) -> None: - """Test that total real edge count equals input edge count.""" - self.assertEqual( - _count_real_edges(self.comps), self.g.num_edges() - ) - class TestTriconnectedK3Doubled(unittest.TestCase): """Tests for triconnected decomposition of K3 with doubled edges. @@ -1850,18 +1715,6 @@ class TestTriconnectedPetersenAugmentedTwice(unittest.TestCase): """Test all decomposition invariants for doubly-aug. Petersen.""" _check_all_invariants(self, self.g, self.comps) - def test_136_total_components(self) -> None: - """Test that the doubly-augmented Petersen yields 136 comps. - - Expected: 60 BOND + 75 POLYGON + 1 TRICONNECTED = 136 total. - """ - self.assertEqual( - len(self.comps), - 136, - f"Doubly-augmented Petersen should have 136 components, " - f"got {len(self.comps)}", - ) - def test_one_triconnected(self) -> None: """Test that there is exactly 1 TRICONNECTED component.""" tc: list[TriconnectedComponent] = [ @@ -2002,13 +1855,6 @@ class TestTriconnectedLadder(unittest.TestCase): self.assertEqual(len(poly), 3, "Expected 3 POLYGON") self.assertEqual(len(bond), 2, "Expected 2 BOND") - def test_real_edge_count(self) -> None: - """Test that total real edge count equals 10.""" - self.assertEqual( - _count_real_edges(self.comps), - self.g.num_edges(), - ) - def _make_c7() -> MultiGraph: """Build the 7-cycle C7 (vertices 0-6). @@ -2164,13 +2010,6 @@ class TestTriconnectedK23(unittest.TestCase): self.assertEqual(len(poly), 3, "Expected 3 POLYGON") self.assertEqual(len(bond), 1, "Expected 1 BOND") - def test_real_edge_count(self) -> None: - """Test that total real edge count equals 6.""" - self.assertEqual( - _count_real_edges(self.comps), - self.g.num_edges(), - ) - def _make_w5() -> MultiGraph: """Build the wheel graph W5 (hub + 5-cycle, 6 vertices). @@ -2484,13 +2323,6 @@ class TestTriconnectedK4OneDoubled(unittest.TestCase): len(tri), 1, "Expected 1 TRICONNECTED", ) - def test_real_edge_count(self) -> None: - """Test that total real edge count equals 7.""" - self.assertEqual( - _count_real_edges(self.comps), - self.g.num_edges(), - ) - def _make_mobius_kantor() -> MultiGraph: """Build the Mobius-Kantor graph GP(8,3) (16 verts, 24 edges). @@ -2611,13 +2443,6 @@ class TestTriconnectedPetersenAugmented(unittest.TestCase): """Test all decomposition invariants for aug. Petersen.""" _check_all_invariants(self, self.g, self.comps) - def test_thirty_one_components(self) -> None: - """Test that augmented Petersen has 31 components.""" - self.assertEqual( - len(self.comps), 31, - f"Expected 31 components, got {len(self.comps)}", - ) - def test_one_triconnected(self) -> None: """Test that there is exactly 1 TRICONNECTED component.""" tri: list[TriconnectedComponent] = [ @@ -2651,13 +2476,6 @@ class TestTriconnectedPetersenAugmented(unittest.TestCase): f"Expected 15 POLYGON, got {len(polys)}", ) - def test_real_edge_count(self) -> None: - """Test that total real edge count equals 60.""" - self.assertEqual( - _count_real_edges(self.comps), - self.g.num_edges(), - ) - def _make_wikimedia_spqr() -> MultiGraph: """Build the Wikimedia Commons SPQR-tree example graph. @@ -2716,10 +2534,6 @@ class TestTriconnectedWikimediaSpqr(unittest.TestCase): self.comps: list[TriconnectedComponent] = \ find_triconnected_components(self.g) - def test_component_count(self) -> None: - """Test that there are exactly 5 components.""" - self.assertEqual(len(self.comps), 5) - def test_triconnected_count(self) -> None: """Test that there are exactly 3 TRICONNECTED.""" n: int = sum( @@ -2801,10 +2615,6 @@ class TestTriconnectedRpstFig1a(unittest.TestCase): self.comps: list[TriconnectedComponent] = \ find_triconnected_components(self.g) - def test_component_count(self) -> None: - """Test that there are exactly 10 components.""" - self.assertEqual(len(self.comps), 10) - def test_triconnected_count(self) -> None: """Test that there is exactly 1 TRICONNECTED.""" n: int = sum( @@ -2911,13 +2721,6 @@ class TestBiconnectivityCheck(unittest.TestCase): find_triconnected_components(g) self.assertEqual(comps, []) - def test_biconnected_graph_ok(self) -> None: - """Test that a biconnected graph does not raise.""" - g: MultiGraph = _make_k3() - comps: list[TriconnectedComponent] = \ - find_triconnected_components(g) - self.assertEqual(len(comps), 1) - # Script used by TestTriconnectedDeterminism to run decomposition # in a subprocess with a specific PYTHONHASHSEED.