def random_access_mmu_stress(_, target): test_harness.build_program(['random_access.S']) test_harness.run_program( target=target, dump_file='obj/vmem.bin', dump_base=DUMP_BASE, dump_length=MEMORY_SIZE * NUM_THREADS, timeout=240, flush_l2=True) # Check that threads have written proper values with open('obj/vmem.bin', 'rb') as memfile: for page_num in range(int(MEMORY_SIZE / PAGE_SIZE)): for thread_id in range(NUM_THREADS): for page_offset in range(0, PAGE_SIZE, 4): val = memfile.read(4) if len(val) < 4: raise test_harness.TestException( 'output file is truncated') num_val, = struct.unpack('<L', val) va = page_num * PAGE_SIZE + \ page_offset + int(DUMP_BASE / 4) expected = (thread_id << 24) | va if num_val != expected: raise test_harness.TestException( 'FAIL: mismatch @{:x} : got {:x} expected {:x}'.format((page_num * 4 + thread_id) * PAGE_SIZE, num_val, expected))
def random_access_mmu_stress(_, target): hex_file = test_harness.build_program(['random_access.S']) test_harness.run_program(hex_file, target, dump_file=MEM_DUMP_FILE, dump_base=DUMP_BASE, dump_length=MEMORY_SIZE * NUM_THREADS, timeout=240, flush_l2=True) # Check that threads have written proper values with open(MEM_DUMP_FILE, 'rb') as memfile: for page_num in range(int(MEMORY_SIZE / PAGE_SIZE)): for thread_id in range(NUM_THREADS): for page_offset in range(0, PAGE_SIZE, 4): val = memfile.read(4) if len(val) < 4: raise test_harness.TestException( 'output file is truncated') num_val, = struct.unpack('<L', val) va = page_num * PAGE_SIZE + \ page_offset + int(DUMP_BASE / 4) expected = (thread_id << 24) | va if num_val != expected: raise test_harness.TestException( 'FAIL: mismatch @{:x} : got {:x} expected {:x}'. format((page_num * 4 + thread_id) * PAGE_SIZE, num_val, expected))
def sdmmc_read(name, target): # Create random file with open(SOURCE_BLOCK_DEV, 'wb') as randfile: randfile.write(os.urandom(FILE_SIZE)) test_harness.build_program(['sdmmc_read.c']) test_harness.run_program(target=target, block_device=SOURCE_BLOCK_DEV, dump_file=MEMDUMP, dump_base=0x200000, dump_length=FILE_SIZE, flush_l2=True) test_harness.assert_files_equal(SOURCE_BLOCK_DEV, MEMDUMP, 'file mismatch')
def sdmmc_read(name, target): # Create random file with open(SOURCE_BLOCK_DEV, 'wb') as randfile: randfile.write(os.urandom(FILE_SIZE)) test_harness.build_program(['sdmmc_read.c']) test_harness.run_program( target=target, block_device=SOURCE_BLOCK_DEV, dump_file=MEMDUMP, dump_base=0x200000, dump_length=FILE_SIZE, flush_l2=True) test_harness.assert_files_equal(SOURCE_BLOCK_DEV, MEMDUMP, 'file mismatch')
def sdmmc_read(name): # Create random file with open(SOURCE_BLOCK_DEV, 'wb') as randfile: randfile.write(os.urandom(FILE_SIZE)) test_harness.build_program(['sdmmc_read.c']) test_harness.run_program( environment='emulator' if name.endswith('_emulator') else 'verilator', block_device=SOURCE_BLOCK_DEV, dump_file=MEMDUMP, dump_base=0x200000, dump_length=FILE_SIZE, flush_l2=True) test_harness.assert_files_equal(SOURCE_BLOCK_DEV, MEMDUMP, 'file mismatch')
def run_io_interrupt(_, target): hex_file = test_harness.build_program(['io_interrupt.S']) result = test_harness.run_program(hex_file, target) lines = result.split('\n') output = None for line in lines: start = line.find('!') if start != -1: output = line[start + 1:] if output is None: raise test_harness.TestException( 'Could not find output string:\n' + result) # Make sure enough interrupts were triggered if output.count('*') < 2: raise test_harness.TestException( 'Not enough interrupts triggered:\n' + result) # Make sure we see at least some of the base string printed after an # interrupt if output.find('*') >= len(output) - 1: raise test_harness.TestException( 'No instances of interrupt return:\n' + result) # Remove all asterisks (interrupts) and make sure string is intact stripped = output.replace('*', '') if stripped != '0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`' \ 'abcdefghijklmnopqrstuvwxyz' * 10: raise test_harness.TestException( 'Base string does not match:\n' + stripped)
def sdmmc_write(_, target): with open(SOURCE_BLOCK_DEV, 'wb') as fsimage: fsimage.write(b'\xcc' * 1536) test_harness.build_program(['sdmmc_write.c']) result = test_harness.run_program(target=target, block_device=SOURCE_BLOCK_DEV) if 'FAIL' in result: raise test_harness.TestException('Test failed ' + result) with open(SOURCE_BLOCK_DEV, 'rb') as fsimage: end_contents = fsimage.read() # Check contents. First block is not modified for index in range(512): if end_contents[index] != 0xcc: raise test_harness.TestException( 'mismatch at {} expected 0xcc got 0x{:02x}'.format( index, end_contents[index])) # Second block has a pattern in it for index in range(512): expected = (index ^ (index >> 3)) & 0xff if end_contents[index + 512] != expected: raise test_harness.TestException( 'mismatch at {} expected 0x{:02x} got 0x{:02x}'.format( index + 512, expected, end_contents[index + 512])) # Third block is not modified for index in range(512): if end_contents[index + 1024] != 0xcc: raise test_harness.TestException( 'mismatch at {} expected 0xcc got 0x{:02x}'.format( index + 1024, end_contents[index + 1024]))
def sdmmc_write(_, target): with open(SOURCE_BLOCK_DEV, 'wb') as fsimage: fsimage.write(b'\xcc' * 1536) test_harness.build_program(['sdmmc_write.c']) result = test_harness.run_program( target=target, block_device=SOURCE_BLOCK_DEV) if 'FAIL' in result: raise test_harness.TestException('Test failed ' + result) with open(SOURCE_BLOCK_DEV, 'rb') as fsimage: end_contents = fsimage.read() # Check contents. First block is not modified for index in range(512): if end_contents[index] != 0xcc: raise test_harness.TestException('mismatch at {} expected 0xcc got 0x{:02x}' .format(index, end_contents[index])) # Second block has a pattern in it for index in range(512): expected = (index ^ (index >> 3)) & 0xff if end_contents[index + 512] != expected: raise test_harness.TestException('mismatch at {} expected 0x{:02x} got 0x{:02x}' .format(index + 512, expected, end_contents[index + 512])) # Third block is not modified for index in range(512): if end_contents[index + 1024] != 0xcc: raise test_harness.TestException('mismatch at {} expected 0xcc got 0x{:02x}' .format(index + 1024, end_contents[index + 1024]))
def atomic(_, target): test_harness.build_program(['atomic.S']) test_harness.run_program(target=target, dump_file=test_harness.WORK_DIR + '/vmem.bin', dump_base=0x100000, dump_length=0x800, flush_l2=True) with open(test_harness.WORK_DIR + '/vmem.bin', 'rb') as memfile: for _ in range(512): val = memfile.read(4) if len(val) < 4: raise test_harness.TestException('output file is truncated') num_val, = struct.unpack('<L', val) if num_val != 10: raise test_harness.TestException('FAIL: mismatch: ' + str(num_val))
def dflush(_): test_harness.build_program(['dflush.S']) test_harness.run_program( environment='verilator', dump_file='obj/vmem.bin', dump_base=BASE_ADDRESS, dump_length=0x40000) with open('obj/vmem.bin', 'rb') as memfile: for index in range(4096): val = memfile.read(4) if len(val) < 4: raise test_harness.TestException('output file is truncated') num_val, = struct.unpack('<L', val) expected = 0x1f0e6231 + (index // 16) if num_val != expected: raise test_harness.TestException('FAIL: mismatch at ' + hex( BASE_ADDRESS + (index * 4)) + ' want ' + str(expected) + ' got ' + str(num_val))
def dflush(_, target): test_harness.build_program(['dflush.S']) test_harness.run_program( target=target, dump_file='obj/vmem.bin', dump_base=BASE_ADDRESS, dump_length=0x40000) with open('obj/vmem.bin', 'rb') as memfile: for index in range(4096): val = memfile.read(4) if len(val) < 4: raise test_harness.TestException('output file is truncated') num_val, = struct.unpack('<L', val) expected = 0x1f0e6231 + (index // 16) if num_val != expected: raise test_harness.TestException('FAIL: mismatch at ' + hex( BASE_ADDRESS + (index * 4)) + ' want ' + str(expected) + ' got ' + str(num_val))
def run_compiler_test(source_file, target): if target == 'host': subprocess.check_call(['cc', source_file, '-o', 'obj/a.out'], stderr=subprocess.STDOUT) result = subprocess.check_output('obj/a.out') test_harness.check_result(source_file, result.decode()) else: test_harness.build_program([source_file]) result = test_harness.run_program(target) test_harness.check_result(source_file, result)
def run_compiler_test(source_file, target): if target == 'host': subprocess.check_call(['cc', source_file, '-o', HOST_EXE_FILE], stderr=subprocess.STDOUT) result = subprocess.check_output(HOST_EXE_FILE) test_harness.check_result(source_file, result.decode()) else: hex_file = test_harness.build_program([source_file]) result = test_harness.run_program(hex_file, target) test_harness.check_result(source_file, result)
def dflush(_, target): hex_file = test_harness.build_program(['dflush.S']) test_harness.run_program(hex_file, target, dump_file=MEM_DUMP_FILE, dump_base=BASE_ADDRESS, dump_length=0x40000) with open(MEM_DUMP_FILE, 'rb') as memfile: for index in range(4096): val = memfile.read(4) if len(val) < 4: raise test_harness.TestException('output file is truncated') num_val, = struct.unpack('<L', val) expected = 0x1f0e6231 + (index // 16) if num_val != expected: raise test_harness.TestException( 'FAIL: mismatch at 0x{:x} want {} got {}'.format( BASE_ADDRESS + (index * 4), expected, num_val))
def dflush(_, target): hex_file = test_harness.build_program(['dflush.S']) test_harness.run_program( hex_file, target, dump_file=MEM_DUMP_FILE, dump_base=BASE_ADDRESS, dump_length=0x40000) with open(MEM_DUMP_FILE, 'rb') as memfile: for index in range(4096): val = memfile.read(4) if len(val) < 4: raise test_harness.TestException('output file is truncated') num_val, = struct.unpack('<L', val) expected = 0x1f0e6231 + (index // 16) if num_val != expected: raise test_harness.TestException('FAIL: mismatch at 0x{:x} want {} got {}'.format( BASE_ADDRESS + (index * 4), expected, num_val))
def atomic(_, target): test_harness.build_program(['atomic.S']) test_harness.run_program( target=target, dump_file=test_harness.WORK_DIR + '/vmem.bin', dump_base=0x100000, dump_length=0x800, flush_l2=True) with open(test_harness.WORK_DIR + '/vmem.bin', 'rb') as memfile: for _ in range(512): val = memfile.read(4) if len(val) < 4: raise test_harness.TestException('output file is truncated') num_val, = struct.unpack('<L', val) if num_val != 10: raise test_harness.TestException( 'FAIL: mismatch: ' + str(num_val))
def profile(*unused): hexfile = test_harness.build_program(['test_program.c']) # XXX hack: this is currently not returned from build_program, but I # know what the name is. elffile = hexfile.replace('.hex', '.elf') profile_file = os.path.join(test_harness.WORK_DIR, 'profile.out') test_harness.run_program(hexfile, 'verilator', profile_file=profile_file) symbol_file = os.path.join(test_harness.WORK_DIR, 'symbols.txt') objdump_args = [ os.path.join(test_harness.COMPILER_BIN_DIR, 'llvm-objdump'), '-t', elffile ] symbols = subprocess.check_output(objdump_args) with open(symbol_file, 'w') as f: f.write(symbols.decode()) profile_args = [ os.path.join(test_harness.TOOL_BIN_DIR, 'profile.py'), symbol_file, profile_file ] profile_output = subprocess.check_output(' '.join(profile_args), shell=True) profile_lines = profile_output.decode().split('\n') profile_tuples = [line.split() for line in profile_lines if line] profile_map = {func: int(count) for count, _, func in profile_tuples} # These tests don't end up being exactly 2x the number of samples. Because # the system samples randomly, it can vary. I could have ran the test longer # to get more samples, but this is really just a smoke test and I didn't want # to bloat the test time unnecessarily. loop5k = profile_map['loop5000'] loop10k = profile_map['loop10000'] loop20k = profile_map['loop20000'] test_harness.assert_greater(loop5k, 0) test_harness.assert_greater(loop10k, loop5k * 1.75) test_harness.assert_greater(loop20k, loop10k * 1.75)
def run_csmith_test(_, target): # Find version of csmith result = subprocess.check_output(['csmith', '-v']).decode() got = VERSION_RE.search(result) if not got: raise test_harness.TestException( 'Could not determine csmith version ' + result) version_str = got.group('version') csmith_include = '-I/usr/local/include/csmith-' + version_str for x in range(100): source_file = 'test%04d.c' % x print('running ' + source_file) # Disable packed structs because we don't support unaligned accesses. # Disable longlong to avoid incompatibilities between 32-bit Nyuzi # and 64-bit hosts. subprocess.check_call([ 'csmith', '-o', source_file, '--no-longlong', '--no-packed-struct' ]) # Compile and run on host subprocess.check_call([ 'cc', '-w', source_file, '-o', test_harness.WORK_DIR + '/a.out', csmith_include ]) result = subprocess.check_output(test_harness.WORK_DIR + '/a.out').decode() got = CHECKSUM_RE.search(result) if not got: raise test_harness.TestException('no checksum in host output') host_checksum = int(got.group('checksum'), 16) print('host checksum %08x' % host_checksum) # Compile and run under emulator test_harness.build_program([source_file], cflags=[csmith_include]) result = test_harness.run_program(target) got = CHECKSUM_RE.search(result) if not got: raise test_harness.TestException('no checksum in host output') emulator_checksum = int(got.group('checksum'), 16) print('emulator checksum %08x' % emulator_checksum) if host_checksum != emulator_checksum: raise test_harness.TestException('checksum mismatch') print('PASS')
def filesystem(_, target): ''' Filesystem tests. This creates a filesystem image with the test file fstest.txt in it, the compiles the program fs.c to perform operations on it. The program will print 'PASS' if it is successful. ''' test_harness.build_program(['fs.c']) subprocess.check_output( [test_harness.BIN_DIR + 'mkfs', test_harness.WORK_DIR + '/fsimage.bin', 'fstest.txt'], stderr=subprocess.STDOUT) result = test_harness.run_program(target=target, block_device=test_harness.WORK_DIR + '/fsimage.bin') if 'PASS' not in result or 'FAIL' in result: raise test_harness.TestException( 'test program did not indicate pass\n' + result)
def filesystem(_): ''' Filesystem tests. This creates a filesystem image with the test file fstest.txt in it, the compiles the program fs.c to perform operations on it. The program will print 'PASS' if it is successful. ''' test_harness.build_program(['fs.c']) subprocess.check_output( [test_harness.PROJECT_TOP + '/bin/mkfs', 'obj/fsimage.bin', 'fstest.txt'], stderr=subprocess.STDOUT) result = test_harness.run_program(environment='emulator', block_device='obj/fsimage.bin') if 'PASS' not in result: raise test_harness.TestException( 'test program did not indicate pass\n' + result)
def run_csmith_test(_, target): # Find version of csmith result = subprocess.check_output(['csmith', '-v']).decode() got = VERSION_RE.search(result) if not got: raise test_harness.TestException( 'Could not determine csmith version ' + result) version_str = got.group('version') csmith_include = '-I/usr/local/include/csmith-' + version_str for x in range(100): source_file = 'test%04d.c' % x print('running ' + source_file) # Disable packed structs because we don't support unaligned accesses. # Disable longlong to avoid incompatibilities between 32-bit Nyuzi # and 64-bit hosts. subprocess.check_call(['csmith', '-o', source_file, '--no-longlong', '--no-packed-struct']) # Compile and run on host subprocess.check_call( ['cc', '-w', source_file, '-o', test_harness.WORK_DIR + '/a.out', csmith_include]) result = subprocess.check_output( test_harness.WORK_DIR + '/a.out').decode() got = CHECKSUM_RE.search(result) if not got: raise test_harness.TestException('no checksum in host output') host_checksum = int(got.group('checksum'), 16) print('host checksum %08x' % host_checksum) # Compile and run under emulator test_harness.build_program([source_file], cflags=[csmith_include]) result = test_harness.run_program(target) got = CHECKSUM_RE.search(result) if not got: raise test_harness.TestException('no checksum in host output') emulator_checksum = int(got.group('checksum'), 16) print('emulator checksum %08x' % emulator_checksum) if host_checksum != emulator_checksum: raise test_harness.TestException('checksum mismatch') print('PASS')
def filesystem(_): ''' Filesystem tests. This creates a filesystem image with the test file fstest.txt in it, the compiles the program fs.c to perform operations on it. The program will print 'PASS' if it is successful. ''' test_harness.build_program(['fs.c']) subprocess.check_output([ test_harness.PROJECT_TOP + '/bin/mkfs', 'obj/fsimage.bin', 'fstest.txt' ], stderr=subprocess.STDOUT) result = test_harness.run_program(environment='emulator', block_device='obj/fsimage.bin') if 'PASS' not in result: raise test_harness.TestException( 'test program did not indicate pass\n' + result)
def filesystem(_, target): """Test the filesystem implementation in libos. This creates a filesystem image with the test file fstest.txt in it, the compiles the program fs.c to perform operations on it. The program will print 'PASS' if it is successful. """ test_harness.build_program(['fs.c']) subprocess.check_output( [test_harness.BIN_DIR + 'mkfs', test_harness.WORK_DIR + '/fsimage.bin', 'fstest.txt'], stderr=subprocess.STDOUT) result = test_harness.run_program(target=target, block_device=test_harness.WORK_DIR + '/fsimage.bin') if 'PASS' not in result or 'FAIL' in result: raise test_harness.TestException( 'test program did not indicate pass\n' + result)
def run_csmith_test(_): # Find version of csmith result = subprocess.check_output(['csmith', '-v']).decode() got = VERSION_RE.search(result) if not got: raise test_harness.TestException( 'Could not determine csmith version ' + result) version_str = got.group('version') csmith_include = '-I/usr/local/include/csmith-' + version_str for x in range(100): source_file = 'test%04x.c' % x print('running ' + source_file) subprocess.check_call(['csmith', '-o', source_file]) # Compile and run on host subprocess.check_call( ['cc', '-w', source_file, '-o', 'obj/a.out', csmith_include]) result = subprocess.check_output('obj/a.out').decode() got = CHECKSUM_RE.search(result) if not got: raise test_harness.TestException('no checksum in host output') host_checksum = int(got.group('checksum'), 16) print('host checksum %08x' % host_checksum) # Compile and run under emulator test_harness.build_program([source_file], cflags=[csmith_include]) result = test_harness.run_program(environment='emulator') got = CHECKSUM_RE.search(result) if not got: raise test_harness.TestException('no checksum in host output') emulator_checksum = int(got.group('checksum'), 16) print('emulator checksum %08x' % emulator_checksum) if host_checksum != emulator_checksum: raise test_harness.TestException('checksum mismatch') print('PASS')
def filesystem(_, target): """Test the filesystem implementation in libos. This creates a filesystem image with the test file fstest.txt in it, the compiles the program fs.c to perform operations on it. The program will print 'PASS' if it is successful. """ hex_file = test_harness.build_program(['fs.c']) subprocess.check_output([ os.path.join(test_harness.TOOL_BIN_DIR, 'mkfs'), FS_IMAGE_PATH, 'fstest.txt' ], stderr=subprocess.STDOUT) result = test_harness.run_program(hex_file, target, block_device=FS_IMAGE_PATH) if 'PASS' not in result or 'FAIL' in result: raise test_harness.TestException( 'test program did not indicate pass\n' + result)
def dinvalidate(_, target): test_harness.build_program(['dinvalidate.S']) result = test_harness.run_program(target=target, dump_file=MEM_DUMP_FILE, dump_base=0x2000, dump_length=4, flush_l2=True, trace=True) # 1. Check that the proper value was read into s2 if '02 deadbeef' not in result: raise test_harness.TestException('incorrect value was written back ' + result) # 2. Read the memory dump to ensure the proper value is flushed from the # L2 cache with open(MEM_DUMP_FILE, 'rb') as memfile: num_val, = struct.unpack('<L', memfile.read(4)) if num_val != 0xdeadbeef: raise test_harness.TestException( 'memory contents were incorrect: ' + hex(num_val))
def dinvalidate(_): test_harness.build_program(['dinvalidate.S']) result = test_harness.run_program( environment='verilator', dump_file='obj/vmem.bin', dump_base=0x2000, dump_length=4, flush_l2=True, trace=True) # 1. Check that the proper value was read into s2 if '02 deadbeef' not in result: raise test_harness.TestException( 'incorrect value was written back ' + result) # 2. Read the memory dump to ensure the proper value is flushed from the # L2 cache with open('obj/vmem.bin', 'rb') as memfile: num_val, = struct.unpack('<L', memfile.read(4)) if num_val != 0xdeadbeef: raise test_harness.TestException( 'memory contents were incorrect: ' + hex(num_val))
def dinvalidate(_, target): hex_file = test_harness.build_program(['dinvalidate.S']) result = test_harness.run_program( hex_file, target, dump_file=MEM_DUMP_FILE, dump_base=0x2000, dump_length=4, flush_l2=True, trace=True) # 1. Check that the proper value was read into s2 if '02 deadbeef' not in result: raise test_harness.TestException( 'incorrect value was written back ' + result) # 2. Read the memory dump to ensure the proper value is flushed from the # L2 cache with open(MEM_DUMP_FILE, 'rb') as memfile: num_val, = struct.unpack('<L', memfile.read(4)) if num_val != 0xdeadbeef: raise test_harness.TestException( 'memory contents were incorrect: 0x{:x}'.format(num_val))
def verilator_timeout(_): test_harness.build_program(['timeout.c']) test_harness.run_program(environment='verilator', timeout=3)
def timeout(_, target): hex_file = test_harness.build_program(['timeout.c']) test_harness.run_program(hex_file, target, timeout=3)
def run_emulator_test(source_file): test_harness.build_program([source_file]) result = test_harness.run_program(environment='emulator') test_harness.check_result(source_file, result)
def perf_counters(_): test_harness.build_program(['perf_counters.c']) result = test_harness.run_program(environment='verilator') if 'PASS' not in result: raise test_harness.TestException( 'test program did not indicate pass\n' + result)
def timeout(_, target): test_harness.build_program(['timeout.c']) test_harness.run_program(target=target, timeout=3)
def multicore(_): test_harness.build_program(['multicore.c']) result = test_harness.run_program(environment='verilator') if '012345678910111213141516171819202122232425262728293031' not in result.replace('\n', ''): raise test_harness.TestException('Output mismatch:\n' + result)
def dflush_wait(_): test_harness.build_program(['dflush_wait.S']) output = test_harness.run_program(environment='verilator') if 'PASS' not in output: raise test_harness.TestException('Test did not signal pass: ' + output)
def run_test(source_file, target): test_harness.build_program([source_file]) result = test_harness.run_program(target) test_harness.check_result(source_file, result)
def ps2(_, target): hex_file = test_harness.build_program(['ps2.c']) result = test_harness.run_program(hex_file, target) if 'PASS' not in result: raise test_harness.TestException( 'program did not indicate pass\n' + result)
def uart(_): test_harness.build_program(['uart.c']) result = test_harness.run_program(environment='verilator') if 'PASS' not in result: raise test_harness.TestException( 'test did not indicate pass\n' + result)
def iinvalidate(_): test_harness.build_program(['iinvalidate.S']) output = test_harness.run_program(environment='verilator') if 'PASS' not in output: raise test_harness.TestException('Test did not signal pass: ' + output)
def uart(_, target): test_harness.build_program(['uart.c']) result = test_harness.run_program(target) if 'PASS' not in result: raise test_harness.TestException( 'test did not indicate pass\n' + result)
def multicore(_, target): hex_file = test_harness.build_program(['multicore.S']) result = test_harness.run_program(hex_file, target) if 'ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`' not in result: raise test_harness.TestException('Output mismatch:\n' + result)
def dflush_wait(_, target): test_harness.build_program(['dflush_wait.S']) output = test_harness.run_program(target) if 'PASS' not in output: raise test_harness.TestException('Test did not signal pass: ' + output)
def uart_hw_test(*unused): hex_file = test_harness.build_program(['uart_hw_test.c']) result = test_harness.run_program(hex_file, 'verilator') if 'PASS' not in result: raise test_harness.TestException( 'test did not indicate pass\n' + result)
def uart_hw_test(*unused): test_harness.build_program(['uart_hw_test.c']) result = test_harness.run_program(target='verilator') if 'PASS' not in result: raise test_harness.TestException('test did not indicate pass\n' + result)
def perf_counters(_, target): test_harness.build_program(['perf_counters.c']) result = test_harness.run_program(target) if 'PASS' not in result: raise test_harness.TestException( 'test program did not indicate pass\n' + result)
def iinvalidate(_, target): hex_file = test_harness.build_program(['iinvalidate.S']) output = test_harness.run_program(hex_file, target) if 'PASS' not in output: raise test_harness.TestException('Test did not signal pass: ' + output)
def ps2(_, target): test_harness.build_program(['ps2.c']) result = test_harness.run_program(target) if 'PASS' not in result: raise test_harness.TestException('program did not indicate pass\n' + result)
def dflush_wait(_, target): hex_file = test_harness.build_program(['dflush_wait.S']) output = test_harness.run_program(hex_file, target) if 'PASS' not in output: raise test_harness.TestException('Test did not signal pass: ' + output)
def iinvalidate(_, target): test_harness.build_program(['iinvalidate.S']) output = test_harness.run_program(target) if 'PASS' not in output: raise test_harness.TestException('Test did not signal pass: ' + output)