def test_sym_expr(self):
node = gtirb.SymAddrConst(
offset=123,
symbol=gtirb.Symbol(name="symbol", payload=gtirb.ProxyBlock()),
)
string = repr(node)
new_node = eval(string)
self.assertEqual(node.offset, new_node.offset)
self.assertTrue(node.symbol.deep_eq(new_node.symbol))
node = gtirb.SymStackConst(
offset=123,
symbol=gtirb.Symbol(name="symbol", payload=gtirb.ProxyBlock()),
)
string = repr(node)
new_node = eval(string)
self.assertEqual(node.offset, new_node.offset)
self.assertTrue(node.symbol.deep_eq(new_node.symbol))
node = gtirb.SymAddrAddr(
offset=123,
scale=2,
symbol1=gtirb.Symbol(name="symbol1", payload=gtirb.ProxyBlock()),
symbol2=gtirb.Symbol(name="symbol2", payload=gtirb.ProxyBlock()),
)
string = repr(node)
new_node = eval(string)
self.assertEqual(node.offset, new_node.offset)
self.assertEqual(node.scale, new_node.scale)
self.assertTrue(node.symbol1.deep_eq(new_node.symbol1))
self.assertTrue(node.symbol2.deep_eq(new_node.symbol2))
def test_proxy_blocks(self):
b = gtirb.ProxyBlock()
self.assertEquals(set(b.references), set())
self.assertEquals(set(b.incoming_edges), set())
self.assertEquals(set(b.outgoing_edges), set())
m = gtirb.Module()
sym1 = gtirb.Symbol("test", payload=b)
sym2 = gtirb.Symbol("test", payload=123)
sym3 = gtirb.Symbol("test", payload=b)
m.symbols |= {sym1, sym2, sym3}
b.module = m
self.assertEquals(set(b.references), {sym1, sym3})
self.assertEquals(set(b.incoming_edges), set())
self.assertEquals(set(b.outgoing_edges), set())
i = gtirb.IR()
m.ir = i
e1 = gtirb.Edge(b, gtirb.ProxyBlock())
e2 = gtirb.Edge(gtirb.ProxyBlock(), b)
e3 = gtirb.Edge(gtirb.ProxyBlock(), gtirb.ProxyBlock())
e4 = gtirb.Edge(b, b)
i.cfg |= {e1, e2, e3, e4}
self.assertEquals(set(b.references), {sym1, sym3})
self.assertEquals(set(b.incoming_edges), {e2, e4})
self.assertEquals(set(b.outgoing_edges), {e1, e4})
def test_proxy_blocks(self):
b = gtirb.ProxyBlock()
self.assertEquals(set(b.references), set())
self.assertEquals(set(b.incoming_edges), set())
self.assertEquals(set(b.outgoing_edges), set())
m = gtirb.Module(name="M")
sym1 = gtirb.Symbol("test", payload=b)
sym2 = gtirb.Symbol("test", payload=123)
sym3 = gtirb.Symbol("test", payload=b)
m.symbols |= {sym1, sym2, sym3}
b.module = m
self.assertEquals(set(b.references), {sym1, sym3})
self.assertEquals(set(b.incoming_edges), set())
self.assertEquals(set(b.outgoing_edges), set())
i = gtirb.IR()
m.ir = i
p1 = gtirb.ProxyBlock()
p2 = gtirb.ProxyBlock()
p3 = gtirb.ProxyBlock()
p4 = gtirb.ProxyBlock()
i.cfg.add(gtirb.Edge(b, p1))
i.cfg.add(gtirb.Edge(p2, b))
i.cfg.add(gtirb.Edge(p3, p4))
i.cfg.add(gtirb.Edge(b, b))
self.assertEquals(set(b.references), {sym1, sym3})
self.assertEquals(set((s, t) for s, t, l in b.incoming_edges),
{(p2, b), (b, b)})
self.assertEquals(set((s, t) for s, t, l in b.outgoing_edges),
{(b, p1), (b, b)})
def test_nx(self):
b1, b2 = gtirb.ProxyBlock(), gtirb.ProxyBlock()
cfg = gtirb.CFG(
[gtirb.Edge(b1, b2, gtirb.Edge.Label(gtirb.Edge.Type.Call))])
for n1, n2, lab in cfg.nx().edges(data="label"):
self.assertEqual(n1, b1)
self.assertEqual(n2, b2)
self.assertEqual(lab, gtirb.Edge.Label(gtirb.Edge.Type.Call))
def test_proxy_blocks(self):
id1 = uuid.uuid4()
id2 = uuid.uuid4()
b1 = gtirb.ProxyBlock(uuid=id1)
b2 = gtirb.ProxyBlock(uuid=id1)
self.assertTrue(b1.deep_eq(b2))
b2 = gtirb.ProxyBlock(uuid=id2)
self.assertFalse(b1.deep_eq(b2))
def test_code_blocks(self):
b = gtirb.CodeBlock()
self.assertEquals(b.address, None)
self.assertEquals(b.contents, b"")
self.assertEquals(set(b.references), set())
self.assertEquals(set(b.incoming_edges), set())
self.assertEquals(set(b.outgoing_edges), set())
bi = gtirb.ByteInterval(address=1, contents=b"abcd1234")
b.offset = 2
b.size = 3
b.byte_interval = bi
self.assertEquals(b.address, 3)
self.assertEquals(b.contents, b"cd1")
self.assertEquals(set(b.references), set())
self.assertEquals(set(b.incoming_edges), set())
self.assertEquals(set(b.outgoing_edges), set())
s = gtirb.Section()
bi.section = s
m = gtirb.Module(name="M")
sym1 = gtirb.Symbol("test", payload=b)
sym2 = gtirb.Symbol("test", payload=123)
sym3 = gtirb.Symbol("test", payload=b)
m.symbols |= {sym1, sym2, sym3}
s.module = m
self.assertEquals(b.address, 3)
self.assertEquals(b.contents, b"cd1")
self.assertEquals(set(b.references), {sym1, sym3})
self.assertEquals(set(b.incoming_edges), set())
self.assertEquals(set(b.outgoing_edges), set())
i = gtirb.IR()
m.ir = i
p1 = gtirb.ProxyBlock()
p2 = gtirb.ProxyBlock()
p3 = gtirb.ProxyBlock()
p4 = gtirb.ProxyBlock()
i.cfg.add(gtirb.Edge(b, p1))
i.cfg.add(gtirb.Edge(p2, b))
i.cfg.add(gtirb.Edge(p3, p4))
i.cfg.add(gtirb.Edge(b, b))
self.assertEquals(b.address, 3)
self.assertEquals(b.contents, b"cd1")
self.assertEquals(set(b.references), {sym1, sym3})
self.assertEquals(
set((s, t) for s, t, l in b.incoming_edges), {(p2, b), (b, b)}
)
self.assertEquals(
set((s, t) for s, t, l in b.outgoing_edges), {(b, p1), (b, b)}
)
def test_add(self):
b1, b2 = gtirb.ProxyBlock(), gtirb.ProxyBlock()
cfg = gtirb.CFG()
cfg.add(gtirb.Edge(b1, b2))
cfg.add(gtirb.Edge(b1, b2))
cfg.add(gtirb.Edge(b1, b2, gtirb.Edge.Label(gtirb.Edge.Type.Branch)))
self.assertEqual(len(cfg), 2)
self.assertTrue(gtirb.Edge(b1, b2) in cfg)
self.assertTrue(
gtirb.Edge(b1, b2, gtirb.Edge.Label(gtirb.Edge.Type.Branch)) in
cfg)
def test_clear(self):
cfg = gtirb.CFG([
gtirb.Edge(gtirb.ProxyBlock(), gtirb.ProxyBlock()),
gtirb.Edge(
gtirb.CodeBlock(offset=0, size=1),
gtirb.CodeBlock(offset=1, size=2),
),
])
self.assertEqual(len(cfg), 2)
cfg.clear()
self.assertEqual(len(cfg), 0)
def test_contains(self):
b1, b2 = gtirb.ProxyBlock(), gtirb.ProxyBlock()
cfg = gtirb.CFG(
[gtirb.Edge(b1, b2, gtirb.Edge.Label(gtirb.Edge.Type.Branch))])
self.assertFalse(
gtirb.Edge(gtirb.ProxyBlock(), gtirb.ProxyBlock()) in cfg)
self.assertFalse(
gtirb.Edge(b1, b2, gtirb.Edge.Label(gtirb.Edge.Type.Fallthrough))
in cfg)
self.assertTrue(
gtirb.Edge(b1, b2, gtirb.Edge.Label(gtirb.Edge.Type.Branch)) in
cfg)
def test_in_edges(self):
b1, b2, b3 = gtirb.ProxyBlock(), gtirb.ProxyBlock(), gtirb.ProxyBlock()
b4 = gtirb.CodeBlock(offset=0, size=1)
cfg = gtirb.CFG([
gtirb.Edge(b1, b2, gtirb.Edge.Label(gtirb.Edge.Type.Fallthrough)),
gtirb.Edge(b3, b2, gtirb.Edge.Label(gtirb.Edge.Type.Branch)),
gtirb.Edge(b1, b3),
])
self.assertEqual(sum(1 for _ in cfg.in_edges(b1)), 0)
self.assertEqual(sum(1 for _ in cfg.in_edges(b2)), 2)
self.assertEqual(sum(1 for _ in cfg.in_edges(b3)), 1)
self.assertEqual(sum(1 for _ in cfg.in_edges(b4)), 0)
def test_sym_exprs(self):
node = gtirb.SymAddrConst(
offset=123,
symbol=gtirb.Symbol(name="symbol", payload=gtirb.ProxyBlock()),
)
self.assertEqual({x.name for x in node.symbols}, {"symbol"})
node = gtirb.SymAddrAddr(
offset=123,
scale=2,
symbol1=gtirb.Symbol(name="symbol1", payload=gtirb.ProxyBlock()),
symbol2=gtirb.Symbol(name="symbol2", payload=gtirb.ProxyBlock()),
)
self.assertEqual({x.name
for x in node.symbols}, {"symbol1", "symbol2"})
def test_discard(self):
b1, b2 = gtirb.ProxyBlock(), gtirb.CodeBlock(offset=0, size=1)
cfg = gtirb.CFG([
gtirb.Edge(b1, b2),
gtirb.Edge(gtirb.ProxyBlock(), gtirb.CodeBlock(offset=1, size=2)),
])
self.assertEqual(len(cfg), 2)
cfg.discard(gtirb.Edge(b1, b2))
self.assertEqual(len(cfg), 1)
self.assertFalse(gtirb.Edge(b1, b2) in cfg)
cfg.discard(gtirb.Edge(b1, b2))
self.assertEqual(len(cfg), 1)
self.assertFalse(gtirb.Edge(b1, b2) in cfg)
def test_code_blocks(self):
b = gtirb.CodeBlock()
self.assertEquals(b.address, None)
self.assertEquals(b.contents, b"")
self.assertEquals(set(b.references), set())
self.assertEquals(set(b.incoming_edges), set())
self.assertEquals(set(b.outgoing_edges), set())
bi = gtirb.ByteInterval(address=1, contents=b"abcd1234")
b.offset = 2
b.size = 3
b.byte_interval = bi
self.assertEquals(b.address, 3)
self.assertEquals(b.contents, b"cd1")
self.assertEquals(set(b.references), set())
self.assertEquals(set(b.incoming_edges), set())
self.assertEquals(set(b.outgoing_edges), set())
s = gtirb.Section()
bi.section = s
m = gtirb.Module()
sym1 = gtirb.Symbol("test", payload=b)
sym2 = gtirb.Symbol("test", payload=123)
sym3 = gtirb.Symbol("test", payload=b)
m.symbols |= {sym1, sym2, sym3}
s.module = m
self.assertEquals(b.address, 3)
self.assertEquals(b.contents, b"cd1")
self.assertEquals(set(b.references), {sym1, sym3})
self.assertEquals(set(b.incoming_edges), set())
self.assertEquals(set(b.outgoing_edges), set())
i = gtirb.IR()
m.ir = i
e1 = gtirb.Edge(b, gtirb.ProxyBlock())
e2 = gtirb.Edge(gtirb.ProxyBlock(), b)
e3 = gtirb.Edge(gtirb.ProxyBlock(), gtirb.ProxyBlock())
e4 = gtirb.Edge(b, b)
i.cfg |= {e1, e2, e3, e4}
self.assertEquals(b.address, 3)
self.assertEquals(b.contents, b"cd1")
self.assertEquals(set(b.references), {sym1, sym3})
self.assertEquals(set(b.incoming_edges), {e2, e4})
self.assertEquals(set(b.outgoing_edges), {e1, e4})
def test_symbol(self):
node = gtirb.Symbol(
name="symbol1",
storage_kind=gtirb.Symbol.StorageKind.Extern,
payload=gtirb.ProxyBlock(),
)
string = repr(node)
new_node = eval(string)
self.assertTrue(node.deep_eq(new_node))
node = gtirb.Symbol(
name="symbol2",
storage_kind=gtirb.Symbol.StorageKind.Extern,
payload=0x123,
)
string = repr(node)
new_node = eval(string)
self.assertTrue(node.deep_eq(new_node))
node = gtirb.Symbol(
name="symbol3",
storage_kind=gtirb.Symbol.StorageKind.Extern,
payload=None,
)
string = repr(node)
new_node = eval(string)
self.assertTrue(node.deep_eq(new_node))
def test_from_uuid_typed(self):
nodes = (
gtirb.IR(),
gtirb.Module(),
gtirb.Block(0, 0),
gtirb.DataObject(0, 0),
gtirb.ProxyBlock(),
gtirb.ImageByteMap(),
gtirb.Section("test", 0, 0),
gtirb.Symbol("test"),
)
for node1 in nodes:
with self.subTest(type(node1).__name__):
for node_cls in map(type, nodes):
node2 = None
try:
node2 = node_cls.from_uuid(node1.uuid)
except TypeError:
if node_cls == type(node1):
self.fail(
"%s.from_uuid raised error returning node of"
"its own type" % node_cls)
else:
if node_cls != type(node1):
self.fail("%s.from_uuid returned despite getting"
"argument for a node of type %s" %
(node_cls, type(node1)))
else:
self.assertEqual(node1, node2)
def test_from_uuid(self):
for node1 in (
gtirb.IR(),
gtirb.Module(),
gtirb.Block(0, 0),
gtirb.DataObject(0, 0),
gtirb.ProxyBlock(),
gtirb.ImageByteMap(),
gtirb.Section("test", 0, 0),
gtirb.Symbol("test"),
):
with self.subTest(type(node1).__name__):
node2 = gtirb.Node.from_uuid(node1.uuid)
self.assertEqual(node1, node2)
def test_sym_expr(self):
node = gtirb.SymAddrConst(
offset=123,
symbol=gtirb.Symbol(name="symbol", payload=gtirb.ProxyBlock()),
attributes=set(),
)
string = repr(node)
new_node = eval(string)
self.assertTrue(node.deep_eq(new_node))
node = gtirb.SymAddrAddr(
offset=123,
scale=2,
symbol1=gtirb.Symbol(name="symbol1", payload=gtirb.ProxyBlock()),
symbol2=gtirb.Symbol(name="symbol2", payload=gtirb.ProxyBlock()),
attributes={
gtirb.SymbolicExpression.Attribute.Adjusted,
gtirb.SymbolicExpression.Attribute.Part0,
},
)
string = repr(node)
new_node = eval(string)
self.assertTrue(node.deep_eq(new_node))
def test_from_uuid(self):
for node1 in (
gtirb.IR(),
gtirb.Module(),
gtirb.CodeBlock(size=0),
gtirb.DataBlock(size=0),
gtirb.ProxyBlock(),
gtirb.Section(name="test"),
gtirb.Symbol(name="test"),
gtirb.ByteInterval(),
):
with self.subTest(type(node1).__name__):
node2 = gtirb.Node.from_uuid(node1.uuid)
self.assertEqual(node1, node2)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
ir = gtirb.IR()
m = gtirb.Module(
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.RAW,
isa=gtirb.Module.ISA.ValidButUnsupported,
name="name",
preferred_addr=1,
rebase_delta=2,
)
m.ir = ir
s = gtirb.Section(
name="name",
flags=(
gtirb.Section.Flag.Executable,
gtirb.Section.Flag.Readable,
gtirb.Section.Flag.Loaded,
gtirb.Section.Flag.Initialized,
),
)
s.module = m
bi = gtirb.ByteInterval(address=0, size=10, contents=b"abcd")
bi.section = s
cb = gtirb.CodeBlock(size=4, offset=0, decode_mode=1)
cb.byte_interval = bi
db = gtirb.DataBlock(size=6, offset=4)
db.byte_interval = bi
sym = gtirb.Symbol(name="name", payload=cb)
sym.module = m
sac = gtirb.SymAddrConst(0, sym,
{gtirb.SymbolicExpression.Attribute.Part1})
bi.symbolic_expressions[2] = sac
p = gtirb.ProxyBlock()
p.module = m
ir.cfg.add(
gtirb.Edge(
cb,
p,
gtirb.Edge.Label(type=gtirb.Edge.Type.Branch,
conditional=False,
direct=True),
))
ir.cfg.add(gtirb.Edge(p, p))
m.aux_data["key"] = gtirb.AuxData(gtirb.Offset(s, 777), "Offset")
ir.aux_data["key"] = gtirb.AuxData("value", "string")
self.ir = ir
def test_symbol(self):
node = gtirb.Symbol(name="symbol1", payload=gtirb.ProxyBlock())
string = repr(node)
new_node = eval(string)
self.assertTrue(node.deep_eq(new_node))
node = gtirb.Symbol(name="symbol2", payload=0x123)
string = repr(node)
new_node = eval(string)
self.assertTrue(node.deep_eq(new_node))
node = gtirb.Symbol(name="symbol3", payload=None)
string = repr(node)
new_node = eval(string)
self.assertTrue(node.deep_eq(new_node))
def test_module(self):
id1 = uuid.uuid4()
id2 = uuid.uuid4()
id3 = uuid.uuid4()
id4 = uuid.uuid4()
id5 = uuid.uuid4()
id6 = uuid.uuid4()
id7 = uuid.uuid4()
id8 = uuid.uuid4()
m1 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id1,
)
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id1,
)
self.assertTrue(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("other_value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id1,
)
self.assertTrue(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="other_binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id1,
)
self.assertFalse(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.PE,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id1,
)
self.assertFalse(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.ARM,
name="name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id1,
)
self.assertFalse(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="other_name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id1,
)
self.assertFalse(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=5,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id1,
)
self.assertFalse(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=1,
rebase_delta=5,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id1,
)
self.assertFalse(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=2, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id1,
)
self.assertFalse(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id4), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id1,
)
self.assertFalse(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id4), ),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id1,
)
self.assertFalse(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym11", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id1,
)
self.assertFalse(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(gtirb.Symbol(name="sym1", uuid=id5), ),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id1,
)
self.assertFalse(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect22", uuid=id8),
),
uuid=id1,
)
self.assertFalse(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(gtirb.Section(name="sect2", uuid=id8), ),
uuid=id1,
)
self.assertFalse(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id2,
)
self.assertFalse(m1.deep_eq(m2))
def test_proxy_block(self):
node = gtirb.ProxyBlock()
string = repr(node)
new_node = eval(string)
self.assertTrue(node.deep_eq(new_node))
