← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/script.py

  • Committer: Vincent Ladeuil
  • Date: 2010-06-17 16:54:26 UTC
  • mto: This revision was merged to the branch mainline in revision 5306.
  • Revision ID: v.ladeuil+lp@free.fr-20100617165426-741tbmgwi62a9zub
https://launchpad.net/bugs/595587
Pass BZR_PLUGINS_AT and BZR_DISABLE_PLINGS to the subprocess fpr test_import_tariff

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/script.py
28
28
from cStringIO import StringIO
29
29
 
30
30
from bzrlib import (
31
 
    errors,
32
31
    osutils,
33
32
    tests,
34
33
    )
57
56
    Input lines start with '<'.
58
57
    Output lines start with nothing.
59
58
    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
59
    """
65
60
 
66
61
    commands = []
80
75
    lineno = 0
81
76
    input, output, error = None, None, None
82
77
    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:
 
78
    for line in text.split('\n'):
91
79
        lineno += 1
92
80
        # Keep a copy for error reporting
93
81
        orig = line
94
82
        comment =  line.find('#')
95
83
        if comment >= 0:
96
84
            # Delete comments
97
 
            # NB: this syntax means comments are allowed inside output, which
98
 
            # may be confusing...
99
85
            line = line[0:comment]
100
86
            line = line.rstrip()
101
 
            if line == '':
102
 
                continue
 
87
        if line == '':
 
88
            # Ignore empty lines
 
89
            continue
103
90
        if line.startswith('$'):
104
91
            # Time to output the current command
105
92
            add_command(cmd_cur, input, output, error)
222
209
        retcode, actual_output, actual_error = method(test_case,
223
210
                                                      str_input, args)
224
211
 
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)
 
212
        self._check_output(output, actual_output, test_case)
 
213
        self._check_output(error, actual_error, test_case)
234
214
        if retcode and not error and actual_error:
235
215
            test_case.fail('In \n\t%s\nUnexpected error: %s'
236
216
                           % (' '.join(cmd), actual_error))
237
217
        return retcode, actual_output, actual_error
238
218
 
239
219
    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 ''
 
220
        if expected is None:
 
221
            # Specifying None means: any output is accepted
 
222
            return
 
223
        if actual is None:
 
224
            test_case.fail('We expected output: %r, but found None'
 
225
                           % (expected,))
249
226
        matching = self.output_checker.check_output(
250
227
            expected, actual, self.check_options)
251
228
        if not matching:
255
232
            # 'expected' parameter. So we just fallback to our good old
256
233
            # assertEqualDiff since we know there *are* differences and the
257
234
            # 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)
 
235
            test_case.assertEqualDiff(expected, actual)
267
236
 
268
237
    def _pre_process_args(self, args):
269
238
        new_args = []
512
481
def run_script(test_case, script_string):
513
482
    """Run the given script within a testcase"""
514
483
    return ScriptRunner().run_script(test_case, script_string)
515