mirror of
https://xff.cz/git/u-boot/
synced 2025-10-31 10:26:10 +01:00
261d29e2f3
Verifies shell variables are replaced by their values. Reviewed-by: Simon Glass <sjg@chromium.org> Signed-off-by: Francis Laniel <francis.laniel@amarulasolutions.com>
511 lines
18 KiB
Python
511 lines
18 KiB
Python
# SPDX-License-Identifier: GPL-2.0
|
|
# Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved.
|
|
|
|
import collections
|
|
import getpass
|
|
import gzip
|
|
import os
|
|
import os.path
|
|
import pytest
|
|
|
|
import u_boot_utils
|
|
# pylint: disable=E0611
|
|
from tests import fs_helper
|
|
|
|
def mkdir_cond(dirname):
|
|
"""Create a directory if it doesn't already exist
|
|
|
|
Args:
|
|
dirname (str): Name of directory to create
|
|
"""
|
|
if not os.path.exists(dirname):
|
|
os.mkdir(dirname)
|
|
|
|
def setup_image(cons, mmc_dev, part_type, second_part=False):
|
|
"""Create a 20MB disk image with a single partition
|
|
|
|
Args:
|
|
cons (ConsoleBase): Console to use
|
|
mmc_dev (int): MMC device number to use, e.g. 1
|
|
part_type (int): Partition type, e.g. 0xc for FAT32
|
|
second_part (bool): True to contain a small second partition
|
|
|
|
Returns:
|
|
tuple:
|
|
str: Filename of MMC image
|
|
str: Directory name of 'mnt' directory
|
|
"""
|
|
fname = os.path.join(cons.config.source_dir, f'mmc{mmc_dev}.img')
|
|
mnt = os.path.join(cons.config.persistent_data_dir, 'mnt')
|
|
mkdir_cond(mnt)
|
|
|
|
spec = f'type={part_type:x}, size=18M, bootable'
|
|
if second_part:
|
|
spec += '\ntype=c'
|
|
|
|
u_boot_utils.run_and_log(cons, 'qemu-img create %s 20M' % fname)
|
|
u_boot_utils.run_and_log(cons, 'sudo sfdisk %s' % fname,
|
|
stdin=spec.encode('utf-8'))
|
|
return fname, mnt
|
|
|
|
def mount_image(cons, fname, mnt, fstype):
|
|
"""Create a filesystem and mount it on partition 1
|
|
|
|
Args:
|
|
cons (ConsoleBase): Console to use
|
|
fname (str): Filename of MMC image
|
|
mnt (str): Directory name of 'mnt' directory
|
|
fstype (str): Filesystem type ('vfat' or 'ext4')
|
|
|
|
Returns:
|
|
str: Name of loop device used
|
|
"""
|
|
out = u_boot_utils.run_and_log(cons, 'sudo losetup --show -f -P %s' % fname)
|
|
loop = out.strip()
|
|
part = f'{loop}p1'
|
|
u_boot_utils.run_and_log(cons, f'sudo mkfs.{fstype} {part}')
|
|
opts = ''
|
|
if fstype == 'vfat':
|
|
opts += f' -o uid={os.getuid()},gid={os.getgid()}'
|
|
u_boot_utils.run_and_log(cons, f'sudo mount -o loop {part} {mnt}{opts}')
|
|
u_boot_utils.run_and_log(cons, f'sudo chown {getpass.getuser()} {mnt}')
|
|
return loop
|
|
|
|
def copy_prepared_image(cons, mmc_dev, fname):
|
|
"""Use a prepared image since we cannot create one
|
|
|
|
Args:
|
|
cons (ConsoleBase): Console touse
|
|
mmc_dev (int): MMC device number
|
|
fname (str): Filename of MMC image
|
|
"""
|
|
infname = os.path.join(cons.config.source_dir,
|
|
f'test/py/tests/bootstd/mmc{mmc_dev}.img.xz')
|
|
u_boot_utils.run_and_log(
|
|
cons,
|
|
['sh', '-c', 'xz -dc %s >%s' % (infname, fname)])
|
|
|
|
def setup_bootmenu_image(cons):
|
|
"""Create a 20MB disk image with a single ext4 partition
|
|
|
|
This is modelled on Armbian 22.08 Jammy
|
|
"""
|
|
mmc_dev = 4
|
|
fname, mnt = setup_image(cons, mmc_dev, 0x83)
|
|
|
|
loop = None
|
|
mounted = False
|
|
complete = False
|
|
try:
|
|
loop = mount_image(cons, fname, mnt, 'ext4')
|
|
mounted = True
|
|
|
|
vmlinux = 'Image'
|
|
initrd = 'uInitrd'
|
|
dtbdir = 'dtb'
|
|
script = '''# DO NOT EDIT THIS FILE
|
|
#
|
|
# Please edit /boot/armbianEnv.txt to set supported parameters
|
|
#
|
|
|
|
setenv load_addr "0x9000000"
|
|
setenv overlay_error "false"
|
|
# default values
|
|
setenv rootdev "/dev/mmcblk%dp1"
|
|
setenv verbosity "1"
|
|
setenv console "both"
|
|
setenv bootlogo "false"
|
|
setenv rootfstype "ext4"
|
|
setenv docker_optimizations "on"
|
|
setenv earlycon "off"
|
|
|
|
echo "Boot script loaded from ${devtype} ${devnum}"
|
|
|
|
if test -e ${devtype} ${devnum} ${prefix}armbianEnv.txt; then
|
|
load ${devtype} ${devnum} ${load_addr} ${prefix}armbianEnv.txt
|
|
env import -t ${load_addr} ${filesize}
|
|
fi
|
|
|
|
if test "${logo}" = "disabled"; then setenv logo "logo.nologo"; fi
|
|
|
|
if test "${console}" = "display" || test "${console}" = "both"; then setenv consoleargs "console=tty1"; fi
|
|
if test "${console}" = "serial" || test "${console}" = "both"; then setenv consoleargs "console=ttyS2,1500000 ${consoleargs}"; fi
|
|
if test "${earlycon}" = "on"; then setenv consoleargs "earlycon ${consoleargs}"; fi
|
|
if test "${bootlogo}" = "true"; then setenv consoleargs "bootsplash.bootfile=bootsplash.armbian ${consoleargs}"; fi
|
|
|
|
# get PARTUUID of first partition on SD/eMMC the boot script was loaded from
|
|
if test "${devtype}" = "mmc"; then part uuid mmc ${devnum}:1 partuuid; fi
|
|
|
|
setenv bootargs "root=${rootdev} rootwait rootfstype=${rootfstype} ${consoleargs} consoleblank=0 loglevel=${verbosity} ubootpart=${partuuid} usb-storage.quirks=${usbstoragequirks} ${extraargs} ${extraboardargs}"
|
|
|
|
if test "${docker_optimizations}" = "on"; then setenv bootargs "${bootargs} cgroup_enable=cpuset cgroup_memory=1 cgroup_enable=memory swapaccount=1"; fi
|
|
|
|
load ${devtype} ${devnum} ${ramdisk_addr_r} ${prefix}uInitrd
|
|
load ${devtype} ${devnum} ${kernel_addr_r} ${prefix}Image
|
|
|
|
load ${devtype} ${devnum} ${fdt_addr_r} ${prefix}dtb/${fdtfile}
|
|
fdt addr ${fdt_addr_r}
|
|
fdt resize 65536
|
|
for overlay_file in ${overlays}; do
|
|
if load ${devtype} ${devnum} ${load_addr} ${prefix}dtb/rockchip/overlay/${overlay_prefix}-${overlay_file}.dtbo; then
|
|
echo "Applying kernel provided DT overlay ${overlay_prefix}-${overlay_file}.dtbo"
|
|
fdt apply ${load_addr} || setenv overlay_error "true"
|
|
fi
|
|
done
|
|
for overlay_file in ${user_overlays}; do
|
|
if load ${devtype} ${devnum} ${load_addr} ${prefix}overlay-user/${overlay_file}.dtbo; then
|
|
echo "Applying user provided DT overlay ${overlay_file}.dtbo"
|
|
fdt apply ${load_addr} || setenv overlay_error "true"
|
|
fi
|
|
done
|
|
if test "${overlay_error}" = "true"; then
|
|
echo "Error applying DT overlays, restoring original DT"
|
|
load ${devtype} ${devnum} ${fdt_addr_r} ${prefix}dtb/${fdtfile}
|
|
else
|
|
if load ${devtype} ${devnum} ${load_addr} ${prefix}dtb/rockchip/overlay/${overlay_prefix}-fixup.scr; then
|
|
echo "Applying kernel provided DT fixup script (${overlay_prefix}-fixup.scr)"
|
|
source ${load_addr}
|
|
fi
|
|
if test -e ${devtype} ${devnum} ${prefix}fixup.scr; then
|
|
load ${devtype} ${devnum} ${load_addr} ${prefix}fixup.scr
|
|
echo "Applying user provided fixup script (fixup.scr)"
|
|
source ${load_addr}
|
|
fi
|
|
fi
|
|
booti ${kernel_addr_r} ${ramdisk_addr_r} ${fdt_addr_r}
|
|
|
|
# Recompile with:
|
|
# mkimage -C none -A arm -T script -d /boot/boot.cmd /boot/boot.scr
|
|
''' % (mmc_dev)
|
|
bootdir = os.path.join(mnt, 'boot')
|
|
mkdir_cond(bootdir)
|
|
cmd_fname = os.path.join(bootdir, 'boot.cmd')
|
|
scr_fname = os.path.join(bootdir, 'boot.scr')
|
|
with open(cmd_fname, 'w') as outf:
|
|
print(script, file=outf)
|
|
|
|
infname = os.path.join(cons.config.source_dir,
|
|
'test/py/tests/bootstd/armbian.bmp.xz')
|
|
bmp_file = os.path.join(bootdir, 'boot.bmp')
|
|
u_boot_utils.run_and_log(
|
|
cons,
|
|
['sh', '-c', f'xz -dc {infname} >{bmp_file}'])
|
|
|
|
u_boot_utils.run_and_log(
|
|
cons, f'mkimage -C none -A arm -T script -d {cmd_fname} {scr_fname}')
|
|
|
|
kernel = 'vmlinuz-5.15.63-rockchip64'
|
|
target = os.path.join(bootdir, kernel)
|
|
with open(target, 'wb') as outf:
|
|
print('kernel', outf)
|
|
|
|
symlink = os.path.join(bootdir, 'Image')
|
|
if os.path.exists(symlink):
|
|
os.remove(symlink)
|
|
u_boot_utils.run_and_log(
|
|
cons, f'echo here {kernel} {symlink}')
|
|
os.symlink(kernel, symlink)
|
|
|
|
u_boot_utils.run_and_log(
|
|
cons, f'mkimage -C none -A arm -T script -d {cmd_fname} {scr_fname}')
|
|
complete = True
|
|
|
|
except ValueError as exc:
|
|
print('Falled to create image, failing back to prepared copy: %s',
|
|
str(exc))
|
|
finally:
|
|
if mounted:
|
|
u_boot_utils.run_and_log(cons, 'sudo umount --lazy %s' % mnt)
|
|
if loop:
|
|
u_boot_utils.run_and_log(cons, 'sudo losetup -d %s' % loop)
|
|
|
|
if not complete:
|
|
copy_prepared_image(cons, mmc_dev, fname)
|
|
|
|
def setup_bootflow_image(cons):
|
|
"""Create a 20MB disk image with a single FAT partition"""
|
|
mmc_dev = 1
|
|
fname, mnt = setup_image(cons, mmc_dev, 0xc, second_part=True)
|
|
|
|
loop = None
|
|
mounted = False
|
|
complete = False
|
|
try:
|
|
loop = mount_image(cons, fname, mnt, 'vfat')
|
|
mounted = True
|
|
|
|
vmlinux = 'vmlinuz-5.3.7-301.fc31.armv7hl'
|
|
initrd = 'initramfs-5.3.7-301.fc31.armv7hl.img'
|
|
dtbdir = 'dtb-5.3.7-301.fc31.armv7hl'
|
|
script = '''# extlinux.conf generated by appliance-creator
|
|
ui menu.c32
|
|
menu autoboot Welcome to Fedora-Workstation-armhfp-31-1.9. Automatic boot in # second{,s}. Press a key for options.
|
|
menu title Fedora-Workstation-armhfp-31-1.9 Boot Options.
|
|
menu hidden
|
|
timeout 20
|
|
totaltimeout 600
|
|
|
|
label Fedora-Workstation-armhfp-31-1.9 (5.3.7-301.fc31.armv7hl)
|
|
kernel /%s
|
|
append ro root=UUID=9732b35b-4cd5-458b-9b91-80f7047e0b8a rhgb quiet LANG=en_US.UTF-8 cma=192MB cma=256MB
|
|
fdtdir /%s/
|
|
initrd /%s''' % (vmlinux, dtbdir, initrd)
|
|
ext = os.path.join(mnt, 'extlinux')
|
|
mkdir_cond(ext)
|
|
|
|
with open(os.path.join(ext, 'extlinux.conf'), 'w') as fd:
|
|
print(script, file=fd)
|
|
|
|
inf = os.path.join(cons.config.persistent_data_dir, 'inf')
|
|
with open(inf, 'wb') as fd:
|
|
fd.write(gzip.compress(b'vmlinux'))
|
|
u_boot_utils.run_and_log(cons, 'mkimage -f auto -d %s %s' %
|
|
(inf, os.path.join(mnt, vmlinux)))
|
|
|
|
with open(os.path.join(mnt, initrd), 'w') as fd:
|
|
print('initrd', file=fd)
|
|
|
|
mkdir_cond(os.path.join(mnt, dtbdir))
|
|
|
|
dtb_file = os.path.join(mnt, '%s/sandbox.dtb' % dtbdir)
|
|
u_boot_utils.run_and_log(
|
|
cons, 'dtc -o %s' % dtb_file, stdin=b'/dts-v1/; / {};')
|
|
complete = True
|
|
except ValueError as exc:
|
|
print('Falled to create image, failing back to prepared copy: %s',
|
|
str(exc))
|
|
finally:
|
|
if mounted:
|
|
u_boot_utils.run_and_log(cons, 'sudo umount --lazy %s' % mnt)
|
|
if loop:
|
|
u_boot_utils.run_and_log(cons, 'sudo losetup -d %s' % loop)
|
|
|
|
if not complete:
|
|
copy_prepared_image(cons, mmc_dev, fname)
|
|
|
|
|
|
def setup_cros_image(cons):
|
|
"""Create a 20MB disk image with ChromiumOS partitions"""
|
|
Partition = collections.namedtuple('part', 'start,size,name')
|
|
parts = {}
|
|
disk_data = None
|
|
|
|
def pack_kernel(cons, arch, kern, dummy):
|
|
"""Pack a kernel containing some fake data
|
|
|
|
Args:
|
|
cons (ConsoleBase): Console to use
|
|
arch (str): Architecture to use ('x86' or 'arm')
|
|
kern (str): Filename containing kernel
|
|
dummy (str): Dummy filename to use for config and bootloader
|
|
|
|
Return:
|
|
bytes: Packed-kernel data
|
|
"""
|
|
kern_part = os.path.join(cons.config.result_dir, 'kern-part-{arch}.bin')
|
|
u_boot_utils.run_and_log(
|
|
cons,
|
|
f'futility vbutil_kernel --pack {kern_part} '
|
|
'--keyblock doc/chromium/files/devkeys/kernel.keyblock '
|
|
'--signprivate doc/chromium/files/devkeys/kernel_data_key.vbprivk '
|
|
f'--version 1 --config {dummy} --bootloader {dummy} '
|
|
f'--vmlinuz {kern}')
|
|
|
|
with open(kern_part, 'rb') as inf:
|
|
kern_part_data = inf.read()
|
|
return kern_part_data
|
|
|
|
def set_part_data(partnum, data):
|
|
"""Set the contents of a disk partition
|
|
|
|
This updates disk_data by putting data in the right place
|
|
|
|
Args:
|
|
partnum (int): Partition number to set
|
|
data (bytes): Data for that partition
|
|
"""
|
|
nonlocal disk_data
|
|
|
|
start = parts[partnum].start * sect_size
|
|
disk_data = disk_data[:start] + data + disk_data[start + len(data):]
|
|
|
|
mmc_dev = 5
|
|
fname = os.path.join(cons.config.source_dir, f'mmc{mmc_dev}.img')
|
|
u_boot_utils.run_and_log(cons, 'qemu-img create %s 20M' % fname)
|
|
#mnt = os.path.join(cons.config.persistent_data_dir, 'mnt')
|
|
#mkdir_cond(mnt)
|
|
u_boot_utils.run_and_log(cons, f'cgpt create {fname}')
|
|
|
|
uuid_state = 'ebd0a0a2-b9e5-4433-87c0-68b6b72699c7'
|
|
uuid_kern = 'fe3a2a5d-4f32-41a7-b725-accc3285a309'
|
|
uuid_root = '3cb8e202-3b7e-47dd-8a3c-7ff2a13cfcec'
|
|
uuid_rwfw = 'cab6e88e-abf3-4102-a07a-d4bb9be3c1d3'
|
|
uuid_reserved = '2e0a753d-9e48-43b0-8337-b15192cb1b5e'
|
|
uuid_efi = 'c12a7328-f81f-11d2-ba4b-00a0c93ec93b'
|
|
|
|
ptr = 40
|
|
|
|
# Number of sectors in 1MB
|
|
sect_size = 512
|
|
sect_1mb = (1 << 20) // sect_size
|
|
|
|
required_parts = [
|
|
{'num': 0xb, 'label':'RWFW', 'type': uuid_rwfw, 'size': '1'},
|
|
{'num': 6, 'label':'KERN_C', 'type': uuid_kern, 'size': '1'},
|
|
{'num': 7, 'label':'ROOT_C', 'type': uuid_root, 'size': '1'},
|
|
{'num': 9, 'label':'reserved', 'type': uuid_reserved, 'size': '1'},
|
|
{'num': 0xa, 'label':'reserved', 'type': uuid_reserved, 'size': '1'},
|
|
|
|
{'num': 2, 'label':'KERN_A', 'type': uuid_kern, 'size': '1M'},
|
|
{'num': 4, 'label':'KERN_B', 'type': uuid_kern, 'size': '1M'},
|
|
|
|
{'num': 8, 'label':'OEM', 'type': uuid_state, 'size': '1M'},
|
|
{'num': 0xc, 'label':'EFI-SYSTEM', 'type': uuid_efi, 'size': '1M'},
|
|
|
|
{'num': 5, 'label':'ROOT_B', 'type': uuid_root, 'size': '1'},
|
|
{'num': 3, 'label':'ROOT_A', 'type': uuid_root, 'size': '1'},
|
|
{'num': 1, 'label':'STATE', 'type': uuid_state, 'size': '1M'},
|
|
]
|
|
|
|
for part in required_parts:
|
|
size_str = part['size']
|
|
if 'M' in size_str:
|
|
size = int(size_str[:-1]) * sect_1mb
|
|
else:
|
|
size = int(size_str)
|
|
u_boot_utils.run_and_log(
|
|
cons,
|
|
f"cgpt add -i {part['num']} -b {ptr} -s {size} -t {part['type']} {fname}")
|
|
ptr += size
|
|
|
|
u_boot_utils.run_and_log(cons, f'cgpt boot -p {fname}')
|
|
out = u_boot_utils.run_and_log(cons, f'cgpt show -q {fname}')
|
|
'''We expect something like this:
|
|
8239 2048 1 Basic data
|
|
45 2048 2 ChromeOS kernel
|
|
8238 1 3 ChromeOS rootfs
|
|
2093 2048 4 ChromeOS kernel
|
|
8237 1 5 ChromeOS rootfs
|
|
41 1 6 ChromeOS kernel
|
|
42 1 7 ChromeOS rootfs
|
|
4141 2048 8 Basic data
|
|
43 1 9 ChromeOS reserved
|
|
44 1 10 ChromeOS reserved
|
|
40 1 11 ChromeOS firmware
|
|
6189 2048 12 EFI System Partition
|
|
'''
|
|
|
|
# Create a dict (indexed by partition number) containing the above info
|
|
for line in out.splitlines():
|
|
start, size, num, name = line.split(maxsplit=3)
|
|
parts[int(num)] = Partition(int(start), int(size), name)
|
|
|
|
dummy = os.path.join(cons.config.result_dir, 'dummy.txt')
|
|
with open(dummy, 'wb') as outf:
|
|
outf.write(b'dummy\n')
|
|
|
|
# For now we just use dummy kernels. This limits testing to just detecting
|
|
# a signed kernel. We could add support for the x86 data structures so that
|
|
# testing could cover getting the cmdline, setup.bin and other pieces.
|
|
kern = os.path.join(cons.config.result_dir, 'kern.bin')
|
|
with open(kern, 'wb') as outf:
|
|
outf.write(b'kernel\n')
|
|
|
|
with open(fname, 'rb') as inf:
|
|
disk_data = inf.read()
|
|
|
|
# put x86 kernel in partition 2 and arm one in partition 4
|
|
set_part_data(2, pack_kernel(cons, 'x86', kern, dummy))
|
|
set_part_data(4, pack_kernel(cons, 'arm', kern, dummy))
|
|
|
|
with open(fname, 'wb') as outf:
|
|
outf.write(disk_data)
|
|
|
|
return fname
|
|
|
|
|
|
def setup_cedit_file(cons):
|
|
infname = os.path.join(cons.config.source_dir,
|
|
'test/boot/files/expo_layout.dts')
|
|
inhname = os.path.join(cons.config.source_dir,
|
|
'test/boot/files/expo_ids.h')
|
|
expo_tool = os.path.join(cons.config.source_dir, 'tools/expo.py')
|
|
outfname = 'cedit.dtb'
|
|
u_boot_utils.run_and_log(
|
|
cons, f'{expo_tool} -e {inhname} -l {infname} -o {outfname}')
|
|
|
|
@pytest.mark.buildconfigspec('ut_dm')
|
|
def test_ut_dm_init(u_boot_console):
|
|
"""Initialize data for ut dm tests."""
|
|
|
|
fn = u_boot_console.config.source_dir + '/testflash.bin'
|
|
if not os.path.exists(fn):
|
|
data = b'this is a test'
|
|
data += b'\x00' * ((4 * 1024 * 1024) - len(data))
|
|
with open(fn, 'wb') as fh:
|
|
fh.write(data)
|
|
|
|
fn = u_boot_console.config.source_dir + '/spi.bin'
|
|
if not os.path.exists(fn):
|
|
data = b'\x00' * (2 * 1024 * 1024)
|
|
with open(fn, 'wb') as fh:
|
|
fh.write(data)
|
|
|
|
# Create a file with a single partition
|
|
fn = u_boot_console.config.source_dir + '/scsi.img'
|
|
if not os.path.exists(fn):
|
|
data = b'\x00' * (2 * 1024 * 1024)
|
|
with open(fn, 'wb') as fh:
|
|
fh.write(data)
|
|
u_boot_utils.run_and_log(
|
|
u_boot_console, f'sfdisk {fn}', stdin=b'type=83')
|
|
|
|
fs_helper.mk_fs(u_boot_console.config, 'ext2', 0x200000, '2MB')
|
|
fs_helper.mk_fs(u_boot_console.config, 'fat32', 0x100000, '1MB')
|
|
|
|
mmc_dev = 6
|
|
fn = os.path.join(u_boot_console.config.source_dir, f'mmc{mmc_dev}.img')
|
|
data = b'\x00' * (12 * 1024 * 1024)
|
|
with open(fn, 'wb') as fh:
|
|
fh.write(data)
|
|
|
|
@pytest.mark.buildconfigspec('cmd_bootflow')
|
|
def test_ut_dm_init_bootstd(u_boot_console):
|
|
"""Initialise data for bootflow tests"""
|
|
|
|
setup_bootflow_image(u_boot_console)
|
|
setup_bootmenu_image(u_boot_console)
|
|
setup_cedit_file(u_boot_console)
|
|
setup_cros_image(u_boot_console)
|
|
|
|
# Restart so that the new mmc1.img is picked up
|
|
u_boot_console.restart_uboot()
|
|
|
|
|
|
def test_ut(u_boot_console, ut_subtest):
|
|
"""Execute a "ut" subtest.
|
|
|
|
The subtests are collected in function generate_ut_subtest() from linker
|
|
generated lists by applying a regular expression to the lines of file
|
|
u-boot.sym. The list entries are created using the C macro UNIT_TEST().
|
|
|
|
Strict naming conventions have to be followed to match the regular
|
|
expression. Use UNIT_TEST(foo_test_bar, _flags, foo_test) for a test bar in
|
|
test suite foo that can be executed via command 'ut foo bar' and is
|
|
implemented in C function foo_test_bar().
|
|
|
|
Args:
|
|
u_boot_console (ConsoleBase): U-Boot console
|
|
ut_subtest (str): test to be executed via command ut, e.g 'foo bar' to
|
|
execute command 'ut foo bar'
|
|
"""
|
|
|
|
if ut_subtest == 'hush hush_test_simple_dollar':
|
|
# ut hush hush_test_simple_dollar prints "Unknown command" on purpose.
|
|
with u_boot_console.disable_check('unknown_command'):
|
|
output = u_boot_console.run_command('ut ' + ut_subtest)
|
|
assert('Unknown command \'quux\' - try \'help\'' in output)
|
|
else:
|
|
output = u_boot_console.run_command('ut ' + ut_subtest)
|
|
assert output.endswith('Failures: 0')
|