def get_test_result(filename, full_graph=False, chain_graph=False):
columns = [
'Count of nodes', 'BFS average time', 'BFS delta time', 'BFS memory',
'DFS average time', 'DFS delta time', 'DFS memory',
'Dijkstra average time', 'Dijkstra delta time', 'Dijkstra memory',
'Ford-Bellman average time', 'Ford-Bellman delta time',
'Ford-Bellman memory', 'A_Star average time', 'A_Star delta time',
'A_Star memory'
]
with open(filename, 'w', newline='') as file:
writer = csv.DictWriter(file,
dialect=csv.excel_tab(),
fieldnames=columns)
writer.writeheader()
tester = Tester()
for i in range(NUMBER_OF_TESTS):
if not chain_graph:
start_node = random.randint(0, NODE_COUNT + STEP * i - 1)
finish_node = random.randint(0, NODE_COUNT + STEP * i - 1)
else:
start_node = 0
finish_node = NODE_COUNT + STEP * i - 1
base_graph_generator = GraphGenerator(NODE_COUNT + STEP * i, False,
False, full_graph,
chain_graph)
graph = base_graph_generator.generate_graph()
weighted_ordered_graph_generator = GraphGenerator(
NODE_COUNT + STEP * i, True, True, full_graph, chain_graph)
weighted_graph = weighted_ordered_graph_generator.generate_graph()
negative_weighted_graph_generator = GraphGenerator(
NODE_COUNT + STEP * i,
True,
True,
full_graph,
chain_graph,
negative_weighted=True)
negative_weighted_graph = (
negative_weighted_graph_generator.generate_graph())
planar_graph_generator = GraphGenerator(NODE_COUNT + STEP * i,
True,
True,
chain_graph=chain_graph,
planar=True)
planar_graph = planar_graph_generator.generate_graph()
result_line = tester.get_test_line(NODE_COUNT + STEP * i,
start_node, finish_node, graph,
weighted_graph, planar_graph,
negative_weighted_graph)
writer.writerow(result_line)
def test_generate_full_graph(self):
graph_generator = GraphGenerator(10, True, False, full_graph=True)
graph = graph_generator.generate_graph()
self.assertFalse(PlanarTest(graph).lr_planarity())
def test_generate_planar_unordered_graph(self):
graph_generator = GraphGenerator(10, True, False, planar=True)
graph = graph_generator.generate_graph()
self.assertIsInstance(graph, WeightedPlanarUnorderedGraph)
def test_is_equal_node_count(self):
graph_generator = GraphGenerator(15, False, True)
graph = graph_generator.generate_graph()
self.assertEqual(graph.node_count, 15)
def test_generate_unweighted_ordered_graph(self):
graph_generator = GraphGenerator(3, False, True)
graph = graph_generator.generate_graph()
self.assertIsInstance(graph, UnweightedOrderedGraph)
def test_generate_weighted_unordered_graph(self):
graph_generator = GraphGenerator(3, True, False)
graph = graph_generator.generate_graph()
self.assertIsInstance(graph, WeightedUnorderedGraph)
from graph_generator import GraphGenerator
from graph_traverser import GraphTraverser
from input_parser import Parser
from possibilities import Possibilities
from state_node import StateNode
parser = Parser()
startNodeSet = parser.parseStartNodes()
adjList = parser.parseReachability()
vulnDict, portDict = parser.parseVulnerabilities()
eventMapping = parser.parseEventMapping()
eventSet = EventFinder()
# Generate attack graph
graphGenerator = GraphGenerator(startNodeSet, adjList, vulnDict, portDict)
DG = graphGenerator.generate_graph()
timestamp, src, dst, port, description, accessLevel = parser.parseNotableEvent(
)
graphTraverser = GraphTraverser(DG, eventSet, eventMapping, portDict.keys())
eventSequence = graphTraverser.start_traversal(timestamp, src, dst, port,
description, accessLevel)
# Print possibilities
crownJewelSet = parser.parseCrownJewels()
possibilitiesGenerator = Possibilities()
notableEventStateNode = StateNode(dst, accessLevel)
possibilitiesGenerator.printPossiblePaths(DG, notableEventStateNode,
crownJewelSet)