1
=== modified file 'bzrlib/tests/__init__.py'
2
--- bzrlib/tests/__init__.py	2009-08-28 21:05:31 +0000
3
+++ bzrlib/tests/__init__.py	2009-09-01 08:24:44 +0000
4
@@ -3618,6 +3618,7 @@
5
3618
        'bzrlib.tests.test_rio',
3618
        'bzrlib.tests.test_rio',
6
3619
        'bzrlib.tests.test_rules',
3619
        'bzrlib.tests.test_rules',
7
3620
        'bzrlib.tests.test_sampler',
3620
        'bzrlib.tests.test_sampler',
8
3621
        'bzrlib.tests.test_script',
9
3621
        'bzrlib.tests.test_selftest',
3622
        'bzrlib.tests.test_selftest',
10
3622
        'bzrlib.tests.test_serializer',
3623
        'bzrlib.tests.test_serializer',
11
3623
        'bzrlib.tests.test_setup',
3624
        'bzrlib.tests.test_setup',
12
3624
3625
13
=== added file 'bzrlib/tests/script.py'
14
--- bzrlib/tests/script.py	1970-01-01 00:00:00 +0000
15
+++ bzrlib/tests/script.py	2009-09-04 14:55:59 +0000
16
@@ -0,0 +1,389 @@
17
1
# Copyright (C) 2009 Canonical Ltd
18
2
#
19
3
# This program is free software; you can redistribute it and/or modify
20
4
# it under the terms of the GNU General Public License as published by
21
5
# the Free Software Foundation; either version 2 of the License, or
22
6
# (at your option) any later version.
23
7
#
24
8
# This program is distributed in the hope that it will be useful,
25
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
26
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
27
11
# GNU General Public License for more details.
28
12
#
29
13
# You should have received a copy of the GNU General Public License
30
14
# along with this program; if not, write to the Free Software
31
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
32
16
"""Shell-like test scripts.
33
17
34
18
This allows users to write tests in a syntax very close to a shell session,
35
19
using a restricted and limited set of commands that should be enough to mimic
36
20
most of the behaviours.
37
21
38
22
A script is a set of commands, each command is composed of:
39
23
- one mandatory command line,
40
24
- one optional set of input lines to feed the command,
41
25
- one optional set of output expected lines,
42
26
- one optional set of error expected lines.
43
27
44
28
The optional lines starts with a special string (mnemonic: shell redirection):
45
29
- '<' for input,
46
30
- '>' for output,
47
31
- '2>' for errors,
48
32
49
33
The execution stops as soon as an expected output or an expected error is not
50
34
matched. 
51
35
52
36
When no output is specified, any ouput from the command is accepted
53
37
and let the execution continue. 
54
38
55
39
If an error occurs and no expected error is specified, the execution stops.
56
40
57
41
The matching is done on a full string comparison basis unless '...' is used, in
58
42
which case expected output/errors can be lees precise.
59
43
60
44
Examples:
61
45
62
46
The following will succeeds only if 'bzr add' outputs 'adding file'.
63
47
64
48
  bzr add file
65
49
  >adding file
66
50
67
51
If you want the command to succeed for any output, just use:
68
52
69
53
  bzr add file
70
54
71
55
The following will stop with an error:
72
56
73
57
  bzr not-a-command
74
58
75
59
If you want it to succeed, use:
76
60
77
61
  bzr not-a-command
78
62
  2> bzr: ERROR: unknown command "not-a-command"
79
63
80
64
You can use ellipsis (...) to replace any piece of text you don't want to be
81
65
matched exactly:
82
66
83
67
  bzr branch not-a-branch
84
68
  2>bzr: ERROR: Not a branch...not-a-branch/".
85
69
86
70
87
71
This can be used to ignore entire lines too:
88
72
89
73
cat
90
74
<first line
91
75
<second line
92
76
<third line
93
77
<fourth line
94
78
<last line
95
79
>first line
96
80
>...
97
81
>last line
98
82
99
83
You can check the content of a file with cat:
100
84
101
85
  cat <file
102
86
  >expected content
103
87
104
88
You can also check the existence of a file with cat, the following will fail if
105
89
the file doesn't exist:
106
90
107
91
  cat file
108
92
109
93
"""
110
94
111
95
import doctest
112
96
import os
113
97
import shlex
114
98
from cStringIO import StringIO
115
99
116
100
from bzrlib import (
117
101
    osutils,
118
102
    tests,
119
103
    )
120
104
121
105
122
106
def split(s):
123
107
    """Split a command line respecting quotes."""
124
108
    scanner = shlex.shlex(s)
125
109
    scanner.quotes = '\'"`'
126
110
    scanner.whitespace_split = True
127
111
    for t in list(scanner):
128
112
        # Strip the simple and double quotes since we don't care about them.
129
113
        # We leave the backquotes in place though since they have a different
130
114
        # semantic.
131
115
        if t[0] in  ('"', "'") and t[0] == t[-1]:
132
116
            yield t[1:-1]
133
117
        else:
134
118
            yield t
135
119
136
120
137
121
def _script_to_commands(text, file_name=None):
138
122
    """Turn a script into a list of commands with their associated IOs.
139
123
140
124
    Each command appears on a line by itself. It can be associated with an
141
125
    input that will feed it and an expected output.
142
126
    Comments starts with '#' until the end of line.
143
127
    Empty lines are ignored.
144
128
    Input and output are full lines terminated by a '\n'.
145
129
    Input lines start with '<'.
146
130
    Output lines start with '>'.
147
131
    Error lines start with '2>'.
148
132
    """
149
133
150
134
    commands = []
151
135
152
136
    def add_command(cmd, input, output, error):
153
137
        if cmd is not None:
154
138
            if input is not None:
155
139
                input = ''.join(input)
156
140
            if output is not None:
157
141
                output = ''.join(output)
158
142
            if error is not None:
159
143
                error = ''.join(error)
160
144
            commands.append((cmd, input, output, error))
161
145
162
146
    cmd_cur = None
163
147
    cmd_line = 1
164
148
    lineno = 0
165
149
    input, output, error = None, None, None
166
150
    for line in text.split('\n'):
167
151
        lineno += 1
168
152
        # Keep a copy for error reporting
169
153
        orig = line
170
154
        comment =  line.find('#')
171
155
        if comment >= 0:
172
156
            # Delete comments
173
157
            line = line[0:comment]
174
158
            line = line.rstrip()
175
159
        if line == '':
176
160
            # Ignore empty lines
177
161
            continue
178
162
        if line.startswith('<'):
179
163
            if input is None:
180
164
                if cmd_cur is None:
181
165
                    raise SyntaxError('No command for that input',
182
166
                                      (file_name, lineno, 1, orig))
183
167
                input = []
184
168
            input.append(line[1:] + '\n')
185
169
            continue
186
170
        elif line.startswith('>'):
187
171
            if output is None:
188
172
                if cmd_cur is None:
189
173
                    raise SyntaxError('No command for that output',
190
174
                                      (file_name, lineno, 1, orig))
191
175
                output = []
192
176
            output.append(line[1:] + '\n')
193
177
            continue
194
178
        elif line.startswith('2>'):
195
179
            if error is None:
196
180
                if cmd_cur is None:
197
181
                    raise SyntaxError('No command for that error',
198
182
                                      (file_name, lineno, 1, orig))
199
183
                error = []
200
184
            error.append(line[2:] + '\n')
201
185
            continue
202
186
        else:
203
187
            # Time to output the current command
204
188
            add_command(cmd_cur, input, output, error)
205
189
            # And start a new one
206
190
            cmd_cur = list(split(line))
207
191
            cmd_line = lineno
208
192
            input, output, error = None, None, None
209
193
    # Add the last seen command
210
194
    add_command(cmd_cur, input, output, error)
211
195
    return commands
212
196
213
197
214
198
def _scan_redirection_options(args):
215
199
    """Recognize and process input and output redirections.
216
200
217
201
    :param args: The command line arguments
218
202
219
203
    :return: A tuple containing: 
220
204
        - The file name redirected from or None
221
205
        - The file name redirected to or None
222
206
        - The mode to open the output file or None
223
207
        - The reamining arguments
224
208
    """
225
209
    remaining = []
226
210
    in_name = None
227
211
    out_name, out_mode = None, None
228
212
    for arg in  args:
229
213
        if arg.startswith('<'):
230
214
            in_name = arg[1:]
231
215
        elif arg.startswith('>>'):
232
216
            out_name = arg[2:]
233
217
            out_mode = 'ab+'
234
218
        elif arg.startswith('>'):
235
219
            out_name = arg[1:]
236
220
            out_mode = 'wb+'
237
221
        else:
238
222
            remaining.append(arg)
239
223
    return in_name, out_name, out_mode, remaining
240
224
241
225
242
226
class ScriptRunner(object):
243
227
244
228
    def __init__(self, test_case):
245
229
        self.test_case = test_case
246
230
        self.output_checker = doctest.OutputChecker()
247
231
        self.check_options = doctest.ELLIPSIS
248
232
249
233
    def run_script(self, text):
250
234
        for cmd, input, output, error in _script_to_commands(text):
251
235
            out, err = self.run_command(cmd, input, output, error)
252
236
253
237
    def _check_output(self, expected, actual):
254
238
        if expected is None:
255
239
            # Specifying None means: any output is accepted
256
240
            return
257
241
        if actual is None:
258
242
            self.test_case.fail('Unexpected: %s' % actual)
259
243
        matching = self.output_checker.check_output(
260
244
            expected, actual, self.check_options)
261
245
        if not matching:
262
246
            # Note that we can't use output_checker.output_difference() here
263
247
            # because... the API is boken (expected must be a doctest specific
264
248
            # object of whicha 'want' attribute will be our 'expected'
265
249
            # parameter. So we just fallbacl to our good old assertEqualDiff
266
250
            # since we know there are differences and the output should be
267
251
            # decently readable.
268
252
            self.test_case.assertEqualDiff(expected, actual)
269
253
270
254
    def run_command(self, cmd, input, output, error):
271
255
        mname = 'do_' + cmd[0]
272
256
        method = getattr(self, mname, None)
273
257
        if method is None:
274
258
            raise SyntaxError('Command not found "%s"' % (cmd[0],),
275
259
                              None, 1, ' '.join(cmd))
276
260
        if input is None:
277
261
            str_input = ''
278
262
        else:
279
263
            str_input = ''.join(input)
280
264
        actual_output, actual_error = method(str_input, cmd[1:])
281
265
282
266
        self._check_output(output, actual_output)
283
267
        self._check_output(error, actual_error)
284
268
        if not error and actual_error:
285
269
            self.test_case.fail('Unexpected error: %s' % actual_error)
286
270
        return actual_output, actual_error
287
271
288
272
    def _read_input(self, input, in_name):
289
273
        if in_name is not None:
290
274
            infile = open(in_name, 'rb')
291
275
            try:
292
276
                # Command redirection takes precedence over provided input
293
277
                input = infile.read()
294
278
            finally:
295
279
                infile.close()
296
280
        return input
297
281
298
282
    def _write_output(self, output, out_name, out_mode):
299
283
        if out_name is not None:
300
284
            outfile = open(out_name, out_mode)
301
285
            try:
302
286
                outfile.write(output)
303
287
            finally:
304
288
                outfile.close()
305
289
            output = None
306
290
        return output
307
291
308
292
    def do_bzr(self, input, args):
309
293
        out, err = self.test_case._run_bzr_core(
310
294
            args, retcode=None, encoding=None, stdin=input, working_dir=None)
311
295
        return out, err
312
296
313
297
    def do_cat(self, input, args):
314
298
        (in_name, out_name, out_mode, args) = _scan_redirection_options(args)
315
299
        if len(args) > 1:
316
300
            raise SyntaxError('Usage: cat [file1]')
317
301
        if args:
318
302
            if in_name is not None:
319
303
                raise SyntaxError('Specify a file OR use redirection')
320
304
            in_name = args[0]
321
305
        input = self._read_input(input, in_name)
322
306
        # Basically cat copy input to output
323
307
        output = input
324
308
        # Handle output redirections
325
309
        output = self._write_output(output, out_name, out_mode)
326
310
        return output, None
327
311
328
312
    def do_echo(self, input, args):
329
313
        (in_name, out_name, out_mode, args) = _scan_redirection_options(args)
330
314
        if input and args:
331
315
                raise SyntaxError('Specify parameters OR use redirection')
332
316
        if args:
333
317
            input = ''.join(args)
334
318
        input = self._read_input(input, in_name)
335
319
        # Always append a \n'
336
320
        input += '\n'
337
321
        # Process output
338
322
        output = input
339
323
        # Handle output redirections
340
324
        output = self._write_output(output, out_name, out_mode)
341
325
        return output, None
342
326
343
327
    def _ensure_in_jail(self, path):
344
328
        jail_root = self.test_case.get_jail_root()
345
329
        if not osutils.is_inside(jail_root, osutils.normalizepath(path)):
346
330
            raise ValueError('%s is not inside %s' % (path, jail_root))
347
331
348
332
    def do_cd(self, input, args):
349
333
        if len(args) > 1:
350
334
            raise SyntaxError('Usage: cd [dir]')
351
335
        if len(args) == 1:
352
336
            d = args[0]
353
337
            self._ensure_in_jail(d)
354
338
        else:
355
339
            d = self.test_case.get_jail_root()
356
340
        os.chdir(d)
357
341
        return None, None
358
342
359
343
    def do_mkdir(self, input, args):
360
344
        if not args or len(args) != 1:
361
345
            raise SyntaxError('Usage: mkdir dir')
362
346
        d = args[0]
363
347
        self._ensure_in_jail(d)
364
348
        os.mkdir(d)
365
349
        return None, None
366
350
367
351
368
352
class TestCaseWithMemoryTransportAndScript(tests.TestCaseWithMemoryTransport):
369
353
370
354
    def setUp(self):
371
355
        super(TestCaseWithMemoryTransportAndScript, self).setUp()
372
356
        self.script_runner = ScriptRunner(self)
373
357
        # Break the circular dependency
374
358
        def break_dependency():
375
359
            self.script_runner = None
376
360
        self.addCleanup(break_dependency)
377
361
378
362
    def get_jail_root(self):
379
363
        raise NotImplementedError(self.get_jail_root)
380
364
381
365
    def run_script(self, script):
382
366
        return self.script_runner.run_script(script)
383
367
384
368
    def run_command(self, cmd, input, output, error):
385
369
        return self.script_runner.run_command(cmd, input, output, error)
386
370
387
371
388
372
class TestCaseWithTransportAndScript(tests.TestCaseWithTransport):
389
373
390
374
    def setUp(self):
391
375
        super(TestCaseWithTransportAndScript, self).setUp()
392
376
        self.script_runner = ScriptRunner(self)
393
377
        # Break the circular dependency
394
378
        def break_dependency():
395
379
            self.script_runner = None
396
380
        self.addCleanup(break_dependency)
397
381
398
382
    def get_jail_root(self):
399
383
        return self.test_dir
400
384
401
385
    def run_script(self, script):
402
386
        return self.script_runner.run_script(script)
403
387
404
388
    def run_command(self, cmd, input, output, error):
405
389
        return self.script_runner.run_command(cmd, input, output, error)
406
0
390
407
=== added file 'bzrlib/tests/test_script.py'
408
--- bzrlib/tests/test_script.py	1970-01-01 00:00:00 +0000
409
+++ bzrlib/tests/test_script.py	2009-09-04 14:55:59 +0000
410
@@ -0,0 +1,257 @@
411
1
# Copyright (C) 2009 Canonical Ltd
412
2
#
413
3
# This program is free software; you can redistribute it and/or modify
414
4
# it under the terms of the GNU General Public License as published by
415
5
# the Free Software Foundation; either version 2 of the License, or
416
6
# (at your option) any later version.
417
7
#
418
8
# This program is distributed in the hope that it will be useful,
419
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
420
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
421
11
# GNU General Public License for more details.
422
12
#
423
13
# You should have received a copy of the GNU General Public License
424
14
# along with this program; if not, write to the Free Software
425
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
426
16
427
17
428
18
from bzrlib import (
429
19
    osutils,
430
20
    tests,
431
21
    )
432
22
from bzrlib.tests import script
433
23
434
24
435
25
class TestScriptSyntax(tests.TestCase):
436
26
437
27
    def test_comment_is_ignored(self):
438
28
        self.assertEquals([], script._script_to_commands('#comment\n'))
439
29
440
30
    def test_empty_line_is_ignored(self):
441
31
        self.assertEquals([], script._script_to_commands('\n'))
442
32
443
33
    def test_simple_command(self):
444
34
        self.assertEquals([(['cd', 'trunk'], None, None, None)],
445
35
                           script._script_to_commands('cd trunk'))
446
36
447
37
    def test_command_with_single_quoted_param(self):
448
38
        story = """bzr commit -m 'two words'"""
449
39
        self.assertEquals([(['bzr', 'commit', '-m', 'two words'],
450
40
                            None, None, None)],
451
41
                           script._script_to_commands(story))
452
42
453
43
    def test_command_with_double_quoted_param(self):
454
44
        story = """bzr commit -m "two words" """
455
45
        self.assertEquals([(['bzr', 'commit', '-m', 'two words'],
456
46
                            None, None, None)],
457
47
                           script._script_to_commands(story))
458
48
459
49
    def test_command_with_input(self):
460
50
        self.assertEquals([(['cat', '>file'], 'content\n', None, None)],
461
51
                           script._script_to_commands('cat >file\n<content\n'))
462
52
463
53
    def test_command_with_output(self):
464
54
        story = """
465
55
bzr add
466
56
>adding file
467
57
>adding file2
468
58
"""
469
59
        self.assertEquals([(['bzr', 'add'], None,
470
60
                            'adding file\nadding file2\n', None)],
471
61
                          script._script_to_commands(story))
472
62
473
63
    def test_command_with_error(self):
474
64
        story = """
475
65
bzr branch foo
476
66
2>bzr: ERROR: Not a branch: "foo"
477
67
"""
478
68
        self.assertEquals([(['bzr', 'branch', 'foo'],
479
69
                            None, None, 'bzr: ERROR: Not a branch: "foo"\n')],
480
70
                          script._script_to_commands(story))
481
71
    def test_input_without_command(self):
482
72
        self.assertRaises(SyntaxError, script._script_to_commands, '<input')
483
73
484
74
    def test_output_without_command(self):
485
75
        self.assertRaises(SyntaxError, script._script_to_commands, '>input')
486
76
487
77
    def test_command_with_backquotes(self):
488
78
        story = """
489
79
foo = `bzr file-id toto`
490
80
"""
491
81
        self.assertEquals([(['foo', '=', '`bzr file-id toto`'],
492
82
                            None, None, None)],
493
83
                          script._script_to_commands(story))
494
84
495
85
496
86
class TestScriptExecution(script.TestCaseWithTransportAndScript):
497
87
498
88
    def test_unknown_command(self):
499
89
        self.assertRaises(SyntaxError, self.run_script, 'foo')
500
90
501
91
    def test_stops_on_unexpected_output(self):
502
92
        story = """
503
93
mkdir dir
504
94
cd dir
505
95
>Hello, I have just cd into dir !
506
96
"""
507
97
        self.assertRaises(AssertionError, self.run_script, story)
508
98
509
99
510
100
    def test_stops_on_unexpected_error(self):
511
101
        story = """
512
102
cat
513
103
<Hello
514
104
bzr not-a-command
515
105
"""
516
106
        self.assertRaises(AssertionError, self.run_script, story)
517
107
518
108
    def test_continue_on_expected_error(self):
519
109
        story = """
520
110
bzr not-a-command
521
111
2>..."not-a-command"
522
112
"""
523
113
        self.run_script(story)
524
114
525
115
    def test_ellipsis_output(self):
526
116
        story = """
527
117
cat
528
118
<first line
529
119
<second line
530
120
<last line
531
121
>first line
532
122
>...
533
123
>last line
534
124
"""
535
125
        self.run_script(story)
536
126
        story = """
537
127
bzr not-a-command
538
128
2>..."not-a-command"
539
129
"""
540
130
        self.run_script(story)
541
131
542
132
        story = """
543
133
bzr branch not-a-branch
544
134
2>bzr: ERROR: Not a branch...not-a-branch/".
545
135
"""
546
136
        self.run_script(story)
547
137
548
138
549
139
class TestCat(script.TestCaseWithTransportAndScript):
550
140
551
141
    def test_cat_usage(self):
552
142
        self.assertRaises(SyntaxError, self.run_script, 'cat foo bar baz')
553
143
        self.assertRaises(SyntaxError, self.run_script, 'cat foo <bar')
554
144
555
145
    def test_cat_input_to_output(self):
556
146
        out, err = self.run_command(['cat'], 'content\n', 'content\n', None)
557
147
        self.assertEquals('content\n', out)
558
148
        self.assertEquals(None, err)
559
149
560
150
    def test_cat_file_to_output(self):
561
151
        self.build_tree_contents([('file', 'content\n')])
562
152
        out, err = self.run_command(['cat', 'file'], None, 'content\n', None)
563
153
        self.assertEquals('content\n', out)
564
154
        self.assertEquals(None, err)
565
155
566
156
    def test_cat_input_to_file(self):
567
157
        out, err = self.run_command(['cat', '>file'], 'content\n', None, None)
568
158
        self.assertFileEqual('content\n', 'file')
569
159
        self.assertEquals(None, out)
570
160
        self.assertEquals(None, err)
571
161
        out, err = self.run_command(['cat', '>>file'], 'more\n', None, None)
572
162
        self.assertFileEqual('content\nmore\n', 'file')
573
163
        self.assertEquals(None, out)
574
164
        self.assertEquals(None, err)
575
165
576
166
    def test_cat_file_to_file(self):
577
167
        self.build_tree_contents([('file', 'content\n')])
578
168
        out, err = self.run_command(['cat', 'file', '>file2'], None, None, None)
579
169
        self.assertFileEqual('content\n', 'file2')
580
170
581
171
582
172
class TestMkdir(script.TestCaseWithTransportAndScript):
583
173
584
174
    def test_mkdir_usage(self):
585
175
        self.assertRaises(SyntaxError, self.run_script, 'mkdir')
586
176
        self.assertRaises(SyntaxError, self.run_script, 'mkdir foo bar')
587
177
588
178
    def test_mkdir_jailed(self):
589
179
        self.assertRaises(ValueError, self.run_script, 'mkdir /out-of-jail')
590
180
        self.assertRaises(ValueError, self.run_script, 'mkdir ../out-of-jail')
591
181
592
182
    def test_mkdir_in_jail(self):
593
183
        self.run_script("""
594
184
mkdir dir
595
185
cd dir
596
186
mkdir ../dir2
597
187
cd ..
598
188
""")
599
189
        self.failUnlessExists('dir')
600
190
        self.failUnlessExists('dir2')
601
191
602
192
603
193
class TestCd(script.TestCaseWithTransportAndScript):
604
194
605
195
    def test_cd_usage(self):
606
196
        self.assertRaises(SyntaxError, self.run_script, 'cd foo bar')
607
197
608
198
    def test_cd_out_of_jail(self):
609
199
        self.assertRaises(ValueError, self.run_script, 'cd /out-of-jail')
610
200
        self.assertRaises(ValueError, self.run_script, 'cd ..')
611
201
612
202
    def test_cd_dir_and_back_home(self):
613
203
        self.assertEquals(self.test_dir, osutils.getcwd())
614
204
        self.run_script("""
615
205
mkdir dir
616
206
cd dir
617
207
""")
618
208
        self.assertEquals(osutils.pathjoin(self.test_dir, 'dir'),
619
209
                          osutils.getcwd())
620
210
621
211
        self.run_script('cd')
622
212
        self.assertEquals(self.test_dir, osutils.getcwd())
623
213
624
214
625
215
class TestBzr(script.TestCaseWithTransportAndScript):
626
216
627
217
    def test_bzr_smoke(self):
628
218
        self.run_script('bzr init branch')
629
219
        self.failUnlessExists('branch')
630
220
631
221
632
222
class TestEcho(script.TestCaseWithMemoryTransportAndScript):
633
223
634
224
    def test_echo_usage(self):
635
225
        story = """
636
226
echo foo
637
227
<bar
638
228
"""
639
229
        self.assertRaises(SyntaxError, self.run_script, story)
640
230
641
231
    def test_echo_to_output(self):
642
232
        out, err = self.run_command(['echo'], None, '\n', None)
643
233
        self.assertEquals('\n', out)
644
234
        self.assertEquals(None, err)
645
235
646
236
    def test_echo_some_to_output(self):
647
237
        out, err = self.run_command(['echo', 'hello'], None, 'hello\n', None)
648
238
        self.assertEquals('hello\n', out)
649
239
        self.assertEquals(None, err)
650
240
651
241
    def test_echo_more_output(self):
652
242
        out, err = self.run_command(['echo', 'hello', 'happy', 'world'],
653
243
                                    None, 'hellohappyworld\n', None)
654
244
        self.assertEquals('hellohappyworld\n', out)
655
245
        self.assertEquals(None, err)
656
246
657
247
    def test_echo_appended(self):
658
248
        out, err = self.run_command(['echo', 'hello', '>file'],
659
249
                                    None, None, None)
660
250
        self.assertEquals(None, out)
661
251
        self.assertEquals(None, err)
662
252
        self.assertFileEqual('hello\n', 'file')
663
253
        out, err = self.run_command(['echo', 'happy', '>>file'],
664
254
                                    None, None, None)
665
255
        self.assertEquals(None, out)
666
256
        self.assertEquals(None, err)
667
257
        self.assertFileEqual('hello\nhappy\n', 'file')
Status:	Rejected
Rejected by:	Vincent Ladeuil on 2009-09-17
Proposed branch:	lp:~vila/bzr/shell-like-tests
Merge into:	lp:bzr
Diff against target:	None lines
To merge this branch:	bzr merge lp:~vila/bzr/shell-like-tests
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Martin Pool		2009-09-04	Needs Fixing on 2009-09-16
Review via email: mp+11204@code.launchpad.net