/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/script.py

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/script.py
24
24
import glob
25
25
import os
26
26
import shlex
27
 
import textwrap
28
27
from cStringIO import StringIO
29
28
 
30
29
from bzrlib import (
31
 
    errors,
32
30
    osutils,
33
31
    tests,
34
32
    )
57
55
    Input lines start with '<'.
58
56
    Output lines start with nothing.
59
57
    Error lines start with '2>'.
60
 
 
61
 
    :return: A sequence of ([args], input, output, errors), where the args are
62
 
        split in to words, and the input, output, and errors are just strings,
63
 
        typically containing newlines.
64
58
    """
65
59
 
66
60
    commands = []
79
73
    cmd_line = 1
80
74
    lineno = 0
81
75
    input, output, error = None, None, None
82
 
    text = textwrap.dedent(text)
83
 
    lines = text.split('\n')
84
 
    # to make use of triple-quoted strings easier, we ignore a blank line
85
 
    # right at the start and right at the end; the rest are meaningful
86
 
    if lines and lines[0] == '':
87
 
        del lines[0]
88
 
    if lines and lines[-1] == '':
89
 
        del lines[-1]
90
 
    for line in lines:
 
76
    for line in text.split('\n'):
91
77
        lineno += 1
92
78
        # Keep a copy for error reporting
93
79
        orig = line
94
80
        comment =  line.find('#')
95
81
        if comment >= 0:
96
82
            # Delete comments
97
 
            # NB: this syntax means comments are allowed inside output, which
98
 
            # may be confusing...
99
83
            line = line[0:comment]
100
84
            line = line.rstrip()
101
 
            if line == '':
102
 
                continue
 
85
        if line == '':
 
86
            # Ignore empty lines
 
87
            continue
103
88
        if line.startswith('$'):
104
89
            # Time to output the current command
105
90
            add_command(cmd_cur, input, output, error)
213
198
        method = getattr(self, mname, None)
214
199
        if method is None:
215
200
            raise SyntaxError('Command not found "%s"' % (cmd[0],),
216
 
                              (None, 1, 1, ' '.join(cmd)))
 
201
                              None, 1, ' '.join(cmd))
217
202
        if input is None:
218
203
            str_input = ''
219
204
        else:
222
207
        retcode, actual_output, actual_error = method(test_case,
223
208
                                                      str_input, args)
224
209
 
225
 
        try:
226
 
            self._check_output(output, actual_output, test_case)
227
 
        except AssertionError, e:
228
 
            raise AssertionError(str(e) + " in stdout of command %s" % cmd)
229
 
        try:
230
 
            self._check_output(error, actual_error, test_case)
231
 
        except AssertionError, e:
232
 
            raise AssertionError(str(e) +
233
 
                " in stderr of running command %s" % cmd)
 
210
        self._check_output(output, actual_output, test_case)
 
211
        self._check_output(error, actual_error, test_case)
234
212
        if retcode and not error and actual_error:
235
213
            test_case.fail('In \n\t%s\nUnexpected error: %s'
236
214
                           % (' '.join(cmd), actual_error))
237
215
        return retcode, actual_output, actual_error
238
216
 
239
217
    def _check_output(self, expected, actual, test_case):
240
 
        if not actual:
241
 
            if expected is None:
242
 
                return
243
 
            elif expected == '...\n':
244
 
                return
245
 
            else:
246
 
                test_case.fail('expected output: %r, but found nothing'
247
 
                            % (expected,))
248
 
        expected = expected or ''
 
218
        if expected is None:
 
219
            # Specifying None means: any output is accepted
 
220
            return
 
221
        if actual is None:
 
222
            test_case.fail('We expected output: %r, but found None'
 
223
                           % (expected,))
249
224
        matching = self.output_checker.check_output(
250
225
            expected, actual, self.check_options)
251
226
        if not matching:
255
230
            # 'expected' parameter. So we just fallback to our good old
256
231
            # assertEqualDiff since we know there *are* differences and the
257
232
            # output should be decently readable.
258
 
            #
259
 
            # As a special case, we allow output that's missing a final
260
 
            # newline to match an expected string that does have one, so that
261
 
            # we can match a prompt printed on one line, then input given on
262
 
            # the next line.
263
 
            if expected == actual + '\n':
264
 
                pass
265
 
            else:
266
 
                test_case.assertEqualDiff(expected, actual)
 
233
            test_case.assertEqualDiff(expected, actual)
267
234
 
268
235
    def _pre_process_args(self, args):
269
236
        new_args = []
508
475
    def run_command(self, cmd, input, output, error):
509
476
        return self.script_runner.run_command(self, cmd, input, output, error)
510
477
 
511
 
 
512
 
def run_script(test_case, script_string):
513
 
    """Run the given script within a testcase"""
514
 
    return ScriptRunner().run_script(test_case, script_string)
515