def test_different_position(self): graph = Graph() initial_node = gen_name() graph.add_node(initial_node, layer=0, position=(0, 0), label='E') if visualize_tests: visualize_graph_3d(graph) pyplot.show() P1().apply(graph, [initial_node], positions=[ (0, 0), (2, 1.5), (1.5, 2), (-0.5, 1.5), ]) # check other nodes vx_bl = get_node_at(graph, 1, (0, 0)) vx_br = get_node_at(graph, 1, (2, 1.5)) vx_tl = get_node_at(graph, 1, (1.5, 2)) vx_tr = get_node_at(graph, 1, (-0.5, 1.5)) self.assertIsNotNone(vx_bl) self.assertIsNotNone(vx_br) self.assertIsNotNone(vx_tl) self.assertIsNotNone(vx_tr) if visualize_tests: visualize_graph_3d(graph) pyplot.show()
def test_happy_path(self): graph = Graph() e1 = gen_name() e2 = gen_name() e3 = gen_name() graph.add_node(e1, layer=1, position=(1.0, 2.0), label='E') graph.add_node(e2, layer=1, position=(1.0, 1.0), label='E') graph.add_node(e3, layer=1, position=(2.0, 1.0), label='E') graph.add_edge(e1, e2) graph.add_edge(e1, e3) graph.add_edge(e2, e3) i = add_interior(graph, e1, e2, e3) if visualize_tests: visualize_graph_3d(graph) pyplot.show() [i1] = P9().apply(graph, [i]) # if correct number of nodes and edges self.assertEqual(len(graph.nodes()), 8) self.assertEqual(len(graph.edges()), 13) # if cross-layer interior connections self.assertEqual(graph.nodes[i]['label'], 'i') self.assertTrue(graph.has_edge(i, i1)) # if new interior has correct label and layer self.assertEqual(graph.nodes[i1]['label'], 'I') self.assertEqual(graph.nodes[i1]['layer'], graph.nodes[i]['layer'] + 1) # if new interior has 3 neighbors i1_neighbors = get_neighbors_at(graph, i1, graph.nodes[i1]['layer']) self.assertEqual(len(i1_neighbors), 3) # if new nodes are in correct positions new_e1 = get_node_at(graph, 2, (1.0, 2.0)) new_e2 = get_node_at(graph, 2, (1.0, 1.0)) new_e3 = get_node_at(graph, 2, (2.0, 1.0)) self.assertIsNotNone(new_e1) self.assertIsNotNone(new_e2) self.assertIsNotNone(new_e3) # if each vertex has correct label for n in i1_neighbors: self.assertEqual(graph.nodes[n]['label'], 'E') # if each vertex has correct number of neighbors for n in i1_neighbors: node_neighbors = get_neighbors_at(graph, n, graph.nodes[n]['layer']) self.assertEqual(len(node_neighbors), 3) if visualize_tests: visualize_graph_3d(graph) pyplot.show()
def testMissingEdge(self): graph = createCorrectGraph() I2 = get_node_at(graph=graph, layer=2, pos=(2.5, 3.5)) e5 = get_node_at(graph=graph, layer=2, pos=(2.0, 2.0)) graph.remove_edge(I2, e5) if visualize_tests: visualize_graph_3d(graph) pyplot.show() prod_input = [x for x, y in graph.nodes(data=True) if y['label'] == 'I'] with self.assertRaises(ValueError): P10().apply(graph, prod_input)
def test_happy_path(self): graph = Graph() initial_node = gen_name() graph.add_node(initial_node, layer=0, position=(0.5, 0.5), label='E') if visualize_tests: visualize_graph_3d(graph) pyplot.show() P1().apply(graph, [initial_node]) nodes_data = graph.nodes(data=True) self.assertEqual(len(graph.nodes()), 7) self.assertEqual(len(graph.edges()), 13) # check the initial node initial_node_data = nodes_data[initial_node] self.assertEqual(initial_node_data['layer'], 0) self.assertEqual(initial_node_data['position'], (0.5, 0.5)) self.assertEqual(initial_node_data['label'], 'e') # check other nodes vx_bl = get_node_at(graph, 1, (0, 0)) vx_br = get_node_at(graph, 1, (1, 0)) vx_tl = get_node_at(graph, 1, (0, 1)) vx_tr = get_node_at(graph, 1, (1, 1)) self.assertIsNotNone(vx_bl) self.assertIsNotNone(vx_br) self.assertIsNotNone(vx_tl) self.assertIsNotNone(vx_tr) self.assertEqual(nodes_data[vx_bl]['label'], 'E') self.assertEqual(nodes_data[vx_br]['label'], 'E') self.assertEqual(nodes_data[vx_tl]['label'], 'E') self.assertEqual(nodes_data[vx_tr]['label'], 'E') vx_i1 = get_node_at(graph, 1, (2 / 3, 1 / 3)) vx_i2 = get_node_at(graph, 1, (1 / 3, 2 / 3)) self.assertIsNotNone(vx_i1) self.assertIsNotNone(vx_i2) self.assertEqual(nodes_data[vx_i1]['label'], 'I') self.assertEqual(nodes_data[vx_i2]['label'], 'I') self.assertTrue(graph.has_edge(initial_node, vx_i1)) self.assertTrue(graph.has_edge(initial_node, vx_i2)) self.assertTrue(graph.has_edge(vx_tl, vx_tr)) self.assertTrue(graph.has_edge(vx_tr, vx_br)) self.assertTrue(graph.has_edge(vx_br, vx_bl)) self.assertTrue(graph.has_edge(vx_bl, vx_tl)) self.assertTrue(graph.has_edge(vx_bl, vx_tr)) self.assertTrue(graph.has_edge(vx_i1, vx_bl)) self.assertTrue(graph.has_edge(vx_i1, vx_br)) self.assertTrue(graph.has_edge(vx_i1, vx_tr)) self.assertTrue(graph.has_edge(vx_i2, vx_bl)) self.assertTrue(graph.has_edge(vx_i2, vx_tl)) self.assertTrue(graph.has_edge(vx_i2, vx_tr)) if visualize_tests: visualize_graph_3d(graph) pyplot.show()
def __check_prod_input(graph, prod_input): if len(set(prod_input)) != 3: raise ValueError('too few interiors') layer = graph.nodes()[prod_input[0]]['layer'] if any(graph.nodes()[interior]['layer'] != layer for interior in prod_input[1:]): raise ValueError('interior vertices come from different layers') if any(graph.nodes()[interior]['label'] != 'I' for interior in prod_input): raise ValueError('interior vertices must have I label') all_I_neighbours = [] for interior in prod_input: interior_neighbours = get_neighbors_at(graph, interior, layer) if len(interior_neighbours) not in [2, 3]: raise ValueError('wrongly connected interior vertices') for neighbour in interior_neighbours: if graph.nodes()[neighbour]['label'] != 'E': raise ValueError( 'interior vertices can be connect only with E vertices' ) all_I_neighbours.append(neighbour) E_vertices = get_vertices_from_layer(graph, layer, "E") E_vertices_position_prev_layer = [] if any(E_vertice not in all_I_neighbours for E_vertice in E_vertices): raise ValueError('wrongly connected E vertices') for E_vertice in E_vertices: E_vertice_neighbours = get_neighbors_at(graph, E_vertice, layer) if len([ I_node for I_node in E_vertice_neighbours if graph.nodes()[I_node]['label'] == "I" ]) not in [1, 2]: raise ValueError( 'each E vertice must be connected with I vertice') E_vertice_E_neighbours = [ neighbour for neighbour in E_vertice_neighbours if graph.nodes()[neighbour]['label'] == "E" ] if len(E_vertice_E_neighbours) not in [1, 2, 3]: raise ValueError( 'each E vertice must be connected with at least one E vertice' ) corresponding_vertice = get_node_at( graph, layer - 1, graph.nodes()[E_vertice]['position']) if corresponding_vertice is not None: E_vertices_position_prev_layer.append(corresponding_vertice) if len(E_vertices_position_prev_layer) != 4 and len( E_vertices_position_prev_layer) != 6: raise ValueError( 'positions of corresponding vertices between layers are incorrect' ) corresponding_positions = [ graph.nodes()[E_vertice]['position'] for E_vertice in E_vertices_position_prev_layer ] noncorresponding_E_vertices = [ E_vertice for E_vertice in E_vertices if graph.nodes()[E_vertice] ['position'] not in corresponding_positions ] possible_positions = [] for i in range(len(corresponding_positions) - 1): x1, y1 = corresponding_positions[i] for j in range(i + 1, len(corresponding_positions)): x2, y2 = corresponding_positions[j] possible_positions.append(((x1 + x2) / 2, (y1 + y2) / 2)) for E_vertice in noncorresponding_E_vertices: x, y = graph.nodes()[E_vertice]['position'] if (x, y) not in possible_positions: raise ValueError( 'position of noncorresponding vertice is incorrect') overlapping_vertices = find_overlapping_vertices(graph) if len(overlapping_vertices) != 4 or \ any(overlapping_vertice1 not in set(all_I_neighbours) or overlapping_vertice2 not in set(all_I_neighbours) for overlapping_vertice1, overlapping_vertice2 in overlapping_vertices): raise ValueError('incorrect shape of graph') vertices_to_join = set() for overlapping_vertice1, overlapping_vertice2 in overlapping_vertices: vertices_to_join.add(overlapping_vertice1) vertices_to_join.add(overlapping_vertice2) if len(vertices_to_join) != 4: raise ValueError('too many overlapping vertices') vertices_to_join_group1 = [ vertice for vertice in vertices_to_join if graph.nodes()[vertice]['position'] == graph.nodes()[list( vertices_to_join)[0]]['position'] ] vertices_to_join_group2 = [ vertice for vertice in vertices_to_join if vertice not in vertices_to_join_group1 ] if len(vertices_to_join_group1) != 2 or len( vertices_to_join_group2) != 2: raise ValueError('too many overlapping vertices') vertice1_neighbours = get_neighbors_at(graph, vertices_to_join_group1[0], layer) vertice2_neighbours = get_neighbors_at(graph, vertices_to_join_group1[1], layer) vertice3_neighbours = get_neighbors_at(graph, vertices_to_join_group2[0], layer) vertice4_neighbours = get_neighbors_at(graph, vertices_to_join_group2[1], layer) I_neighbours_vertice1 = [ neighbour for neighbour in vertice1_neighbours if graph.nodes()[neighbour]['label'] == "I" ] I_neighbours_vertice2 = [ neighbour for neighbour in vertice2_neighbours if graph.nodes()[neighbour]['label'] == "I" ] I_neighbours_vertice3 = [ neighbour for neighbour in vertice3_neighbours if graph.nodes()[neighbour]['label'] == "I" ] I_neighbours_vertice4 = [ neighbour for neighbour in vertice4_neighbours if graph.nodes()[neighbour]['label'] == "I" ] if len(I_neighbours_vertice1) != 1 or len(I_neighbours_vertice2) != 1 or \ len(I_neighbours_vertice3) != 1 or len(I_neighbours_vertice4) != 1: raise ValueError( 'vertices to join wrongly connected with I vertices') common_I_neighbour_vertices_to_join = [] if I_neighbours_vertice1 == I_neighbours_vertice3: common_I_neighbour_vertices_to_join.append( vertices_to_join_group1[0]) common_I_neighbour_vertices_to_join.append( vertices_to_join_group2[0]) elif I_neighbours_vertice1 == I_neighbours_vertice4: common_I_neighbour_vertices_to_join.append( vertices_to_join_group1[0]) common_I_neighbour_vertices_to_join.append( vertices_to_join_group2[1]) elif I_neighbours_vertice2 == I_neighbours_vertice3: common_I_neighbour_vertices_to_join.append( vertices_to_join_group1[1]) common_I_neighbour_vertices_to_join.append( vertices_to_join_group2[0]) elif I_neighbours_vertice2 == I_neighbours_vertice4: common_I_neighbour_vertices_to_join.append( vertices_to_join_group1[1]) common_I_neighbour_vertices_to_join.append( vertices_to_join_group2[1]) else: raise ValueError( 'vertices to join wrongly connected with I vertices') noncommon_I_neighbour_vertices_to_join = [ vertice for vertice in vertices_to_join if vertice not in common_I_neighbour_vertices_to_join ] if len(noncommon_I_neighbour_vertices_to_join) != 2: raise ValueError( 'vertices to join wrongly connected with I vertices') if len( set(common_I_neighbour_vertices_to_join).intersection( set(noncommon_I_neighbour_vertices_to_join))) != 0: raise ValueError('vertices to join wrongly connected') common_vertice1_neighbours = get_neighbors_at( graph, common_I_neighbour_vertices_to_join[0], layer) common_vertice2_neighbours = get_neighbors_at( graph, common_I_neighbour_vertices_to_join[1], layer) if common_I_neighbour_vertices_to_join[ 1] not in common_vertice1_neighbours: raise ValueError( 'vertices to join with common I neighbour are not connected') if len( set(common_vertice1_neighbours).intersection( set(common_vertice2_neighbours))) not in [1, 2]: raise ValueError( 'vertices to join with common I neighbour are wrongly connected' ) noncommon_vertice1_neighbours = get_neighbors_at( graph, noncommon_I_neighbour_vertices_to_join[0], layer) noncommon_vertice2_neighbours = get_neighbors_at( graph, noncommon_I_neighbour_vertices_to_join[1], layer) if noncommon_I_neighbour_vertices_to_join[ 1] in noncommon_vertice1_neighbours: raise ValueError( 'vertices to join with non-common I neighbour are connected') if len( set(noncommon_vertice1_neighbours).intersection( set(noncommon_vertice2_neighbours))) not in [1, 2]: raise ValueError( 'vertices to join with common I neighbour are wrongly connected' )
def test_happy_path(self): graph = Graph() e1 = gen_name() e2 = gen_name() e3 = gen_name() graph.add_node(e1, layer=0, position=(1.0, 2.0), label='E') graph.add_node(e2, layer=0, position=(1.0, 1.0), label='E') graph.add_node(e3, layer=0, position=(2.0, 1.0), label='E') graph.add_edge(e1, e2) graph.add_edge(e1, e3) graph.add_edge(e2, e3) i = add_interior(graph, e1, e2, e3) if visualize_tests: visualize_graph_3d(graph) pyplot.show() [i1, i2] = P2().apply(graph, [i]) self.assertIsNotNone(get_node_at(graph, 1, (1.0, 2.0))) self.assertIsNotNone(get_node_at(graph, 1, (1.0, 1.0))) self.assertIsNotNone(get_node_at(graph, 1, (2.0, 1.0))) self.assertIsNotNone(get_node_at(graph, 1, (1.5, 1.0))) (i1_x, i1_y) = graph.nodes[i1]['position'] (i2_x, i2_y) = graph.nodes[i2]['position'] self.assertTrue(isclose(i1_x, 1.166666, rel_tol=eps)) self.assertTrue(isclose(i1_y, 1.333333, rel_tol=eps)) self.assertTrue(isclose(i2_x, 1.5, rel_tol=eps)) self.assertTrue(isclose(i2_y, 1.333333, rel_tol=eps)) self.assertEqual(len(graph.nodes()), 10) self.assertEqual(len(graph.edges()), 19) self.assertEqual(graph.nodes[i]['label'], 'i') self.assertTrue(graph.has_edge(i, i1)) self.assertTrue(graph.has_edge(i, i2)) self.assertEqual(graph.nodes[i1]['label'], 'I') self.assertEqual(graph.nodes[i2]['label'], 'I') self.assertEqual(graph.nodes[i1]['layer'], graph.nodes[i]['layer'] + 1) self.assertEqual(graph.nodes[i2]['layer'], graph.nodes[i]['layer'] + 1) i1_neighbors = get_neighbors_at(graph, i1, graph.nodes[i1]['layer']) self.assertEqual(len(i1_neighbors), 3) i2_neighbors = get_neighbors_at(graph, i2, graph.nodes[i2]['layer']) self.assertEqual(len(i2_neighbors), 3) common_neighbors = [x for x in i1_neighbors if x in i2_neighbors] for n in i1_neighbors: if n not in common_neighbors: self.assertEqual(graph.nodes[n]['label'], 'E') self.assertEqual( len(get_neighbors_at(graph, n, graph.nodes[i1]['layer'])), 3) for n in i2_neighbors: if n not in common_neighbors: self.assertEqual(graph.nodes[n]['label'], 'E') self.assertEqual( len(get_neighbors_at(graph, n, graph.nodes[i2]['layer'])), 3) for c_neighbor in common_neighbors: self.assertEqual(graph.nodes[c_neighbor]['label'], 'E') self.assertEqual( len( get_neighbors_at(graph, c_neighbor, graph.nodes[i1]['layer'])), 5) if visualize_tests: visualize_graph_3d(graph) pyplot.show()
def __check_prod_input(graph, prod_input): if len(set(prod_input)) != 4: raise ValueError('too few interiors') layer = graph.nodes()[prod_input[0]]['layer'] if any(graph.nodes()[interior]['layer'] != layer for interior in prod_input[1:]): raise ValueError('interior vertices come from different layers') if any(graph.nodes()[interior]['label'] != 'I' for interior in prod_input): raise ValueError('interior vertices must have I label') all_I_neighbours = [] for interior in prod_input: interior_neighbours = get_neighbors_at(graph, interior, layer) if len(interior_neighbours) not in [2, 3]: raise ValueError('wrongly connected interior vertices') for neighbour in interior_neighbours: if graph.nodes()[neighbour]['label'] != 'E': raise ValueError( 'interior vertices can be connect only with E vertices' ) all_I_neighbours.append(neighbour) E_vertices = get_vertices_from_layer(graph, layer, 'E') E_vertices_position_prev_layer = [] if any(E_vertice not in all_I_neighbours for E_vertice in E_vertices): raise ValueError('wrongly connected E vertices') for E_vertice in E_vertices: E_vertice_neighbours = get_neighbors_at(graph, E_vertice, layer) if len([ I_node for I_node in E_vertice_neighbours if graph.nodes()[I_node]['label'] == "I" ]) != 2: raise ValueError( 'each E vertice must be connected with two I vertices') E_vertice_E_neighbours = [ neighbour for neighbour in E_vertice_neighbours if graph.nodes()[neighbour]['label'] == "E" ] if len(E_vertice_E_neighbours) not in [1, 2, 3, 4]: print(len(E_vertice_E_neighbours)) raise ValueError( 'each E vertice must be connected with at least one E vertice' ) corresponding_vertice = get_node_at( graph, layer - 1, graph.nodes()[E_vertice]['position']) if corresponding_vertice is not None: E_vertices_position_prev_layer.append(corresponding_vertice) if len(E_vertices_position_prev_layer) != 2 and len( E_vertices_position_prev_layer) != 4: raise ValueError( 'positions of corresponding vertices between layers are incorrect' ) corresponding_positions = [ graph.nodes()[E_vertice]['position'] for E_vertice in E_vertices_position_prev_layer ] noncorresponding_E_vertices = [ E_vertice for E_vertice in E_vertices if graph.nodes()[E_vertice] ['position'] not in corresponding_positions ] possible_positions = [] for i in range(len(corresponding_positions) - 1): x1, y1 = corresponding_positions[i] for j in range(i + 1, len(corresponding_positions)): x2, y2 = corresponding_positions[j] possible_positions.append(((x1 + x2) / 2, (y1 + y2) / 2)) for E_vertice in noncorresponding_E_vertices: x, y = graph.nodes()[E_vertice]['position'] if (x, y) not in possible_positions: raise ValueError( 'positions of noncorresponding vertices are incorrect') overlapping_vertices = find_overlapping_vertices(graph) if len(overlapping_vertices) != 2 or \ any(overlapping_vertice1 not in set(all_I_neighbours) or overlapping_vertice2 not in set(all_I_neighbours) for overlapping_vertice1, overlapping_vertice2 in overlapping_vertices): raise ValueError('incorrect shape of graph') vertices_to_join = [ neighbour for neighbour in set(all_I_neighbours) if graph.nodes()[neighbour]['position'] == graph.nodes()[ overlapping_vertices[0][0]]['position'] ] if len(vertices_to_join) != 2: raise ValueError('too many overlapping vertices') vertice1_neighbours = get_neighbors_at(graph, vertices_to_join[0], layer) vertice2_neighbours = get_neighbors_at(graph, vertices_to_join[1], layer) common_neighbours = set(vertice1_neighbours).intersection( set(vertice2_neighbours)) if len(common_neighbours) != 2: raise ValueError('vertices to join wrongly connected') I_neighbours_vertice1 = [ neighbour for neighbour in vertice1_neighbours if graph.nodes()[neighbour]['label'] == "I" ] I_neighbours_vertice2 = [ neighbour for neighbour in vertice2_neighbours if graph.nodes()[neighbour]['label'] == "I" ] if len(I_neighbours_vertice1) != 2 or len(I_neighbours_vertice2) != 2: raise ValueError( 'vertices to join wrongly connected with I vertices') if len(set(I_neighbours_vertice1).intersection( I_neighbours_vertice2)) != 0: raise ValueError('vertices to join have common I neighbour')
def test_happy_path(self): graph = Graph() positions = [(1.0, 1.0), (1.0, 2.0), (1.0, 3.0), (2.0, 3.0), (3.0, 3.0), (2.0, 2.0)] [e1, e12, e2, e23, e3, e31] = self.create_nodes(graph, 1, 'E', positions) self.create_edges_chain(graph, [e1, e12, e2, e23, e3, e31, e1]) i = add_interior(graph, e1, e2, e3) if visualize_tests: pyplot.title("Correct input", fontsize=16) visualize_graph_3d(graph) pyplot.show() [i1, i3, i2a, i2b] = P5().apply(graph, [i]) if visualize_tests: pyplot.title("Correct output", fontsize=16) visualize_graph_3d(graph) pyplot.show() pyplot.title("Correct output (layer = 1)", fontsize=16) visualize_graph_layer(graph, 1) pyplot.show() pyplot.title("Correct output (layer = 2)", fontsize=16) visualize_graph_layer(graph, 2) pyplot.show() # if correct number of nodes and edges self.assertEqual(len(graph.nodes()), 17) self.assertEqual(len(graph.edges()), 34) # if cross-layer interior connections self.assertEqual(graph.nodes[i]['label'], 'i') self.assertTrue(graph.has_edge(i, i1)) self.assertTrue(graph.has_edge(i, i3)) self.assertTrue(graph.has_edge(i, i2a)) self.assertTrue(graph.has_edge(i, i2b)) # if new interiors has correct labels and layers self.assertEqual(graph.nodes[i1]['label'], 'I') self.assertEqual(graph.nodes[i3]['label'], 'I') self.assertEqual(graph.nodes[i2a]['label'], 'I') self.assertEqual(graph.nodes[i2b]['label'], 'I') self.assertEqual(graph.nodes[i1]['layer'], graph.nodes[i]['layer'] + 1) self.assertEqual(graph.nodes[i3]['layer'], graph.nodes[i]['layer'] + 1) self.assertEqual(graph.nodes[i2a]['layer'], graph.nodes[i]['layer'] + 1) self.assertEqual(graph.nodes[i2b]['layer'], graph.nodes[i]['layer'] + 1) # if each new interior has 3 neighbors i1_neighbors = get_neighbors_at(graph, i1, graph.nodes[i1]['layer']) self.assertEqual(len(i1_neighbors), 3) i3_neighbors = get_neighbors_at(graph, i3, graph.nodes[i3]['layer']) self.assertEqual(len(i3_neighbors), 3) i2a_neighbors = get_neighbors_at(graph, i2a, graph.nodes[i2a]['layer']) self.assertEqual(len(i2a_neighbors), 3) i2b_neighbors = get_neighbors_at(graph, i2b, graph.nodes[i2b]['layer']) self.assertEqual(len(i2b_neighbors), 3) # if new nodes are in correct positions new_e1 = get_node_at(graph, 2, (1.0, 1.0)) new_e12 = get_node_at(graph, 2, (1.0, 2.0)) new_e2 = get_node_at(graph, 2, (1.0, 3.0)) new_e23 = get_node_at(graph, 2, (2.0, 3.0)) new_e3 = get_node_at(graph, 2, (3.0, 3.0)) new_e31 = get_node_at(graph, 2, (2.0, 2.0)) self.assertIsNotNone(new_e1) self.assertIsNotNone(new_e12) self.assertIsNotNone(new_e2) self.assertIsNotNone(new_e23) self.assertIsNotNone(new_e3) self.assertIsNotNone(new_e31) # if interiors connect with all new 6 vertices all_neighbors = i1_neighbors + i3_neighbors + i2a_neighbors + i2b_neighbors all_neighbors = list(dict.fromkeys(all_neighbors)) # remove duplicates self.assertEqual(len(all_neighbors), 6) # if each vertex has correct label for n in all_neighbors: self.assertEqual(graph.nodes[n]['label'], 'E') # if each vertex has correct number of neighbors (based on neighbour interiors count) for n in all_neighbors: node_neighbors = get_neighbors_at(graph, n, graph.nodes[n]['layer']) i_neighbors = [ x for x in node_neighbors if graph.nodes[x]['label'] == 'I' ] if len(i_neighbors) == 1: self.assertEqual(len(node_neighbors), 3) elif len(i_neighbors) == 2: self.assertEqual(len(node_neighbors), 5) else: # 4 self.assertEqual(len(node_neighbors), 9)
def test_happy_path(self): graph = Graph() e1 = gen_name() e2 = gen_name() e3 = gen_name() e4 = gen_name() e1_1 = gen_name() e1_2 = gen_name() e1_3 = gen_name() e2_1 = gen_name() e2_2 = gen_name() e2_4 = gen_name() e3_5 = gen_name() graph.add_node(e1, layer=1, position=(1.0, 1.0), label='E') graph.add_node(e2, layer=1, position=(2.0, 2.0), label='E') graph.add_node(e3, layer=1, position=(1.0, 2.0), label='E') graph.add_node(e4, layer=1, position=(2.0, 1.0), label='E') graph.add_node(e1_1, layer=2, position=(1.0, 1.0), label='E') graph.add_node(e1_2, layer=2, position=(2.0, 2.0), label='E') graph.add_node(e1_3, layer=2, position=(1.0, 2.0), label='E') graph.add_node(e2_1, layer=2, position=(1.0, 1.0), label='E') graph.add_node(e2_2, layer=2, position=(2.0, 2.0), label='E') graph.add_node(e2_4, layer=2, position=(2.0, 1.0), label='E') graph.add_node(e3_5, layer=2, position=(2.0, 3.0), label='E') graph.add_edge(e1, e2) graph.add_edge(e1, e3) graph.add_edge(e1, e4) graph.add_edge(e2, e3) graph.add_edge(e2, e4) graph.add_edge(e1_1, e1_2) graph.add_edge(e1_1, e1_3) graph.add_edge(e1_2, e1_3) graph.add_edge(e2_1, e2_2) graph.add_edge(e2_1, e2_4) graph.add_edge(e2_2, e2_4) graph.add_edge(e3_5, e1_2) graph.add_edge(e3_5, e1_3) i1 = add_interior(graph, e1, e2, e3) i2 = add_interior(graph, e1, e2, e4) i1_1 = add_interior(graph, e1_1, e1_2, e1_3) i2_1 = add_interior(graph, e2_1, e2_2, e2_4) i3_1 = add_interior(graph, e3_5, e1_2, e1_3) graph.nodes[i1]['label'] = 'i' graph.nodes[i2]['label'] = 'i' graph.add_edge(i1, i1_1) graph.add_edge(i2, i2_1) graph.add_edge(i1, i3_1) if visualize_tests: visualize_graph_3d(graph) pyplot.show() P12().apply(graph, [i1, i2, i1_1, i2_1]) # if correct number of nodes and edges self.assertEqual(len(graph.nodes()), 14) self.assertEqual(len(graph.edges()), 30) # if interiors has correct labels, layers and are connected self.assertEqual(graph.nodes[i1]['label'], 'i') self.assertEqual(graph.nodes[i2]['label'], 'i') self.assertEqual(graph.nodes[i1_1]['label'], 'I') self.assertEqual(graph.nodes[i2_1]['label'], 'I') self.assertEqual(graph.nodes[i1]['layer'], 1) self.assertEqual(graph.nodes[i2]['layer'], 1) self.assertEqual(graph.nodes[i1_1]['layer'], 2) self.assertEqual(graph.nodes[i2_1]['layer'], 2) self.assertTrue(graph.has_edge(i1, i1_1)) self.assertTrue(graph.has_edge(i2, i2_1)) # if each interior has 3 neighbors i1_neighbors = get_neighbors_at(graph, i1, graph.nodes[i1]['layer']) self.assertEqual(len(i1_neighbors), 3) i2_neighbors = get_neighbors_at(graph, i2, graph.nodes[i2]['layer']) self.assertEqual(len(i2_neighbors), 3) i1_1_neighbors = get_neighbors_at(graph, i1_1, graph.nodes[i1_1]['layer']) self.assertEqual(len(i1_1_neighbors), 3) i2_1_neighbors = get_neighbors_at(graph, i2_1, graph.nodes[i2_1]['layer']) self.assertEqual(len(i2_1_neighbors), 3) # if nodes in lower layer exists and are correctly connected new_e1 = get_node_at(graph, 2, (1.0, 1.0)) new_e2 = get_node_at(graph, 2, (2.0, 2.0)) new_e3 = get_node_at(graph, 2, (1.0, 2.0)) new_e4 = get_node_at(graph, 2, (2.0, 1.0)) self.assertIsNotNone(new_e1) self.assertIsNotNone(new_e2) self.assertIsNotNone(new_e3) self.assertIsNotNone(new_e4) self.assertTrue(graph.has_edge(new_e1, new_e2)) self.assertTrue(graph.has_edge(new_e1, new_e3)) self.assertTrue(graph.has_edge(new_e1, new_e4)) self.assertTrue(graph.has_edge(new_e2, new_e3)) self.assertTrue(graph.has_edge(new_e2, new_e4)) # if lower interiors connect with all 4 vertices all_neighbors = i1_1_neighbors + i2_1_neighbors all_neighbors = list(dict.fromkeys(all_neighbors)) # remove duplicates self.assertEqual(len(all_neighbors), 4) # if each vertex has correct label for n in all_neighbors: self.assertEqual(graph.nodes[n]['label'], 'E') # if each vertex has correct number of neighbors (based on neighbour interiors count) for n in all_neighbors: node_neighbors = get_neighbors_at(graph, n, graph.nodes[n]['layer']) i_neighbors = [ x for x in node_neighbors if graph.nodes[x]['label'] == 'I' ] if len(i_neighbors) == 1: self.assertEqual(len(node_neighbors), 3) elif len(i_neighbors) == 2: self.assertEqual(len(node_neighbors), 5) else: self.assertEqual(len(node_neighbors), 7) if visualize_tests: visualize_graph_3d(graph) pyplot.show()
def testOnBiggerGraph(self): graph = Graph() initial_node_name = gen_name() graph.add_node(initial_node_name, layer=0, position=(0.5, 0.5), label='E') [i1, i2] = P1().apply(graph, [initial_node_name]) [i1_1, i1_2] = P2().apply(graph, [i1], orientation=1) [i2_1] = P9().apply(graph, [i2], orientation=1) if visualize_tests: visualize_graph_3d(graph) pyplot.show() [i1_1new, i1_2new, i2_1new] = P10().apply(graph, [i1_1, i1_2, i2_1]) self.assertEqual(len(graph.nodes()), 15) self.assertEqual(len(graph.edges()), 32) e = get_node_at(graph=graph, layer=0, pos=(0.5, 0.5)) e1 = get_node_at(graph=graph, layer=1, pos=(0.0, 0.0)) e2 = get_node_at(graph=graph, layer=1, pos=(1.0, 0.0)) e3 = get_node_at(graph=graph, layer=1, pos=(1.0, 1.0)) e4 = get_node_at(graph=graph, layer=1, pos=(0.0, 1.0)) e5 = get_node_at(graph=graph, layer=2, pos=(0.0, 0.0)) e6 = get_node_at(graph=graph, layer=2, pos=(1.0, 0.0)) e7 = get_node_at(graph=graph, layer=2, pos=(1.0, 1.0)) e8 = get_node_at(graph=graph, layer=2, pos=(0.0, 1.0)) e9 = get_node_at(graph=graph, layer=2, pos=(0.5, 0.5)) # check position self.assertIsNotNone(e) self.assertIsNotNone(e1) self.assertIsNotNone(e2) self.assertIsNotNone(e3) self.assertIsNotNone(e4) self.assertIsNotNone(e5) self.assertIsNotNone(e6) self.assertIsNotNone(e7) self.assertIsNotNone(e8) self.assertIsNotNone(e9) self.assertEqual(graph.nodes[i1_1new]['position'], graph.nodes[i1_1]['position']) self.assertEqual(graph.nodes[i1_2new]['position'], graph.nodes[i1_2]['position']) self.assertEqual(graph.nodes[i2_1new]['position'], graph.nodes[i2]['position']) # ten co jest z prawe self.assertEqual(graph.nodes[i1_1new]['layer'], graph.nodes[i1_1]['layer']) self.assertEqual(graph.nodes[i1_2new]['layer'], graph.nodes[i1_2]['layer']) self.assertEqual(graph.nodes[i2_1new]['layer'], graph.nodes[i2_1]['layer']) i1_new = get_node_at(graph=graph, layer=1, pos=graph.nodes[i1]['position']) i2_new = get_node_at(graph=graph, layer=1, pos=graph.nodes[i2]['position']) self.assertIsNotNone(i1_new) self.assertIsNotNone(i2_new) # zero self.assertTrue(graph.has_edge(e, i1_new)) self.assertTrue(graph.has_edge(e, i2_new)) # first self.assertTrue(graph.has_edge(e1, e2)) self.assertTrue(graph.has_edge(e1, e3)) self.assertTrue(graph.has_edge(e1, e4)) self.assertTrue(graph.has_edge(e1, i2_new)) self.assertTrue(graph.has_edge(e1, i1_new)) self.assertTrue(graph.has_edge(e2, e3)) self.assertTrue(graph.has_edge(e2, i2_new)) self.assertTrue(graph.has_edge(e3, e4)) self.assertTrue(graph.has_edge(e3, i1_new)) self.assertTrue(graph.has_edge(e3, i2_new)) self.assertTrue(graph.has_edge(e4, i1_new)) # second self.assertTrue(graph.has_edge(e5, e6)) self.assertTrue(graph.has_edge(e5, e9)) self.assertTrue(graph.has_edge(e5, e8)) self.assertTrue(graph.has_edge(e6, e7)) self.assertTrue(graph.has_edge(e7, e9)) self.assertTrue(graph.has_edge(e7, e8)) self.assertTrue(graph.has_edge(i1_new, i1_1new)) self.assertTrue(graph.has_edge(i1_new, i1_2new)) self.assertTrue(graph.has_edge(i2_new, i2_1new)) self.assertTrue(graph.has_edge(e5, i1_1new)) self.assertTrue(graph.has_edge(e8, i1_1new)) self.assertTrue(graph.has_edge(e9, i1_1new)) self.assertTrue(graph.has_edge(e7, i1_2new)) self.assertTrue(graph.has_edge(e8, i1_2new)) self.assertTrue(graph.has_edge(e9, i1_2new)) self.assertTrue(graph.has_edge(e5, i2_1new)) self.assertTrue(graph.has_edge(e6, i2_1new)) self.assertTrue(graph.has_edge(e7, i2_1new)) # check labels self.assertEqual(graph.nodes[e]['label'], 'e') self.assertEqual(graph.nodes[e1]['label'], 'E') self.assertEqual(graph.nodes[e2]['label'], 'E') self.assertEqual(graph.nodes[e3]['label'], 'E') self.assertEqual(graph.nodes[e4]['label'], 'E') self.assertEqual(graph.nodes[e5]['label'], 'E') self.assertEqual(graph.nodes[e6]['label'], 'E') self.assertEqual(graph.nodes[e7]['label'], 'E') self.assertEqual(graph.nodes[e8]['label'], 'E') self.assertEqual(graph.nodes[e9]['label'], 'E') self.assertEqual(graph.nodes[i1_1new]['label'], 'I') self.assertEqual(graph.nodes[i1_2new]['label'], 'I') self.assertEqual(graph.nodes[i2_1new]['label'], 'I') self.assertEqual(graph.nodes[i1_new]['label'], 'i') self.assertEqual(graph.nodes[i2_new]['label'], 'i')
def testHappyPath(self): graph = createCorrectGraph() prod_input = [x for x, y in graph.nodes(data=True) if y['label'] == 'I'] P10().apply(graph, prod_input) if visualize_tests: visualize_graph_3d(graph) pyplot.show() #test if number of nodes and edges is correct self.assertEqual(len(graph.nodes()), 10) self.assertEqual(len(graph.edges()), 16) e1 = get_node_at(graph=graph, layer=1, pos=(1.0, 2.0)) e2 = get_node_at(graph=graph, layer=1, pos=(3.0, 2.0)) i1 = get_node_at(graph=graph, layer=1, pos=(2.0, 3.0)) i2 = get_node_at(graph=graph, layer=1, pos=(2.0, 1.0)) I1 = get_node_at(graph=graph, layer=2, pos=(1.5, 3.5)) I2 = get_node_at(graph=graph, layer=2, pos=(2.5, 3.5)) e3 = get_node_at(graph=graph, layer=2, pos=(1.0, 2.0)) e4 = get_node_at(graph=graph, layer=2, pos=(3.0, 2.0)) e5 = get_node_at(graph=graph, layer=2, pos=(2.0, 2.0)) I3 = get_node_at(graph=graph, layer=2, pos=(2.5, 0.5)) #check position self.assertIsNotNone(e1) self.assertIsNotNone(e2) self.assertIsNotNone(i1) self.assertIsNotNone(i2) self.assertIsNotNone(I1) self.assertIsNotNone(I2) self.assertIsNotNone(e3) self.assertIsNotNone(e4) self.assertIsNotNone(e5) self.assertIsNotNone(I3) #check edges # upper layer edges self.assertTrue(graph.has_edge(e1, i1)) self.assertTrue(graph.has_edge(e1, i2)) self.assertTrue(graph.has_edge(e2, i1)) self.assertTrue(graph.has_edge(e2, i2)) self.assertTrue(graph.has_edge(e1, e2)) # interlayer connections self.assertTrue(graph.has_edge(I1, i1)) self.assertTrue(graph.has_edge(I2, i1)) self.assertTrue(graph.has_edge(I3, i2)) # lower layer connections self.assertTrue(graph.has_edge(I1, e3)) self.assertTrue(graph.has_edge(I1, e5)) self.assertTrue(graph.has_edge(e3, e5)) self.assertTrue(graph.has_edge(I2, e4)) self.assertTrue(graph.has_edge(I2, e5)) self.assertTrue(graph.has_edge(e4, e5)) self.assertTrue(graph.has_edge(I3, e3)) self.assertTrue(graph.has_edge(I3, e4)) #check labels self.assertEqual(graph.nodes[e1]['label'], 'E') self.assertEqual(graph.nodes[e2]['label'], 'E') self.assertEqual(graph.nodes[i1]['label'], 'i') self.assertEqual(graph.nodes[i2]['label'], 'i') self.assertEqual(graph.nodes[I1]['label'], 'I') self.assertEqual(graph.nodes[I2]['label'], 'I') self.assertEqual(graph.nodes[e3]['label'], 'E') self.assertEqual(graph.nodes[e4]['label'], 'E') self.assertEqual(graph.nodes[e5]['label'], 'E') self.assertEqual(graph.nodes[I3]['label'], 'I')
def test_happy_path(self): graph = Graph() e1_1, e2_1, e3_1, e4_1 = [gen_name() for _ in range(4)] graph.add_node(e1_1, layer=1, position=(0.0, 0.0), label='E') graph.add_node(e2_1, layer=1, position=(1.0, 0.0), label='E') graph.add_node(e3_1, layer=1, position=(0.5, 0.5), label='E') graph.add_node(e4_1, layer=1, position=(0.0, 1.0), label='E') graph.add_edge(e1_1, e2_1) graph.add_edge(e1_1, e3_1) graph.add_edge(e1_1, e4_1) graph.add_edge(e2_1, e3_1) graph.add_edge(e3_1, e4_1) i1_1 = add_interior(graph, e1_1, e2_1, e3_1) i2_1 = add_interior(graph, e1_1, e3_1, e4_1) graph.nodes[i1_1]['label'] = 'i' graph.nodes[i2_1]['label'] = 'i' e1_2, e2_2, e3_2, e4_2, e5_2 = [gen_name() for _ in range(5)] graph.add_node(e1_2, layer=2, position=(0.0, 0.0), label='E') graph.add_node(e5_2, layer=2, position=(0.0, 0.0), label='E') graph.add_node(e2_2, layer=2, position=(1.0, 0.0), label='E') graph.add_node(e3_2, layer=2, position=(0.5, 0.5), label='E') graph.add_node(e4_2, layer=2, position=(0.0, 1.0), label='E') graph.add_edge(e1_2, e2_2) graph.add_edge(e1_2, e3_2) graph.add_edge(e5_2, e4_2) graph.add_edge(e5_2, e3_2) graph.add_edge(e2_2, e3_2) graph.add_edge(e3_2, e4_2) i1_2 = add_interior(graph, e1_2, e2_2, e3_2) i2_2 = add_interior(graph, e5_2, e3_2, e4_2) graph.add_edge(i1_1, i1_2) graph.add_edge(i2_1, i2_2) if visualize_tests: visualize_graph_3d(graph) pyplot.show() P13().apply(graph, [i1_1, i2_1, i1_2, i2_2]) # based on test_p12 # if correct number of nodes and edges self.assertEqual(len(graph.nodes()), 12) self.assertEqual(len(graph.edges()), 24) # if interiors has correct labels, layers and are connected self.assertEqual(graph.nodes[i1_1]['label'], 'i') self.assertEqual(graph.nodes[i2_1]['label'], 'i') self.assertEqual(graph.nodes[i1_1]['layer'], 1) self.assertEqual(graph.nodes[i2_1]['layer'], 1) self.assertEqual(graph.nodes[i1_2]['label'], 'I') self.assertEqual(graph.nodes[i2_2]['label'], 'I') self.assertEqual(graph.nodes[i1_2]['layer'], 2) self.assertEqual(graph.nodes[i2_2]['layer'], 2) self.assertTrue(graph.has_edge(i1_1, i1_2)) self.assertTrue(graph.has_edge(i2_1, i2_2)) # if each interior has 3 neighbors on the corresponding layer i1_1_neighbors = get_neighbors_at(graph, i1_1, graph.nodes[i1_1]['layer']) self.assertEqual(len(i1_1_neighbors), 3) i2_1_neighbors = get_neighbors_at(graph, i2_1, graph.nodes[i2_1]['layer']) self.assertEqual(len(i2_1_neighbors), 3) i1_2_neighbors = get_neighbors_at(graph, i1_2, graph.nodes[i1_2]['layer']) self.assertEqual(len(i1_2_neighbors), 3) i2_2_neighbors = get_neighbors_at(graph, i2_2, graph.nodes[i2_2]['layer']) self.assertEqual(len(i2_2_neighbors), 3) # if nodes in lower layer exists and are correctly connected new_e1_2 = get_node_at(graph, 2, (0.0, 0.0)) new_e2_2 = get_node_at(graph, 2, (1.0, 0.0)) new_e3_2 = get_node_at(graph, 2, (0.5, 0.5)) new_e4_2 = get_node_at(graph, 2, (0.0, 1.0)) self.assertIsNotNone(new_e1_2) self.assertIsNotNone(new_e2_2) self.assertIsNotNone(new_e3_2) self.assertIsNotNone(new_e4_2) self.assertTrue(graph.has_edge(new_e1_2, new_e2_2)) self.assertTrue(graph.has_edge(new_e1_2, new_e3_2)) self.assertTrue(graph.has_edge(new_e1_2, new_e4_2)) self.assertTrue(graph.has_edge(new_e2_2, new_e3_2)) self.assertTrue(graph.has_edge(new_e3_2, new_e4_2)) # if lower interiors connect with all 4 vertices all_neighbors = i1_2_neighbors + i2_2_neighbors all_neighbors = list(dict.fromkeys(all_neighbors)) # remove duplicates self.assertEqual(len(all_neighbors), 4) # if each vertex has correct label for n in all_neighbors: self.assertEqual(graph.nodes[n]['label'], 'E') # if each vertex has correct number of neighbors (based on neighbour interiors count) for n in all_neighbors: node_neighbors = get_neighbors_at(graph, n, graph.nodes[n]['layer']) i_neighbors = [ x for x in node_neighbors if graph.nodes[x]['label'] == 'I' ] if len(i_neighbors) == 1: self.assertEqual(len(node_neighbors), 3) elif len(i_neighbors) == 2: self.assertEqual(len(node_neighbors), 5) else: self.assertEqual(len(node_neighbors), 7) if visualize_tests: visualize_graph_3d(graph) pyplot.show()