def test_init(self):
prop = fdt.Property('prop')
self.assertIsInstance(prop, fdt.Property)
self.assertEqual(prop.name, 'prop')
with self.assertRaises(ValueError):
prop = fdt.Property('prop\0')
with self.assertRaises(ValueError):
prop = fdt.Property(5)
def test_merge(self):
root_node = self.node_a.copy()
root_node.append(fdt.Node('node_a', props=[fdt.Property('prop_a')]))
root_node.append(fdt.Node('node_b', props=[fdt.Property('prop_b')]))
root_node.append(fdt.Node('node_c', props=[fdt.Property('prop_c')]))
node = self.node_a.copy()
node.set_name("test_node")
root_node.merge(node)
self.assertNotEqual(root_node, node)
def test_merge(self):
root_node = copy.deepcopy(self.node_a)
root_node.append(fdt.Node('node_a', [fdt.Property('prop_a')]),
'sub_node')
root_node.append(fdt.Node('node_b', [fdt.Property('prop_b')]),
'sub_node/node_a')
root_node.append(fdt.Node('node_c', [fdt.Property('prop_c')]),
'sub_node/node_a/node_b')
node = copy.deepcopy(self.node_a)
node.name = "test_node"
root_node.merge(node)
self.assertNotEqual(root_node, node)
def test_append(self):
root_node = self.node_a.copy()
root_node.append(fdt.Node('node_a', props=[fdt.Property('prop_a')]))
root_node.append(fdt.Node('node_b', props=[fdt.Property('prop_b')]))
root_node.append(fdt.Node('node_c', props=[fdt.Property('prop_c')]))
node = root_node.get_subnode('node_a')
self.assertIsInstance(node, fdt.Node)
prop = node.get_property('prop_a')
self.assertIsInstance(prop, fdt.Property)
node.remove_property('prop_a')
prop = node.get_property('prop_a')
self.assertIsNone(prop, fdt.Property)
def test_append(self):
root_node = copy.deepcopy(self.node_a)
root_node.append(fdt.Node('node_a', [fdt.Property('prop_a')]),
'sub_node')
root_node.append(fdt.Node('node_b', [fdt.Property('prop_b')]),
'sub_node/node_a')
root_node.append(fdt.Node('node_c', [fdt.Property('prop_c')]),
'sub_node/node_a/node_b')
node = root_node.get_subnode('sub_node/node_a/node_b/node_c')
self.assertIsInstance(node, fdt.Node)
prop = root_node.get_property('sub_node/node_a/node_b/node_c/prop_c')
self.assertIsInstance(prop, fdt.Property)
root_node.remove_property('sub_node/node_a/node_b/node_c/prop_c')
prop = root_node.get_property('sub_node/node_a/node_b/node_c/prop_c')
self.assertIsNone(prop, fdt.Property)
def setUp(self):
self.node_a = fdt.Node('/')
self.node_a.append(fdt.Property('prop'))
self.node_a.append(fdt.PropStrings('prop_str', 'test', 'test'))
self.node_a.append(fdt.PropWords('prop_word', 0x11111111, 0x55555555))
self.node_a.append(fdt.PropBytes('prop_byte', [0x10, 0x50]))
self.node_a.append(fdt.Node('sub_node'))
def test_export(self):
prop = fdt.Property('prop')
str_data = prop.to_dts()
self.assertEqual(str_data, 'prop;\n')
blob_data, str_data, pos = prop.to_dtb('')
self.assertEqual(blob_data, struct.pack('>III', 0x03, 0, 0))
self.assertEqual(str_data, 'prop\0')
self.assertEqual(pos, 12)
def test_init(self):
self.assertIsInstance(self.node_a, fdt.Node)
self.assertEqual(self.node_a.name, '/')
self.assertEqual(len(self.node_a.props), 4)
self.assertEqual(len(self.node_a.nodes), 1)
with self.assertRaises(TypeError):
self.node_a.append('test')
with self.assertRaises(TypeError):
self.node_a.append(256)
with self.assertRaises(Exception):
self.node_a.append(fdt.Property('prop'))
def test_base_property():
prop = fdt.Property('prop')
assert isinstance(prop, fdt.Property)
assert prop.name == 'prop'
with pytest.raises(AssertionError):
_ = fdt.Property('prop\0')
with pytest.raises(AssertionError):
_ = fdt.Property(5)
prop1 = fdt.Property('prop1')
assert prop1 != prop
prop1 = fdt.Property('prop')
assert prop1 == prop
str_data = prop.to_dts()
assert str_data == 'prop;\n'
blob_data, str_data, pos = prop.to_dtb('')
assert blob_data == struct.pack('>III', 0x03, 0, 0)
assert str_data == 'prop\0'
assert pos == 12
def test_fdt_methods():
fdt_obj = fdt.FDT()
assert isinstance(fdt_obj, fdt.FDT)
fdt_obj.add_item(fdt.Property('prop'))
fdt_obj.set_property("prop", 10, path="/node1")
fdt_obj.set_property("prop", [10, 20], path="/node1/node2")
fdt_obj.set_property("prop_bytes", b"\x10\x20", path="/node1/node2")
assert fdt_obj.exist_node("node1")
assert fdt_obj.exist_property("prop", "/node1")
assert fdt_obj.exist_property("prop", "/node1/node2")
items = fdt_obj.search("")
assert len(items) == 7
fdt_obj.remove_property("prop")
items = fdt_obj.search("")
assert len(items) == 6
items = fdt_obj.search("", itype=fdt.ItemType.NODE)
assert len(items) == 3
items = fdt_obj.search("", itype=fdt.ItemType.PROP)
assert len(items) == 3
items = fdt_obj.search("", itype=fdt.ItemType.PROP_BASE)
assert len(items) == 0
items = fdt_obj.search("", itype=fdt.ItemType.PROP_WORDS)
assert len(items) == 2
items = fdt_obj.search("", itype=fdt.ItemType.PROP_BYTES)
assert len(items) == 1
items = fdt_obj.search("", itype=fdt.ItemType.PROP_STRINGS)
assert len(items) == 0
fdt_obj.update_phandles()
items = fdt_obj.search("phandle", itype=fdt.ItemType.PROP, path="node1", recursive=False)
assert len(items) == 1
fdt_obj.remove_node("node1")
assert len(fdt_obj.search("prop")) == 0
def test_fdt_object():
fdt_obj = fdt.FDT()
assert isinstance(fdt_obj, fdt.FDT)
fdt_obj.add_item(fdt.Property('prop'))
fdt_obj.set_property("prop", 10, "/node1")
fdt_obj.set_property("prop", 10, "/node1/node2")
fdt_obj.update_phandles()
assert fdt_obj.exist_node("node1")
assert fdt_obj.exist_property("prop", "/node1")
assert fdt_obj.exist_property("prop", "/node1/node2")
assert len(fdt_obj.search("prop")) == 3
fdt_obj.remove_property("prop")
assert len(fdt_obj.search("prop")) == 2
fdt_obj.remove_node("node1")
assert len(fdt_obj.search("prop")) == 0
def test_compare(self):
prop1 = fdt.Property('prop1')
prop2 = fdt.Property('prop2')
self.assertEqual(prop1, prop1)
self.assertNotEqual(prop1, prop2)
def test_node():
# create node object
node = fdt.Node('/')
node.append(fdt.Property('prop'))
node.append(fdt.PropStrings('prop_str', 'test', 'test'))
node.append(fdt.PropWords('prop_word', 0x11111111, 0x55555555))
node.append(fdt.PropBytes('prop_byte', [0x10, 0x50]))
subnode0 = fdt.Node('subnode0')
subnode0.append(fdt.Property('prop0'))
subnode0.append(fdt.PropStrings('prop_str0', 'test'))
subnode1 = fdt.Node('subnode1')
subnode1.append(fdt.Property('prop1'))
subnode1.append(fdt.PropWords('prop_word1', 0x11111111))
subnode0.append(subnode1)
node.append(subnode0)
assert isinstance(node, fdt.Node)
assert node.name == '/'
assert len(node.props) == 4
assert len(node.nodes) == 1
# Use only node constructor
new_node = fdt.Node('/',
fdt.Property('prop'),
fdt.PropStrings('prop_str', 'test', 'test'),
fdt.PropWords('prop_word', 0x11111111, 0x55555555),
fdt.PropBytes('prop_byte', [0x10, 0x50]),
fdt.Node('subnode0',
fdt.Property('prop0'),
fdt.PropStrings('prop_str0', 'test'),
fdt.Node('subnode1',
fdt.Property('prop1'),
fdt.PropWords('prop_word1', 0x11111111)
)
)
)
assert node == new_node
with pytest.raises(AssertionError):
node.append('test')
with pytest.raises(Exception):
node.append(256)
with pytest.raises(Exception):
node.append(fdt.Property('prop'))
copy_node = node.copy()
assert copy_node == node
copy_node.set_property('prop_word', [0x10, 0x50])
assert copy_node != node
# export to dts
str_data = node.to_dts()
out = "/ {\n"
out += " prop;\n"
out += " prop_str = \"test\", \"test\";\n"
out += " prop_word = <0x11111111 0x55555555>;\n"
out += " prop_byte = [10 50];\n"
out += " subnode0 {\n"
out += " prop0;\n"
out += " prop_str0 = \"test\";\n"
out += " subnode1 {\n"
out += " prop1;\n"
out += " prop_word1 = <0x11111111>;\n"
out += " };\n"
out += " };\n"
out += "};\n"
assert str_data == out
