def two_graph_db_session(
db: unlabelled_graph_database.Database,
) -> unlabelled_graph_database.Database.SessionType:
a = unlabelled_graph_database.ProgramGraph.Create(
proto=random_programl_generator.CreateRandomProto(), ir_id=1
)
b = unlabelled_graph_database.ProgramGraph.Create(
proto=random_programl_generator.CreateRandomProto(), ir_id=2
)
with db.Session() as session:
session.add_all([a, b])
session.commit()
# Sanity check that the graphs have been added to the database.
assert (
session.query(
sql.func.count(unlabelled_graph_database.ProgramGraph.ir_id)
).scalar()
== 2
)
assert (
session.query(
sql.func.count(unlabelled_graph_database.ProgramGraphData.ir_id)
).scalar()
== 2
)
yield session
def CreateRandomGraph(
node_x_dimensionality: int = 1,
node_y_dimensionality: int = 0,
graph_x_dimensionality: int = 0,
graph_y_dimensionality: int = 0,
node_count: int = None,
) -> nx.MultiDiGraph:
"""Generate a random graph.
This generates a random graph which has sensible values for fields, but does
not have meaningful semantics, e.g. there may be data flow edges between
identifiers, etc. For speed, this generator guarantees only that:
1. There is a 'root' node with outgoing call edges.
2. Nodes are either statements, identifiers, or immediates.
3. Nodes have text, preprocessed_text, and a single node_x value.
4. Edges are either control, data, or call.
5. Edges have positions.
6. The graph is strongly connected.
"""
proto = random_programl_generator.CreateRandomProto(
node_x_dimensionality=node_x_dimensionality,
node_y_dimensionality=node_y_dimensionality,
graph_x_dimensionality=graph_x_dimensionality,
graph_y_dimensionality=graph_y_dimensionality,
node_count=node_count,
)
return programl.ProgramGraphToNetworkX(proto)
def proto_db(
request, ir_db: ir_database.Database
) -> unlabelled_graph_database.Database:
"""A test fixture which yields a graph database with random graph tuples."""
with ir_db.Session() as session:
ir_ids = [
row.id for row in session.query(ir_database.IntermediateRepresentation.id)
]
with testing_databases.DatabaseContext(
unlabelled_graph_database.Database, request.param
) as db:
with db.Session(commit=True) as session:
session.add_all(
[
unlabelled_graph_database.ProgramGraph.Create(
proto=random_programl_generator.CreateRandomProto(
graph_y_dimensionality=2
),
ir_id=ir_id,
)
for ir_id in ir_ids
]
)
yield db
def test_fuzz_proto_networkx_equivalence(
node_x_dimensionality: int,
node_y_dimensionality: int,
graph_x_dimensionality: int,
graph_y_dimensionality: int,
node_count: int,
):
"""Fuzz proto -> networkx -> proto on random generated graphs."""
proto_in = random_programl_generator.CreateRandomProto(
node_x_dimensionality=node_x_dimensionality,
node_y_dimensionality=node_y_dimensionality,
graph_x_dimensionality=graph_x_dimensionality,
graph_y_dimensionality=graph_y_dimensionality,
node_count=node_count,
)
# proto -> networkx
g = programl.ProgramGraphToNetworkX(proto_in)
assert g.number_of_nodes() == len(proto_in.node)
assert g.number_of_edges() == len(proto_in.edge)
# Check that the functions match up.
functions_in_graph = set([
function for _, function in g.nodes(data="function")
if function is not None
])
functions_in_proto = [function.name for function in proto_in.function]
assert sorted(functions_in_proto) == sorted(functions_in_graph)
# networkx -> proto
proto_out = programl.NetworkXToProgramGraph(g)
assert proto_out.function == proto_in.function
assert proto_out.node == proto_in.node
# Randomly generated graphs don't have a stable edge order.
assert len(proto_out.edge) == len(proto_in.edge)
def test_fuzz_MakeAnnotated():
"""Opaque black-box test of reachability annotator."""
n = random.randint(1, 20)
proto = random_programl_generator.CreateRandomProto()
annotator = reachability.ReachabilityAnnotator(proto)
annotated = annotator.MakeAnnotated(n=n)
assert len(annotated.graphs) <= 20
assert len(annotated.protos) <= 20
def test_fuzz_ProgramGraph_Create(db: unlabelled_graph_database.Database):
"""Fuzz the networkx -> proto conversion using randomly generated graphs."""
global ir_id
ir_id += 1
with db.Session(commit=True) as session:
session.add(
unlabelled_graph_database.ProgramGraph.Create(
proto=random_programl_generator.CreateRandomProto(),
ir_id=ir_id,
split=random.randint(0, 10) if random.random() < 0.5 else None,
))
def populated_proto_db(
proto_db: graph_tuple_database.Database,
opencl_relpaths: Set[str]) -> graph_tuple_database.Database:
"""A test fixture which yields a graph database with 256 OpenCL IR entries."""
rows = []
# Create random rows using OpenCL relpaths.
for i, relpath in enumerate(opencl_relpaths):
proto = unlabelled_graph_database.ProgramGraph.Create(
proto=random_programl_generator.CreateRandomProto(), ir_id=i + 1)
proto.id = len(opencl_relpaths) - i
rows.append(proto)
with proto_db.Session(commit=True) as session:
session.add_all(rows)
return proto_db
def benchmark_proto(
node_x_dimensionality: int,
node_y_dimensionality: int,
graph_x_dimensionality: int,
graph_y_dimensionality: int,
node_count: int,
) -> List[programl_pb2.ProgramGraph]:
"""A fixture which returns 10 protos for benchmarking."""
return [
random_programl_generator.CreateRandomProto(
node_x_dimensionality=node_x_dimensionality,
node_y_dimensionality=node_y_dimensionality,
graph_x_dimensionality=graph_x_dimensionality,
graph_y_dimensionality=graph_y_dimensionality,
node_count=node_count,
) for _ in range(10)
]
def CreateRandomProgramGraph(
node_x_dimensionality: int = 1,
node_y_dimensionality: int = 0,
graph_x_dimensionality: int = 0,
graph_y_dimensionality: int = 0,
split_count: int = 0,
) -> unlabelled_graph_database.ProgramGraph:
"""Create a random unlabelled graph."""
return unlabelled_graph_database.ProgramGraph.Create(
proto=random_programl_generator.CreateRandomProto(
node_x_dimensionality=node_x_dimensionality,
node_y_dimensionality=node_y_dimensionality,
graph_x_dimensionality=graph_x_dimensionality,
graph_y_dimensionality=graph_y_dimensionality,
with_data_flow=False,
),
# Note that ir_id is a primary key, so you may need to set this value
# explicitly to avoid integrity errors.
ir_id=random.randint(0, int(4e6)),
split=random.randint(0, split_count) if split_count else None,
)
def test_CreateRandomProto(
node_x_dimensionality: int,
node_y_dimensionality: int,
graph_x_dimensionality: int,
graph_y_dimensionality: int,
):
"""Black-box test of generator properties."""
proto = random_programl_generator.CreateRandomProto(
node_x_dimensionality=node_x_dimensionality,
node_y_dimensionality=node_y_dimensionality,
graph_x_dimensionality=graph_x_dimensionality,
graph_y_dimensionality=graph_y_dimensionality,
)
assert proto.IsInitialized()
for node in proto.node:
assert len(node.x) == node_x_dimensionality
assert len(node.y) == node_y_dimensionality
if node.function:
assert node.function <= len(proto.function)
for edge in proto.edge:
assert edge.source_node < len(proto.node)
assert edge.destination_node < len(proto.node)
assert len(proto.x) == graph_x_dimensionality
assert len(proto.y) == graph_y_dimensionality
def test_CreateRandomProto_node_count(node_count: int):
"""Test generating protos with specific node counts."""
proto = random_programl_generator.CreateRandomProto(node_count=node_count)
assert len(proto.node) == node_count
def test_fuzz_proto_bytes_equivalence(fmt: programl.InputOutputFormat):
"""Test that conversion to and from bytes does not change the proto."""
input = random_programl_generator.CreateRandomProto()
output = programl.FromBytes(programl.ToBytes(input, fmt), fmt)
assert input == output
