/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/__init__.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-11-02 11:05:12 UTC
  • mfrom: (4780.1.5 subunit)
  • Revision ID: pqm@pqm.ubuntu.com-20091102110512-yw3aimu88nbmvoo9
(robertc) Overhaul TestResult handling of test outcomes to degrade
        more gracefully and be more compatible with Python2.7 (Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/__init__.py
298
298
        Called from the TestCase run() method when the test
299
299
        fails with an unexpected error.
300
300
        """
301
 
        self._testConcluded(test)
302
 
        if isinstance(err[1], TestNotApplicable):
303
 
            return self._addNotApplicable(test, err)
304
 
        elif isinstance(err[1], UnavailableFeature):
305
 
            return self.addNotSupported(test, err[1].args[0])
306
 
        else:
307
 
            self._post_mortem()
308
 
            unittest.TestResult.addError(self, test, err)
309
 
            self.error_count += 1
310
 
            self.report_error(test, err)
311
 
            if self.stop_early:
312
 
                self.stop()
313
 
            self._cleanupLogFile(test)
 
301
        self._post_mortem()
 
302
        unittest.TestResult.addError(self, test, err)
 
303
        self.error_count += 1
 
304
        self.report_error(test, err)
 
305
        if self.stop_early:
 
306
            self.stop()
 
307
        self._cleanupLogFile(test)
314
308
 
315
309
    def addFailure(self, test, err):
316
310
        """Tell result that test failed.
318
312
        Called from the TestCase run() method when the test
319
313
        fails because e.g. an assert() method failed.
320
314
        """
321
 
        self._testConcluded(test)
322
 
        if isinstance(err[1], KnownFailure):
323
 
            return self._addKnownFailure(test, err)
324
 
        else:
325
 
            self._post_mortem()
326
 
            unittest.TestResult.addFailure(self, test, err)
327
 
            self.failure_count += 1
328
 
            self.report_failure(test, err)
329
 
            if self.stop_early:
330
 
                self.stop()
331
 
            self._cleanupLogFile(test)
 
315
        self._post_mortem()
 
316
        unittest.TestResult.addFailure(self, test, err)
 
317
        self.failure_count += 1
 
318
        self.report_failure(test, err)
 
319
        if self.stop_early:
 
320
            self.stop()
 
321
        self._cleanupLogFile(test)
332
322
 
333
323
    def addSuccess(self, test):
334
324
        """Tell result that test completed successfully.
335
325
 
336
326
        Called from the TestCase run()
337
327
        """
338
 
        self._testConcluded(test)
339
328
        if self._bench_history is not None:
340
329
            benchmark_time = self._extractBenchmarkTime(test)
341
330
            if benchmark_time is not None:
347
336
        unittest.TestResult.addSuccess(self, test)
348
337
        test._log_contents = ''
349
338
 
350
 
    def _testConcluded(self, test):
351
 
        """Common code when a test has finished.
352
 
 
353
 
        Called regardless of whether it succeded, failed, etc.
354
 
        """
355
 
        pass
356
 
 
357
 
    def _addKnownFailure(self, test, err):
 
339
    def addExpectedFailure(self, test, err):
358
340
        self.known_failure_count += 1
359
341
        self.report_known_failure(test, err)
360
342
 
362
344
        """The test will not be run because of a missing feature.
363
345
        """
364
346
        # this can be called in two different ways: it may be that the
365
 
        # test started running, and then raised (through addError)
 
347
        # test started running, and then raised (through requireFeature)
366
348
        # UnavailableFeature.  Alternatively this method can be called
367
 
        # while probing for features before running the tests; in that
368
 
        # case we will see startTest and stopTest, but the test will never
369
 
        # actually run.
 
349
        # while probing for features before running the test code proper; in
 
350
        # that case we will see startTest and stopTest, but the test will
 
351
        # never actually run.
370
352
        self.unsupported.setdefault(str(feature), 0)
371
353
        self.unsupported[str(feature)] += 1
372
354
        self.report_unsupported(test, feature)
376
358
        self.skip_count += 1
377
359
        self.report_skip(test, reason)
378
360
 
379
 
    def _addNotApplicable(self, test, skip_excinfo):
380
 
        if isinstance(skip_excinfo[1], TestNotApplicable):
381
 
            self.not_applicable_count += 1
382
 
            self.report_not_applicable(test, skip_excinfo)
383
 
        try:
384
 
            test.tearDown()
385
 
        except KeyboardInterrupt:
386
 
            raise
387
 
        except:
388
 
            self.addError(test, test.exc_info())
389
 
        else:
390
 
            # seems best to treat this as success from point-of-view of unittest
391
 
            # -- it actually does nothing so it barely matters :)
392
 
            unittest.TestResult.addSuccess(self, test)
393
 
            test._log_contents = ''
 
361
    def addNotApplicable(self, test, reason):
 
362
        self.not_applicable_count += 1
 
363
        self.report_not_applicable(test, reason)
394
364
 
395
365
    def printErrorList(self, flavour, errors):
396
366
        for test, err in errors:
535
505
    def report_skip(self, test, reason):
536
506
        pass
537
507
 
538
 
    def report_not_applicable(self, test, skip_excinfo):
 
508
    def report_not_applicable(self, test, reason):
539
509
        pass
540
510
 
541
511
    def report_unsupported(self, test, feature):
602
572
        self.stream.writeln(' SKIP %s\n%s'
603
573
                % (self._testTimeString(test), reason))
604
574
 
605
 
    def report_not_applicable(self, test, skip_excinfo):
606
 
        self.stream.writeln('  N/A %s\n%s'
607
 
                % (self._testTimeString(test),
608
 
                   self._error_summary(skip_excinfo)))
 
575
    def report_not_applicable(self, test, reason):
 
576
        self.stream.writeln('  N/A %s\n    %s'
 
577
                % (self._testTimeString(test), reason))
609
578
 
610
579
    def report_unsupported(self, test, feature):
611
580
        """test cannot be run because feature is missing."""
713
682
class UnavailableFeature(Exception):
714
683
    """A feature required for this test was not available.
715
684
 
 
685
    This can be considered a specialised form of SkippedTest.
 
686
 
716
687
    The feature should be used to construct the exception.
717
688
    """
718
689
 
1595
1566
    def _do_skip(self, result, reason):
1596
1567
        addSkip = getattr(result, 'addSkip', None)
1597
1568
        if not callable(addSkip):
1598
 
            result.addError(self, sys.exc_info())
 
1569
            result.addSuccess(result)
1599
1570
        else:
1600
1571
            addSkip(self, reason)
1601
1572
 
 
1573
    def _do_known_failure(self, result):
 
1574
        err = sys.exc_info()
 
1575
        addExpectedFailure = getattr(result, 'addExpectedFailure', None)
 
1576
        if addExpectedFailure is not None:
 
1577
            addExpectedFailure(self, err)
 
1578
        else:
 
1579
            result.addSuccess(self)
 
1580
 
 
1581
    def _do_not_applicable(self, result, e):
 
1582
        if not e.args:
 
1583
            reason = 'No reason given'
 
1584
        else:
 
1585
            reason = e.args[0]
 
1586
        addNotApplicable = getattr(result, 'addNotApplicable', None)
 
1587
        if addNotApplicable is not None:
 
1588
            result.addNotApplicable(self, reason)
 
1589
        else:
 
1590
            self._do_skip(result, reason)
 
1591
 
 
1592
    def _do_unsupported_or_skip(self, result, reason):
 
1593
        addNotSupported = getattr(result, 'addNotSupported', None)
 
1594
        if addNotSupported is not None:
 
1595
            result.addNotSupported(self, reason)
 
1596
        else:
 
1597
            self._do_skip(result, reason)
 
1598
 
1602
1599
    def run(self, result=None):
1603
1600
        if result is None: result = self.defaultTestResult()
 
1601
        result.startTest(self)
 
1602
        try:
 
1603
            self._run(result)
 
1604
            return result
 
1605
        finally:
 
1606
            result.stopTest(self)
 
1607
 
 
1608
    def _run(self, result):
1604
1609
        for feature in getattr(self, '_test_needs_features', []):
1605
1610
            if not feature.available():
1606
 
                result.startTest(self)
1607
 
                if getattr(result, 'addNotSupported', None):
1608
 
                    result.addNotSupported(self, feature)
1609
 
                else:
1610
 
                    result.addSuccess(self)
1611
 
                result.stopTest(self)
1612
 
                return result
 
1611
                return self._do_unsupported_or_skip(result, feature)
1613
1612
        try:
 
1613
            absent_attr = object()
 
1614
            # Python 2.5
 
1615
            method_name = getattr(self, '_testMethodName', absent_attr)
 
1616
            if method_name is absent_attr:
 
1617
                # Python 2.4
 
1618
                method_name = getattr(self, '_TestCase__testMethodName')
 
1619
            testMethod = getattr(self, method_name)
1614
1620
            try:
1615
 
                result.startTest(self)
1616
 
                absent_attr = object()
1617
 
                # Python 2.5
1618
 
                method_name = getattr(self, '_testMethodName', absent_attr)
1619
 
                if method_name is absent_attr:
1620
 
                    # Python 2.4
1621
 
                    method_name = getattr(self, '_TestCase__testMethodName')
1622
 
                testMethod = getattr(self, method_name)
1623
 
                try:
1624
 
                    try:
1625
 
                        self.setUp()
1626
 
                        if not self._bzr_test_setUp_run:
1627
 
                            self.fail(
1628
 
                                "test setUp did not invoke "
1629
 
                                "bzrlib.tests.TestCase's setUp")
1630
 
                    except KeyboardInterrupt:
1631
 
                        self._runCleanups()
1632
 
                        raise
1633
 
                    except TestSkipped, e:
1634
 
                        self._do_skip(result, e.args[0])
1635
 
                        self.tearDown()
1636
 
                        return result
1637
 
                    except:
1638
 
                        result.addError(self, sys.exc_info())
1639
 
                        self._runCleanups()
1640
 
                        return result
1641
 
 
 
1621
                try:
 
1622
                    self.setUp()
 
1623
                    if not self._bzr_test_setUp_run:
 
1624
                        self.fail(
 
1625
                            "test setUp did not invoke "
 
1626
                            "bzrlib.tests.TestCase's setUp")
 
1627
                except KeyboardInterrupt:
 
1628
                    self._runCleanups()
 
1629
                    raise
 
1630
                except KnownFailure:
 
1631
                    self._do_known_failure(result)
 
1632
                    self.tearDown()
 
1633
                    return
 
1634
                except TestNotApplicable, e:
 
1635
                    self._do_not_applicable(result, e)
 
1636
                    self.tearDown()
 
1637
                    return
 
1638
                except TestSkipped, e:
 
1639
                    self._do_skip(result, e.args[0])
 
1640
                    self.tearDown()
 
1641
                    return result
 
1642
                except UnavailableFeature, e:
 
1643
                    self._do_unsupported_or_skip(result, e.args[0])
 
1644
                    self.tearDown()
 
1645
                    return
 
1646
                except:
 
1647
                    result.addError(self, sys.exc_info())
 
1648
                    self._runCleanups()
 
1649
                    return result
 
1650
 
 
1651
                ok = False
 
1652
                try:
 
1653
                    testMethod()
 
1654
                    ok = True
 
1655
                except KnownFailure:
 
1656
                    self._do_known_failure(result)
 
1657
                except self.failureException:
 
1658
                    result.addFailure(self, sys.exc_info())
 
1659
                except TestNotApplicable, e:
 
1660
                    self._do_not_applicable(result, e)
 
1661
                except TestSkipped, e:
 
1662
                    if not e.args:
 
1663
                        reason = "No reason given."
 
1664
                    else:
 
1665
                        reason = e.args[0]
 
1666
                    self._do_skip(result, reason)
 
1667
                except UnavailableFeature, e:
 
1668
                    self._do_unsupported_or_skip(result, e.args[0])
 
1669
                except KeyboardInterrupt:
 
1670
                    self._runCleanups()
 
1671
                    raise
 
1672
                except:
 
1673
                    result.addError(self, sys.exc_info())
 
1674
 
 
1675
                try:
 
1676
                    self.tearDown()
 
1677
                    if not self._bzr_test_tearDown_run:
 
1678
                        self.fail(
 
1679
                            "test tearDown did not invoke "
 
1680
                            "bzrlib.tests.TestCase's tearDown")
 
1681
                except KeyboardInterrupt:
 
1682
                    self._runCleanups()
 
1683
                    raise
 
1684
                except:
 
1685
                    result.addError(self, sys.exc_info())
 
1686
                    self._runCleanups()
1642
1687
                    ok = False
1643
 
                    try:
1644
 
                        testMethod()
1645
 
                        ok = True
1646
 
                    except self.failureException:
1647
 
                        result.addFailure(self, sys.exc_info())
1648
 
                    except TestSkipped, e:
1649
 
                        if not e.args:
1650
 
                            reason = "No reason given."
1651
 
                        else:
1652
 
                            reason = e.args[0]
1653
 
                        self._do_skip(result, reason)
1654
 
                    except KeyboardInterrupt:
1655
 
                        self._runCleanups()
1656
 
                        raise
1657
 
                    except:
1658
 
                        result.addError(self, sys.exc_info())
1659
 
 
1660
 
                    try:
1661
 
                        self.tearDown()
1662
 
                        if not self._bzr_test_tearDown_run:
1663
 
                            self.fail(
1664
 
                                "test tearDown did not invoke "
1665
 
                                "bzrlib.tests.TestCase's tearDown")
1666
 
                    except KeyboardInterrupt:
1667
 
                        self._runCleanups()
1668
 
                        raise
1669
 
                    except:
1670
 
                        result.addError(self, sys.exc_info())
1671
 
                        self._runCleanups()
1672
 
                        ok = False
1673
 
                    if ok: result.addSuccess(self)
1674
 
                finally:
1675
 
                    result.stopTest(self)
 
1688
                if ok: result.addSuccess(self)
1676
1689
                return result
1677
 
            except TestNotApplicable:
1678
 
                # Not moved from the result [yet].
1679
 
                self._runCleanups()
1680
 
                raise
1681
1690
            except KeyboardInterrupt:
1682
1691
                self._runCleanups()
1683
1692
                raise
3381
3390
    def addFailure(self, test, err):
3382
3391
        known = self._error_looks_like('KnownFailure: ', err)
3383
3392
        if known is not None:
3384
 
            self.result._addKnownFailure(test, [KnownFailure,
3385
 
                                                KnownFailure(known), None])
 
3393
            self.result.addExpectedFailure(test,
 
3394
                [KnownFailure, KnownFailure(known), None])
3386
3395
        else:
3387
3396
            self.result.addFailure(test, err)
3388
3397