1# SPDX-License-Identifier: GPL-2.0+
2# Copyright (c) 2016 Google, Inc
3# Written by Simon Glass <sjg@chromium.org>
4#
5# Test for the Entry class
6
7import collections
8import importlib
9import os
10import sys
11import unittest
12
13from binman import entry
14from binman.etype.blob import Entry_blob
15from dtoc import fdt
16from dtoc import fdt_util
17from u_boot_pylib import tools
18
19class TestEntry(unittest.TestCase):
20    def setUp(self):
21        tools.prepare_output_dir(None)
22
23    def tearDown(self):
24        tools.finalise_output_dir()
25
26    def GetNode(self):
27        binman_dir = os.path.dirname(os.path.realpath(sys.argv[0]))
28        fname = fdt_util.EnsureCompiled(
29            os.path.join(binman_dir,('test/005_simple.dts')))
30        dtb = fdt.FdtScan(fname)
31        return dtb.GetNode('/binman/u-boot')
32
33    def _ReloadEntry(self):
34        global entry
35        if entry:
36            importlib.reload(entry)
37        else:
38            from binman import entry
39
40    def testEntryContents(self):
41        """Test the Entry bass class"""
42        from binman import entry
43        base_entry = entry.Entry(None, None, None)
44        self.assertEqual(True, base_entry.ObtainContents())
45
46    def testUnknownEntry(self):
47        """Test that unknown entry types are detected"""
48        Node = collections.namedtuple('Node', ['name', 'path'])
49        node = Node('invalid-name', 'invalid-path')
50        with self.assertRaises(ValueError) as e:
51            entry.Entry.Create(None, node, node.name)
52        self.assertIn("Unknown entry type 'invalid-name' in node "
53                      "'invalid-path'", str(e.exception))
54
55    def testUniqueName(self):
56        """Test Entry.GetUniqueName"""
57        Node = collections.namedtuple('Node', ['name', 'parent'])
58        base_node = Node('root', None)
59        base_entry = entry.Entry(None, None, base_node)
60        self.assertEqual('root', base_entry.GetUniqueName())
61        sub_node = Node('subnode', base_node)
62        sub_entry = entry.Entry(None, None, sub_node)
63        self.assertEqual('root.subnode', sub_entry.GetUniqueName())
64
65    def testGetDefaultFilename(self):
66        """Trivial test for this base class function"""
67        base_entry = entry.Entry(None, None, None)
68        self.assertIsNone(base_entry.GetDefaultFilename())
69
70    def testBlobFdt(self):
71        """Test the GetFdtEtype() method of the blob-dtb entries"""
72        base = entry.Entry.Create(None, self.GetNode(), 'blob-dtb')
73        self.assertIsNone(base.GetFdtEtype())
74
75        dtb = entry.Entry.Create(None, self.GetNode(), 'u-boot-dtb')
76        self.assertEqual('u-boot-dtb', dtb.GetFdtEtype())
77
78    def testWriteChildData(self):
79        """Test the WriteChildData() method of the base class"""
80        base = entry.Entry.Create(None, self.GetNode(), 'blob-dtb')
81        self.assertTrue(base.WriteChildData(base))
82
83    def testReadChildData(self):
84        """Test the ReadChildData() method of the base class"""
85        base = entry.Entry.Create(None, self.GetNode(), 'blob-dtb')
86        self.assertIsNone(base.ReadChildData(base))
87
88    def testExpandedEntry(self):
89        """Test use of an expanded entry when available"""
90        base = entry.Entry.Create(None, self.GetNode())
91        self.assertEqual('u-boot', base.etype)
92
93        expanded = entry.Entry.Create(None, self.GetNode(), expanded=True)
94        self.assertEqual('u-boot-expanded', expanded.etype)
95
96        with self.assertRaises(ValueError) as e:
97            entry.Entry.Create(None, self.GetNode(), 'missing', expanded=True)
98        self.assertIn("Unknown entry type 'missing' in node '/binman/u-boot'",
99                      str(e.exception))
100
101    def testMissingEtype(self):
102        """Test use of a blob etype when the requested one is not available"""
103        ent = entry.Entry.Create(None, self.GetNode(), 'missing',
104                                 missing_etype=True)
105        self.assertTrue(isinstance(ent, Entry_blob))
106        self.assertEquals('missing', ent.etype)
107
108    def testDecompressData(self):
109        """Test the DecompressData() method of the base class"""
110        base = entry.Entry.Create(None, self.GetNode(), 'blob-dtb')
111        base.compress = 'lz4'
112        bintools = {}
113        base.comp_bintool = base.AddBintool(bintools, '_testing')
114        self.assertEquals(tools.get_bytes(0, 1024), base.CompressData(b'abc'))
115        self.assertEquals(tools.get_bytes(0, 1024), base.DecompressData(b'abc'))
116
117    def testLookupOffset(self):
118        """Test the lookup_offset() method of the base class"""
119        def MyFindEntryByNode(node):
120            return self.found
121
122        base = entry.Entry.Create(None, self.GetNode(), 'blob-dtb')
123        base.FindEntryByNode = MyFindEntryByNode
124        base.section = base
125        self.found = None
126        base.offset_from_elf = [self.GetNode(), 'start', 0]
127        with self.assertRaises(ValueError) as e:
128            base.lookup_offset()
129        self.assertIn("Cannot find entry for node 'u-boot'", str(e.exception))
130
131        self.found = base
132        with self.assertRaises(ValueError) as e:
133            base.lookup_offset()
134        self.assertIn("Need elf-fname property 'u-boot'", str(e.exception))
135
136
137if __name__ == "__main__":
138    unittest.main()
139