There is a debugging option in the Makefile to allow people to figure out which u-boot.dtsi files are used in the build. But is it not easy to use since it only shows files it finds, not those it is looking for. Update it and update the mention of it to the docs.

Signed-off-by: Simon Glass sjg@chromium.org ---

scripts/Makefile.lib | 18 ++++++++++++++---- tools/binman/README | 3 ++- 2 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/scripts/Makefile.lib b/scripts/Makefile.lib index 0d5c5291a1b..8f19b2db56d 100644 --- a/scripts/Makefile.lib +++ b/scripts/Makefile.lib @@ -165,17 +165,27 @@ cpp_flags = -Wp,-MD,$(depfile) $(NOSTDINC_FLAGS) $(UBOOTINCLUDE) \ ld_flags = $(LDFLAGS) $(ldflags-y)

# Try these files in order to find the U-Boot-specific .dtsi include file -u_boot_dtsi_options = $(wildcard $(dir $<)$(basename $(notdir $<))-u-boot.dtsi) \ +u_boot_dtsi_options = $(strip $(wildcard $(dir $<)$(basename $(notdir $<))-u-boot.dtsi) \ $(wildcard $(dir $<)$(subst $",,$(CONFIG_SYS_SOC))-u-boot.dtsi) \ $(wildcard $(dir $<)$(subst $",,$(CONFIG_SYS_CPU))-u-boot.dtsi) \ $(wildcard $(dir $<)$(subst $",,$(CONFIG_SYS_VENDOR))-u-boot.dtsi) \ - $(wildcard $(dir $<)u-boot.dtsi) + $(wildcard $(dir $<)u-boot.dtsi)) + +u_boot_dtsi_options_raw = $(warning Automatic .dtsi inclusion: options: \ + $(dir $<)$(basename $(notdir $<))-u-boot.dtsi \ + $(dir $<)$(subst $",,$(CONFIG_SYS_SOC))-u-boot.dtsi \ + $(dir $<)$(subst $",,$(CONFIG_SYS_CPU))-u-boot.dtsi \ + $(dir $<)$(subst $",,$(CONFIG_SYS_VENDOR))-u-boot.dtsi \ + $(dir $<)u-boot.dtsi ... \ + found: $(if $(u_boot_dtsi_options),"$(u_boot_dtsi_options)",nothing!))

# Uncomment for debugging -# $(warning u_boot_dtsi_options: $(u_boot_dtsi_options)) +# This shows all the files that were considered and the one that we chose. +# u_boot_dtsi_options_debug = $(u_boot_dtsi_options_raw)

# We use the first match -u_boot_dtsi = $(notdir $(firstword $(u_boot_dtsi_options))) +u_boot_dtsi = $(strip $(u_boot_dtsi_options_debug) \ + $(notdir $(firstword $(u_boot_dtsi_options))))

# Modified for U-Boot dtc_cpp_flags = -Wp,-MD,$(depfile).pre.tmp -nostdinc \ diff --git a/tools/binman/README b/tools/binman/README index cb47e73599a..63f97226429 100644 --- a/tools/binman/README +++ b/tools/binman/README @@ -446,7 +446,8 @@ If you are having trouble figuring out what is going on, you can uncomment the 'warning' line in scripts/Makefile.lib to see what it has found:

# Uncomment for debugging - # $(warning binman_dtsi_options: $(binman_dtsi_options)) + # This shows all the files that were considered and the one that we chose. + # u_boot_dtsi_options_debug = $(u_boot_dtsi_options_raw)

Code coverage

The process is not obvious. Add a little section to explain how to move a board to use binman.

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/binman/README | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+)

diff --git a/tools/binman/README b/tools/binman/README index 63f97226429..4ef76c8f089 100644 --- a/tools/binman/README +++ b/tools/binman/README @@ -206,6 +206,27 @@ for its instructions in the 'binman' node. Binman has a few other options which you can see by running 'binman -h'.

+Enabling binman for a board +--------------------------- + +At present binman is invoked from a rule in the main Makefile. Typically you +will have a rule like: + +ifneq ($(CONFIG_ARCH_<something>),) +u-boot-<your_suffix>.bin: <input_file_1> <input_file_2> checkbinman FORCE + $(call if_changed,binman) +endif + +This assumes that u-boot-<your_suffix>.bin is a target, and is the final file +that you need to produce. You can make it a target by adding it to ALL-y +either in the main Makefile or in a config.mk file in your arch subdirectory. + +Once binman is executed it will pick up its instructions from a device-tree +file, typically <soc>-u-boot.dtsi, where <soc> is your CONFIG_SYS_SOC value. +You can use other, more specific CONFIG options - see 'Automatic .dtsi +inclusion' below. + + Image description format ------------------------

These test programs are includedd as binary files in U-Boot to avoid having to build them (and associated toolchain differences). Instructions on building are in the files themselves, but it seems better to provide a Makefile which can be manually run when desired.

Add a Makefile, separate from the normal build system, to handle this.

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/binman/test/Makefile | 36 +++++++++++++++++++++++++++++++++ tools/binman/test/u_boot_no_ucode_ptr.c | 4 ---- tools/binman/test/u_boot_ucode_ptr.c | 4 ---- 3 files changed, 36 insertions(+), 8 deletions(-) create mode 100644 tools/binman/test/Makefile

diff --git a/tools/binman/test/Makefile b/tools/binman/test/Makefile new file mode 100644 index 00000000000..786d1b05778 --- /dev/null +++ b/tools/binman/test/Makefile @@ -0,0 +1,36 @@ +# +# Builds test programs +# +# Copyright (C) 2017 Google, Inc +# Written by Simon Glass sjg@chromium.org +# +# SPDX-License-Identifier: GPL-2.0+ +# + +CFLAGS := -march=i386 -m32 -nostdlib -I ../../../include + +LDS_UCODE := -T u_boot_ucode_ptr.lds + +TARGETS = u_boot_ucode_ptr u_boot_no_ucode_ptr + +all: $(TARGETS) + +u_boot_no_ucode_ptr: CFLAGS += $(LDS_UCODE) +u_boot_no_ucode_ptr: u_boot_no_ucode_ptr.c + +u_boot_ucode_ptr: CFLAGS += $(LDS_UCODE) +u_boot_ucode_ptr: u_boot_ucode_ptr.c + +clean: + rm -f $(TARGETS) + +help: + @echo "Makefile for binman test programs" + @echo + @echo "Intended for use on x86 hosts" + @echo + @echo "Targets:" + @echo + @echo -e "\thelp - Print help (this is it!)" + @echo -e "\tall - Builds test programs (default targget)" + @echo -e "\tclean - Delete output files" diff --git a/tools/binman/test/u_boot_no_ucode_ptr.c b/tools/binman/test/u_boot_no_ucode_ptr.c index a17bb4c6c20..c4a2b85fc95 100644 --- a/tools/binman/test/u_boot_no_ucode_ptr.c +++ b/tools/binman/test/u_boot_no_ucode_ptr.c @@ -5,10 +5,6 @@ * * Simple program to create a bad _dt_ucode_base_size symbol to create an * error when it is used. This is used by binman tests. - * - * Build with: - * cc -march=i386 -m32 -o u_boot_no_ucode_ptr -T u_boot_ucode_ptr.lds \ - -nostdlib u_boot_no_ucode_ptr.c */

static unsigned long not__dt_ucode_base_size[2] diff --git a/tools/binman/test/u_boot_ucode_ptr.c b/tools/binman/test/u_boot_ucode_ptr.c index 434c9f44003..24f349fb9e4 100644 --- a/tools/binman/test/u_boot_ucode_ptr.c +++ b/tools/binman/test/u_boot_ucode_ptr.c @@ -5,10 +5,6 @@ * * Simple program to create a _dt_ucode_base_size symbol which can be read * by 'nm'. This is used by binman tests. - * - * Build with: - * cc -march=i386 -m32 -o u_boot_ucode_ptr -T u_boot_ucode_ptr.lds -nostdlib \ - u_boot_ucode_ptr.c */

static unsigned long _dt_ucode_base_size[2]

At present these tests use the same filename as patman. This adds confusion when running all tests, since error messages look very similar. In fact binman tries to run the wrong tests at present.

Rename the tests.

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/binman/binman.py | 4 ++-- tools/binman/{func_test.py => ftest.py} | 0 2 files changed, 2 insertions(+), 2 deletions(-) rename tools/binman/{func_test.py => ftest.py} (100%)

diff --git a/tools/binman/binman.py b/tools/binman/binman.py index e75a59d9517..d264bcdfa8c 100755 --- a/tools/binman/binman.py +++ b/tools/binman/binman.py @@ -34,7 +34,7 @@ def RunTests(): """Run the functional tests and any embedded doctests""" import entry_test import fdt_test - import func_test + import ftest import test import doctest

@@ -44,7 +44,7 @@ def RunTests(): suite.run(result)

sys.argv = [sys.argv[0]] - for module in (func_test.TestFunctional, fdt_test.TestFdt, + for module in (ftest.TestFunctional, fdt_test.TestFdt, entry_test.TestEntry): suite = unittest.TestLoader().loadTestsFromTestCase(module) suite.run(result) diff --git a/tools/binman/func_test.py b/tools/binman/ftest.py similarity index 100% rename from tools/binman/func_test.py rename to tools/binman/ftest.py

These warnings are not useful for binman tests. Disable them.

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/dtoc/fdt_util.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tools/dtoc/fdt_util.py b/tools/dtoc/fdt_util.py index 338d47a5e14..ba0b6cc3815 100644 --- a/tools/dtoc/fdt_util.py +++ b/tools/dtoc/fdt_util.py @@ -75,7 +75,8 @@ def EnsureCompiled(fname): search_list = [] for path in search_paths: search_list.extend(['-i', path]) - args = ['-I', 'dts', '-o', dtb_output, '-O', 'dtb'] + args = ['-I', 'dts', '-o', dtb_output, '-O', 'dtb', + '-W', 'no-unit_address_vs_reg'] args.extend(search_list) args.append(dts_input) command.Run('dtc', *args)

This script runs the tests but does not report failure. Also it always returns an exit code of 0 even on failure.

Fix these problems by checking the result of each test.

Signed-off-by: Simon Glass sjg@chromium.org ---

test/run | 20 +++++++++++++++++--- 1 file changed, 17 insertions(+), 3 deletions(-)

diff --git a/test/run b/test/run index b1649ee1015..caee4f83f2c 100755 --- a/test/run +++ b/test/run @@ -1,10 +1,24 @@ -#!/bin/sh +#!/bin/bash + +run_test() { + $@ + [ $? -ne 0 ] && result=$((result+1)) + echo "result $result" +}

# Run all tests that the standard sandbox build can support -./test/py/test.py --bd sandbox --build +run_test ./test/py/test.py --bd sandbox --build

# Run tests which require sandbox_spl -./test/py/test.py --bd sandbox_spl --build -k test/py/tests/test_ofplatdata.py +run_test ./test/py/test.py --bd sandbox_spl --build -k \ + test/py/tests/test_ofplatdata.py

# Run tests for the flat DT version of sandbox ./test/py/test.py --bd sandbox_flattree --build + +if [ $result == 0 ]; then + echo "Tests passed!" +else + echo "Tests FAILED" + exit 1 +fi

Update the test script to run the binman tests also.

Signed-off-by: Simon Glass sjg@chromium.org ---

test/run | 2 ++ 1 file changed, 2 insertions(+)

diff --git a/test/run b/test/run index caee4f83f2c..b9ed3edb3e4 100755 --- a/test/run +++ b/test/run @@ -16,6 +16,8 @@ run_test ./test/py/test.py --bd sandbox_spl --build -k \ # Run tests for the flat DT version of sandbox ./test/py/test.py --bd sandbox_flattree --build

+PYTHONPATH=build-sandbox_spl/tools run_test ./tools/binman/binman -t + if [ $result == 0 ]; then echo "Tests passed!" else

Accessing the network slows down the test and limits the environment in which it can be run. Add an option to disable network tests.

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/buildman/buildman.py | 6 ++++-- tools/buildman/cmdline.py | 2 ++ tools/buildman/test.py | 7 +++++-- 3 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/tools/buildman/buildman.py b/tools/buildman/buildman.py index 607429df7bc..11a4f162c5f 100755 --- a/tools/buildman/buildman.py +++ b/tools/buildman/buildman.py @@ -30,7 +30,7 @@ import patchstream import terminal import toolchain

-def RunTests(): +def RunTests(skip_net_tests): import func_test import test import doctest @@ -41,6 +41,8 @@ def RunTests(): suite.run(result)

sys.argv = [sys.argv[0]] + if skip_net_tests: + test.use_network = False for module in (test.TestBuild, func_test.TestFunctional): suite = unittest.TestLoader().loadTestsFromTestCase(module) suite.run(result) @@ -56,7 +58,7 @@ options, args = cmdline.ParseArgs()

# Run our meagre tests if options.test: - RunTests() + RunTests(options.skip_net_tests)

# Build selected commits for selected boards else: diff --git a/tools/buildman/cmdline.py b/tools/buildman/cmdline.py index 0060e0317c7..74247f0aff1 100644 --- a/tools/buildman/cmdline.py +++ b/tools/buildman/cmdline.py @@ -82,6 +82,8 @@ def ParseArgs(): default=False, help='Show a build summary') parser.add_option('-S', '--show-sizes', action='store_true', default=False, help='Show image size variation in summary') + parser.add_option('--skip-net-tests', action='store_true', default=False, + help='Skip tests which need the network') parser.add_option('--step', type='int', default=1, help='Only build every n commits (0=just first and last)') parser.add_option('-t', '--test', action='store_true', dest='test', diff --git a/tools/buildman/test.py b/tools/buildman/test.py index 53ebc3756c9..e81400f3725 100644 --- a/tools/buildman/test.py +++ b/tools/buildman/test.py @@ -24,6 +24,8 @@ import commit import terminal import toolchain

+use_network = True + settings_data = ''' # Buildman settings file

@@ -410,8 +412,9 @@ class TestBuild(unittest.TestCase):

def testToolchainDownload(self): """Test that we can download toolchains""" - self.assertEqual('https://www.kernel.org/pub/tools/crosstool/files/bin/x86_64/4.9.0/x86_64-gcc...', - self.toolchains.LocateArchUrl('arm')) + if use_network: + self.assertEqual('https://www.kernel.org/pub/tools/crosstool/files/bin/x86_64/4.9.0/x86_64-gcc...', + self.toolchains.LocateArchUrl('arm'))

if __name__ == "__main__":

The tests were broken by two separate commits which adjusted the output when boards are listed. Fix this by adding back a PowerPC board and putting the name of each board in the test.

Fixes: b9f7d881 (powerpc, 5xx: remove some "5xx" remains) Fixes: 8d7523c5 (buildman: Allow showing the list of boards with -n)

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/buildman/test.py | 31 +++++++++++++++++++++---------- 1 file changed, 21 insertions(+), 10 deletions(-)

diff --git a/tools/buildman/test.py b/tools/buildman/test.py index e81400f3725..e564a8a142f 100644 --- a/tools/buildman/test.py +++ b/tools/buildman/test.py @@ -91,6 +91,7 @@ boards = [ ['Active', 'arm', 'armv7', '', 'Tester', 'ARM Board 1', 'board0', ''], ['Active', 'arm', 'armv7', '', 'Tester', 'ARM Board 2', 'board1', ''], ['Active', 'powerpc', 'powerpc', '', 'Tester', 'PowerPC board 1', 'board2', ''], + ['Active', 'powerpc', 'mpc83xx', '', 'Tester', 'PowerPC board 2', 'board3', ''], ['Active', 'sandbox', 'sandbox', '', 'Tester', 'Sandbox board', 'board4', ''], ]

@@ -313,50 +314,60 @@ class TestBuild(unittest.TestCase): def testBoardSingle(self): """Test single board selection""" self.assertEqual(self.boards.SelectBoards(['sandbox']), - {'all': 1, 'sandbox': 1}) + {'all': ['board4'], 'sandbox': ['board4']})

def testBoardArch(self): """Test single board selection""" self.assertEqual(self.boards.SelectBoards(['arm']), - {'all': 2, 'arm': 2}) + {'all': ['board0', 'board1'], + 'arm': ['board0', 'board1']})

def testBoardArchSingle(self): """Test single board selection""" self.assertEqual(self.boards.SelectBoards(['arm sandbox']), - {'all': 3, 'arm': 2, 'sandbox' : 1}) + {'sandbox': ['board4'], + 'all': ['board0', 'board1', 'board4'], + 'arm': ['board0', 'board1']}) +

def testBoardArchSingleMultiWord(self): """Test single board selection""" self.assertEqual(self.boards.SelectBoards(['arm', 'sandbox']), - {'all': 3, 'arm': 2, 'sandbox' : 1}) + {'sandbox': ['board4'], 'all': ['board0', 'board1', 'board4'], 'arm': ['board0', 'board1']})

def testBoardSingleAnd(self): """Test single board selection""" self.assertEqual(self.boards.SelectBoards(['Tester & arm']), - {'all': 2, 'Tester&arm': 2}) + {'Tester&arm': ['board0', 'board1'], 'all': ['board0', 'board1']})

def testBoardTwoAnd(self): """Test single board selection""" self.assertEqual(self.boards.SelectBoards(['Tester', '&', 'arm', 'Tester' '&', 'powerpc', 'sandbox']), - {'all': 5, 'Tester&powerpc': 2, 'Tester&arm': 2, - 'sandbox' : 1}) + {'sandbox': ['board4'], + 'all': ['board0', 'board1', 'board2', 'board3', + 'board4'], + 'Tester&powerpc': ['board2', 'board3'], + 'Tester&arm': ['board0', 'board1']})

def testBoardAll(self): """Test single board selection""" - self.assertEqual(self.boards.SelectBoards([]), {'all': 5}) + self.assertEqual(self.boards.SelectBoards([]), + {'all': ['board0', 'board1', 'board2', 'board3', + 'board4']})

def testBoardRegularExpression(self): """Test single board selection""" self.assertEqual(self.boards.SelectBoards(['T.*r&^Po']), - {'T.*r&^Po': 2, 'all': 2}) + {'all': ['board2', 'board3'], + 'T.*r&^Po': ['board2', 'board3']})

def testBoardDuplicate(self): """Test single board selection""" self.assertEqual(self.boards.SelectBoards(['sandbox sandbox', 'sandbox']), - {'all': 1, 'sandbox': 1}) + {'all': ['board4'], 'sandbox': ['board4']}) def CheckDirs(self, build, dirname): self.assertEqual('base%s' % dirname, build._GetOutputDir(1)) self.assertEqual('base%s/fred' % dirname,

Update the test script to run the buildman tests also.

Signed-off-by: Simon Glass sjg@chromium.org ---

test/run | 1 + 1 file changed, 1 insertion(+)

diff --git a/test/run b/test/run index f18e36e05e2..f695f2ecc5d 100755 --- a/test/run +++ b/test/run @@ -18,6 +18,7 @@ run_test ./test/py/test.py --bd sandbox_spl --build -k \

PYTHONPATH=build-sandbox_spl/tools run_test ./tools/binman/binman -t run_test ./tools/patman/patman --test +run_test ./tools/buildman/buildman -t

if [ $result == 0 ]; then echo "Tests passed!"

Rather that overwrite this, append to it, in case the caller has already set up the path correctly.

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/binman/binman.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/binman/binman.py b/tools/binman/binman.py index d264bcdfa8c..963d43a3761 100755 --- a/tools/binman/binman.py +++ b/tools/binman/binman.py @@ -58,7 +58,7 @@ def RunTests(): def RunTestCoverage(): """Run the tests and check that we get 100% coverage""" # This uses the build output from sandbox_spl to get _libfdt.so - cmd = ('PYTHONPATH=%s/sandbox_spl/tools coverage run ' + cmd = ('PYTHONPATH=$PYTHONPATH:%s/sandbox_spl/tools coverage run ' '--include "tools/binman/*.py" --omit "*test*,*binman.py" ' 'tools/binman/binman.py -t' % options.build_dir) os.system(cmd)

There is a little check at the top of entry.py which decides if importlib is available. At present this has no test coverage. To add this we will need to import the module twice, once with importlib and once without. In preparation for allowing a test to control the importing of this module, remove all global imports of the 'entry' module.

Signed-off-by: Simon Glass sjg@chromium.org

---

tools/binman/entry_test.py | 4 ++-- tools/binman/ftest.py | 4 +++- tools/binman/image.py | 7 +++++-- 3 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/tools/binman/entry_test.py b/tools/binman/entry_test.py index 8a9ae017f03..85c4196892f 100644 --- a/tools/binman/entry_test.py +++ b/tools/binman/entry_test.py @@ -9,16 +9,16 @@ import collections import unittest

-import entry - class TestEntry(unittest.TestCase): def testEntryContents(self): """Test the Entry bass class""" + import entry base_entry = entry.Entry(None, None, None, read_node=False) self.assertEqual(True, base_entry.ObtainContents())

def testUnknownEntry(self): """Test that unknown entry types are detected""" + import entry Node = collections.namedtuple('Node', ['name', 'path']) node = Node('invalid-name', 'invalid-path') with self.assertRaises(ValueError) as e: diff --git a/tools/binman/ftest.py b/tools/binman/ftest.py index c4207ce5d29..eae1ab1c4b1 100644 --- a/tools/binman/ftest.py +++ b/tools/binman/ftest.py @@ -20,7 +20,6 @@ import binman import cmdline import command import control -import entry import fdt import fdt_util import tools @@ -56,6 +55,9 @@ class TestFunctional(unittest.TestCase): """ @classmethod def setUpClass(self): + global entry + import entry + # Handle the case where argv[0] is 'python' self._binman_dir = os.path.dirname(os.path.realpath(sys.argv[0])) self._binman_pathname = os.path.join(self._binman_dir, 'binman') diff --git a/tools/binman/image.py b/tools/binman/image.py index 07fc9306659..24c4f6f578a 100644 --- a/tools/binman/image.py +++ b/tools/binman/image.py @@ -9,8 +9,6 @@ from collections import OrderedDict from operator import attrgetter

-import entry -from entry import Entry import fdt_util import tools

@@ -48,6 +46,11 @@ class Image: _entries: OrderedDict() of entries """ def __init__(self, name, node): + global entry + global Entry + import entry + from entry import Entry + self._node = node self._name = name self._size = None

Add a test that the 'entry' module works with or without importlib. The tests are numbered so that they are executed in the correct order.

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/binman/binman.py | 8 ++++++-- tools/binman/entry_test.py | 30 ++++++++++++++++++++++++++++++ 2 files changed, 36 insertions(+), 2 deletions(-)

diff --git a/tools/binman/binman.py b/tools/binman/binman.py index 963d43a3761..cf83edfd044 100755 --- a/tools/binman/binman.py +++ b/tools/binman/binman.py @@ -44,8 +44,12 @@ def RunTests(): suite.run(result)

sys.argv = [sys.argv[0]] - for module in (ftest.TestFunctional, fdt_test.TestFdt, - entry_test.TestEntry): + + # Run the entry tests first ,since these need to be the first to import the + # 'entry' module. + suite = unittest.TestLoader().loadTestsFromTestCase(entry_test.TestEntry) + suite.run(result) + for module in (ftest.TestFunctional, fdt_test.TestFdt): suite = unittest.TestLoader().loadTestsFromTestCase(module) suite.run(result)

diff --git a/tools/binman/entry_test.py b/tools/binman/entry_test.py index 85c4196892f..789b26fd9f5 100644 --- a/tools/binman/entry_test.py +++ b/tools/binman/entry_test.py @@ -7,9 +7,39 @@ # Test for the Entry class

import collections +import os +import sys import unittest

+import fdt +import fdt_util +import tools + class TestEntry(unittest.TestCase): + def GetNode(self): + binman_dir = os.path.dirname(os.path.realpath(sys.argv[0])) + tools.PrepareOutputDir(None) + fname = fdt_util.EnsureCompiled( + os.path.join(binman_dir,('test/05_simple.dts'))) + dtb = fdt.FdtScan(fname) + return dtb.GetNode('/binman/u-boot') + + def test1EntryNoImportLib(self): + """Test that we can import Entry subclassess successfully""" + + sys.modules['importlib'] = None + global entry + import entry + entry.Entry.Create(None, self.GetNode(), 'u-boot') + + def test2EntryImportLib(self): + del sys.modules['importlib'] + global entry + reload(entry) + entry.Entry.Create(None, self.GetNode(), 'u-boot-spl') + tools._RemoveOutputDir() + del entry + def testEntryContents(self): """Test the Entry bass class""" import entry

Add a main program so that the tests can be executed directly, without going through the main binman program.

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/binman/entry_test.py | 4 ++++ tools/binman/ftest.py | 4 ++++ 2 files changed, 8 insertions(+)

diff --git a/tools/binman/entry_test.py b/tools/binman/entry_test.py index 789b26fd9f5..caa523ebf89 100644 --- a/tools/binman/entry_test.py +++ b/tools/binman/entry_test.py @@ -55,3 +55,7 @@ class TestEntry(unittest.TestCase): entry.Entry.Create(None, node, node.name) self.assertIn("Unknown entry type 'invalid-name' in node " "'invalid-path'", str(e.exception)) + + +if __name__ == "__main__": + unittest.main() diff --git a/tools/binman/ftest.py b/tools/binman/ftest.py index eae1ab1c4b1..539ebc57f57 100644 --- a/tools/binman/ftest.py +++ b/tools/binman/ftest.py @@ -813,3 +813,7 @@ class TestFunctional(unittest.TestCase): """Test that an image with a VBT binary can be created""" data = self._DoReadFile('46_intel-vbt.dts') self.assertEqual(VBT_DATA, data[:len(VBT_DATA)]) + + +if __name__ == "__main__": + unittest.main()

Make a minor tweak to fix test coverage.

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/binman/etype/u_boot_ucode.py | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/tools/binman/etype/u_boot_ucode.py b/tools/binman/etype/u_boot_ucode.py index 8e51e99a119..f9f434d2cc2 100644 --- a/tools/binman/etype/u_boot_ucode.py +++ b/tools/binman/etype/u_boot_ucode.py @@ -58,13 +58,10 @@ class Entry_u_boot_ucode(Entry_blob): def ObtainContents(self): # If the image does not need microcode, there is nothing to do ucode_dest_entry = self.image.FindEntryType('u-boot-with-ucode-ptr') - if ucode_dest_entry and not ucode_dest_entry.target_pos: - self.data = '' - return True - - # Handle microcode in SPL image as well - ucode_dest_entry = self.image.FindEntryType('u-boot-spl-with-ucode-ptr') - if ucode_dest_entry and not ucode_dest_entry.target_pos: + ucode_dest_entry_spl = self.image.FindEntryType( + 'u-boot-spl-with-ucode-ptr') + if ((not ucode_dest_entry or not ucode_dest_entry.target_pos) and + (not ucode_dest_entry_spl or not ucode_dest_entry_spl.target_pos)): self.data = '' return True

Files that are never imported are not shown in the test-coverage report. Detect these and show an error.

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/binman/binman.py | 22 +++++++++++++++++++--- 1 file changed, 19 insertions(+), 3 deletions(-)

diff --git a/tools/binman/binman.py b/tools/binman/binman.py index cf83edfd044..7ad4d3030b9 100755 --- a/tools/binman/binman.py +++ b/tools/binman/binman.py @@ -10,6 +10,7 @@

"""See README for more information"""

+import glob import os import sys import traceback @@ -67,12 +68,27 @@ def RunTestCoverage(): 'tools/binman/binman.py -t' % options.build_dir) os.system(cmd) stdout = command.Output('coverage', 'report') - coverage = stdout.splitlines()[-1].split(' ')[-1] + lines = stdout.splitlines() + + test_set= set([os.path.basename(line.split()[0]) + for line in lines if '/etype/' in line]) + glob_list = glob.glob(os.path.join(our_path, 'etype/*.py')) + all_set = set([os.path.basename(item) for item in glob_list]) + missing_list = all_set + missing_list.difference_update(test_set) + missing_list.remove('_testing.py') + coverage = lines[-1].split(' ')[-1] + ok = True + if missing_list: + print 'Missing tests for %s' % (', '.join(missing_list)) + ok = False if coverage != '100%': print stdout print "Type 'coverage html' to get a report in htmlcov/index.html" - raise ValueError('Coverage error: %s, but should be 100%%' % coverage) - + print 'Coverage error: %s, but should be 100%%' % coverage + ok = False + if not ok: + raise ValueError('Test coverage failure')

def RunBinman(options, args): """Main entry point to binman once arguments are parsed

Add a test that we can pad the BSS with zero bytes.

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/binman/ftest.py | 9 +++++++++ tools/binman/test/47_spl_bss_pad.dts | 17 +++++++++++++++++ tools/binman/test/Makefile | 5 ++++- tools/binman/test/bss_data | Bin 0 -> 5020 bytes tools/binman/test/bss_data.c | 18 ++++++++++++++++++ tools/binman/test/bss_data.lds | 16 ++++++++++++++++ 6 files changed, 64 insertions(+), 1 deletion(-) create mode 100644 tools/binman/test/47_spl_bss_pad.dts create mode 100755 tools/binman/test/bss_data create mode 100644 tools/binman/test/bss_data.c create mode 100644 tools/binman/test/bss_data.lds

diff --git a/tools/binman/ftest.py b/tools/binman/ftest.py index 539ebc57f57..4e6aaad9d6b 100644 --- a/tools/binman/ftest.py +++ b/tools/binman/ftest.py @@ -88,6 +88,10 @@ class TestFunctional(unittest.TestCase): with open(self.TestFile('descriptor.bin')) as fd: TestFunctional._MakeInputFile('descriptor.bin', fd.read())

+ # ELF file with a '__bss_size' symbol + with open(self.TestFile('bss_data')) as fd: + TestFunctional._MakeInputFile('spl/u-boot-spl', fd.read()) + @classmethod def tearDownClass(self): """Remove the temporary input directory and its contents""" @@ -814,6 +818,11 @@ class TestFunctional(unittest.TestCase): data = self._DoReadFile('46_intel-vbt.dts') self.assertEqual(VBT_DATA, data[:len(VBT_DATA)])

+ def testSplBssPad(self): + """Test that we can pad SPL's BSS with zeros""" + data = self._DoReadFile('47_spl_bss_pad.dts') + self.assertEqual(U_BOOT_SPL_DATA + (chr(0) * 10) + U_BOOT_DATA, data) +

if __name__ == "__main__": unittest.main() diff --git a/tools/binman/test/47_spl_bss_pad.dts b/tools/binman/test/47_spl_bss_pad.dts new file mode 100644 index 00000000000..6bd88b83f98 --- /dev/null +++ b/tools/binman/test/47_spl_bss_pad.dts @@ -0,0 +1,17 @@ +/dts-v1/; + +/ { + #address-cells = <1>; + #size-cells = <1>; + + binman { + u-boot-spl { + }; + + u-boot-spl-bss-pad { + }; + + u-boot { + }; + }; +}; diff --git a/tools/binman/test/Makefile b/tools/binman/test/Makefile index 786d1b05778..217d13c666f 100644 --- a/tools/binman/test/Makefile +++ b/tools/binman/test/Makefile @@ -11,7 +11,7 @@ CFLAGS := -march=i386 -m32 -nostdlib -I ../../../include

LDS_UCODE := -T u_boot_ucode_ptr.lds

-TARGETS = u_boot_ucode_ptr u_boot_no_ucode_ptr +TARGETS = u_boot_ucode_ptr u_boot_no_ucode_ptr bss_data

all: $(TARGETS)

@@ -21,6 +21,9 @@ u_boot_no_ucode_ptr: u_boot_no_ucode_ptr.c u_boot_ucode_ptr: CFLAGS += $(LDS_UCODE) u_boot_ucode_ptr: u_boot_ucode_ptr.c

+bss_data: CFLAGS += bss_data.lds +bss_data: bss_data.c + clean: rm -f $(TARGETS)

diff --git a/tools/binman/test/bss_data b/tools/binman/test/bss_data new file mode 100755 index 0000000000000000000000000000000000000000..afa28282aa157f6717c1ba244ecbfc6e1b081734 GIT binary patch literal 5020 zcmeHLyKWOf6uoP&!GJ+|Af+(H7C{(6hJ>s{1O*}i;vz!9k|7jmvEv0>!j5FGr4S(= z1rl`m016r?sner~AE2ip9R*N@0-1AWb`nc8lqu#)$M-R39(#6N?0tS?>89s-Vl5+C zVfN$CU=YG@j+l{90?A29j!9mR>*@<XFTe^W5IGjX=X`p3hjGA1SOyLOtTX>YU@kF< zm|&e)-boq-EK+#s=ZTZ35qA7G#*zMGT%X&LM}8Jqyj7L$-{T)<zJ0y(_Vh>Z{jc>) zoA)Lv)i*nzb0r)u1JV{C_dj{X>=n-E`M(bagY)oQhvscm#Cw|eiUr?)4Z<nZh%N9m z=h}(<tIYiI-10UUoZ-wV;1qBQI0c*nP64NYQ@|<U6mSYS1)Ks0M}ZQKvbeBtIVe@@ z{Z7&kLN%wtsf&G`%{-e4)pV$4&zic3>OE;EwK{y#HNI)1&RP<yN1eW^_gjw}Q>})m zBwkNM#m(qpx7LoMW}~~GiE7l6ny7lOCu()A-HtoS|Lal&^)SHCcil&Tp9HMgPjH0- zzvtN-*hQ~l7v6r;Bi!p{glWw6bl(A!hIw|q`5|6_-b4W29BS4qZwUqN%N~U8gQR^A zrZmf|AkG8i1!zb3;PIVU3)0{&JlC5}bMnrmF&)Q<Q9$nrPrCr#109(ka%l8?R%_)k z^iEJbiUPs&VX7PfhSyse7rBm_HM^e8hdtj5bJI~W`kUPBOr1?`cA%anPt}1QCfA)M zt&hodCyAl9EN;T^Iehs!uw(Sh3-I>2Mv+e-r`{#_QQVFIo;@!(Jhvxj;Qe&}5sc3w z=l$WG7=v<r=lkP1xr)3z#1~xah!<R~N)$2awKn3tszkk{)=lh?j@z|XN1|B&E26m5 FkiP*om$v`_

literal 0 HcmV?d00001

diff --git a/tools/binman/test/bss_data.c b/tools/binman/test/bss_data.c new file mode 100644 index 00000000000..f865a9d9f67 --- /dev/null +++ b/tools/binman/test/bss_data.c @@ -0,0 +1,18 @@ +/* + * Copyright (c) 2016 Google, Inc + * + * SPDX-License-Identifier: GPL-2.0+ + * + * Simple program to create a _dt_ucode_base_size symbol which can be read + * by 'nm'. This is used by binman tests. + */ + +int bss_data[10]; +int __bss_size = sizeof(bss_data); + +int main() +{ + bss_data[2] = 2; + + return 0; +} diff --git a/tools/binman/test/bss_data.lds b/tools/binman/test/bss_data.lds new file mode 100644 index 00000000000..6b2fe09d351 --- /dev/null +++ b/tools/binman/test/bss_data.lds @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2016 Google, Inc + * + * SPDX-License-Identifier: GPL-2.0+ + */ + +OUTPUT_FORMAT("elf32-i386", "elf32-i386", "elf32-i386") +OUTPUT_ARCH(i386) +ENTRY(_start) + +SECTIONS +{ + . = 0xfffffdf0; + _start = .; + __bss_size = 10; +}

This allows us to put the 16-bit x86 start-up code in SPL. Add a test for it.

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/binman/ftest.py | 10 +++++++++- tools/binman/test/48_x86-start16-spl.dts | 13 +++++++++++++ 2 files changed, 22 insertions(+), 1 deletion(-) create mode 100644 tools/binman/test/48_x86-start16-spl.dts

diff --git a/tools/binman/ftest.py b/tools/binman/ftest.py index 4e6aaad9d6b..c381a700311 100644 --- a/tools/binman/ftest.py +++ b/tools/binman/ftest.py @@ -34,6 +34,7 @@ ME_DATA = '0abcd' VGA_DATA = 'vga' U_BOOT_DTB_DATA = 'udtb' X86_START16_DATA = 'start16' +X86_START16_SPL_DATA = 'start16spl' U_BOOT_NODTB_DATA = 'nodtb with microcode pointer somewhere in here' FSP_DATA = 'fsp' CMC_DATA = 'cmc' @@ -74,6 +75,8 @@ class TestFunctional(unittest.TestCase): TestFunctional._MakeInputFile('vga.bin', VGA_DATA) TestFunctional._MakeInputFile('u-boot.dtb', U_BOOT_DTB_DATA) TestFunctional._MakeInputFile('u-boot-x86-16bit.bin', X86_START16_DATA) + TestFunctional._MakeInputFile('spl/u-boot-x86-16bit-spl.bin', + X86_START16_SPL_DATA) TestFunctional._MakeInputFile('u-boot-nodtb.bin', U_BOOT_NODTB_DATA) TestFunctional._MakeInputFile('fsp.bin', FSP_DATA) TestFunctional._MakeInputFile('cmc.bin', CMC_DATA) @@ -677,7 +680,7 @@ class TestFunctional(unittest.TestCase):

# Check that the microcode appears immediately after the Fdt # This matches the concatenation of the data properties in - # the /microcode/update@xxx nodes in x86_ucode.dts. + # the /microcode/update@xxx nodes in 34_x86_ucode.dts. ucode_data = struct.pack('>4L', 0x12345678, 0x12345679, 0xabcd0000, 0x78235609) self.assertEqual(ucode_data, third[:len(ucode_data)]) @@ -823,6 +826,11 @@ class TestFunctional(unittest.TestCase): data = self._DoReadFile('47_spl_bss_pad.dts') self.assertEqual(U_BOOT_SPL_DATA + (chr(0) * 10) + U_BOOT_DATA, data)

+ def testPackStart16Spl(self): + """Test that an image with an x86 start16 region can be created""" + data = self._DoReadFile('48_x86-start16-spl.dts') + self.assertEqual(X86_START16_SPL_DATA, data[:len(X86_START16_SPL_DATA)]) +

if __name__ == "__main__": unittest.main() diff --git a/tools/binman/test/48_x86-start16-spl.dts b/tools/binman/test/48_x86-start16-spl.dts new file mode 100644 index 00000000000..e2009f15f05 --- /dev/null +++ b/tools/binman/test/48_x86-start16-spl.dts @@ -0,0 +1,13 @@ +/dts-v1/; + +/ { + #address-cells = <1>; + #size-cells = <1>; + + binman { + size = <16>; + + x86-start16-spl { + }; + }; +};

Add a test for this feature. It allows SPL to hold a pointer to the microcode block. This is used for 64-bit U-Boot on x86.

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/binman/etype/u_boot_spl_with_ucode_ptr.py | 2 +- tools/binman/ftest.py | 84 ++++++++++++++++--------- tools/binman/test/49_x86_ucode_spl.dts | 29 +++++++++ 3 files changed, 84 insertions(+), 31 deletions(-) create mode 100644 tools/binman/test/49_x86_ucode_spl.dts

diff --git a/tools/binman/etype/u_boot_spl_with_ucode_ptr.py b/tools/binman/etype/u_boot_spl_with_ucode_ptr.py index 1c6706df6db..7b25ccb0488 100644 --- a/tools/binman/etype/u_boot_spl_with_ucode_ptr.py +++ b/tools/binman/etype/u_boot_spl_with_ucode_ptr.py @@ -25,4 +25,4 @@ class Entry_u_boot_spl_with_ucode_ptr(Entry_u_boot_with_ucode_ptr): self.elf_fname = 'spl/u-boot-spl'

def GetDefaultFilename(self): - return 'spl/u-boot-spl.bin' + return 'spl/u-boot-spl-nodtb.bin' diff --git a/tools/binman/ftest.py b/tools/binman/ftest.py index c381a700311..dff7448f08f 100644 --- a/tools/binman/ftest.py +++ b/tools/binman/ftest.py @@ -26,19 +26,20 @@ import tools import tout

# Contents of test files, corresponding to different entry types -U_BOOT_DATA = '1234' -U_BOOT_IMG_DATA = 'img' -U_BOOT_SPL_DATA = '567' -BLOB_DATA = '89' -ME_DATA = '0abcd' -VGA_DATA = 'vga' -U_BOOT_DTB_DATA = 'udtb' -X86_START16_DATA = 'start16' -X86_START16_SPL_DATA = 'start16spl' -U_BOOT_NODTB_DATA = 'nodtb with microcode pointer somewhere in here' -FSP_DATA = 'fsp' -CMC_DATA = 'cmc' -VBT_DATA = 'vbt' +U_BOOT_DATA = '1234' +U_BOOT_IMG_DATA = 'img' +U_BOOT_SPL_DATA = '567' +BLOB_DATA = '89' +ME_DATA = '0abcd' +VGA_DATA = 'vga' +U_BOOT_DTB_DATA = 'udtb' +X86_START16_DATA = 'start16' +X86_START16_SPL_DATA = 'start16spl' +U_BOOT_NODTB_DATA = 'nodtb with microcode pointer somewhere in here' +U_BOOT_SPL_NODTB_DATA = 'splnodtb with microcode pointer somewhere in here' +FSP_DATA = 'fsp' +CMC_DATA = 'cmc' +VBT_DATA = 'vbt'

class TestFunctional(unittest.TestCase): """Functional tests for binman @@ -78,6 +79,8 @@ class TestFunctional(unittest.TestCase): TestFunctional._MakeInputFile('spl/u-boot-x86-16bit-spl.bin', X86_START16_SPL_DATA) TestFunctional._MakeInputFile('u-boot-nodtb.bin', U_BOOT_NODTB_DATA) + TestFunctional._MakeInputFile('spl/u-boot-spl-nodtb.bin', + U_BOOT_SPL_NODTB_DATA) TestFunctional._MakeInputFile('fsp.bin', FSP_DATA) TestFunctional._MakeInputFile('cmc.bin', CMC_DATA) TestFunctional._MakeInputFile('vbt.bin', VBT_DATA) @@ -91,10 +94,6 @@ class TestFunctional(unittest.TestCase): with open(self.TestFile('descriptor.bin')) as fd: TestFunctional._MakeInputFile('descriptor.bin', fd.read())

- # ELF file with a '__bss_size' symbol - with open(self.TestFile('bss_data')) as fd: - TestFunctional._MakeInputFile('spl/u-boot-spl', fd.read()) - @classmethod def tearDownClass(self): """Remove the temporary input directory and its contents""" @@ -653,19 +652,11 @@ class TestFunctional(unittest.TestCase): data = self._DoReadFile('33_x86-start16.dts') self.assertEqual(X86_START16_DATA, data[:len(X86_START16_DATA)])

- def testPackUbootMicrocode(self): - """Test that x86 microcode can be handled correctly - - We expect to see the following in the image, in order: - u-boot-nodtb.bin with a microcode pointer inserted at the correct - place - u-boot.dtb with the microcode removed - the microcode - """ - data = self._DoReadFile('34_x86_ucode.dts', True) + def _RunMicrocodeTest(self, dts_fname, nodtb_data): + data = self._DoReadFile(dts_fname, True)

# Now check the device tree has no microcode - second = data[len(U_BOOT_NODTB_DATA):] + second = data[len(nodtb_data):] fname = tools.GetOutputFilename('test.dtb') with open(fname, 'wb') as fd: fd.write(second) @@ -684,13 +675,26 @@ class TestFunctional(unittest.TestCase): ucode_data = struct.pack('>4L', 0x12345678, 0x12345679, 0xabcd0000, 0x78235609) self.assertEqual(ucode_data, third[:len(ucode_data)]) - ucode_pos = len(U_BOOT_NODTB_DATA) + fdt_len + ucode_pos = len(nodtb_data) + fdt_len

# Check that the microcode pointer was inserted. It should match the # expected position and size pos_and_size = struct.pack('<2L', 0xfffffe00 + ucode_pos, len(ucode_data)) - first = data[:len(U_BOOT_NODTB_DATA)] + first = data[:len(nodtb_data)] + return first, pos_and_size + + def testPackUbootMicrocode(self): + """Test that x86 microcode can be handled correctly + + We expect to see the following in the image, in order: + u-boot-nodtb.bin with a microcode pointer inserted at the correct + place + u-boot.dtb with the microcode removed + the microcode + """ + first, pos_and_size = self._RunMicrocodeTest('34_x86_ucode.dts', + U_BOOT_NODTB_DATA) self.assertEqual('nodtb with microcode' + pos_and_size + ' somewhere in here', first)

@@ -823,6 +827,9 @@ class TestFunctional(unittest.TestCase):

def testSplBssPad(self): """Test that we can pad SPL's BSS with zeros""" + # ELF file with a '__bss_size' symbol + with open(self.TestFile('bss_data')) as fd: + TestFunctional._MakeInputFile('spl/u-boot-spl', fd.read()) data = self._DoReadFile('47_spl_bss_pad.dts') self.assertEqual(U_BOOT_SPL_DATA + (chr(0) * 10) + U_BOOT_DATA, data)

@@ -831,6 +838,23 @@ class TestFunctional(unittest.TestCase): data = self._DoReadFile('48_x86-start16-spl.dts') self.assertEqual(X86_START16_SPL_DATA, data[:len(X86_START16_SPL_DATA)])

+ def testPackUbootSplMicrocode(self): + """Test that x86 microcode can be handled correctly in SPL + + We expect to see the following in the image, in order: + u-boot-spl-nodtb.bin with a microcode pointer inserted at the + correct place + u-boot.dtb with the microcode removed + the microcode + """ + # ELF file with a '_dt_ucode_base_size' symbol + with open(self.TestFile('u_boot_ucode_ptr')) as fd: + TestFunctional._MakeInputFile('spl/u-boot-spl', fd.read()) + first, pos_and_size = self._RunMicrocodeTest('49_x86_ucode_spl.dts', + U_BOOT_SPL_NODTB_DATA) + self.assertEqual('splnodtb with microc' + pos_and_size + + 'ter somewhere in here', first) +

if __name__ == "__main__": unittest.main() diff --git a/tools/binman/test/49_x86_ucode_spl.dts b/tools/binman/test/49_x86_ucode_spl.dts new file mode 100644 index 00000000000..67db93ad502 --- /dev/null +++ b/tools/binman/test/49_x86_ucode_spl.dts @@ -0,0 +1,29 @@ +/dts-v1/; + +/ { + #address-cells = <1>; + #size-cells = <1>; + + binman { + sort-by-pos; + end-at-4gb; + size = <0x200>; + u-boot-spl-with-ucode-ptr { + }; + + u-boot-dtb-with-ucode { + }; + + u-boot-ucode { + }; + }; + + microcode { + update@0 { + data = <0x12345678 0x12345679>; + }; + update@1 { + data = <0xabcd0000 0x78235609>; + }; + }; +};

MRC (Memory Reference Code) is a binary blob used to set up the SDRAM controller on some Intel boards. Add a test for this feature.

With this test coverage on binman is back up to 100%.

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/binman/ftest.py | 7 +++++++ tools/binman/test/50_intel_mrc.dts | 13 +++++++++++++ 2 files changed, 20 insertions(+) create mode 100644 tools/binman/test/50_intel_mrc.dts

diff --git a/tools/binman/ftest.py b/tools/binman/ftest.py index dff7448f08f..9083143894f 100644 --- a/tools/binman/ftest.py +++ b/tools/binman/ftest.py @@ -40,6 +40,7 @@ U_BOOT_SPL_NODTB_DATA = 'splnodtb with microcode pointer somewhere in here' FSP_DATA = 'fsp' CMC_DATA = 'cmc' VBT_DATA = 'vbt' +MRC_DATA = 'mrc'

class TestFunctional(unittest.TestCase): """Functional tests for binman @@ -84,6 +85,7 @@ class TestFunctional(unittest.TestCase): TestFunctional._MakeInputFile('fsp.bin', FSP_DATA) TestFunctional._MakeInputFile('cmc.bin', CMC_DATA) TestFunctional._MakeInputFile('vbt.bin', VBT_DATA) + TestFunctional._MakeInputFile('mrc.bin', MRC_DATA) self._output_setup = False

# ELF file with a '_dt_ucode_base_size' symbol @@ -855,6 +857,11 @@ class TestFunctional(unittest.TestCase): self.assertEqual('splnodtb with microc' + pos_and_size + 'ter somewhere in here', first)

+ def testPackMrc(self): + """Test that an image with an MRC binary can be created""" + data = self._DoReadFile('50_intel_mrc.dts') + self.assertEqual(MRC_DATA, data[:len(MRC_DATA)]) +

if __name__ == "__main__": unittest.main() diff --git a/tools/binman/test/50_intel_mrc.dts b/tools/binman/test/50_intel_mrc.dts new file mode 100644 index 00000000000..54cd52a2b71 --- /dev/null +++ b/tools/binman/test/50_intel_mrc.dts @@ -0,0 +1,13 @@ +/dts-v1/; + +/ { + #address-cells = <1>; + #size-cells = <1>; + + binman { + size = <16>; + + intel-mrc { + }; + }; +};

Return exit code 1 when test fail so that callers can detect this.

Signed-off-by: Simon Glass sjg@chromium.org ---

tools/binman/binman.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/tools/binman/binman.py b/tools/binman/binman.py index 7ad4d3030b9..3ccf25f1f88 100755 --- a/tools/binman/binman.py +++ b/tools/binman/binman.py @@ -58,7 +58,11 @@ def RunTests(): for test, err in result.errors: print test.id(), err for test, err in result.failures: - print err + print err, result.failures + if result.errors or result.failures: + print 'binman tests FAILED' + return 1 + return 0

def RunTestCoverage(): """Run the tests and check that we get 100% coverage""" @@ -106,7 +110,7 @@ def RunBinman(options, args): sys.tracebacklimit = 0

if options.test: - RunTests() + ret_code = RunTests()

elif options.test_coverage: RunTestCoverage()

Binman has 100% test coverage for the code as it is at present. To encourage it to stay that way, run the code-coverage test as part of the normal U-Boot tests.

This is RFC because it requires the Python code coverage tools to be available.

Signed-off-by: Simon Glass sjg@chromium.org ---

test/run | 6 ++++++ 1 file changed, 6 insertions(+)

diff --git a/test/run b/test/run index d40a5cdc807..507c61a9e9c 100755 --- a/test/run +++ b/test/run @@ -21,6 +21,12 @@ run_test ./tools/patman/patman --test run_test ./tools/buildman/buildman -t PYTHONPATH=build-sandbox_spl/tools run_test ./tools/dtoc/dtoc -t

+# This needs you to set up Python test coverage tools. +# To enable Python test coverage on Debian-type distributions (e.g. Ubuntu): +# $ sudo apt-get install python-pip python-pytest +# $ sudo pip install coverage +PYTHONPATH=build-sandbox_spl/tools run_test ./tools/binman/binman -T + if [ $result == 0 ]; then echo "Tests passed!" else