LineageOS/android_external_dtc
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

pylibfdt: Adjust for deprecated test methods

Browse Source 
Python recently deprecated some test methods in favour of others. Adjust
the code to avoid warnings.

Signed-off-by: Simon Glass <sjg@chromium.org>
Message-Id: <20191113012410.62550-1-sjg@chromium.org>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
This commit is contained in:
Simon Glass
2019-11-12 18:24:10 -07:00
committed by David Gibson
parent dbe80d577e
commit 7a22132c79
1 changed files with 99 additions and 99 deletions
Download Patch File Download Diff File Expand all files Collapse all files

198
tests/pylibfdt_tests.py
View File

@@ -118,34 +118,34 @@ class PyLibfdtBasicTests(unittest.TestCase):
def testImport(self): def testImport(self):
"""Check that we can import the library correctly""" """Check that we can import the library correctly"""
self.assertEquals(type(libfdt), types.ModuleType) self.assertEqual(type(libfdt), types.ModuleType)
def testBadFdt(self): def testBadFdt(self):
"""Check that a filename provided accidentally is not accepted""" """Check that a filename provided accidentally is not accepted"""
with self.assertRaises(FdtException) as e: with self.assertRaises(FdtException) as e:
fdt = libfdt.Fdt(b'a string') fdt = libfdt.Fdt(b'a string')
self.assertEquals(e.exception.err, -libfdt.BADMAGIC) self.assertEqual(e.exception.err, -libfdt.BADMAGIC)
def testSubnodeOffset(self): def testSubnodeOffset(self):
"""check that we can locate a subnode by name""" """check that we can locate a subnode by name"""
node1 = self.fdt.path_offset('/subnode@1') node1 = self.fdt.path_offset('/subnode@1')
self.assertEquals(self.fdt.subnode_offset(0, 'subnode@1'), node1) self.assertEqual(self.fdt.subnode_offset(0, 'subnode@1'), node1)
with self.assertRaises(FdtException) as e: with self.assertRaises(FdtException) as e:
self.fdt.subnode_offset(0, 'missing') self.fdt.subnode_offset(0, 'missing')
self.assertEquals(e.exception.err, -libfdt.NOTFOUND) self.assertEqual(e.exception.err, -libfdt.NOTFOUND)
node2 = self.fdt.path_offset('/subnode@1/subsubnode') node2 = self.fdt.path_offset('/subnode@1/subsubnode')
self.assertEquals(self.fdt.subnode_offset(node1, 'subsubnode'), node2) self.assertEqual(self.fdt.subnode_offset(node1, 'subsubnode'), node2)
def testPathOffset(self): def testPathOffset(self):
"""Check that we can find the offset of a node""" """Check that we can find the offset of a node"""
self.assertEquals(self.fdt.path_offset('/'), 0) self.assertEqual(self.fdt.path_offset('/'), 0)
self.assertTrue(self.fdt.path_offset('/subnode@1') > 0) self.assertTrue(self.fdt.path_offset('/subnode@1') > 0)
with self.assertRaises(FdtException) as e: with self.assertRaises(FdtException) as e:
self.fdt.path_offset('/wibble') self.fdt.path_offset('/wibble')
self.assertEquals(e.exception.err, -libfdt.NOTFOUND) self.assertEqual(e.exception.err, -libfdt.NOTFOUND)
self.assertEquals(self.fdt.path_offset('/wibble', QUIET_NOTFOUND), self.assertEqual(self.fdt.path_offset('/wibble', QUIET_NOTFOUND),
-libfdt.NOTFOUND) -libfdt.NOTFOUND)
def testPropertyOffset(self): def testPropertyOffset(self):
@@ -156,54 +156,54 @@ class PyLibfdtBasicTests(unittest.TestCase):
next_offset = self.fdt.next_property_offset(offset) next_offset = self.fdt.next_property_offset(offset)
self.assertTrue(next_offset > offset) self.assertTrue(next_offset > offset)
offset = next_offset offset = next_offset
self.assertEquals(self.fdt.next_property_offset(offset, QUIET_NOTFOUND), self.assertEqual(self.fdt.next_property_offset(offset, QUIET_NOTFOUND),
-libfdt.NOTFOUND) -libfdt.NOTFOUND)
def testPropertyOffsetExceptions(self): def testPropertyOffsetExceptions(self):
"""Check that exceptions are raised as expected""" """Check that exceptions are raised as expected"""
with self.assertRaises(FdtException) as e: with self.assertRaises(FdtException) as e:
self.fdt.first_property_offset(107) self.fdt.first_property_offset(107)
self.assertEquals(e.exception.err, -libfdt.BADOFFSET) self.assertEqual(e.exception.err, -libfdt.BADOFFSET)
# Quieten the NOTFOUND exception and check that a BADOFFSET # Quieten the NOTFOUND exception and check that a BADOFFSET
# exception is still raised. # exception is still raised.
with self.assertRaises(FdtException) as e: with self.assertRaises(FdtException) as e:
self.fdt.first_property_offset(107, QUIET_NOTFOUND) self.fdt.first_property_offset(107, QUIET_NOTFOUND)
self.assertEquals(e.exception.err, -libfdt.BADOFFSET) self.assertEqual(e.exception.err, -libfdt.BADOFFSET)
with self.assertRaises(FdtException) as e: with self.assertRaises(FdtException) as e:
self.fdt.next_property_offset(107, QUIET_NOTFOUND) self.fdt.next_property_offset(107, QUIET_NOTFOUND)
self.assertEquals(e.exception.err, -libfdt.BADOFFSET) self.assertEqual(e.exception.err, -libfdt.BADOFFSET)
# Check that NOTFOUND can be quietened. # Check that NOTFOUND can be quietened.
node = self.fdt.path_offset('/subnode@1/ss1') node = self.fdt.path_offset('/subnode@1/ss1')
self.assertEquals(self.fdt.first_property_offset(node, QUIET_NOTFOUND), self.assertEqual(self.fdt.first_property_offset(node, QUIET_NOTFOUND),
-libfdt.NOTFOUND) -libfdt.NOTFOUND)
with self.assertRaises(FdtException) as e: with self.assertRaises(FdtException) as e:
self.fdt.first_property_offset(node) self.fdt.first_property_offset(node)
self.assertEquals(e.exception.err, -libfdt.NOTFOUND) self.assertEqual(e.exception.err, -libfdt.NOTFOUND)
def testGetName(self): def testGetName(self):
"""Check that we can get the name of a node""" """Check that we can get the name of a node"""
self.assertEquals(self.fdt.get_name(0), '') self.assertEqual(self.fdt.get_name(0), '')
node = self.fdt.path_offset('/subnode@1/subsubnode') node = self.fdt.path_offset('/subnode@1/subsubnode')
self.assertEquals(self.fdt.get_name(node), 'subsubnode') self.assertEqual(self.fdt.get_name(node), 'subsubnode')
with self.assertRaises(FdtException) as e: with self.assertRaises(FdtException) as e:
self.fdt.get_name(-2) self.fdt.get_name(-2)
self.assertEquals(e.exception.err, -libfdt.BADOFFSET) self.assertEqual(e.exception.err, -libfdt.BADOFFSET)
def testGetPropertyByOffset(self): def testGetPropertyByOffset(self):
"""Check that we can read the name and contents of a property""" """Check that we can read the name and contents of a property"""
root = 0 root = 0
poffset = self.fdt.first_property_offset(root) poffset = self.fdt.first_property_offset(root)
prop = self.fdt.get_property_by_offset(poffset) prop = self.fdt.get_property_by_offset(poffset)
self.assertEquals(prop.name, 'compatible') self.assertEqual(prop.name, 'compatible')
self.assertEquals(prop, b'test_tree1\0') self.assertEqual(prop, b'test_tree1\0')
with self.assertRaises(FdtException) as e: with self.assertRaises(FdtException) as e:
self.fdt.get_property_by_offset(-2) self.fdt.get_property_by_offset(-2)
self.assertEquals(e.exception.err, -libfdt.BADOFFSET) self.assertEqual(e.exception.err, -libfdt.BADOFFSET)
self.assertEquals( self.assertEqual(
-libfdt.BADOFFSET, -libfdt.BADOFFSET,
self.fdt.get_property_by_offset(-2, [libfdt.BADOFFSET])) self.fdt.get_property_by_offset(-2, [libfdt.BADOFFSET]))
@@ -211,21 +211,21 @@ class PyLibfdtBasicTests(unittest.TestCase):
"""Check that we can read the contents of a property by name""" """Check that we can read the contents of a property by name"""
root = self.fdt.path_offset('/') root = self.fdt.path_offset('/')
value = self.fdt.getprop(root, "compatible") value = self.fdt.getprop(root, "compatible")
self.assertEquals(value, b'test_tree1\0') self.assertEqual(value, b'test_tree1\0')
self.assertEquals(-libfdt.NOTFOUND, self.fdt.getprop(root, 'missing', self.assertEqual(-libfdt.NOTFOUND, self.fdt.getprop(root, 'missing',
QUIET_NOTFOUND)) QUIET_NOTFOUND))
with self.assertRaises(FdtException) as e: with self.assertRaises(FdtException) as e:
self.fdt.getprop(root, 'missing') self.fdt.getprop(root, 'missing')
self.assertEquals(e.exception.err, -libfdt.NOTFOUND) self.assertEqual(e.exception.err, -libfdt.NOTFOUND)
node = self.fdt.path_offset('/subnode@1/subsubnode') node = self.fdt.path_offset('/subnode@1/subsubnode')
value = self.fdt.getprop(node, "compatible") value = self.fdt.getprop(node, "compatible")
self.assertEquals(value, b'subsubnode1\0subsubnode\0') self.assertEqual(value, b'subsubnode1\0subsubnode\0')
def testStrError(self): def testStrError(self):
"""Check that we can get an error string""" """Check that we can get an error string"""
self.assertEquals(libfdt.strerror(-libfdt.NOTFOUND), self.assertEqual(libfdt.strerror(-libfdt.NOTFOUND),
'FDT_ERR_NOTFOUND') 'FDT_ERR_NOTFOUND')
def testNextNodeOffset(self): def testNextNodeOffset(self):
@@ -236,7 +236,7 @@ class PyLibfdtBasicTests(unittest.TestCase):
while depth >= 0: while depth >= 0:
node_list.append([depth, self.fdt.get_name(node)]) node_list.append([depth, self.fdt.get_name(node)])
node, depth = self.fdt.next_node(node, depth, (libfdt.BADOFFSET,)) node, depth = self.fdt.next_node(node, depth, (libfdt.BADOFFSET,))
self.assertEquals(node_list, [ self.assertEqual(node_list, [
[0, ''], [0, ''],
[1, 'subnode@1'], [1, 'subnode@1'],
[2, 'subsubnode'], [2, 'subsubnode'],
@@ -253,155 +253,155 @@ class PyLibfdtBasicTests(unittest.TestCase):
while node >= 0: while node >= 0:
node_list.append(self.fdt.get_name(node)) node_list.append(self.fdt.get_name(node))
node = self.fdt.next_subnode(node, QUIET_NOTFOUND) node = self.fdt.next_subnode(node, QUIET_NOTFOUND)
self.assertEquals(node_list, ['subnode@1', 'subnode@2']) self.assertEqual(node_list, ['subnode@1', 'subnode@2'])
def testFirstNextSubnodeOffsetExceptions(self): def testFirstNextSubnodeOffsetExceptions(self):
"""Check except handling for first/next subnode functions""" """Check except handling for first/next subnode functions"""
node = self.fdt.path_offset('/subnode@1/subsubnode', QUIET_NOTFOUND) node = self.fdt.path_offset('/subnode@1/subsubnode', QUIET_NOTFOUND)
self.assertEquals(self.fdt.first_subnode(node, QUIET_NOTFOUND), self.assertEqual(self.fdt.first_subnode(node, QUIET_NOTFOUND),
-libfdt.NOTFOUND) -libfdt.NOTFOUND)
with self.assertRaises(FdtException) as e: with self.assertRaises(FdtException) as e:
self.fdt.first_subnode(node) self.fdt.first_subnode(node)
self.assertEquals(e.exception.err, -libfdt.NOTFOUND) self.assertEqual(e.exception.err, -libfdt.NOTFOUND)
node = self.fdt.path_offset('/subnode@1/ss1', QUIET_NOTFOUND) node = self.fdt.path_offset('/subnode@1/ss1', QUIET_NOTFOUND)
self.assertEquals(self.fdt.next_subnode(node, QUIET_NOTFOUND), self.assertEqual(self.fdt.next_subnode(node, QUIET_NOTFOUND),
-libfdt.NOTFOUND) -libfdt.NOTFOUND)
with self.assertRaises(FdtException) as e: with self.assertRaises(FdtException) as e:
self.fdt.next_subnode(node) self.fdt.next_subnode(node)
self.assertEquals(e.exception.err, -libfdt.NOTFOUND) self.assertEqual(e.exception.err, -libfdt.NOTFOUND)
def testDeleteProperty(self): def testDeleteProperty(self):
"""Test that we can delete a property""" """Test that we can delete a property"""
node_name = '/subnode@1' node_name = '/subnode@1'
self.assertEquals(self.GetPropList(node_name), self.assertEqual(self.GetPropList(node_name),
['compatible', 'reg', 'prop-int']) ['compatible', 'reg', 'prop-int'])
node = self.fdt.path_offset('/%s' % node_name) node = self.fdt.path_offset('/%s' % node_name)
self.assertEquals(self.fdt.delprop(node, 'reg'), 0) self.assertEqual(self.fdt.delprop(node, 'reg'), 0)
self.assertEquals(self.GetPropList(node_name), self.assertEqual(self.GetPropList(node_name),
['compatible', 'prop-int']) ['compatible', 'prop-int'])
def testHeader(self): def testHeader(self):
"""Test that we can access the header values""" """Test that we can access the header values"""
self.assertEquals(self.fdt.magic(), 0xd00dfeed) self.assertEqual(self.fdt.magic(), 0xd00dfeed)
self.assertEquals(self.fdt.totalsize(), len(self.fdt._fdt)) self.assertEqual(self.fdt.totalsize(), len(self.fdt._fdt))
self.assertEquals(self.fdt.off_dt_struct(), 88) self.assertEqual(self.fdt.off_dt_struct(), 88)
self.assertEquals(self.fdt.off_dt_strings(), 652) self.assertEqual(self.fdt.off_dt_strings(), 652)
self.assertEquals(self.fdt.off_mem_rsvmap(), 40) self.assertEqual(self.fdt.off_mem_rsvmap(), 40)
self.assertEquals(self.fdt.version(), 17) self.assertEqual(self.fdt.version(), 17)
self.assertEquals(self.fdt.last_comp_version(), 16) self.assertEqual(self.fdt.last_comp_version(), 16)
self.assertEquals(self.fdt.boot_cpuid_phys(), 0) self.assertEqual(self.fdt.boot_cpuid_phys(), 0)
self.assertEquals(self.fdt.size_dt_strings(), 105) self.assertEqual(self.fdt.size_dt_strings(), 105)
self.assertEquals(self.fdt.size_dt_struct(), 564) self.assertEqual(self.fdt.size_dt_struct(), 564)
def testPack(self): def testPack(self):
"""Test that we can pack the tree after deleting something""" """Test that we can pack the tree after deleting something"""
orig_size = self.fdt.totalsize() orig_size = self.fdt.totalsize()
node = self.fdt.path_offset('/subnode@2', QUIET_NOTFOUND) node = self.fdt.path_offset('/subnode@2', QUIET_NOTFOUND)
self.assertEquals(self.fdt.delprop(node, 'prop-int'), 0) self.assertEqual(self.fdt.delprop(node, 'prop-int'), 0)
self.assertEquals(orig_size, self.fdt.totalsize()) self.assertEqual(orig_size, self.fdt.totalsize())
self.assertEquals(self.fdt.pack(), 0) self.assertEqual(self.fdt.pack(), 0)
self.assertTrue(self.fdt.totalsize() < orig_size) self.assertTrue(self.fdt.totalsize() < orig_size)
self.assertEquals(self.fdt.totalsize(), len(self.fdt.as_bytearray())) self.assertEqual(self.fdt.totalsize(), len(self.fdt.as_bytearray()))
def testBadPropertyOffset(self): def testBadPropertyOffset(self):
"""Test that bad property offsets are detected""" """Test that bad property offsets are detected"""
with self.assertRaises(FdtException) as e: with self.assertRaises(FdtException) as e:
self.fdt.get_property_by_offset(13) self.fdt.get_property_by_offset(13)
self.assertEquals(e.exception.err, -libfdt.BADOFFSET) self.assertEqual(e.exception.err, -libfdt.BADOFFSET)
with self.assertRaises(FdtException) as e: with self.assertRaises(FdtException) as e:
self.fdt.first_property_offset(3) self.fdt.first_property_offset(3)
self.assertEquals(e.exception.err, -libfdt.BADOFFSET) self.assertEqual(e.exception.err, -libfdt.BADOFFSET)
with self.assertRaises(FdtException) as e: with self.assertRaises(FdtException) as e:
self.fdt.next_property_offset(3) self.fdt.next_property_offset(3)
self.assertEquals(e.exception.err, -libfdt.BADOFFSET) self.assertEqual(e.exception.err, -libfdt.BADOFFSET)
def testBadPathOffset(self): def testBadPathOffset(self):
"""Test that bad path names are detected""" """Test that bad path names are detected"""
with self.assertRaisesRegexp(FdtException, get_err(libfdt.BADPATH)): with self.assertRaisesRegex(FdtException, get_err(libfdt.BADPATH)):
self.fdt.path_offset('not-present') self.fdt.path_offset('not-present')
def testQuietAll(self): def testQuietAll(self):
"""Check that exceptions can be masked by QUIET_ALL""" """Check that exceptions can be masked by QUIET_ALL"""
self.assertEquals(-libfdt.NOTFOUND, self.assertEqual(-libfdt.NOTFOUND,
self.fdt.path_offset('/missing', QUIET_ALL)) self.fdt.path_offset('/missing', QUIET_ALL))
self.assertEquals(-libfdt.BADOFFSET, self.assertEqual(-libfdt.BADOFFSET,
self.fdt.get_property_by_offset(13, QUIET_ALL)) self.fdt.get_property_by_offset(13, QUIET_ALL))
self.assertEquals(-libfdt.BADPATH, self.assertEqual(-libfdt.BADPATH,
self.fdt.path_offset('missing', QUIET_ALL)) self.fdt.path_offset('missing', QUIET_ALL))
def testIntegers(self): def testIntegers(self):
"""Check that integers can be passed and returned""" """Check that integers can be passed and returned"""
self.assertEquals(0, libfdt.fdt_get_phandle(self.fdt._fdt, 0)) self.assertEqual(0, libfdt.fdt_get_phandle(self.fdt._fdt, 0))
node2 = self.fdt.path_offset('/subnode@2') node2 = self.fdt.path_offset('/subnode@2')
self.assertEquals(0x2000, libfdt.fdt_get_phandle(self.fdt._fdt, node2)) self.assertEqual(0x2000, libfdt.fdt_get_phandle(self.fdt._fdt, node2))
def testGetPhandle(self): def testGetPhandle(self):
"""Test for the get_phandle() method""" """Test for the get_phandle() method"""
self.assertEquals(0, self.fdt.get_phandle(0)) self.assertEqual(0, self.fdt.get_phandle(0))
node2 = self.fdt.path_offset('/subnode@2') node2 = self.fdt.path_offset('/subnode@2')
self.assertEquals(0x2000, self.fdt.get_phandle(node2)) self.assertEqual(0x2000, self.fdt.get_phandle(node2))
def testGetAlias(self): def testGetAlias(self):
"""Test for the get_alias() method""" """Test for the get_alias() method"""
self.assertEquals("/subnode@1", self.fdt3.get_alias('s1')) self.assertEqual("/subnode@1", self.fdt3.get_alias('s1'))
self.assertEquals("/subnode@1/subsubnode", self.fdt3.get_alias('ss1')) self.assertEqual("/subnode@1/subsubnode", self.fdt3.get_alias('ss1'))
self.assertEquals("/subnode@1/subsubnode/subsubsubnode", self.fdt3.get_alias('sss1')) self.assertEqual("/subnode@1/subsubnode/subsubsubnode", self.fdt3.get_alias('sss1'))
def testParentOffset(self): def testParentOffset(self):
"""Test for the parent_offset() method""" """Test for the parent_offset() method"""
self.assertEquals(-libfdt.NOTFOUND, self.assertEqual(-libfdt.NOTFOUND,
self.fdt.parent_offset(0, QUIET_NOTFOUND)) self.fdt.parent_offset(0, QUIET_NOTFOUND))
with self.assertRaises(FdtException) as e: with self.assertRaises(FdtException) as e:
self.fdt.parent_offset(0) self.fdt.parent_offset(0)
self.assertEquals(e.exception.err, -libfdt.NOTFOUND) self.assertEqual(e.exception.err, -libfdt.NOTFOUND)
node1 = self.fdt.path_offset('/subnode@2') node1 = self.fdt.path_offset('/subnode@2')
self.assertEquals(0, self.fdt.parent_offset(node1)) self.assertEqual(0, self.fdt.parent_offset(node1))
node2 = self.fdt.path_offset('/subnode@2/subsubnode@0') node2 = self.fdt.path_offset('/subnode@2/subsubnode@0')
self.assertEquals(node1, self.fdt.parent_offset(node2)) self.assertEqual(node1, self.fdt.parent_offset(node2))
def testNodeOffsetByPhandle(self): def testNodeOffsetByPhandle(self):
"""Test for the node_offset_by_phandle() method""" """Test for the node_offset_by_phandle() method"""
self.assertEquals(-libfdt.NOTFOUND, self.assertEqual(-libfdt.NOTFOUND,
self.fdt.node_offset_by_phandle(1, QUIET_NOTFOUND)) self.fdt.node_offset_by_phandle(1, QUIET_NOTFOUND))
node1 = self.fdt.path_offset('/subnode@2') node1 = self.fdt.path_offset('/subnode@2')
self.assertEquals(node1, self.fdt.node_offset_by_phandle(0x2000)) self.assertEqual(node1, self.fdt.node_offset_by_phandle(0x2000))
node2 = self.fdt.path_offset('/subnode@2/subsubnode@0') node2 = self.fdt.path_offset('/subnode@2/subsubnode@0')
self.assertEquals(node2, self.fdt.node_offset_by_phandle(0x2001)) self.assertEqual(node2, self.fdt.node_offset_by_phandle(0x2001))
def get_prop(self, name): def get_prop(self, name):
return self.fdt2.getprop(0, name) return self.fdt2.getprop(0, name)
def testGetIntProperties(self): def testGetIntProperties(self):
"""Test that we can access properties as integers""" """Test that we can access properties as integers"""
self.assertEquals(0xdeadbeef, self.get_prop("prop-hex32").as_uint32()) self.assertEqual(0xdeadbeef, self.get_prop("prop-hex32").as_uint32())
self.assertEquals(123, self.get_prop("prop-uint32").as_uint32()) self.assertEqual(123, self.get_prop("prop-uint32").as_uint32())
self.assertEquals(-2, self.get_prop("prop-int32").as_int32()) self.assertEqual(-2, self.get_prop("prop-int32").as_int32())
self.assertEquals(9223372036854775807, self.assertEqual(9223372036854775807,
self.get_prop("prop-uint64").as_uint64()) self.get_prop("prop-uint64").as_uint64())
self.assertEquals(-2, self.get_prop("prop-int64").as_int64()) self.assertEqual(-2, self.get_prop("prop-int64").as_int64())
def testReserveMap(self): def testReserveMap(self):
"""Test that we can access the memory reserve map""" """Test that we can access the memory reserve map"""
self.assertEquals(2, self.fdt.num_mem_rsv()) self.assertEqual(2, self.fdt.num_mem_rsv())
self.assertEquals([ 0xdeadbeef00000000, 0x100000], self.assertEqual([ 0xdeadbeef00000000, 0x100000],
self.fdt.get_mem_rsv(0)) self.fdt.get_mem_rsv(0))
self.assertEquals([123456789, 0o10000], self.fdt.get_mem_rsv(1)) self.assertEqual([123456789, 0o10000], self.fdt.get_mem_rsv(1))
def testEmpty(self): def testEmpty(self):
"""Test that we can create an empty tree""" """Test that we can create an empty tree"""
self.assertEquals(-libfdt.NOSPACE, self.assertEqual(-libfdt.NOSPACE,
Fdt.create_empty_tree(1, (libfdt.NOSPACE,))) Fdt.create_empty_tree(1, (libfdt.NOSPACE,)))
fdt = Fdt.create_empty_tree(128) fdt = Fdt.create_empty_tree(128)
self.assertEquals(128, fdt.totalsize()) self.assertEqual(128, fdt.totalsize())
def testOpenInto(self): def testOpenInto(self):
"""Test that we can resize a tree""" """Test that we can resize a tree"""
fdt = Fdt.create_empty_tree(128) fdt = Fdt.create_empty_tree(128)
self.assertEquals(128, fdt.totalsize()) self.assertEqual(128, fdt.totalsize())
fdt.resize(256) fdt.resize(256)
self.assertEquals(256, fdt.totalsize()) self.assertEqual(256, fdt.totalsize())
fdt.pack() fdt.pack()
self.assertTrue(fdt.totalsize() < 128) self.assertTrue(fdt.totalsize() < 128)
@@ -409,27 +409,27 @@ class PyLibfdtBasicTests(unittest.TestCase):
"""Test that we can update and create properties""" """Test that we can update and create properties"""
node = self.fdt.path_offset('/subnode@1') node = self.fdt.path_offset('/subnode@1')
self.fdt.setprop(node, 'compatible', TEST_BYTES_1) self.fdt.setprop(node, 'compatible', TEST_BYTES_1)
self.assertEquals(TEST_BYTES_1, self.fdt.getprop(node, 'compatible')) self.assertEqual(TEST_BYTES_1, self.fdt.getprop(node, 'compatible'))
# Check that this property is missing, and that we don't have space to # Check that this property is missing, and that we don't have space to
# add it # add it
self.assertEquals(-libfdt.NOTFOUND, self.assertEqual(-libfdt.NOTFOUND,
self.fdt.getprop(node, 'missing', QUIET_NOTFOUND)) self.fdt.getprop(node, 'missing', QUIET_NOTFOUND))
self.assertEquals(-libfdt.NOSPACE, self.assertEqual(-libfdt.NOSPACE,
self.fdt.setprop(node, 'missing', TEST_BYTES_1, self.fdt.setprop(node, 'missing', TEST_BYTES_1,
quiet=(libfdt.NOSPACE,))) quiet=(libfdt.NOSPACE,)))
# Expand the device tree so we now have room # Expand the device tree so we now have room
self.fdt.resize(self.fdt.totalsize() + 50) self.fdt.resize(self.fdt.totalsize() + 50)
self.fdt.setprop(node, 'missing', TEST_BYTES_1) self.fdt.setprop(node, 'missing', TEST_BYTES_1)
self.assertEquals(TEST_BYTES_1, self.fdt.getprop(node, 'missing')) self.assertEqual(TEST_BYTES_1, self.fdt.getprop(node, 'missing'))
def testSetPropU32(self): def testSetPropU32(self):
"""Test that we can update and create integer properties""" """Test that we can update and create integer properties"""
node = 0 node = 0
prop = 'prop-int' prop = 'prop-int'
self.fdt.setprop_u32(node, prop, TEST_VALUE_1) self.fdt.setprop_u32(node, prop, TEST_VALUE_1)
self.assertEquals(struct.pack('>I', TEST_VALUE_1), self.assertEqual(struct.pack('>I', TEST_VALUE_1),
self.fdt.getprop(node, prop)) self.fdt.getprop(node, prop))
def testSetPropU64(self): def testSetPropU64(self):
@@ -437,16 +437,16 @@ class PyLibfdtBasicTests(unittest.TestCase):
node = 0 node = 0
prop = 'prop-int64' prop = 'prop-int64'
self.fdt.setprop_u64(node, prop, TEST_VALUE64_1) self.fdt.setprop_u64(node, prop, TEST_VALUE64_1)
self.assertEquals(struct.pack('>Q', TEST_VALUE64_1), self.assertEqual(struct.pack('>Q', TEST_VALUE64_1),
self.fdt.getprop(node, prop)) self.fdt.getprop(node, prop))
def testSetPropStr(self): def testSetPropStr(self):
"""Test that we can set a property to a particular string""" """Test that we can set a property to a particular string"""
node = 0 node = 0
prop = 'prop-str' prop = 'prop-str'
self.assertEquals(TEST_STRING_1, self.fdt.getprop(node, prop).as_str()) self.assertEqual(TEST_STRING_1, self.fdt.getprop(node, prop).as_str())
self.fdt.setprop_str(node, prop, TEST_STRING_2) self.fdt.setprop_str(node, prop, TEST_STRING_2)
self.assertEquals(TEST_STRING_2, self.fdt.getprop(node, prop).as_str()) self.assertEqual(TEST_STRING_2, self.fdt.getprop(node, prop).as_str())
with self.assertRaises(ValueError) as e: with self.assertRaises(ValueError) as e:
self.fdt.getprop(node, 'prop-int').as_str() self.fdt.getprop(node, 'prop-int').as_str()
self.assertIn('lacks nul termination', str(e.exception)) self.assertIn('lacks nul termination', str(e.exception))
@@ -460,7 +460,7 @@ class PyLibfdtBasicTests(unittest.TestCase):
self.fdt.resize(self.fdt.totalsize() + 50) self.fdt.resize(self.fdt.totalsize() + 50)
prop = 'prop-unicode' prop = 'prop-unicode'
self.fdt.setprop_str(node, prop, TEST_STRING_3) self.fdt.setprop_str(node, prop, TEST_STRING_3)
self.assertEquals(TEST_STRING_3, self.assertEqual(TEST_STRING_3,
self.fdt.getprop(node, prop).as_str()) self.fdt.getprop(node, prop).as_str())
def testSetName(self): def testSetName(self):
@@ -468,7 +468,7 @@ class PyLibfdtBasicTests(unittest.TestCase):
node = self.fdt.path_offset('/subnode@1') node = self.fdt.path_offset('/subnode@1')
old_val = self.fdt.get_name(node) old_val = self.fdt.get_name(node)
self.fdt.set_name(node, 'test') self.fdt.set_name(node, 'test')
self.assertEquals('test', self.fdt.get_name(node)) self.assertEqual('test', self.fdt.get_name(node))
with self.assertRaises(ValueError) as e: with self.assertRaises(ValueError) as e:
self.fdt.set_name(node, 'some\0name') self.fdt.set_name(node, 'some\0name')
@@ -481,27 +481,27 @@ class PyLibfdtBasicTests(unittest.TestCase):
def testAddDeleteNodes(self): def testAddDeleteNodes(self):
"""Test that we can add and delete nodes""" """Test that we can add and delete nodes"""
node_name = '/subnode@1' node_name = '/subnode@1'
self.assertEquals(self.GetSubnodes(node_name), ['subsubnode', 'ss1']) self.assertEqual(self.GetSubnodes(node_name), ['subsubnode', 'ss1'])
node = self.fdt.path_offset('%s/subsubnode' % node_name) node = self.fdt.path_offset('%s/subsubnode' % node_name)
self.assertEquals(self.fdt.del_node(node, 'subsubnode'), 0) self.assertEqual(self.fdt.del_node(node, 'subsubnode'), 0)
self.assertEquals(self.GetSubnodes(node_name), ['ss1']) self.assertEqual(self.GetSubnodes(node_name), ['ss1'])
node = self.fdt.path_offset(node_name) node = self.fdt.path_offset(node_name)
offset = self.fdt.add_subnode(node, 'more') offset = self.fdt.add_subnode(node, 'more')
self.assertTrue(offset > 0) self.assertTrue(offset > 0)
self.assertEquals(self.GetSubnodes(node_name), ['more', 'ss1']) self.assertEqual(self.GetSubnodes(node_name), ['more', 'ss1'])
class PyLibfdtSwTests(unittest.TestCase): class PyLibfdtSwTests(unittest.TestCase):
"""Test class for pylibfdt sequential-write DT creation """Test class for pylibfdt sequential-write DT creation
""" """
def assertOk(self, err_code): def assertOk(self, err_code):
self.assertEquals(0, err_code) self.assertEqual(0, err_code)
def testCreate(self): def testCreate(self):
# First check the minimum size and also the FdtSw() constructor # First check the minimum size and also the FdtSw() constructor
with self.assertRaisesRegexp(FdtException, get_err(libfdt.NOSPACE)): with self.assertRaisesRegex(FdtException, get_err(libfdt.NOSPACE)):
self.assertEquals(-libfdt.NOSPACE, FdtSw(3)) self.assertEqual(-libfdt.NOSPACE, FdtSw(3))
sw = FdtSw() sw = FdtSw()
sw.add_reservemap_entry(TEST_ADDR_1, TEST_SIZE_1) sw.add_reservemap_entry(TEST_ADDR_1, TEST_SIZE_1)