FM / tests

/opt/imh-python/lib/python3.9/site-packages/tests/

/opt/imh-python/lib/python3.9/site-packages/tests

Name	Size	Mode	Actions
__pycache__/	-	0755	rm
test_a_star_search.py	3860	0644	edit dl rm
test_bfs.py	2151	0644	edit dl rm
test_biconnected_components.py	9773	0644	edit dl rm
test_connected_components.py	6806	0644	edit dl rm
test_dfs.py	3677	0644	edit dl rm
test_directed_graph.py	6062	0644	edit dl rm
test_make_subgraph.py	3305	0644	edit dl rm
test_merge_graphs.py	7812	0644	edit dl rm
test_planarity.py	6465	0644	edit dl rm
test_spanning_tree.py	3161	0644	edit dl rm
test_undirected_graph.py	5676	0644	edit dl rm
utility_functions.py	6798	0644	edit dl rm
__init__.py	0	0644	edit dl rm

Edit: /opt/imh-python/lib/python3.9/site-packages/tests/test_a_star_search.py (3860B)

"""Provides unit tests to verify that the A* search algorithm is functioning correctly."""

import unittest

from ..pygraph import UndirectedGraph, a_star_search
from . import utility_functions
from ..pygraph.exceptions import NonexistentNodeError

class AStarSearchTest(unittest.TestCase):
    def test_a_star_search_with_invalid_nodes(self):
        """Does the ''a_star_search'' function throw an error for invalid nodes?"""
        graph = UndirectedGraph()

# --Test 1: Empty graph, both nodes invalid
        node_a = 1
        node_b = 2

try:
            path = a_star_search(graph, node_a, node_b)
        except NonexistentNodeError:
            pass
        else:
            self.fail('a_star_search function accepts an invalid node id for an empty graph')

# --Test 2: Single-node graph, node_b invalid
        node_a = graph.new_node()

try:
            path = a_star_search(graph, node_a, node_b)
        except NonexistentNodeError:
            pass
        else:
            self.fail('a_star_search function accepts an invalid node id {}'.format(node_b))

# --Test 3: Single-node graph, node_a invalid
        node_b = graph.new_node()
        graph.delete_node(node_a)

try:
            path = a_star_search(graph, node_a, node_b)
        except NonexistentNodeError:
            pass
        else:
            self.fail('a_star_search function accepts an invalid node id {}'.format(node_a))

# --Test 4: Dual-node graph, both nodes valid
        node_a = graph.new_node()

try:
            path = a_star_search(graph, node_a, node_b)
        except NonexistentNodeError:
            self.fail('a_star_search function throws an error with valid nodes')
        else:
            pass

def test_a_star_search_with_single_path(self):
        """Does the ''a_star_search'' function return a valid path when there's only one possible path?"""
        graph = utility_functions.build_simple_test_graph()

expected_path = [4, 1, 2, 5]
        path = a_star_search(graph, 4, 5)

self.assertEqual(expected_path, path)

def test_a_star_search_with_direct_connection(self):
        """Does the ''a_star_search'' function return the shortest path when there is a direct connection?"""
        graph = utility_functions.build_simple_test_graph()

# Add an edge to the graph to directly connect 2 nodes, providing a shorter path between them
        graph.new_edge(4, 5)

expected_path = [4, 5]
        path = a_star_search(graph, 4, 5)

self.assertEqual(expected_path, path)

def test_a_star_search_with_path_choices(self):
        """Does the ''a_star_search'' function return the shortest path between multiple available paths?"""
        graph = utility_functions.build_simple_test_graph()

# Add an edge to the graph to provide a shorter path between the start and goal nodes
        graph.new_edge(1, 5)

expected_path = [4, 1, 5]
        path = a_star_search(graph, 4, 5)

self.assertEqual(expected_path, path)

def test_a_star_search_with_no_path(self):
        """Does the ''a_star_search'' function return an empty list when no path exists?"""
        graph = utility_functions.build_simple_test_graph()

expected_path = []
        path = a_star_search(graph, 4, 3)

self.assertEqual(expected_path, path)

def test_a_star_search_with_square_graph_and_costs(self):
        """Does the ''a_star_search'' function return the proper path for a square graph with costs?"""
        graph = utility_functions.build_square_test_graph_with_costs()

# --The edge from 1 to 4 costs 10, while the cost of the [1, 2, 3, 4] path is [2, 3, 1], which sums to 6
        expected_path = [1, 2, 3, 4]
        path = a_star_search(graph, 1, 4)

self.assertEqual(expected_path, path)

"""Provides unit tests to verify that the A* search algorithm is functioning correctly.""" import unittest from ..pygraph import UndirectedGraph, a_star_search from . import utility_functions from ..pygraph.exceptions import NonexistentNodeError class AStarSearchTest(unittest.TestCase): def test_a_star_search_with_invalid_nodes(self): """Does the ''a_star_search'' function throw an error for invalid nodes?""" graph = UndirectedGraph() # --Test 1: Empty graph, both nodes invalid node_a = 1 node_b = 2 try: path = a_star_search(graph, node_a, node_b) except NonexistentNodeError: pass else: self.fail('a_star_search function accepts an invalid node id for an empty graph') # --Test 2: Single-node graph, node_b invalid node_a = graph.new_node() try: path = a_star_search(graph, node_a, node_b) except NonexistentNodeError: pass else: self.fail('a_star_search function accepts an invalid node id {}'.format(node_b)) # --Test 3: Single-node graph, node_a invalid node_b = graph.new_node() graph.delete_node(node_a) try: path = a_star_search(graph, node_a, node_b) except NonexistentNodeError: pass else: self.fail('a_star_search function accepts an invalid node id {}'.format(node_a)) # --Test 4: Dual-node graph, both nodes valid node_a = graph.new_node() try: path = a_star_search(graph, node_a, node_b) except NonexistentNodeError: self.fail('a_star_search function throws an error with valid nodes') else: pass def test_a_star_search_with_single_path(self): """Does the ''a_star_search'' function return a valid path when there's only one possible path?""" graph = utility_functions.build_simple_test_graph() expected_path = [4, 1, 2, 5] path = a_star_search(graph, 4, 5) self.assertEqual(expected_path, path) def test_a_star_search_with_direct_connection(self): """Does the ''a_star_search'' function return the shortest path when there is a direct connection?""" graph = utility_functions.build_simple_test_graph() # Add an edge to the graph to directly connect 2 nodes, providing a shorter path between them graph.new_edge(4, 5) expected_path = [4, 5] path = a_star_search(graph, 4, 5) self.assertEqual(expected_path, path) def test_a_star_search_with_path_choices(self): """Does the ''a_star_search'' function return the shortest path between multiple available paths?""" graph = utility_functions.build_simple_test_graph() # Add an edge to the graph to provide a shorter path between the start and goal nodes graph.new_edge(1, 5) expected_path = [4, 1, 5] path = a_star_search(graph, 4, 5) self.assertEqual(expected_path, path) def test_a_star_search_with_no_path(self): """Does the ''a_star_search'' function return an empty list when no path exists?""" graph = utility_functions.build_simple_test_graph() expected_path = [] path = a_star_search(graph, 4, 3) self.assertEqual(expected_path, path) def test_a_star_search_with_square_graph_and_costs(self): """Does the ''a_star_search'' function return the proper path for a square graph with costs?""" graph = utility_functions.build_square_test_graph_with_costs() # --The edge from 1 to 4 costs 10, while the cost of the [1, 2, 3, 4] path is [2, 3, 1], which sums to 6 expected_path = [1, 2, 3, 4] path = a_star_search(graph, 1, 4) self.assertEqual(expected_path, path)