13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
17
"""UI tests for the test framework."""
25
21
from bzrlib import (
28
from bzrlib.errors import ParamikoNotPresent
29
24
from bzrlib.tests import (
32
TestCaseWithMemoryTransport,
33
TestCaseWithTransport,
37
from bzrlib.symbol_versioning import (
40
from bzrlib.tests.blackbox import ExternalBase
43
class TestOptions(TestCase):
27
from bzrlib.transport import memory
31
def get_params_passed_to_core(self, cmdline):
33
def selftest(*args, **kwargs):
34
"""Capture the arguments selftest was run with."""
35
params.append((args, kwargs))
37
# Yes this prevents using threads to run the test suite in parallel,
38
# however we don't have a clean dependency injector for commands,
39
# and even if we did - we'd still be testing that the glue is wired
40
# up correctly. XXX: TODO: Solve this testing problem.
41
original_selftest = tests.selftest
42
tests.selftest = selftest
47
tests.selftest = original_selftest
50
class TestOptions(tests.TestCase, SelfTestPatch):
52
def test_load_list(self):
53
params = self.get_params_passed_to_core('selftest --load-list foo')
54
self.assertEqual('foo', params[1]['load_list'])
47
56
def test_transport_set_to_sftp(self):
48
# test the --transport option has taken effect from within the
51
import bzrlib.transport.sftp
52
except ParamikoNotPresent:
53
raise TestSkipped("Paramiko not present")
54
if TestOptions.current_test != "test_transport_set_to_sftp":
56
self.assertEqual(bzrlib.transport.sftp.SFTPAbsoluteServer,
57
bzrlib.tests.default_transport)
57
# Test that we can pass a transport to the selftest core - sftp
59
self.requireFeature(features.paramiko)
60
from bzrlib.tests import stub_sftp
61
params = self.get_params_passed_to_core('selftest --transport=sftp')
62
self.assertEqual(stub_sftp.SFTPAbsoluteServer,
63
params[1]["transport"])
59
65
def test_transport_set_to_memory(self):
60
# test the --transport option has taken effect from within the
62
import bzrlib.transport.memory
63
if TestOptions.current_test != "test_transport_set_to_memory":
65
self.assertEqual(bzrlib.transport.memory.MemoryServer,
66
bzrlib.tests.default_transport)
68
def test_transport(self):
69
# test that --transport=sftp works
71
import bzrlib.transport.sftp
72
except ParamikoNotPresent:
73
raise TestSkipped("Paramiko not present")
74
old_transport = bzrlib.tests.default_transport
75
old_root = TestCaseWithMemoryTransport.TEST_ROOT
76
TestCaseWithMemoryTransport.TEST_ROOT = None
78
TestOptions.current_test = "test_transport_set_to_sftp"
79
stdout = self.run_bzr(
80
'selftest --transport=sftp test_transport_set_to_sftp')[0]
81
self.assertContainsRe(stdout, 'Ran 1 test')
82
self.assertEqual(old_transport, bzrlib.tests.default_transport)
84
TestOptions.current_test = "test_transport_set_to_memory"
85
stdout = self.run_bzr(
86
'selftest --transport=memory test_transport_set_to_memory')[0]
87
self.assertContainsRe(stdout, 'Ran 1 test')
88
self.assertEqual(old_transport, bzrlib.tests.default_transport)
90
bzrlib.tests.default_transport = old_transport
91
TestOptions.current_test = None
92
TestCaseWithMemoryTransport.TEST_ROOT = old_root
95
class TestRunBzr(ExternalBase):
97
def _run_bzr_core(self, argv, retcode=0, encoding=None, stdin=None,
99
"""Override _run_bzr_core to test how it is invoked by run_bzr.
101
Attempts to run bzr from inside this class don't actually run it.
103
We test how run_bzr actually invokes bzr in another location.
104
Here we only need to test that it is run_bzr passes the right
105
parameters to run_bzr.
107
self.argv = list(argv)
108
self.retcode = retcode
109
self.encoding = encoding
111
self.working_dir = working_dir
115
"""Test that run_bzr passes args correctly to _run_bzr_core"""
116
## self.callDeprecated(
117
## ['passing varargs to run_bzr was deprecated in version 0.18.'],
119
## 'arg1', 'arg2', 'arg3', retcode=1)
120
self.run_bzr('arg1', 'arg2', 'arg3', retcode=1)
121
self.assertEqual(['arg1', 'arg2', 'arg3'], self.argv)
123
def test_encoding(self):
124
"""Test that run_bzr passes encoding to _run_bzr_core"""
125
self.run_bzr('foo bar')
126
self.assertEqual(None, self.encoding)
127
self.assertEqual(['foo', 'bar'], self.argv)
129
self.run_bzr('foo bar', encoding='baz')
130
self.assertEqual('baz', self.encoding)
131
self.assertEqual(['foo', 'bar'], self.argv)
133
def test_retcode(self):
134
"""Test that run_bzr passes retcode to _run_bzr_core"""
135
# Default is retcode == 0
136
self.run_bzr('foo bar')
137
self.assertEqual(0, self.retcode)
138
self.assertEqual(['foo', 'bar'], self.argv)
140
self.run_bzr('foo bar', retcode=1)
141
self.assertEqual(1, self.retcode)
142
self.assertEqual(['foo', 'bar'], self.argv)
144
self.run_bzr('foo bar', retcode=None)
145
self.assertEqual(None, self.retcode)
146
self.assertEqual(['foo', 'bar'], self.argv)
148
self.run_bzr(['foo', 'bar'], retcode=3)
149
self.assertEqual(3, self.retcode)
150
self.assertEqual(['foo', 'bar'], self.argv)
152
def test_stdin(self):
153
# test that the stdin keyword to run_bzr is passed through to
154
# _run_bzr_core as-is. We do this by overriding
155
# _run_bzr_core in this class, and then calling run_bzr,
156
# which is a convenience function for _run_bzr_core, so
158
self.run_bzr('foo bar', stdin='gam')
159
self.assertEqual('gam', self.stdin)
160
self.assertEqual(['foo', 'bar'], self.argv)
162
self.run_bzr('foo bar', stdin='zippy')
163
self.assertEqual('zippy', self.stdin)
164
self.assertEqual(['foo', 'bar'], self.argv)
166
def test_working_dir(self):
167
"""Test that run_bzr passes working_dir to _run_bzr_core"""
168
self.run_bzr('foo bar')
169
self.assertEqual(None, self.working_dir)
170
self.assertEqual(['foo', 'bar'], self.argv)
172
self.run_bzr('foo bar', working_dir='baz')
173
self.assertEqual('baz', self.working_dir)
174
self.assertEqual(['foo', 'bar'], self.argv)
177
class TestBenchmarkTests(TestCaseWithTransport):
179
def test_benchmark_runs_benchmark_tests(self):
180
"""bzr selftest --benchmark should not run the default test suite."""
181
# We test this by passing a regression test name to --benchmark, which
182
# should result in 0 rests run.
183
old_root = TestCaseWithMemoryTransport.TEST_ROOT
185
TestCaseWithMemoryTransport.TEST_ROOT = None
186
out, err = self.run_bzr(['selftest', '--benchmark',
187
'workingtree_implementations'])
189
TestCaseWithMemoryTransport.TEST_ROOT = old_root
190
self.assertContainsRe(out, 'Ran 0 tests.*\n\nOK')
194
benchfile = open(".perf_history", "rt")
196
lines = benchfile.readlines()
199
self.assertEqual(1, len(lines))
200
self.assertContainsRe(lines[0], "--date [0-9.]+")
203
class TestRunBzrCaptured(ExternalBase):
205
def apply_redirected(self, stdin=None, stdout=None, stderr=None,
206
a_callable=None, *args, **kwargs):
208
self.factory_stdin = getattr(bzrlib.ui.ui_factory, "stdin", None)
209
self.factory = bzrlib.ui.ui_factory
210
self.working_dir = osutils.getcwd()
211
stdout.write('foo\n')
212
stderr.write('bar\n')
215
def test_stdin(self):
216
# test that the stdin keyword to _run_bzr_core is passed through to
217
# apply_redirected as a StringIO. We do this by overriding
218
# apply_redirected in this class, and then calling _run_bzr_core,
219
# which calls apply_redirected.
220
self.run_bzr(['foo', 'bar'], stdin='gam')
221
self.assertEqual('gam', self.stdin.read())
222
self.assertTrue(self.stdin is self.factory_stdin)
223
self.run_bzr(['foo', 'bar'], stdin='zippy')
224
self.assertEqual('zippy', self.stdin.read())
225
self.assertTrue(self.stdin is self.factory_stdin)
227
def test_ui_factory(self):
228
# each invocation of self.run_bzr should get its
229
# own UI factory, which is an instance of TestUIFactory,
230
# with stdin, stdout and stderr attached to the stdin,
231
# stdout and stderr of the invoked run_bzr
232
current_factory = bzrlib.ui.ui_factory
233
self.run_bzr(['foo'])
234
self.failIf(current_factory is self.factory)
235
self.assertNotEqual(sys.stdout, self.factory.stdout)
236
self.assertNotEqual(sys.stderr, self.factory.stderr)
237
self.assertEqual('foo\n', self.factory.stdout.getvalue())
238
self.assertEqual('bar\n', self.factory.stderr.getvalue())
239
self.assertIsInstance(self.factory, TestUIFactory)
241
def test_working_dir(self):
242
self.build_tree(['one/', 'two/'])
243
cwd = osutils.getcwd()
245
# Default is to work in the current directory
246
self.run_bzr(['foo', 'bar'])
247
self.assertEqual(cwd, self.working_dir)
249
self.run_bzr(['foo', 'bar'], working_dir=None)
250
self.assertEqual(cwd, self.working_dir)
252
# The function should be run in the alternative directory
253
# but afterwards the current working dir shouldn't be changed
254
self.run_bzr(['foo', 'bar'], working_dir='one')
255
self.assertNotEqual(cwd, self.working_dir)
256
self.assertEndsWith(self.working_dir, 'one')
257
self.assertEqual(cwd, osutils.getcwd())
259
self.run_bzr(['foo', 'bar'], working_dir='two')
260
self.assertNotEqual(cwd, self.working_dir)
261
self.assertEndsWith(self.working_dir, 'two')
262
self.assertEqual(cwd, osutils.getcwd())
265
class TestRunBzrSubprocess(TestCaseWithTransport):
267
def test_run_bzr_subprocess(self):
268
"""The run_bzr_helper_external comand behaves nicely."""
269
result = self.run_bzr_subprocess('--version')
270
result = self.run_bzr_subprocess('--version', retcode=None)
271
self.assertContainsRe(result[0], 'is free software')
272
self.assertRaises(AssertionError, self.run_bzr_subprocess,
274
result = self.run_bzr_subprocess('--versionn', retcode=3)
275
result = self.run_bzr_subprocess('--versionn', retcode=None)
276
self.assertContainsRe(result[1], 'unknown command')
277
err = self.run_bzr_subprocess('merge', '--merge-type', 'magic merge',
279
self.assertContainsRe(err, 'Bad value "magic merge" for option'
282
def test_run_bzr_subprocess_env(self):
283
"""run_bzr_subprocess can set environment variables in the child only.
285
These changes should not change the running process, only the child.
287
# The test suite should unset this variable
288
self.assertEqual(None, os.environ.get('BZR_EMAIL'))
289
out, err = self.run_bzr_subprocess('whoami', env_changes={
290
'BZR_EMAIL':'Joe Foo <joe@foo.com>'
291
}, universal_newlines=True)
292
self.assertEqual('', err)
293
self.assertEqual('Joe Foo <joe@foo.com>\n', out)
294
# And it should not be modified
295
self.assertEqual(None, os.environ.get('BZR_EMAIL'))
297
# Do it again with a different address, just to make sure
298
# it is actually changing
299
out, err = self.run_bzr_subprocess('whoami', env_changes={
300
'BZR_EMAIL':'Barry <bar@foo.com>'
301
}, universal_newlines=True)
302
self.assertEqual('', err)
303
self.assertEqual('Barry <bar@foo.com>\n', out)
304
self.assertEqual(None, os.environ.get('BZR_EMAIL'))
306
def test_run_bzr_subprocess_env_del(self):
307
"""run_bzr_subprocess can remove environment variables too."""
308
# Create a random email, so we are sure this won't collide
309
rand_bzr_email = 'John Doe <jdoe@%s.com>' % (osutils.rand_chars(20),)
310
rand_email = 'Jane Doe <jdoe@%s.com>' % (osutils.rand_chars(20),)
311
os.environ['BZR_EMAIL'] = rand_bzr_email
312
os.environ['EMAIL'] = rand_email
314
# By default, the child will inherit the current env setting
315
out, err = self.run_bzr_subprocess('whoami', universal_newlines=True)
316
self.assertEqual('', err)
317
self.assertEqual(rand_bzr_email + '\n', out)
319
# Now that BZR_EMAIL is not set, it should fall back to EMAIL
320
out, err = self.run_bzr_subprocess('whoami',
321
env_changes={'BZR_EMAIL':None},
322
universal_newlines=True)
323
self.assertEqual('', err)
324
self.assertEqual(rand_email + '\n', out)
326
# This switches back to the default email guessing logic
327
# Which shouldn't match either of the above addresses
328
out, err = self.run_bzr_subprocess('whoami',
329
env_changes={'BZR_EMAIL':None, 'EMAIL':None},
330
universal_newlines=True)
332
self.assertEqual('', err)
333
self.assertNotEqual(rand_bzr_email + '\n', out)
334
self.assertNotEqual(rand_email + '\n', out)
336
# TestCase cleans up BZR_EMAIL, and EMAIL at startup
337
del os.environ['BZR_EMAIL']
338
del os.environ['EMAIL']
340
def test_run_bzr_subprocess_env_del_missing(self):
341
"""run_bzr_subprocess won't fail if deleting a nonexistant env var"""
342
self.failIf('NON_EXISTANT_ENV_VAR' in os.environ)
343
out, err = self.run_bzr_subprocess('rocks',
344
env_changes={'NON_EXISTANT_ENV_VAR':None},
345
universal_newlines=True)
346
self.assertEqual('It sure does!\n', out)
347
self.assertEqual('', err)
349
def test_run_bzr_subprocess_working_dir(self):
350
"""Test that we can specify the working dir for the child"""
351
cwd = osutils.getcwd()
353
self.make_branch_and_tree('.')
354
self.make_branch_and_tree('one')
355
self.make_branch_and_tree('two')
357
def get_root(**kwargs):
358
"""Spawn a process to get the 'root' of the tree.
360
You can pass in arbitrary new arguments. This just makes
361
sure that the returned path doesn't have trailing whitespace.
363
return self.run_bzr_subprocess('root', **kwargs)[0].rstrip()
365
self.assertEqual(cwd, get_root())
366
self.assertEqual(cwd, get_root(working_dir=None))
367
# Has our path changed?
368
self.assertEqual(cwd, osutils.getcwd())
370
dir1 = get_root(working_dir='one')
371
self.assertEndsWith(dir1, 'one')
372
self.assertEqual(cwd, osutils.getcwd())
374
dir2 = get_root(working_dir='two')
375
self.assertEndsWith(dir2, 'two')
376
self.assertEqual(cwd, osutils.getcwd())
379
class _DontSpawnProcess(Exception):
380
"""A simple exception which just allows us to skip unnecessary steps"""
383
class TestRunBzrSubprocessCommands(TestCaseWithTransport):
385
def _popen(self, *args, **kwargs):
386
"""Record the command that is run, so that we can ensure it is correct"""
387
self._popen_args = args
388
self._popen_kwargs = kwargs
389
raise _DontSpawnProcess()
391
def test_run_bzr_subprocess_no_plugins(self):
392
self.assertRaises(_DontSpawnProcess, self.run_bzr_subprocess)
393
command = self._popen_args[0]
394
self.assertEqual(sys.executable, command[0])
395
self.assertEqual(self.get_bzr_path(), command[1])
396
self.assertEqual(['--no-plugins'], command[2:])
398
def test_allow_plugins(self):
399
self.assertRaises(_DontSpawnProcess,
400
self.run_bzr_subprocess, allow_plugins=True)
401
command = self._popen_args[0]
402
self.assertEqual([], command[2:])
405
class TestBzrSubprocess(TestCaseWithTransport):
407
def test_start_and_stop_bzr_subprocess(self):
408
"""We can start and perform other test actions while that process is
411
process = self.start_bzr_subprocess(['--version'])
412
result = self.finish_bzr_subprocess(process)
413
self.assertContainsRe(result[0], 'is free software')
414
self.assertEqual('', result[1])
416
def test_start_and_stop_bzr_subprocess_with_error(self):
417
"""finish_bzr_subprocess allows specification of the desired exit code.
419
process = self.start_bzr_subprocess(['--versionn'])
420
result = self.finish_bzr_subprocess(process, retcode=3)
421
self.assertEqual('', result[0])
422
self.assertContainsRe(result[1], 'unknown command')
424
def test_start_and_stop_bzr_subprocess_ignoring_retcode(self):
425
"""finish_bzr_subprocess allows the exit code to be ignored."""
426
process = self.start_bzr_subprocess(['--versionn'])
427
result = self.finish_bzr_subprocess(process, retcode=None)
428
self.assertEqual('', result[0])
429
self.assertContainsRe(result[1], 'unknown command')
431
def test_start_and_stop_bzr_subprocess_with_unexpected_retcode(self):
432
"""finish_bzr_subprocess raises self.failureException if the retcode is
433
not the expected one.
435
process = self.start_bzr_subprocess(['--versionn'])
436
self.assertRaises(self.failureException, self.finish_bzr_subprocess,
439
def test_start_and_stop_bzr_subprocess_send_signal(self):
440
"""finish_bzr_subprocess raises self.failureException if the retcode is
441
not the expected one.
443
process = self.start_bzr_subprocess(['wait-until-signalled'],
444
skip_if_plan_to_signal=True)
445
self.assertEqual('running\n', process.stdout.readline())
446
result = self.finish_bzr_subprocess(process, send_signal=signal.SIGINT,
448
self.assertEqual('', result[0])
449
self.assertEqual('bzr: interrupted\n', result[1])
451
def test_start_and_stop_working_dir(self):
452
cwd = osutils.getcwd()
454
self.make_branch_and_tree('one')
456
process = self.start_bzr_subprocess(['root'], working_dir='one')
457
result = self.finish_bzr_subprocess(process, universal_newlines=True)
458
self.assertEndsWith(result[0], 'one\n')
459
self.assertEqual('', result[1])
462
class TestRunBzrError(ExternalBase):
464
def test_run_bzr_error(self):
465
out, err = self.run_bzr_error(['^$'], ['rocks'], retcode=0)
466
self.assertEqual(out, 'It sure does!\n')
468
out, err = self.run_bzr_error(["bzr: ERROR: foobarbaz is not versioned"],
469
['file-id', 'foobarbaz'])
472
class TestSelftestCleanOutput(TestCaseInTempDir):
474
def test_clean_output(self):
475
# check that 'bzr selftest --clean-output' works correct
476
dirs = ('test0000.tmp', 'test0001.tmp', 'bzrlib', 'tests')
477
files = ('bzr', 'setup.py', 'test9999.tmp')
482
f.write('content of ')
487
before = os.listdir(root)
489
self.assertEquals(['bzr','bzrlib','setup.py',
490
'test0000.tmp','test0001.tmp',
491
'test9999.tmp','tests'],
494
out, err = self.run_bzr(['selftest','--clean-output'],
497
self.assertEquals(['delete directory: test0000.tmp',
498
'delete directory: test0001.tmp'],
499
sorted(out.splitlines()))
500
self.assertEquals('', err)
502
after = os.listdir(root)
504
self.assertEquals(['bzr','bzrlib','setup.py',
505
'test9999.tmp','tests'],
509
class TestSelftestListOnly(TestCase):
512
def _parse_test_list(lines, newlines_in_header=1):
66
# Test that we can pass a transport to the selftest core - memory
68
params = self.get_params_passed_to_core('selftest --transport=memory')
69
self.assertEqual(memory.MemoryServer, params[1]["transport"])
71
def test_parameters_passed_to_core(self):
72
params = self.get_params_passed_to_core('selftest --list-only')
73
self.assertTrue("list_only" in params[1])
74
params = self.get_params_passed_to_core('selftest --list-only selftest')
75
self.assertTrue("list_only" in params[1])
76
params = self.get_params_passed_to_core(['selftest', '--list-only',
77
'--exclude', 'selftest'])
78
self.assertTrue("list_only" in params[1])
79
params = self.get_params_passed_to_core(['selftest', '--list-only',
80
'selftest', '--randomize', 'now'])
81
self.assertSubset(["list_only", "random_seed"], params[1])
83
def test_starting_with(self):
84
params = self.get_params_passed_to_core('selftest --starting-with foo')
85
self.assertEqual(['foo'], params[1]['starting_with'])
87
def test_starting_with_multiple_argument(self):
88
params = self.get_params_passed_to_core(
89
'selftest --starting-with foo --starting-with bar')
90
self.assertEqual(['foo', 'bar'], params[1]['starting_with'])
92
def test_subunit(self):
93
self.requireFeature(features.subunit)
94
params = self.get_params_passed_to_core('selftest --subunit')
95
self.assertEqual(tests.SubUnitBzrRunner, params[1]['runner_class'])
97
def _parse_test_list(self, lines, newlines_in_header=0):
513
98
"Parse a list of lines into a tuple of 3 lists (header,body,footer)."
99
in_header = newlines_in_header != 0
516
100
in_footer = False
520
header_newlines_found = 0
104
header_newlines_found = 0
521
105
for line in lines:
535
119
footer.append(line)
536
120
# If the last body line is blank, drop it off the list
537
121
if len(body) > 0 and body[-1] == '':
539
123
return (header,body,footer)
541
125
def test_list_only(self):
542
# check that bzr selftest --list-only works correctly
543
out,err = self.run_bzr(['selftest', 'selftest',
545
self.assertEndsWith(err, 'tests passed\n')
546
(header,body,footer) = self._parse_test_list(out.splitlines())
547
num_tests = len(body)
548
self.assertContainsRe(footer[0], 'Listed %s tests in' % num_tests)
550
def test_list_only_filtered(self):
551
# check that a filtered --list-only works, both include and exclude
552
out_all,err_all = self.run_bzr(['selftest', '--list-only'])
553
tests_all = self._parse_test_list(out_all.splitlines())[1]
554
out_incl,err_incl = self.run_bzr(['selftest', '--list-only',
556
tests_incl = self._parse_test_list(out_incl.splitlines())[1]
557
self.assertSubset(tests_incl, tests_all)
558
out_excl,err_excl = self.run_bzr(['selftest', '--list-only',
559
'--exclude', 'selftest'])
560
tests_excl = self._parse_test_list(out_excl.splitlines())[1]
561
self.assertSubset(tests_excl, tests_all)
562
set_incl = set(tests_incl)
563
set_excl = set(tests_excl)
564
intersection = set_incl.intersection(set_excl)
565
self.assertEquals(0, len(intersection))
566
self.assertEquals(len(tests_all), len(tests_incl) + len(tests_excl))
568
def test_list_only_random(self):
569
# check that --randomize works correctly
570
out_all,err_all = self.run_bzr(['selftest', '--list-only',
572
tests_all = self._parse_test_list(out_all.splitlines())[1]
573
# XXX: It looks like there are some orders for generating tests that
574
# fail as of 20070504 - maybe because of import order dependencies.
575
# So unfortunately this will rarely intermittently fail at the moment.
577
out_rand,err_rand = self.run_bzr(['selftest', '--list-only',
578
'selftest', '--randomize', 'now'])
579
(header_rand,tests_rand,dummy) = self._parse_test_list(
580
out_rand.splitlines(), 2)
581
self.assertNotEqual(tests_all, tests_rand)
582
self.assertEqual(sorted(tests_all), sorted(tests_rand))
583
# Check that the seed can be reused to get the exact same order
584
seed_re = re.compile('Randomizing test order using seed (\w+)')
585
match_obj = seed_re.search(header_rand[-1])
586
seed = match_obj.group(1)
587
out_rand2,err_rand2 = self.run_bzr(['selftest', '--list-only',
588
'selftest', '--randomize', seed])
589
(header_rand2,tests_rand2,dummy) = self._parse_test_list(
590
out_rand2.splitlines(), 2)
591
self.assertEqual(tests_rand, tests_rand2)
126
# check that bzr selftest --list-only outputs no ui noise
127
def selftest(*args, **kwargs):
128
"""Capture the arguments selftest was run with."""
130
def outputs_nothing(cmdline):
131
out,err = self.run_bzr(cmdline)
132
(header,body,footer) = self._parse_test_list(out.splitlines())
133
num_tests = len(body)
134
self.assertLength(0, header)
135
self.assertLength(0, footer)
136
self.assertEqual('', err)
137
# Yes this prevents using threads to run the test suite in parallel,
138
# however we don't have a clean dependency injector for commands,
139
# and even if we did - we'd still be testing that the glue is wired
140
# up correctly. XXX: TODO: Solve this testing problem.
141
original_selftest = tests.selftest
142
tests.selftest = selftest
144
outputs_nothing('selftest --list-only')
145
outputs_nothing('selftest --list-only selftest')
146
outputs_nothing(['selftest', '--list-only', '--exclude', 'selftest'])
148
tests.selftest = original_selftest
150
def test_lsprof_tests(self):
151
params = self.get_params_passed_to_core('selftest --lsprof-tests')
152
self.assertEqual(True, params[1]["lsprof_tests"])
154
def test_parallel_fork_unsupported(self):
155
if getattr(os, "fork", None) is not None:
156
self.addCleanup(setattr, os, "fork", os.fork)
158
out, err = self.run_bzr(["selftest", "--parallel=fork", "-s", "bt.x"],
160
self.assertIn("platform does not support fork", err)
161
self.assertFalse(out)
added
removed
bzrlib/tests/blackbox/test_selftest.py
