16 print_log_names
= False
17 real_stdout
= sys
.stdout
19 # Note that gdb comes with its own testsuite. I was unable to figure out how to
20 # run that testsuite against the spike simulator.
23 for directory
in (os
.getcwd(), os
.path
.dirname(__file__
)):
24 fullpath
= os
.path
.join(directory
, path
)
25 relpath
= os
.path
.relpath(fullpath
)
26 if len(relpath
) >= len(fullpath
):
28 if os
.path
.exists(relpath
):
32 def compile(args
, xlen
=32): # pylint: disable=redefined-builtin
33 cc
= os
.path
.expandvars("$RISCV/bin/riscv64-unknown-elf-gcc")
36 cmd
.append("-march=rv32imac")
37 cmd
.append("-mabi=ilp32")
39 cmd
.append("-march=rv64imac")
40 cmd
.append("-mabi=lp64")
42 found
= find_file(arg
)
48 print "+", " ".join(cmd
)
49 process
= subprocess
.Popen(cmd
, stdout
=subprocess
.PIPE
,
50 stderr
=subprocess
.PIPE
)
51 stdout
, stderr
= process
.communicate()
52 if process
.returncode
:
56 raise Exception("Compile failed!")
59 def __init__(self
, target
, halted
=False, timeout
=None, with_jtag_gdb
=True,
60 isa
=None, progbufsize
=None):
61 """Launch spike. Return tuple of its process and the port it's running
65 self
.progbufsize
= progbufsize
72 cmd
= self
.command(target
, harts
, halted
, timeout
, with_jtag_gdb
)
73 self
.infinite_loop
= target
.compile(harts
[0],
74 "programs/checksum.c", "programs/tiny-malloc.c",
75 "programs/infinite_loop.S", "-DDEFINE_MALLOC", "-DDEFINE_FREE")
76 cmd
.append(self
.infinite_loop
)
77 self
.logfile
= tempfile
.NamedTemporaryFile(prefix
="spike-",
79 self
.logname
= self
.logfile
.name
81 real_stdout
.write("Temporary spike log: %s\n" % self
.logname
)
82 self
.logfile
.write("+ %s\n" % " ".join(cmd
))
84 self
.process
= subprocess
.Popen(cmd
, stdin
=subprocess
.PIPE
,
85 stdout
=self
.logfile
, stderr
=self
.logfile
)
90 m
= re
.search(r
"Listening for remote bitbang connection on "
91 r
"port (\d+).", open(self
.logname
).read())
93 self
.port
= int(m
.group(1))
94 os
.environ
['REMOTE_BITBANG_PORT'] = m
.group(1)
98 print_log(self
.logname
)
99 raise Exception("Didn't get spike message about bitbang "
102 def command(self
, target
, harts
, halted
, timeout
, with_jtag_gdb
):
103 # pylint: disable=no-self-use
105 cmd
= shlex
.split(target
.sim_cmd
)
107 spike
= os
.path
.expandvars("$RISCV/bin/spike")
110 cmd
+= ["-p%d" % len(harts
)]
112 assert len(set(t
.xlen
for t
in harts
)) == 1, \
113 "All spike harts must have the same XLEN"
118 isa
= "RV%dG" % harts
[0].xlen
120 cmd
+= ["--isa", isa
]
121 cmd
+= ["--debug-auth"]
123 if not self
.progbufsize
is None:
124 cmd
+= ["--progsize", str(self
.progbufsize
)]
125 cmd
+= ["--debug-sba", "32"]
127 assert len(set(t
.ram
for t
in harts
)) == 1, \
128 "All spike harts must have the same RAM layout"
129 assert len(set(t
.ram_size
for t
in harts
)) == 1, \
130 "All spike harts must have the same RAM layout"
131 cmd
+= ["-m0x%x:0x%x" % (harts
[0].ram
, harts
[0].ram_size
)]
134 cmd
= ["timeout", str(timeout
)] + cmd
139 cmd
+= ['--rbb-port', '0']
140 os
.environ
['REMOTE_BITBANG_HOST'] = 'localhost'
152 def wait(self
, *args
, **kwargs
):
153 return self
.process
.wait(*args
, **kwargs
)
155 class VcsSim(object):
156 logfile
= tempfile
.NamedTemporaryFile(prefix
='simv', suffix
='.log')
157 logname
= logfile
.name
159 def __init__(self
, sim_cmd
=None, debug
=False, timeout
=300):
161 cmd
= shlex
.split(sim_cmd
)
164 cmd
+= ["+jtag_vpi_enable"]
166 cmd
[0] = cmd
[0] + "-debug"
167 cmd
+= ["+vcdplusfile=output/gdbserver.vpd"]
169 logfile
= open(self
.logname
, "w")
171 real_stdout
.write("Temporary VCS log: %s\n" % self
.logname
)
172 logfile
.write("+ %s\n" % " ".join(cmd
))
175 listenfile
= open(self
.logname
, "r")
176 listenfile
.seek(0, 2)
177 self
.process
= subprocess
.Popen(cmd
, stdin
=subprocess
.PIPE
,
178 stdout
=logfile
, stderr
=logfile
)
182 # Fail if VCS exits early
183 exit_code
= self
.process
.poll()
184 if exit_code
is not None:
185 raise RuntimeError('VCS simulator exited early with status %d'
188 line
= listenfile
.readline()
191 match
= re
.match(r
"^Listening on port (\d+)$", line
)
194 self
.port
= int(match
.group(1))
195 os
.environ
['JTAG_VPI_PORT'] = str(self
.port
)
197 if (time
.time() - start
) > timeout
:
198 raise Exception("Timed out waiting for VCS to listen for JTAG "
208 class Openocd(object):
209 logfile
= tempfile
.NamedTemporaryFile(prefix
='openocd', suffix
='.log')
210 logname
= logfile
.name
212 def __init__(self
, server_cmd
=None, config
=None, debug
=False, timeout
=60):
213 self
.timeout
= timeout
216 cmd
= shlex
.split(server_cmd
)
218 openocd
= os
.path
.expandvars("$RISCV/bin/openocd")
223 # This command needs to come before any config scripts on the command
224 # line, since they are executed in order.
226 # Tell OpenOCD to bind gdb to an unused, ephemeral port.
229 # Disable tcl and telnet servers, since they are unused and because
230 # the port numbers will conflict if multiple OpenOCD processes are
231 # running on the same server.
235 "telnet_port disabled",
239 f
= find_file(config
)
241 print "Unable to read file " + config
248 logfile
= open(Openocd
.logname
, "w")
250 real_stdout
.write("Temporary OpenOCD log: %s\n" % Openocd
.logname
)
251 env_entries
= ("REMOTE_BITBANG_HOST", "REMOTE_BITBANG_PORT")
252 env_entries
= [key
for key
in env_entries
if key
in os
.environ
]
253 logfile
.write("+ %s%s\n" % (
254 "".join("%s=%s " % (key
, os
.environ
[key
]) for key
in env_entries
),
255 " ".join(map(pipes
.quote
, cmd
))))
259 self
.process
= self
.start(cmd
, logfile
)
261 def start(self
, cmd
, logfile
):
262 process
= subprocess
.Popen(cmd
, stdin
=subprocess
.PIPE
,
263 stdout
=logfile
, stderr
=logfile
)
266 # Wait for OpenOCD to have made it through riscv_examine(). When
267 # using OpenOCD to communicate with a simulator this may take a
268 # long time, and gdb will time out when trying to connect if we
272 fd
= open(Openocd
.logname
, "r")
276 if not process
.poll() is None:
277 raise Exception("OpenOCD exited early.")
281 m
= re
.search(r
"Listening on port (\d+) for gdb connections",
284 self
.gdb_ports
.append(int(m
.group(1)))
286 if "telnet server disabled" in line
:
289 if not messaged
and time
.time() - start
> 1:
291 print "Waiting for OpenOCD to start..."
292 if (time
.time() - start
) > self
.timeout
:
293 raise Exception("Timed out waiting for OpenOCD to "
297 print_log(Openocd
.logname
)
304 except (OSError, AttributeError):
307 class OpenocdCli(object):
308 def __init__(self
, port
=4444):
309 self
.child
= pexpect
.spawn(
310 "sh -c 'telnet localhost %d | tee openocd-cli.log'" % port
)
311 self
.child
.expect("> ")
313 def command(self
, cmd
):
314 self
.child
.sendline(cmd
)
315 self
.child
.expect(cmd
)
316 self
.child
.expect("\n")
317 self
.child
.expect("> ")
318 return self
.child
.before
.strip("\t\r\n \0")
320 def reg(self
, reg
=''):
321 output
= self
.command("reg %s" % reg
)
322 matches
= re
.findall(r
"(\w+) \(/\d+\): (0x[0-9A-F]+)", output
)
323 values
= {r
: int(v
, 0) for r
, v
in matches
}
328 def load_image(self
, image
):
329 output
= self
.command("load_image %s" % image
)
330 if 'invalid ELF file, only 32bits files are supported' in output
:
331 raise TestNotApplicable(output
)
333 class CannotAccess(Exception):
334 def __init__(self
, address
):
335 Exception.__init
__(self
)
336 self
.address
= address
338 class CouldNotFetch(Exception):
339 def __init__(self
, regname
, explanation
):
340 Exception.__init
__(self
)
341 self
.regname
= regname
342 self
.explanation
= explanation
344 Thread
= collections
.namedtuple('Thread', ('id', 'description', 'target_id',
348 """A single gdb class which can interact with one or more gdb instances."""
350 # pylint: disable=too-many-public-methods
351 # pylint: disable=too-many-instance-attributes
353 def __init__(self
, ports
,
354 cmd
=os
.path
.expandvars("$RISCV/bin/riscv64-unknown-elf-gdb"),
355 timeout
=60, binary
=None):
360 self
.timeout
= timeout
369 logfile
= tempfile
.NamedTemporaryFile(prefix
="gdb@%d-" % port
,
371 self
.logfiles
.append(logfile
)
373 real_stdout
.write("Temporary gdb log: %s\n" % logfile
.name
)
374 child
= pexpect
.spawn(cmd
)
375 child
.logfile
= logfile
376 child
.logfile
.write("+ %s\n" % cmd
)
377 self
.children
.append(child
)
378 self
.active_child
= self
.children
[0]
381 for port
, child
in zip(self
.ports
, self
.children
):
382 self
.select_child(child
)
384 self
.command("set confirm off")
385 self
.command("set width 0")
386 self
.command("set height 0")
388 self
.command("set print entry-values no")
389 self
.command("set remotetimeout %d" % self
.timeout
)
390 self
.command("target extended-remote localhost:%d" % port
)
392 self
.command("file %s" % self
.binary
)
393 threads
= self
.threads()
397 m
= re
.search(r
"Hart (\d+)", t
.name
)
399 hartid
= int(m
.group(1))
402 hartid
= max(self
.harts
) + 1
405 # solo: True iff this is the only thread on this child
406 self
.harts
[hartid
] = {'child': child
,
408 'solo': len(threads
) == 1}
411 for child
in self
.children
:
414 def one_hart_per_gdb(self
):
415 return all(h
['solo'] for h
in self
.harts
.itervalues())
418 return [logfile
.name
for logfile
in self
.logfiles
]
420 def select_child(self
, child
):
421 self
.active_child
= child
423 def select_hart(self
, hart
):
424 h
= self
.harts
[hart
.id]
425 self
.select_child(h
['child'])
427 output
= self
.command("thread %s" % h
['thread'].id, ops
=5)
428 assert "Unknown" not in output
430 def push_state(self
):
432 'active_child': self
.active_child
436 state
= self
.stack
.pop()
437 self
.active_child
= state
['active_child']
440 """Wait for prompt."""
441 self
.active_child
.expect(r
"\(gdb\)")
443 def command(self
, command
, ops
=1):
444 """ops is the estimated number of operations gdb will have to perform
445 to perform this command. It is used to compute a timeout based on
447 timeout
= ops
* self
.timeout
448 self
.active_child
.sendline(command
)
449 self
.active_child
.expect("\n", timeout
=timeout
)
450 self
.active_child
.expect(r
"\(gdb\)", timeout
=timeout
)
451 return self
.active_child
.before
.strip()
453 def global_command(self
, command
):
454 """Execute this command on every gdb that we control."""
455 with
PrivateState(self
):
456 for child
in self
.children
:
457 self
.select_child(child
)
458 self
.command(command
)
460 def c(self
, wait
=True, async=False):
463 In RTOS mode, gdb will resume all harts.
464 In multi-gdb mode, this command will just go to the current gdb, so
465 will only resume one hart.
473 output
= self
.command("c%s" % async, ops
=ops
)
474 assert "Continuing" in output
477 self
.active_child
.sendline("c%s" % async)
478 self
.active_child
.expect("Continuing", timeout
=ops
* self
.timeout
)
480 def c_all(self
, wait
=True):
484 This function works fine when using multiple gdb sessions, but the
485 caller must be careful when using it nonetheless. gdb's behavior is to
486 not set breakpoints until just before the hart is resumed, and then
487 clears them as soon as the hart halts. That means that you can't set
488 one software breakpoint, and expect multiple harts to hit it. It's
489 possible that the first hart completes set/run/halt/clear before the
490 second hart even gets to resume, so it will never hit the breakpoint.
492 with
PrivateState(self
):
493 for child
in self
.children
:
495 child
.expect("Continuing")
498 for child
in self
.children
:
499 child
.expect(r
"\(gdb\)")
502 self
.active_child
.send("\003")
503 self
.active_child
.expect(r
"\(gdb\)", timeout
=6000)
504 return self
.active_child
.before
.strip()
506 def interrupt_all(self
):
507 for child
in self
.children
:
508 self
.select_child(child
)
511 def x(self
, address
, size
='w'):
512 output
= self
.command("x/%s %s" % (size
, address
))
513 value
= int(output
.split(':')[1].strip(), 0)
516 def p_raw(self
, obj
):
517 output
= self
.command("p %s" % obj
)
518 m
= re
.search("Cannot access memory at address (0x[0-9a-f]+)", output
)
520 raise CannotAccess(int(m
.group(1), 0))
521 return output
.split('=')[-1].strip()
523 def parse_string(self
, text
):
525 if text
.startswith("{") and text
.endswith("}"):
527 return [self
.parse_string(t
) for t
in inner
.split(", ")]
528 elif text
.startswith('"') and text
.endswith('"'):
533 def p(self
, obj
, fmt
="/x"):
534 output
= self
.command("p%s %s" % (fmt
, obj
))
535 m
= re
.search("Cannot access memory at address (0x[0-9a-f]+)", output
)
537 raise CannotAccess(int(m
.group(1), 0))
538 m
= re
.search(r
"Could not fetch register \"(\w
+)\"; (.*)$
", output)
540 raise CouldNotFetch(m.group(1), m.group(2))
541 rhs = output.split('=')[-1]
542 return self.parse_string(rhs)
544 def p_string(self, obj):
545 output = self.command("p
%s" % obj)
546 value = shlex.split(output.split('=')[-1].strip())[1]
550 output = self.command("stepi
", ops=10)
554 output = self.command("load
", ops=1000)
555 assert "failed
" not in output
556 assert "Transfer rate
" in output
557 output = self.command("compare
-sections
", ops=1000)
558 assert "MIS
" not in output
560 def b(self, location):
561 output = self.command("b
%s" % location, ops=5)
562 assert "not defined
" not in output
563 assert "Breakpoint
" in output
566 def hbreak(self, location):
567 output = self.command("hbreak
%s" % location, ops=5)
568 assert "not defined
" not in output
569 assert "Hardware assisted breakpoint
" in output
573 output = self.command("info threads
", ops=100)
575 for line in output.splitlines():
578 r"(Remote target|
Thread (\d
+)\s
*\
(Name
: ([^\
)]+))"
581 threads.append(Thread(*m.groups()))
584 #>>> threads.append(Thread('1', '1', 'Default', '???'))
587 def thread(self, thread):
588 return self.command("thread
%s" % thread.id)
591 return self.command("where
1")
593 class PrivateState(object):
594 def __init__(self, gdb):
598 self.gdb.push_state()
600 def __exit__(self, _type, _value, _traceback):
603 def run_all_tests(module, target, parsed):
605 os.makedirs(parsed.logs)
607 # There's a race where multiple instances of the test program might
608 # decide to create the logs directory at the same time.
611 overall_start = time.time()
613 global gdb_cmd # pylint: disable=global-statement
617 examine_added = False
618 for hart in target.harts:
620 hart.misa = int(parsed.misaval, 16)
621 print "Using $misa
from command line
: 0x
%x" % hart.misa
623 print "Using $misa
from hart definition
: 0x
%x" % hart.misa
624 elif not examine_added:
625 todo.append(("ExamineTarget
", ExamineTarget, None))
628 for name in dir(module):
629 definition = getattr(module, name)
630 if isinstance(definition, type) and hasattr(definition, 'test') and \
631 (not parsed.test or any(test in name for test in parsed.test)):
632 todo.append((name, definition, None))
634 results, count = run_tests(parsed, target, todo)
636 header("ran
%d tests
in %.0fs
" % (count, time.time() - overall_start),
639 return print_results(results)
641 good_results = set(('pass', 'not_applicable'))
642 def run_tests(parsed, target, todo):
646 for name, definition, hart in todo:
647 log_name = os.path.join(parsed.logs, "%s-%s-%s.log
" %
648 (time.strftime("%Y
%m
%d-%H
%M
%S
"), type(target).__name__, name))
649 log_fd = open(log_name, 'w')
650 print "[%s] Starting
> %s" % (name, log_name)
651 instance = definition(target, hart)
653 log_fd.write("Test
: %s\n" % name)
654 log_fd.write("Target
: %s\n" % type(target).__name__)
656 global real_stdout # pylint: disable=global-statement
657 real_stdout = sys.stdout
660 result = instance.run()
661 log_fd.write("Result
: %s\n" % result)
662 log_fd.write("Logfile
: %s\n" % log_name)
663 log_fd.write("Reproduce
: %s %s %s\n" % (sys.argv[0], parsed.target,
666 sys.stdout = real_stdout
667 log_fd.write("Time elapsed
: %.2fs
\n" % (time.time() - start))
669 print "[%s] %s in %.2fs
" % (name, result, time.time() - start)
670 if result not in good_results and parsed.print_failures:
671 sys.stdout.write(open(log_name).read())
673 results.setdefault(result, []).append((name, log_name))
675 if result not in good_results and parsed.fail_fast:
678 return results, count
680 def print_results(results):
682 for key, value in results.iteritems():
683 print "%d tests returned
%s" % (len(value), key)
684 if key not in good_results:
686 for name, log_name in value:
687 print " %s > %s" % (name, log_name)
691 def add_test_run_options(parser):
692 parser.add_argument("--logs
", default="logs
",
693 help="Store logs
in the specified directory
.")
694 parser.add_argument("--fail
-fast
", "-f
", action="store_true
",
695 help="Exit
as soon
as any test fails
.")
696 parser.add_argument("--print-failures
", action="store_true
",
697 help="When a test fails
, print the log
file to stdout
.")
698 parser.add_argument("--print-log
-names
", "--pln
", action="store_true
",
699 help="Print names of temporary log files
as soon
as they are
"
701 parser.add_argument("test
", nargs='*',
702 help="Run only tests that are named here
.")
703 parser.add_argument("--gdb
",
704 help="The command to use to start gdb
.")
705 parser.add_argument("--misaval
",
706 help="Don
't run ExamineTarget, just assume the misa value which is "
709 def header(title, dash='-', length=78):
711 dashes = dash * (length - 4 - len(title))
712 before = dashes[:len(dashes)/2]
713 after = dashes[len(dashes)/2:]
714 print "%s[ %s ]%s" % (before, title, after)
720 for l in open(path, "r"):
724 class BaseTest(object):
727 def __init__(self, target, hart=None):
732 self.hart = random.choice(target.harts)
733 self.hart = target.harts[-1] #<<<
735 self.target_process = None
740 def early_applicable(self):
741 """Return a false value if the test has determined it cannot run
742 without ever needing to talk to the target or server."""
743 # pylint: disable=no-self-use
750 compile_args = getattr(self, 'compile_args
', None)
752 if compile_args not in BaseTest.compiled:
753 BaseTest.compiled[compile_args] = \
754 self.target.compile(self.hart, *compile_args)
755 self.binary = BaseTest.compiled.get(compile_args)
757 def classSetup(self):
759 self.target_process = self.target.create()
760 if self.target_process:
761 self.logs.append(self.target_process.logname)
763 self.server = self.target.server()
764 self.logs.append(self.server.logname)
766 for log in self.logs:
770 def classTeardown(self):
772 del self.target_process
774 def postMortem(self):
779 If compile_args is set, compile a program and set self.binary.
783 Then call test() and return the result, displaying relevant information
784 if an exception is raised.
789 if not self.early_applicable():
790 return "not_applicable"
792 self.start = time.time()
797 result = self.test() # pylint: disable=no-member
798 except TestNotApplicable:
799 result = "not_applicable"
800 except Exception as e: # pylint: disable=broad-except
801 if isinstance(e, TestFailed):
805 if isinstance(e, TestFailed):
809 traceback.print_exc(file=sys.stdout)
812 except Exception as e: # pylint: disable=broad-except
813 header("postMortem Exception")
815 traceback.print_exc(file=sys.stdout)
819 for log in self.logs:
821 header("End of logs")
829 class GdbTest(BaseTest):
830 def __init__(self, target, hart=None):
831 BaseTest.__init__(self, target, hart=hart)
834 def classSetup(self):
835 BaseTest.classSetup(self)
838 self.gdb = Gdb(self.server.gdb_ports, gdb_cmd,
839 timeout=self.target.timeout_sec, binary=self.binary)
841 self.gdb = Gdb(self.server.gdb_ports,
842 timeout=self.target.timeout_sec, binary=self.binary)
844 self.logs += self.gdb.lognames()
847 self.gdb.global_command("set remotetimeout %d" %
848 self.target.timeout_sec)
850 for cmd in self.target.gdb_setup:
851 self.gdb.command(cmd)
853 self.gdb.select_hart(self.hart)
855 # FIXME: OpenOCD doesn't handle PRIV now
856 #self.gdb.p("$priv=3")
858 def postMortem(self
):
862 self
.gdb
.command("disassemble", ops
=20)
863 self
.gdb
.command("info registers all", ops
=100)
864 self
.gdb
.command("flush regs")
865 self
.gdb
.command("info threads", ops
=100)
867 def classTeardown(self
):
869 BaseTest
.classTeardown(self
)
871 def parkOtherHarts(self
):
872 """Park harts besides the currently selected one in loop_forever()."""
873 for hart
in self
.target
.harts
:
874 # Park all harts that we're not using in a safe place.
875 if hart
!= self
.hart
:
876 self
.gdb
.select_hart(hart
)
877 self
.gdb
.p("$pc=loop_forever")
879 self
.gdb
.select_hart(self
.hart
)
881 class GdbSingleHartTest(GdbTest
):
882 def classSetup(self
):
883 GdbTest
.classSetup(self
)
884 self
.parkOtherHarts()
886 class ExamineTarget(GdbTest
):
888 for hart
in self
.target
.harts
:
889 self
.gdb
.select_hart(hart
)
891 hart
.misa
= self
.gdb
.p("$misa")
895 if ((hart
.misa
& 0xFFFFFFFF) >> 30) == 1:
897 elif ((hart
.misa
& 0xFFFFFFFFFFFFFFFF) >> 62) == 2:
899 elif ((hart
.misa
& 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) >> 126) == 3:
902 raise TestFailed("Couldn't determine XLEN from $misa (0x%x)" %
905 if misa_xlen
!= hart
.xlen
:
906 raise TestFailed("MISA reported XLEN of %d but we were "\
907 "expecting XLEN of %d\n" % (misa_xlen
, hart
.xlen
))
909 txt
+= ("%d" % misa_xlen
)
912 if hart
.misa
& (1<<i
):
913 txt
+= chr(i
+ ord('A'))
916 class TestFailed(Exception):
917 def __init__(self
, message
):
918 Exception.__init
__(self
)
919 self
.message
= message
921 class TestNotApplicable(Exception):
922 def __init__(self
, message
):
923 Exception.__init
__(self
)
924 self
.message
= message
926 def assertEqual(a
, b
):
928 raise TestFailed("%r != %r" % (a
, b
))
930 def assertNotEqual(a
, b
):
932 raise TestFailed("%r == %r" % (a
, b
))
936 raise TestFailed("%r not in %r" % (a
, b
))
938 def assertNotIn(a
, b
):
940 raise TestFailed("%r in %r" % (a
, b
))
942 def assertGreater(a
, b
):
944 raise TestFailed("%r not greater than %r" % (a
, b
))
946 def assertLess(a
, b
):
948 raise TestFailed("%r not less than %r" % (a
, b
))
952 raise TestFailed("%r is not True" % a
)
954 def assertRegexpMatches(text
, regexp
):
955 if not re
.search(regexp
, text
):
956 raise TestFailed("can't find %r in %r" % (regexp
, text
))