You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
658 lines
26 KiB
658 lines
26 KiB
# SPDX-License-Identifier: (GPL-2.0-or-later OR BSD-2-Clause) |
|
# pylibfdt - Tests for Flat Device Tree manipulation in Python |
|
# Copyright (C) 2017 Google, Inc. |
|
# Written by Simon Glass <sjg@chromium.org> |
|
# |
|
|
|
import struct |
|
import sys |
|
import types |
|
import unittest |
|
|
|
sys.path.insert(0, '../pylibfdt') |
|
import libfdt |
|
from libfdt import Fdt, FdtSw, FdtException, QUIET_NOTFOUND, QUIET_ALL |
|
|
|
TEST_ADDR_1H = 0xdeadbeef |
|
TEST_ADDR_1L = 0x00000000 |
|
TEST_ADDR_1 = (TEST_ADDR_1H << 32) | TEST_ADDR_1L |
|
TEST_ADDR_1 = 0x8000000000000000 |
|
TEST_SIZE_1H = 0x00000000 |
|
TEST_SIZE_1L = 0x00100000 |
|
TEST_SIZE_1 = (TEST_SIZE_1H << 32) | TEST_SIZE_1L |
|
TEST_ADDR_2H = 0 |
|
TEST_ADDR_2L = 123456789 |
|
TEST_ADDR_2 = (TEST_ADDR_2H << 32) | TEST_ADDR_2L |
|
TEST_SIZE_2H = 0 |
|
TEST_SIZE_2L = 0o10000 |
|
TEST_SIZE_2 = (TEST_SIZE_2H << 32) | TEST_SIZE_2L |
|
|
|
TEST_VALUE_1 = 0xdeadbeef |
|
TEST_VALUE_2 = 123456789 |
|
|
|
TEST_VALUE64_1H = 0xdeadbeef |
|
TEST_VALUE64_1L = 0x01abcdef |
|
TEST_VALUE64_1 = (TEST_VALUE64_1H << 32) | TEST_VALUE64_1L |
|
|
|
PHANDLE_1 = 0x2000 |
|
PHANDLE_2 = 0x2001 |
|
|
|
TEST_BYTES_1 = b'hello world' |
|
|
|
TEST_STRING_1 = 'hello world' |
|
TEST_STRING_2 = 'hi world' |
|
TEST_STRING_3 = u'unicode \u01d3' |
|
|
|
|
|
def get_err(err_code): |
|
"""Convert an error code into an error message |
|
|
|
Args: |
|
err_code: Error code value (FDT_ERR_...) |
|
|
|
Returns: |
|
String error code |
|
""" |
|
return 'pylibfdt error %d: %s' % (-err_code, libfdt.strerror(-err_code)) |
|
|
|
def _ReadFdt(fname): |
|
"""Read a device tree file into an Fdt object, ready for use |
|
|
|
Args: |
|
fname: Filename to read from |
|
|
|
Returns: |
|
Fdt bytearray suitable for passing to libfdt functions |
|
""" |
|
with open(fname, mode='rb') as f: |
|
return libfdt.Fdt(f.read()) |
|
|
|
class PyLibfdtBasicTests(unittest.TestCase): |
|
"""Test class for basic pylibfdt access functions |
|
|
|
Properties: |
|
fdt: Device tree file used for testing |
|
""" |
|
|
|
def setUp(self): |
|
"""Read in the device tree we use for testing""" |
|
self.fdt = _ReadFdt('test_tree1.dtb') |
|
self.fdt2 = _ReadFdt('test_props.dtb') |
|
self.fdt3 = _ReadFdt('aliases.dtb') |
|
|
|
def GetPropList(self, node_path): |
|
"""Read a list of properties from a node |
|
|
|
Args: |
|
node_path: Full path to node, e.g. '/subnode@1/subsubnode' |
|
|
|
Returns: |
|
List of property names for that node, e.g. ['compatible', 'reg'] |
|
""" |
|
prop_list = [] |
|
node = self.fdt.path_offset(node_path) |
|
poffset = self.fdt.first_property_offset(node, QUIET_NOTFOUND) |
|
while poffset > 0: |
|
prop = self.fdt.get_property_by_offset(poffset) |
|
prop_list.append(prop.name) |
|
poffset = self.fdt.next_property_offset(poffset, QUIET_NOTFOUND) |
|
return prop_list |
|
|
|
def GetSubnodes(self, node_path): |
|
"""Read a list of subnodes from a node |
|
|
|
Args: |
|
node_path: Full path to node, e.g. '/subnode@1/subsubnode' |
|
|
|
Returns: |
|
List of subnode names for that node, e.g. ['subsubnode', 'ss1'] |
|
""" |
|
subnode_list = [] |
|
node = self.fdt.path_offset(node_path) |
|
offset = self.fdt.first_subnode(node, QUIET_NOTFOUND) |
|
while offset > 0: |
|
name = self.fdt.get_name(offset) |
|
subnode_list.append(name) |
|
offset = self.fdt.next_subnode(offset, QUIET_NOTFOUND) |
|
return subnode_list |
|
|
|
def testImport(self): |
|
"""Check that we can import the library correctly""" |
|
self.assertEqual(type(libfdt), types.ModuleType) |
|
|
|
def testBadFdt(self): |
|
"""Check that a filename provided accidentally is not accepted""" |
|
with self.assertRaises(FdtException) as e: |
|
fdt = libfdt.Fdt(b'a string') |
|
self.assertEqual(e.exception.err, -libfdt.BADMAGIC) |
|
|
|
def testSubnodeOffset(self): |
|
"""check that we can locate a subnode by name""" |
|
node1 = self.fdt.path_offset('/subnode@1') |
|
self.assertEqual(self.fdt.subnode_offset(0, 'subnode@1'), node1) |
|
|
|
with self.assertRaises(FdtException) as e: |
|
self.fdt.subnode_offset(0, 'missing') |
|
self.assertEqual(e.exception.err, -libfdt.NOTFOUND) |
|
|
|
node2 = self.fdt.path_offset('/subnode@1/subsubnode') |
|
self.assertEqual(self.fdt.subnode_offset(node1, 'subsubnode'), node2) |
|
|
|
def testPathOffset(self): |
|
"""Check that we can find the offset of a node""" |
|
self.assertEqual(self.fdt.path_offset('/'), 0) |
|
self.assertTrue(self.fdt.path_offset('/subnode@1') > 0) |
|
with self.assertRaises(FdtException) as e: |
|
self.fdt.path_offset('/wibble') |
|
self.assertEqual(e.exception.err, -libfdt.NOTFOUND) |
|
self.assertEqual(self.fdt.path_offset('/wibble', QUIET_NOTFOUND), |
|
-libfdt.NOTFOUND) |
|
|
|
def testPropertyOffset(self): |
|
"""Walk through all the properties in the root node""" |
|
offset = self.fdt.first_property_offset(0) |
|
self.assertTrue(offset > 0) |
|
for i in range(5): |
|
next_offset = self.fdt.next_property_offset(offset) |
|
self.assertTrue(next_offset > offset) |
|
offset = next_offset |
|
self.assertEqual(self.fdt.next_property_offset(offset, QUIET_NOTFOUND), |
|
-libfdt.NOTFOUND) |
|
|
|
def testPropertyOffsetExceptions(self): |
|
"""Check that exceptions are raised as expected""" |
|
with self.assertRaises(FdtException) as e: |
|
self.fdt.first_property_offset(107) |
|
self.assertEqual(e.exception.err, -libfdt.BADOFFSET) |
|
|
|
# Quieten the NOTFOUND exception and check that a BADOFFSET |
|
# exception is still raised. |
|
with self.assertRaises(FdtException) as e: |
|
self.fdt.first_property_offset(107, QUIET_NOTFOUND) |
|
self.assertEqual(e.exception.err, -libfdt.BADOFFSET) |
|
with self.assertRaises(FdtException) as e: |
|
self.fdt.next_property_offset(107, QUIET_NOTFOUND) |
|
self.assertEqual(e.exception.err, -libfdt.BADOFFSET) |
|
|
|
# Check that NOTFOUND can be quietened. |
|
node = self.fdt.path_offset('/subnode@1/ss1') |
|
self.assertEqual(self.fdt.first_property_offset(node, QUIET_NOTFOUND), |
|
-libfdt.NOTFOUND) |
|
with self.assertRaises(FdtException) as e: |
|
self.fdt.first_property_offset(node) |
|
self.assertEqual(e.exception.err, -libfdt.NOTFOUND) |
|
|
|
def testGetName(self): |
|
"""Check that we can get the name of a node""" |
|
self.assertEqual(self.fdt.get_name(0), '') |
|
node = self.fdt.path_offset('/subnode@1/subsubnode') |
|
self.assertEqual(self.fdt.get_name(node), 'subsubnode') |
|
|
|
with self.assertRaises(FdtException) as e: |
|
self.fdt.get_name(-2) |
|
self.assertEqual(e.exception.err, -libfdt.BADOFFSET) |
|
|
|
def testGetPropertyByOffset(self): |
|
"""Check that we can read the name and contents of a property""" |
|
root = 0 |
|
poffset = self.fdt.first_property_offset(root) |
|
prop = self.fdt.get_property_by_offset(poffset) |
|
self.assertEqual(prop.name, 'compatible') |
|
self.assertEqual(prop, b'test_tree1\0') |
|
|
|
with self.assertRaises(FdtException) as e: |
|
self.fdt.get_property_by_offset(-2) |
|
self.assertEqual(e.exception.err, -libfdt.BADOFFSET) |
|
self.assertEqual( |
|
-libfdt.BADOFFSET, |
|
self.fdt.get_property_by_offset(-2, [libfdt.BADOFFSET])) |
|
|
|
def testGetProp(self): |
|
"""Check that we can read the contents of a property by name""" |
|
root = self.fdt.path_offset('/') |
|
value = self.fdt.getprop(root, "compatible") |
|
self.assertEqual(value, b'test_tree1\0') |
|
self.assertEqual(-libfdt.NOTFOUND, self.fdt.getprop(root, 'missing', |
|
QUIET_NOTFOUND)) |
|
|
|
with self.assertRaises(FdtException) as e: |
|
self.fdt.getprop(root, 'missing') |
|
self.assertEqual(e.exception.err, -libfdt.NOTFOUND) |
|
|
|
node = self.fdt.path_offset('/subnode@1/subsubnode') |
|
value = self.fdt.getprop(node, "compatible") |
|
self.assertEqual(value, b'subsubnode1\0subsubnode\0') |
|
|
|
def testStrError(self): |
|
"""Check that we can get an error string""" |
|
self.assertEqual(libfdt.strerror(-libfdt.NOTFOUND), |
|
'FDT_ERR_NOTFOUND') |
|
|
|
def testNextNodeOffset(self): |
|
"""Check that we can walk through nodes""" |
|
node_list = [] |
|
node = 0 |
|
depth = 0 |
|
while depth >= 0: |
|
node_list.append([depth, self.fdt.get_name(node)]) |
|
node, depth = self.fdt.next_node(node, depth, (libfdt.BADOFFSET,)) |
|
self.assertEqual(node_list, [ |
|
[0, ''], |
|
[1, 'subnode@1'], |
|
[2, 'subsubnode'], |
|
[2, 'ss1'], |
|
[1, 'subnode@2'], |
|
[2, 'subsubnode@0'], |
|
[2, 'ss2'], |
|
]) |
|
|
|
def testFirstNextSubnodeOffset(self): |
|
"""Check that we can walk through subnodes""" |
|
node_list = [] |
|
node = self.fdt.first_subnode(0, QUIET_NOTFOUND) |
|
while node >= 0: |
|
node_list.append(self.fdt.get_name(node)) |
|
node = self.fdt.next_subnode(node, QUIET_NOTFOUND) |
|
self.assertEqual(node_list, ['subnode@1', 'subnode@2']) |
|
|
|
def testFirstNextSubnodeOffsetExceptions(self): |
|
"""Check except handling for first/next subnode functions""" |
|
node = self.fdt.path_offset('/subnode@1/subsubnode', QUIET_NOTFOUND) |
|
self.assertEqual(self.fdt.first_subnode(node, QUIET_NOTFOUND), |
|
-libfdt.NOTFOUND) |
|
with self.assertRaises(FdtException) as e: |
|
self.fdt.first_subnode(node) |
|
self.assertEqual(e.exception.err, -libfdt.NOTFOUND) |
|
|
|
node = self.fdt.path_offset('/subnode@1/ss1', QUIET_NOTFOUND) |
|
self.assertEqual(self.fdt.next_subnode(node, QUIET_NOTFOUND), |
|
-libfdt.NOTFOUND) |
|
with self.assertRaises(FdtException) as e: |
|
self.fdt.next_subnode(node) |
|
self.assertEqual(e.exception.err, -libfdt.NOTFOUND) |
|
|
|
def testDeleteProperty(self): |
|
"""Test that we can delete a property""" |
|
node_name = '/subnode@1' |
|
self.assertEqual(self.GetPropList(node_name), |
|
['compatible', 'reg', 'prop-int']) |
|
node = self.fdt.path_offset('/%s' % node_name) |
|
self.assertEqual(self.fdt.delprop(node, 'reg'), 0) |
|
self.assertEqual(self.GetPropList(node_name), |
|
['compatible', 'prop-int']) |
|
|
|
def testHeader(self): |
|
"""Test that we can access the header values""" |
|
self.assertEqual(self.fdt.magic(), 0xd00dfeed) |
|
self.assertEqual(self.fdt.totalsize(), len(self.fdt._fdt)) |
|
self.assertEqual(self.fdt.off_dt_struct(), 88) |
|
self.assertEqual(self.fdt.off_dt_strings(), 652) |
|
self.assertEqual(self.fdt.off_mem_rsvmap(), 40) |
|
self.assertEqual(self.fdt.version(), 17) |
|
self.assertEqual(self.fdt.last_comp_version(), 16) |
|
self.assertEqual(self.fdt.boot_cpuid_phys(), 0) |
|
self.assertEqual(self.fdt.size_dt_strings(), 105) |
|
self.assertEqual(self.fdt.size_dt_struct(), 564) |
|
|
|
def testPack(self): |
|
"""Test that we can pack the tree after deleting something""" |
|
orig_size = self.fdt.totalsize() |
|
node = self.fdt.path_offset('/subnode@2', QUIET_NOTFOUND) |
|
self.assertEqual(self.fdt.delprop(node, 'prop-int'), 0) |
|
self.assertEqual(orig_size, self.fdt.totalsize()) |
|
self.assertEqual(self.fdt.pack(), 0) |
|
self.assertTrue(self.fdt.totalsize() < orig_size) |
|
self.assertEqual(self.fdt.totalsize(), len(self.fdt.as_bytearray())) |
|
|
|
def testBadPropertyOffset(self): |
|
"""Test that bad property offsets are detected""" |
|
with self.assertRaises(FdtException) as e: |
|
self.fdt.get_property_by_offset(13) |
|
self.assertEqual(e.exception.err, -libfdt.BADOFFSET) |
|
with self.assertRaises(FdtException) as e: |
|
self.fdt.first_property_offset(3) |
|
self.assertEqual(e.exception.err, -libfdt.BADOFFSET) |
|
with self.assertRaises(FdtException) as e: |
|
self.fdt.next_property_offset(3) |
|
self.assertEqual(e.exception.err, -libfdt.BADOFFSET) |
|
|
|
def testBadPathOffset(self): |
|
"""Test that bad path names are detected""" |
|
with self.assertRaisesRegex(FdtException, get_err(libfdt.BADPATH)): |
|
self.fdt.path_offset('not-present') |
|
|
|
def testQuietAll(self): |
|
"""Check that exceptions can be masked by QUIET_ALL""" |
|
self.assertEqual(-libfdt.NOTFOUND, |
|
self.fdt.path_offset('/missing', QUIET_ALL)) |
|
self.assertEqual(-libfdt.BADOFFSET, |
|
self.fdt.get_property_by_offset(13, QUIET_ALL)) |
|
self.assertEqual(-libfdt.BADPATH, |
|
self.fdt.path_offset('missing', QUIET_ALL)) |
|
|
|
def testIntegers(self): |
|
"""Check that integers can be passed and returned""" |
|
self.assertEqual(0, libfdt.fdt_get_phandle(self.fdt._fdt, 0)) |
|
node2 = self.fdt.path_offset('/subnode@2') |
|
self.assertEqual(0x2000, libfdt.fdt_get_phandle(self.fdt._fdt, node2)) |
|
|
|
def testGetPhandle(self): |
|
"""Test for the get_phandle() method""" |
|
self.assertEqual(0, self.fdt.get_phandle(0)) |
|
node2 = self.fdt.path_offset('/subnode@2') |
|
self.assertEqual(0x2000, self.fdt.get_phandle(node2)) |
|
|
|
def testGetAlias(self): |
|
"""Test for the get_alias() method""" |
|
self.assertEqual("/subnode@1", self.fdt3.get_alias('s1')) |
|
self.assertEqual("/subnode@1/subsubnode", self.fdt3.get_alias('ss1')) |
|
self.assertEqual("/subnode@1/subsubnode/subsubsubnode", self.fdt3.get_alias('sss1')) |
|
|
|
def testGetPath(self): |
|
"""Test for the get_path() method""" |
|
node = self.fdt.path_offset('/subnode@1') |
|
node2 = self.fdt.path_offset('/subnode@1/subsubnode') |
|
self.assertEqual("/subnode@1", self.fdt.get_path(node)) |
|
self.assertEqual("/subnode@1/subsubnode", self.fdt.get_path(node2)) |
|
self.assertEqual("/subnode@1/subsubnode", self.fdt.get_path(node2, size_hint=1)) |
|
|
|
with self.assertRaises(FdtException) as e: |
|
self.fdt.get_path(-1) |
|
self.assertEqual(e.exception.err, -libfdt.BADOFFSET) |
|
|
|
self.assertEqual(-libfdt.BADOFFSET, self.fdt.get_path(-1, quiet=(libfdt.BADOFFSET,))) |
|
|
|
def testParentOffset(self): |
|
"""Test for the parent_offset() method""" |
|
self.assertEqual(-libfdt.NOTFOUND, |
|
self.fdt.parent_offset(0, QUIET_NOTFOUND)) |
|
with self.assertRaises(FdtException) as e: |
|
self.fdt.parent_offset(0) |
|
self.assertEqual(e.exception.err, -libfdt.NOTFOUND) |
|
|
|
node1 = self.fdt.path_offset('/subnode@2') |
|
self.assertEqual(0, self.fdt.parent_offset(node1)) |
|
node2 = self.fdt.path_offset('/subnode@2/subsubnode@0') |
|
self.assertEqual(node1, self.fdt.parent_offset(node2)) |
|
|
|
def testNodeOffsetByPhandle(self): |
|
"""Test for the node_offset_by_phandle() method""" |
|
self.assertEqual(-libfdt.NOTFOUND, |
|
self.fdt.node_offset_by_phandle(1, QUIET_NOTFOUND)) |
|
node1 = self.fdt.path_offset('/subnode@2') |
|
self.assertEqual(node1, self.fdt.node_offset_by_phandle(0x2000)) |
|
node2 = self.fdt.path_offset('/subnode@2/subsubnode@0') |
|
self.assertEqual(node2, self.fdt.node_offset_by_phandle(0x2001)) |
|
|
|
def get_prop(self, name): |
|
return self.fdt2.getprop(0, name) |
|
|
|
def testGetIntProperties(self): |
|
"""Test that we can access properties as integers""" |
|
self.assertEqual(0xdeadbeef, self.get_prop("prop-hex32").as_uint32()) |
|
self.assertEqual(123, self.get_prop("prop-uint32").as_uint32()) |
|
self.assertEqual(-2, self.get_prop("prop-int32").as_int32()) |
|
self.assertEqual(9223372036854775807, |
|
self.get_prop("prop-uint64").as_uint64()) |
|
self.assertEqual(-2, self.get_prop("prop-int64").as_int64()) |
|
|
|
def testGetIntListProperties(self): |
|
"""Test that we can access properties as integer lists""" |
|
self.assertEqual([128, -16, -2], |
|
self.get_prop("prop-int32-array").as_int32_list()) |
|
self.assertEqual([0x1, 0x98765432, 0xdeadbeef], |
|
self.get_prop("prop-uint32-array").as_uint32_list()) |
|
self.assertEqual([0x100000000, -2], |
|
self.get_prop("prop-int64-array").as_int64_list()) |
|
self.assertEqual([0x100000000, 0x1], |
|
self.get_prop("prop-uint64-array").as_uint64_list()) |
|
|
|
def testGetStringlistProperties(self): |
|
"""Test that we can access properties as string list""" |
|
node = self.fdt.path_offset('/subnode@1/subsubnode') |
|
self.assertEqual(["subsubnode1", "subsubnode"], |
|
self.fdt.getprop(node, "compatible").as_stringlist()) |
|
self.assertEqual(["this is a placeholder string", "string2"], |
|
self.fdt.getprop(node, "placeholder").as_stringlist()) |
|
|
|
def testReserveMap(self): |
|
"""Test that we can access the memory reserve map""" |
|
self.assertEqual(2, self.fdt.num_mem_rsv()) |
|
self.assertEqual([ 0xdeadbeef00000000, 0x100000], |
|
self.fdt.get_mem_rsv(0)) |
|
self.assertEqual([123456789, 0o10000], self.fdt.get_mem_rsv(1)) |
|
|
|
def testEmpty(self): |
|
"""Test that we can create an empty tree""" |
|
self.assertEqual(-libfdt.NOSPACE, |
|
Fdt.create_empty_tree(1, (libfdt.NOSPACE,))) |
|
fdt = Fdt.create_empty_tree(128) |
|
self.assertEqual(128, fdt.totalsize()) |
|
|
|
def testOpenInto(self): |
|
"""Test that we can resize a tree""" |
|
fdt = Fdt.create_empty_tree(128) |
|
self.assertEqual(128, fdt.totalsize()) |
|
fdt.resize(256) |
|
self.assertEqual(256, fdt.totalsize()) |
|
fdt.pack() |
|
self.assertTrue(fdt.totalsize() < 128) |
|
|
|
def testSetProp(self): |
|
"""Test that we can update and create properties""" |
|
node = self.fdt.path_offset('/subnode@1') |
|
self.fdt.setprop(node, 'compatible', TEST_BYTES_1) |
|
self.assertEqual(TEST_BYTES_1, self.fdt.getprop(node, 'compatible')) |
|
|
|
# Check that this property is missing, and that we don't have space to |
|
# add it |
|
self.assertEqual(-libfdt.NOTFOUND, |
|
self.fdt.getprop(node, 'missing', QUIET_NOTFOUND)) |
|
self.assertEqual(-libfdt.NOSPACE, |
|
self.fdt.setprop(node, 'missing', TEST_BYTES_1, |
|
quiet=(libfdt.NOSPACE,))) |
|
|
|
# Expand the device tree so we now have room |
|
self.fdt.resize(self.fdt.totalsize() + 50) |
|
self.fdt.setprop(node, 'missing', TEST_BYTES_1) |
|
self.assertEqual(TEST_BYTES_1, self.fdt.getprop(node, 'missing')) |
|
|
|
def testSetPropU32(self): |
|
"""Test that we can update and create integer properties""" |
|
node = 0 |
|
prop = 'prop-int' |
|
self.fdt.setprop_u32(node, prop, TEST_VALUE_1) |
|
self.assertEqual(struct.pack('>I', TEST_VALUE_1), |
|
self.fdt.getprop(node, prop)) |
|
|
|
def testSetPropU64(self): |
|
"""Test that we can update and create integer properties""" |
|
node = 0 |
|
prop = 'prop-int64' |
|
self.fdt.setprop_u64(node, prop, TEST_VALUE64_1) |
|
self.assertEqual(struct.pack('>Q', TEST_VALUE64_1), |
|
self.fdt.getprop(node, prop)) |
|
|
|
def testSetPropStr(self): |
|
"""Test that we can set a property to a particular string""" |
|
node = 0 |
|
prop = 'prop-str' |
|
self.assertEqual(TEST_STRING_1, self.fdt.getprop(node, prop).as_str()) |
|
self.fdt.setprop_str(node, prop, TEST_STRING_2) |
|
self.assertEqual(TEST_STRING_2, self.fdt.getprop(node, prop).as_str()) |
|
with self.assertRaises(ValueError) as e: |
|
self.fdt.getprop(node, 'prop-int').as_str() |
|
self.assertIn('lacks nul termination', str(e.exception)) |
|
|
|
node2 = self.fdt.path_offset('/subnode@1/subsubnode') |
|
with self.assertRaises(ValueError) as e: |
|
self.fdt.getprop(node2, 'compatible').as_str() |
|
self.assertIn('embedded nul', str(e.exception)) |
|
|
|
# Expand the device tree so we now have room |
|
self.fdt.resize(self.fdt.totalsize() + 50) |
|
prop = 'prop-unicode' |
|
self.fdt.setprop_str(node, prop, TEST_STRING_3) |
|
self.assertEqual(TEST_STRING_3, |
|
self.fdt.getprop(node, prop).as_str()) |
|
|
|
def testHasProp(self): |
|
"""Test that we can check if a node has a property""" |
|
node = 0 |
|
self.assertFalse(self.fdt2.hasprop(node, 'missing')) |
|
self.assertTrue(self.fdt2.hasprop(node, 'prop-bool')) |
|
|
|
# Test a property with a non-empty value |
|
self.assertTrue(self.fdt2.hasprop(node, 'prop-uint64')) |
|
|
|
def testSetPropBool(self): |
|
"""Test that we can update and create boolean properties""" |
|
node = 0 |
|
prop = 'prop-bool' |
|
|
|
# Make some space and then try setting a new boolean property |
|
self.fdt.resize(self.fdt.totalsize() + 50) |
|
self.fdt.hasprop(node, 'missing') |
|
self.fdt.setprop_bool(node, 'missing', True) |
|
self.assertTrue(self.fdt.hasprop(node, 'missing')) |
|
|
|
# Trying toggling an existing boolean property. Do each operation twice |
|
# to make sure that the behaviour is correct when setting the property |
|
# to the same value. |
|
self.assertTrue(self.fdt2.hasprop(node, prop)) |
|
self.fdt2.setprop_bool(node, prop, False) |
|
self.assertFalse(self.fdt2.hasprop(node, prop)) |
|
self.fdt2.setprop_bool(node, prop, False) |
|
self.assertFalse(self.fdt2.hasprop(node, prop)) |
|
self.fdt2.setprop_bool(node, prop, True) |
|
self.assertTrue(self.fdt2.hasprop(node, prop)) |
|
self.fdt2.setprop_bool(node, prop, True) |
|
self.assertTrue(self.fdt2.hasprop(node, prop)) |
|
|
|
def testSetName(self): |
|
"""Test that we can update a node name""" |
|
node = self.fdt.path_offset('/subnode@1') |
|
old_val = self.fdt.get_name(node) |
|
self.fdt.set_name(node, 'test') |
|
self.assertEqual('test', self.fdt.get_name(node)) |
|
|
|
with self.assertRaises(ValueError) as e: |
|
self.fdt.set_name(node, 'some\0name') |
|
self.assertIn('embedded nul', str(e.exception)) |
|
|
|
with self.assertRaises(ValueError) as e: |
|
self.fdt.set_name(node, 'name\0') |
|
self.assertIn('embedded nul', str(e.exception)) |
|
|
|
def testAddDeleteNodes(self): |
|
"""Test that we can add and delete nodes""" |
|
node_name = '/subnode@1' |
|
self.assertEqual(self.GetSubnodes(node_name), ['subsubnode', 'ss1']) |
|
node = self.fdt.path_offset('%s/subsubnode' % node_name) |
|
self.assertEqual(self.fdt.del_node(node, 'subsubnode'), 0) |
|
self.assertEqual(self.GetSubnodes(node_name), ['ss1']) |
|
|
|
node = self.fdt.path_offset(node_name) |
|
offset = self.fdt.add_subnode(node, 'more') |
|
self.assertTrue(offset > 0) |
|
self.assertEqual(self.GetSubnodes(node_name), ['more', 'ss1']) |
|
|
|
|
|
class PyLibfdtSwTests(unittest.TestCase): |
|
"""Test class for pylibfdt sequential-write DT creation |
|
""" |
|
def assertOk(self, err_code): |
|
self.assertEqual(0, err_code) |
|
|
|
def testCreate(self): |
|
# First check the minimum size and also the FdtSw() constructor |
|
with self.assertRaisesRegex(FdtException, get_err(libfdt.NOSPACE)): |
|
self.assertEqual(-libfdt.NOSPACE, FdtSw(3)) |
|
|
|
sw = FdtSw() |
|
sw.add_reservemap_entry(TEST_ADDR_1, TEST_SIZE_1) |
|
sw.add_reservemap_entry(TEST_ADDR_2, TEST_SIZE_2) |
|
sw.finish_reservemap() |
|
|
|
sw.begin_node('') |
|
sw.property_string('compatible', 'test_tree1') |
|
sw.property_u32('prop-int', TEST_VALUE_1) |
|
|
|
sw.property_u32('prop-int', TEST_VALUE_1) |
|
sw.property_u64('prop-int64', TEST_VALUE64_1) |
|
sw.property_string('prop-str', TEST_STRING_1) |
|
sw.property_u32('#address-cells', 1) |
|
sw.property_u32('#size-cells', 0) |
|
|
|
sw.begin_node('subnode@1') |
|
sw.property_string('compatible', 'subnode1') |
|
sw.property_u32('reg', 1) |
|
sw.property_cell('prop-int', TEST_VALUE_1) |
|
sw.property('data', b'\x00data\x01') |
|
sw.begin_node('subsubnode') |
|
sw.property('compatible', b'subsubnode1\0subsubnode') |
|
sw.property_cell('prop-int', TEST_VALUE_1) |
|
sw.end_node() |
|
sw.begin_node('ss1') |
|
sw.end_node() |
|
sw.end_node() |
|
|
|
for i in range(2, 11): |
|
with sw.add_node('subnode@%d' % i): |
|
sw.property_u32('reg', 2) |
|
sw.property_cell('linux,phandle', PHANDLE_1) |
|
sw.property_cell('prop-int', TEST_VALUE_2) |
|
sw.property_u32('#address-cells', 1) |
|
sw.property_u32('#size-cells', 0) |
|
with sw.add_node('subsubnode@0'): |
|
sw.property_u32('reg', 0) |
|
sw.property_cell('phandle', PHANDLE_2) |
|
sw.property('compatible', b'subsubnode2\0subsubnode') |
|
sw.property_cell('prop-int', TEST_VALUE_2) |
|
with sw.add_node('ss2'): |
|
pass |
|
sw.end_node() |
|
|
|
fdt = sw.as_fdt() |
|
self.assertEqual(2, fdt.num_mem_rsv()) |
|
self.assertEqual([TEST_ADDR_1, TEST_SIZE_1], fdt.get_mem_rsv(0)) |
|
|
|
# Make sure we can add a few more things |
|
with sw.add_node('another'): |
|
sw.property_u32('reg', 3) |
|
|
|
# Make sure we can read from the tree too |
|
node = sw.path_offset('/subnode@1') |
|
self.assertEqual(b'subnode1\0', sw.getprop(node, 'compatible')) |
|
|
|
# Make sure we did at least two resizes |
|
self.assertTrue(len(fdt.as_bytearray()) > FdtSw.INC_SIZE * 2) |
|
|
|
|
|
class PyLibfdtRoTests(unittest.TestCase): |
|
"""Test class for read-only pylibfdt access functions |
|
|
|
This just tests a few simple cases. Most of the tests are in |
|
PyLibfdtBasicTests. |
|
|
|
Properties: |
|
fdt: Device tree file used for testing |
|
""" |
|
|
|
def setUp(self): |
|
"""Read in the device tree we use for testing""" |
|
with open('test_tree1.dtb', mode='rb') as f: |
|
self.fdt = libfdt.FdtRo(f.read()) |
|
|
|
def testAccess(self): |
|
"""Basic sanity check for the FdtRo class""" |
|
node = self.fdt.path_offset('/subnode@1') |
|
self.assertEqual(b'subnode1\0', |
|
self.fdt.getprop(node, 'compatible')) |
|
node = self.fdt.first_subnode(node) |
|
self.assertEqual(b'this is a placeholder string\0string2\0', |
|
self.fdt.getprop(node, 'placeholder')) |
|
|
|
|
|
if __name__ == "__main__": |
|
unittest.main()
|
|
|