~bzr-pqm/bzr/bzr.dev

class TestTransportProviderAdapter(TestCase):

    """A group of tests that test the transport implementation adaption core.

 

    transports.

 

    test file even though it is specific to transport tests at the moment.

    """

 

        permutation_count = 0

        for module in modules:

            try:

                    (module + ".get_test_permutations").split('.')[1:],

                     __import__(module))())

            except errors.DependencyNotPresent:

            ("new id 2", {"bzrdir_format":None}))

        # input_test should have been altered.

        self.assertRaises(AttributeError, getattr, input_test, "bzrdir_format")

        # made new ones, and unspecified elements in the scenario

        # should not have been altered.

        self.assertEqual("bzr_format", adapted_test1.bzrdir_format)

        """The test_home_dir for TestCaseWithMemoryTransport is missing.

 

        This is because TestCaseWithMemoryTransport is for tests that do not

        few tests should need to do that), and having a missing dir as home is

        an effective way to ensure that this is the case.

        """

            self.TEST_ROOT + "/MemoryTransportMissingHomeDir",

            self.test_home_dir)

        self.assertIsSameRealPath(self.test_home_dir, os.environ['HOME'])

    def test_cwd_is_TEST_ROOT(self):

        self.assertIsSameRealPath(self.test_dir, self.TEST_ROOT)

        cwd = osutils.getcwd()

    def test_make_bzrdir_preserves_transport(self):

        t = self.get_transport()

        result_bzrdir = self.make_bzrdir('subdir')

                              MemoryTransport)

        # should not be on disk, should only be in memory

        self.failIfExists('subdir')

                time.sleep(0.003)

        self.check_timing(ShortDelayTestCase('test_short_delay'),

                          r"^ +[0-9]+ms$")

    def test_assigned_benchmark_file_stores_date(self):

        output = StringIO()

        result = bzrlib.tests.TextTestResult(self._log_file,

        self.assertContainsRe(lines[1],

            " *[0-9]+ms bzrlib.tests.test_selftest.TestTestResult"

            "._time_hello_world_encoding")

    def _time_hello_world_encoding(self):

        """Profile two sleep calls

        This is used to exercise the test framework.

        """

        self.time(unicode, 'hello', errors='replace')

        # execute the test, which should succeed and record profiles

        example_test_case.run(result)

        # lsprofile_something()

        # LSProf output for <built in function unicode> (['hello'], {'errors': 'replace'})

        #    CallCount    Recursive    Total(ms)   Inline(ms) module:lineno(function)

        # (the lsprof header)

        # ... an arbitrary number of lines

        # and the function call which is time.sleep.

        # and then repeated but with 'world', rather than 'hello'.

        # this should appear in the output stream of our test result.

        output = result_stream.getvalue()

        output = result_stream.getvalue()[prefix:]

        lines = output.splitlines()

        self.assertEqual(lines, ['NODEP                   0ms', "    The feature 'Feature' is not available."])

    def test_text_report_unsupported(self):

        # text test output formatting

        pb = MockProgress()

            ('update', '[2 in 0s, 2 missing] passing_test', None, None),

            ],

            pb.calls[1:])

    def test_unavailable_exception(self):

        """An UnavailableFeature being raised should invoke addNotSupported."""

        class InstrumentedTestResult(ExtendedTestResult):

        result.addNotSupported(test, feature)

        self.assertFalse(result.wasStrictlySuccessful())

        self.assertEqual(None, result._extractBenchmarkTime(test))

    def test_strict_with_known_failure(self):

        result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,

                                             verbosity=1)

 

        This current saves and restores:

        TestCaseInTempDir.TEST_ROOT

        There should be no tests in this file that use bzrlib.tests.TextTestRunner

        without using this convenience method, because of our use of global state.

        """

        orig_selftest_flags = tests.selftest_debug_flags

        self.addCleanup(self._restore_selftest_debug_flags, orig_selftest_flags)

        tests.selftest_debug_flags = set(new_flags)

    def _restore_selftest_debug_flags(self, flags):

        tests.selftest_debug_flags = flags

 

        # should setup a new log, log content to it, setup a child case (B),

        # which should log independently, then case (A) should log a trailer

        # and return.

        # logs after the outer child finishes is correct, which a bad clean

        # up routine in tearDown might trigger a fault in our test with only

        # one child, we should instead see the bad result inside our test with

 

    def test__gather_lsprof_in_benchmarks(self):

        """When _gather_lsprof_in_benchmarks is on, accumulate profile data.

        Each self.time() call is individually and separately profiled.

        """

        self.requireFeature(test_lsprof.LSProfFeature)

        # needed.

        self._gather_lsprof_in_benchmarks = True

        self.time(time.sleep, 0.000)

    def test_run_no_parameters(self):

        test = SampleTestCase('_test_pass')

        test.run()

    def test_run_enabled_unittest_result(self):

        """Test we revert to regular behaviour when the test is enabled."""

        test = SampleTestCase('_test_pass')

        self.assertEqual(2, self.applyDeprecated(zero_eleven,

            sample_deprecated_function))

        # calling a nested deprecation with the wrong deprecation version

        # supplied version.

        self.assertRaises(AssertionError, self.applyDeprecated,

            zero_eleven, sample_object.sample_nested_deprecation)

    def test_callDeprecated(self):

        def testfunc(be_deprecated, result=None):

            if be_deprecated is True:

                                       stacklevel=1)

            return result

        result = self.callDeprecated(['i am deprecated'], testfunc, True)

            return TestSuite()

        out = StringIO()

        err = StringIO()

            test_suite_factory=factory)

        self.assertEqual([True], factory_called)