tools/binman/binman.py

   1 #!/usr/bin/env python2
   2 # SPDX-License-Identifier: GPL-2.0+
   3
   4 # Copyright (c) 2016 Google, Inc
   5 # Written by Simon Glass <sjg@chromium.org>
   6 #
   7 # Creates binary images from input files controlled by a description
   8 #
   9
  10 """See README for more information"""
  11
  12 from __future__ import print_function
  13
  14 import glob
  15 import multiprocessing
  16 import os
  17 import sys
  18 import traceback
  19 import unittest
  20
  21 # Bring in the patman and dtoc libraries
  22 our_path = os.path.dirname(os.path.realpath(__file__))
  23 for dirname in ['../patman', '../dtoc', '..', '../concurrencytest']:
  24     sys.path.insert(0, os.path.join(our_path, dirname))
  25
  26 # Bring in the libfdt module
  27 sys.path.insert(0, 'scripts/dtc/pylibfdt')
  28 sys.path.insert(0, os.path.join(our_path,
  29                 '../../build-sandbox_spl/scripts/dtc/pylibfdt'))
  30
  31 import cmdline
  32 import command
  33 use_concurrent = True
  34 try:
  35     from concurrencytest import ConcurrentTestSuite, fork_for_tests
  36 except:
  37     use_concurrent = False
  38 import control
  39 import test_util
  40
  41 def RunTests(debug, processes, args):
  42     """Run the functional tests and any embedded doctests
  43
  44     Args:
  45         debug: True to enable debugging, which shows a full stack trace on error
  46         args: List of positional args provided to binman. This can hold a test
  47             name to execute (as in 'binman -t testSections', for example)
  48         processes: Number of processes to use to run tests (None=same as #CPUs)
  49     """
  50     import elf_test
  51     import entry_test
  52     import fdt_test
  53     import ftest
  54     import image_test
  55     import test
  56     import doctest
  57
  58     result = unittest.TestResult()
  59     for module in []:
  60         suite = doctest.DocTestSuite(module)
  61         suite.run(result)
  62
  63     sys.argv = [sys.argv[0]]
  64     if debug:
  65         sys.argv.append('-D')
  66     if debug:
  67         sys.argv.append('-D')
  68
  69     # Run the entry tests first ,since these need to be the first to import the
  70     # 'entry' module.
  71     test_name = args and args[0] or None
  72     suite = unittest.TestSuite()
  73     loader = unittest.TestLoader()
  74     for module in (entry_test.TestEntry, ftest.TestFunctional, fdt_test.TestFdt,
  75                    elf_test.TestElf, image_test.TestImage):
  76         if test_name:
  77             try:
  78                 suite.addTests(loader.loadTestsFromName(test_name, module))
  79             except AttributeError:
  80                 continue
  81         else:
  82             suite.addTests(loader.loadTestsFromTestCase(module))
  83     if use_concurrent and processes != 1:
  84         concurrent_suite = ConcurrentTestSuite(suite,
  85                 fork_for_tests(processes or multiprocessing.cpu_count()))
  86         concurrent_suite.run(result)
  87     else:
  88         suite.run(result)
  89
  90     # Remove errors which just indicate a missing test. Since Python v3.5 If an
  91     # ImportError or AttributeError occurs while traversing name then a
  92     # synthetic test that raises that error when run will be returned. These
  93     # errors are included in the errors accumulated by result.errors.
  94     if test_name:
  95         errors = []
  96         for test, err in result.errors:
  97             if ("has no attribute '%s'" % test_name) not in err:
  98                 errors.append((test, err))
  99             result.testsRun -= 1
 100         result.errors = errors
 101
 102     print(result)
 103     for test, err in result.errors:
 104         print(test.id(), err)
 105     for test, err in result.failures:
 106         print(err, result.failures)
 107     if result.errors or result.failures:
 108       print('binman tests FAILED')
 109       return 1
 110     return 0
 111
 112 def GetEntryModules(include_testing=True):
 113     """Get a set of entry class implementations
 114
 115     Returns:
 116         Set of paths to entry class filenames
 117     """
 118     glob_list = glob.glob(os.path.join(our_path, 'etype/*.py'))
 119     return set([os.path.splitext(os.path.basename(item))[0]
 120                 for item in glob_list
 121                 if include_testing or '_testing' not in item])
 122
 123 def RunTestCoverage():
 124     """Run the tests and check that we get 100% coverage"""
 125     glob_list = GetEntryModules(False)
 126     all_set = set([os.path.splitext(os.path.basename(item))[0]
 127                    for item in glob_list if '_testing' not in item])
 128     test_util.RunTestCoverage('tools/binman/binman.py', None,
 129             ['*test*', '*binman.py', 'tools/patman/*', 'tools/dtoc/*'],
 130             options.build_dir, all_set)
 131
 132 def RunBinman(options, args):
 133     """Main entry point to binman once arguments are parsed
 134
 135     Args:
 136         options: Command-line options
 137         args: Non-option arguments
 138     """
 139     ret_code = 0
 140
 141     # For testing: This enables full exception traces.
 142     #options.debug = True
 143
 144     if not options.debug:
 145         sys.tracebacklimit = 0
 146
 147     if options.test:
 148         ret_code = RunTests(options.debug, options.processes, args[1:])
 149
 150     elif options.test_coverage:
 151         RunTestCoverage()
 152
 153     elif options.entry_docs:
 154         control.WriteEntryDocs(GetEntryModules())
 155
 156     else:
 157         try:
 158             ret_code = control.Binman(options, args)
 159         except Exception as e:
 160             print('binman: %s' % e)
 161             if options.debug:
 162                 print()
 163                 traceback.print_exc()
 164             ret_code = 1
 165     return ret_code
 166
 167
 168 if __name__ == "__main__":
 169     (options, args) = cmdline.ParseArgs(sys.argv)
 170     ret_code = RunBinman(options, args)
 171     sys.exit(ret_code)