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

merge bzr.dev into cleanup

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_selftest.py
490
490
        self.assertEqualStat(real, fake)
491
491
 
492
492
    def test_assertEqualStat_notequal(self):
493
 
        self.build_tree(["foo", "bar"])
 
493
        self.build_tree(["foo", "longname"])
494
494
        self.assertRaises(AssertionError, self.assertEqualStat,
495
 
            os.lstat("foo"), os.lstat("bar"))
 
495
            os.lstat("foo"), os.lstat("longname"))
496
496
 
497
497
 
498
498
class TestTestCaseWithMemoryTransport(tests.TestCaseWithMemoryTransport):
516
516
        cwd = osutils.getcwd()
517
517
        self.assertIsSameRealPath(self.test_dir, cwd)
518
518
 
 
519
    def test_BZR_HOME_and_HOME_are_bytestrings(self):
 
520
        """The $BZR_HOME and $HOME environment variables should not be unicode.
 
521
 
 
522
        See https://bugs.launchpad.net/bzr/+bug/464174
 
523
        """
 
524
        self.assertIsInstance(os.environ['BZR_HOME'], str)
 
525
        self.assertIsInstance(os.environ['HOME'], str)
 
526
 
519
527
    def test_make_branch_and_memory_tree(self):
520
528
        """In TestCaseWithMemoryTransport we should not make the branch on disk.
521
529
 
827
835
            def report_known_failure(self, test, err):
828
836
                self._call = test, err
829
837
        result = InstrumentedTestResult(None, None, None, None)
830
 
        def test_function():
831
 
            raise tests.KnownFailure('failed!')
832
 
        test = unittest.FunctionTestCase(test_function)
 
838
        class Test(tests.TestCase):
 
839
            def test_function(self):
 
840
                raise tests.KnownFailure('failed!')
 
841
        test = Test("test_function")
833
842
        test.run(result)
834
843
        # it should invoke 'report_known_failure'.
835
844
        self.assertEqual(2, len(result._call))
913
922
        result.report_unsupported(test, feature)
914
923
        output = result_stream.getvalue()[prefix:]
915
924
        lines = output.splitlines()
916
 
        self.assertEqual(lines, ['NODEP        0ms',
917
 
                                 "    The feature 'Feature' is not available."])
 
925
        # We don't check for the final '0ms' since it may fail on slow hosts
 
926
        self.assertStartsWith(lines[0], 'NODEP')
 
927
        self.assertEqual(lines[1],
 
928
                         "    The feature 'Feature' is not available.")
918
929
 
919
930
    def test_unavailable_exception(self):
920
931
        """An UnavailableFeature being raised should invoke addNotSupported."""
926
937
                self._call = test, feature
927
938
        result = InstrumentedTestResult(None, None, None, None)
928
939
        feature = tests.Feature()
929
 
        def test_function():
930
 
            raise tests.UnavailableFeature(feature)
931
 
        test = unittest.FunctionTestCase(test_function)
 
940
        class Test(tests.TestCase):
 
941
            def test_function(self):
 
942
                raise tests.UnavailableFeature(feature)
 
943
        test = Test("test_function")
932
944
        test.run(result)
933
945
        # it should invoke 'addNotSupported'.
934
946
        self.assertEqual(2, len(result._call))
951
963
                                             verbosity=1)
952
964
        test = self.get_passing_test()
953
965
        err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
954
 
        result._addKnownFailure(test, err)
 
966
        result.addExpectedFailure(test, err)
955
967
        self.assertFalse(result.wasStrictlySuccessful())
956
968
        self.assertEqual(None, result._extractBenchmarkTime(test))
957
969
 
1014
1026
    def test_known_failure_failed_run(self):
1015
1027
        # run a test that generates a known failure which should be printed in
1016
1028
        # the final output when real failures occur.
1017
 
        def known_failure_test():
1018
 
            raise tests.KnownFailure('failed')
 
1029
        class Test(tests.TestCase):
 
1030
            def known_failure_test(self):
 
1031
                raise tests.KnownFailure('failed')
1019
1032
        test = unittest.TestSuite()
1020
 
        test.addTest(unittest.FunctionTestCase(known_failure_test))
 
1033
        test.addTest(Test("known_failure_test"))
1021
1034
        def failing_test():
1022
1035
            raise AssertionError('foo')
1023
1036
        test.addTest(unittest.FunctionTestCase(failing_test))
1041
1054
            )
1042
1055
 
1043
1056
    def test_known_failure_ok_run(self):
1044
 
        # run a test that generates a known failure which should be printed in the final output.
1045
 
        def known_failure_test():
1046
 
            raise tests.KnownFailure('failed')
1047
 
        test = unittest.FunctionTestCase(known_failure_test)
 
1057
        # run a test that generates a known failure which should be printed in
 
1058
        # the final output.
 
1059
        class Test(tests.TestCase):
 
1060
            def known_failure_test(self):
 
1061
                raise tests.KnownFailure('failed')
 
1062
        test = Test("known_failure_test")
1048
1063
        stream = StringIO()
1049
1064
        runner = tests.TextTestRunner(stream=stream)
1050
1065
        result = self.run_test_runner(runner, test)
1127
1142
 
1128
1143
    def test_not_applicable(self):
1129
1144
        # run a test that is skipped because it's not applicable
1130
 
        def not_applicable_test():
1131
 
            raise tests.TestNotApplicable('this test never runs')
 
1145
        class Test(tests.TestCase):
 
1146
            def not_applicable_test(self):
 
1147
                raise tests.TestNotApplicable('this test never runs')
1132
1148
        out = StringIO()
1133
1149
        runner = tests.TextTestRunner(stream=out, verbosity=2)
1134
 
        test = unittest.FunctionTestCase(not_applicable_test)
 
1150
        test = Test("not_applicable_test")
1135
1151
        result = self.run_test_runner(runner, test)
1136
1152
        self._log_file.write(out.getvalue())
1137
1153
        self.assertTrue(result.wasSuccessful())
2481
2497
        self.assertIs(feature, exception.args[0])
2482
2498
 
2483
2499
 
 
2500
class TestModuleAvailableFeature(tests.TestCase):
 
2501
 
 
2502
    def test_available_module(self):
 
2503
        feature = tests.ModuleAvailableFeature('bzrlib.tests')
 
2504
        self.assertEqual('bzrlib.tests', feature.module_name)
 
2505
        self.assertEqual('bzrlib.tests', str(feature))
 
2506
        self.assertTrue(feature.available())
 
2507
        self.assertIs(tests, feature.module)
 
2508
 
 
2509
    def test_unavailable_module(self):
 
2510
        feature = tests.ModuleAvailableFeature('bzrlib.no_such_module_exists')
 
2511
        self.assertEqual('bzrlib.no_such_module_exists', str(feature))
 
2512
        self.assertFalse(feature.available())
 
2513
        self.assertIs(None, feature.module)
 
2514
 
 
2515
 
2484
2516
class TestSelftestFiltering(tests.TestCase):
2485
2517
 
2486
2518
    def setUp(self):