tools/binman/entry_test.py

   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
   7 import collections
   8 import importlib
   9 import os
  10 import sys
  11 import unittest
  12
  13 from binman import entry
  14 from binman.etype.blob import Entry_blob
  15 from dtoc import fdt
  16 from dtoc import fdt_util
  17 from patman import tools
  18
  19 class 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
 109 if __name__ == "__main__":
 110     unittest.main()