def test_verbose(self):
a = ArrayStream()
m = metered_stream.MeteredStream(verbose=True, stream=a)
self.assertTrue(a.empty())
m.write("foo")
self.assertEquals(a.get(), ['foo'])
m.update("bar")
# FIXME: figure out how to test that this went to the logger. Is this
# good enough?
self.assertEquals(a.get(), ['foo'])
m.progress("dropped")
self.assertEquals(a.get(), ['foo'])
def test_regular(self):
a = ArrayStream()
m = metered_stream.MeteredStream(verbose=False, stream=a)
self.assertTrue(a.empty())
# basic test - note that the flush() is a no-op, but we include it
# for coverage.
m.write("foo")
m.flush()
exp = ['foo']
self.assertEquals(a.get(), exp)
# now check that a second write() does not overwrite the first.
m.write("bar")
exp.append('bar')
self.assertEquals(a.get(), exp)
m.update("batter")
exp.append('batter')
self.assertEquals(a.get(), exp)
# The next update() should overwrite the laste update() but not the
# other text. Note that the cursor is effectively positioned at the
# end of 'foo', even though we had to erase three more characters.
m.update("foo")
exp.append('\b\b\b\b\b\b \b\b\b\b\b\b')
exp.append('foo')
self.assertEquals(a.get(), exp)
m.progress("progress")
exp.append('\b\b\b \b\b\b')
exp.append('progress')
self.assertEquals(a.get(), exp)
# now check that a write() does overwrite the progress bar
m.write("foo")
exp.append('\b\b\b\b\b\b\b\b \b\b\b\b\b\b\b\b')
exp.append('foo')
self.assertEquals(a.get(), exp)
# Now test that we only back up to the most recent newline.
# Note also that we do not back up to erase the most recent write(),
# i.e., write()s do not get erased.
a.reset()
m.update("foo\nbar")
m.update("baz")
self.assertEquals(a.get(), ['foo\nbar', '\b\b\b \b\b\b', 'baz'])
def test_verbose(self):
a = ArrayStream()
m = metered_stream.MeteredStream(verbose=True, stream=a)
self.assertTrue(a.empty())
m.write("foo")
self.assertEquals(a.get(), ['foo'])
import logging
b = ArrayStream()
logger = logging.getLogger()
handler = logging.StreamHandler(b)
logger.addHandler(handler)
m.update("bar")
logger.handlers.remove(handler)
self.assertEquals(a.get(), ['foo'])
self.assertEquals(b.get(), ['bar\n'])
m.progress("dropped")
self.assertEquals(a.get(), ['foo'])
self.assertEquals(b.get(), ['bar\n'])
def __init__(self, port, options, regular_output, buildbot_output,
child_processes, is_fully_parallel):
"""
Args
port interface to port-specific routines
options OptionParser object with command line settings
regular_output stream to which output intended only for humans
should be written
buildbot_output stream to which output intended to be read by
the buildbots (and humans) should be written
child_processes number of parallel threads running (usually
controlled by --child-processes)
is_fully_parallel are the tests running in a single queue, or
in shards (usually controlled by
--experimental-fully-parallel)
Note that the last two args are separate rather than bundled into
the options structure so that this object does not assume any flags
set in options that weren't returned from logging_options(), above.
The two are used to determine whether or not we can sensibly use
the 'detailed-progress' option, or can only use 'one-line-progress'.
"""
self._buildbot_stream = buildbot_output
self._options = options
self._port = port
self._stream = regular_output
# These are used for --print detailed-progress to track status by
# directory.
self._current_dir = None
self._current_progress_str = ""
self._current_test_number = 0
self._meter = metered_stream.MeteredStream(options.verbose,
regular_output)
self._logging_handler = _configure_logging(self._meter,
options.verbose)
self.switches = parse_print_options(options.print_options,
options.verbose, child_processes,
is_fully_parallel)