def testExtractMinAllEqualReturnFirstNode(self):
expected = Node(0)
nodes = {0: expected, 1: Node(1), 2: Node(2)}
result = self.solution.extractMin(nodes)
self.assertEqual(expected, result)
def testExtractMinLastNodeHasShortedDistance(self):
expected = Node(2)
expected.distance = 0
nodes = {0: Node(0), 1: Node(1), 2: expected}
result = self.solution.extractMin(nodes)
self.assertEqual(expected, result)
def testInitializeNodesLastNodeIsSource(self):
number_of_nodes = 3
source = 2
source_node = Node(source)
source_node.distance = 0
expected = {0: Node(0), 1: Node(1), 2: source_node}
self._assertInitializeNodes(expected, number_of_nodes, source)
def testInitializeNodesMiddleNodeIsSource(self):
number_of_nodes = 3
source = 1
source_node = Node(source)
source_node.distance = 0
expected = {0: Node(0), 1: source_node, 2: Node(2)}
self._assertInitializeNodes(expected, number_of_nodes, source)
def testInitializeNodesFirstNodeIsSource(self):
number_of_nodes = 3
source = 0
source_node = Node(source)
source_node.distance = 0
expected = {0: source_node, 1: Node(1), 2: Node(2)}
self._assertInitializeNodes(expected, number_of_nodes, source)
def testRelaxNewDistanceIsLessChangesParent(self):
flight = (1, 100)
current = Node(0)
current.distance = 0
target = Node(1)
target.distance = MORE_THAN_MAX_COST
target.depth = 0
target.parent = None
nodes = {1: target, 2: Node(2)}
max_stops = 1
self.solution.relax(flight, current, nodes, max_stops)
self.assertEqual(100, nodes.get(1).distance)
self.assertEqual(current, nodes.get(1).parent)
self.assertEqual(1, nodes.get(1).depth)
def testRelaxNewDistanceIsMoreDoesNotChangeParent(self):
flight = (1, 100)
current = Node(0)
current.distance = 0
parent = Node(2)
target = Node(1)
target.distance = 50
target.depth = 2
target.parent = parent
nodes = {1: target, 2: parent}
max_stops = 0
self.solution.relax(flight, current, nodes, max_stops)
self.assertEqual(50, nodes.get(1).distance)
self.assertEqual(parent, nodes.get(1).parent)
self.assertEqual(2, nodes.get(1).depth)
def testShortestPathsOneDestinationNotWithinNumberOfStops(self):
adjacency_lists = {0: {1: 100, 2: 500}, 1: {2: 100}}
n = 3
src = 0
node_0 = Node(0)
node_0.distance = 0
node_1 = Node(1)
node_1.distance = 100
node_1.depth = 1
node_1.parent = node_0
node_2 = Node(2)
node_2.distance = 500
node_2.depth = 1
node_2.parent = node_0
expected = {0: node_0, 1: node_1, 2: node_2}
max_depth = 1
result = self.solution.shortestPaths(adjacency_lists, n, src,
max_depth)
self.assertEqual(expected, result)