~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_osutils.py

  • Committer: Ian Clatworthy
  • Date: 2009-07-02 08:26:00 UTC
  • mto: (4527.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 4529.
  • Revision ID: ian.clatworthy@canonical.com-20090702082600-qwb1evvvfa8ctnye
first draft of a 2.0 Upgrade Guide

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
29
29
    errors,
30
30
    osutils,
31
31
    tests,
32
 
    trace,
33
32
    win32utils,
34
33
    )
35
34
from bzrlib.tests import (
36
 
    features,
37
35
    file_utils,
38
36
    test__walkdirs_win32,
39
37
    )
54
52
 
55
53
UTF8DirReaderFeature = _UTF8DirReaderFeature()
56
54
 
57
 
term_ios_feature = tests.ModuleAvailableFeature('termios')
58
 
 
59
55
 
60
56
def _already_unicode(s):
61
57
    return s
62
58
 
63
59
 
 
60
def _fs_enc_to_unicode(s):
 
61
    return s.decode(osutils._fs_enc)
 
62
 
 
63
 
64
64
def _utf8_to_unicode(s):
65
65
    return s.decode('UTF-8')
66
66
 
83
83
                          dict(_dir_reader_class=_readdir_pyx.UTF8DirReader,
84
84
                               _native_to_unicode=_utf8_to_unicode)))
85
85
 
86
 
    if test__walkdirs_win32.win32_readdir_feature.available():
 
86
    if test__walkdirs_win32.Win32ReadDirFeature.available():
87
87
        try:
88
88
            from bzrlib import _walkdirs_win32
 
89
            # TODO: check on windows, it may be that we need to use/add
 
90
            # safe_unicode instead of _fs_enc_to_unicode
89
91
            scenarios.append(
90
92
                ('win32',
91
93
                 dict(_dir_reader_class=_walkdirs_win32.Win32ReadDir,
92
 
                      _native_to_unicode=_already_unicode)))
 
94
                      _native_to_unicode=_fs_enc_to_unicode)))
93
95
        except ImportError:
94
96
            pass
95
97
    return scenarios
123
125
 
124
126
class TestRename(tests.TestCaseInTempDir):
125
127
 
126
 
    def create_file(self, filename, content):
127
 
        f = open(filename, 'wb')
128
 
        try:
129
 
            f.write(content)
130
 
        finally:
131
 
            f.close()
132
 
 
133
 
    def _fancy_rename(self, a, b):
134
 
        osutils.fancy_rename(a, b, rename_func=os.rename,
135
 
                             unlink_func=os.unlink)
136
 
 
137
128
    def test_fancy_rename(self):
138
129
        # This should work everywhere
139
 
        self.create_file('a', 'something in a\n')
140
 
        self._fancy_rename('a', 'b')
 
130
        def rename(a, b):
 
131
            osutils.fancy_rename(a, b,
 
132
                    rename_func=os.rename,
 
133
                    unlink_func=os.unlink)
 
134
 
 
135
        open('a', 'wb').write('something in a\n')
 
136
        rename('a', 'b')
141
137
        self.failIfExists('a')
142
138
        self.failUnlessExists('b')
143
139
        self.check_file_contents('b', 'something in a\n')
144
140
 
145
 
        self.create_file('a', 'new something in a\n')
146
 
        self._fancy_rename('b', 'a')
 
141
        open('a', 'wb').write('new something in a\n')
 
142
        rename('b', 'a')
147
143
 
148
144
        self.check_file_contents('a', 'something in a\n')
149
145
 
150
 
    def test_fancy_rename_fails_source_missing(self):
151
 
        # An exception should be raised, and the target should be left in place
152
 
        self.create_file('target', 'data in target\n')
153
 
        self.assertRaises((IOError, OSError), self._fancy_rename,
154
 
                          'missingsource', 'target')
155
 
        self.failUnlessExists('target')
156
 
        self.check_file_contents('target', 'data in target\n')
157
 
 
158
 
    def test_fancy_rename_fails_if_source_and_target_missing(self):
159
 
        self.assertRaises((IOError, OSError), self._fancy_rename,
160
 
                          'missingsource', 'missingtarget')
161
 
 
162
146
    def test_rename(self):
163
147
        # Rename should be semi-atomic on all platforms
164
 
        self.create_file('a', 'something in a\n')
 
148
        open('a', 'wb').write('something in a\n')
165
149
        osutils.rename('a', 'b')
166
150
        self.failIfExists('a')
167
151
        self.failUnlessExists('b')
168
152
        self.check_file_contents('b', 'something in a\n')
169
153
 
170
 
        self.create_file('a', 'new something in a\n')
 
154
        open('a', 'wb').write('new something in a\n')
171
155
        osutils.rename('b', 'a')
172
156
 
173
157
        self.check_file_contents('a', 'something in a\n')
310
294
        self.assertEqual("/", osutils.kind_marker(osutils._directory_kind))
311
295
        self.assertEqual("@", osutils.kind_marker("symlink"))
312
296
        self.assertEqual("+", osutils.kind_marker("tree-reference"))
313
 
        self.assertEqual("", osutils.kind_marker("fifo"))
314
 
        self.assertEqual("", osutils.kind_marker("socket"))
315
 
        self.assertEqual("", osutils.kind_marker("unknown"))
 
297
        self.assertRaises(errors.BzrError, osutils.kind_marker, "unknown")
316
298
 
317
299
 
318
300
class TestUmask(tests.TestCaseInTempDir):
383
365
        # Instead blackbox.test_locale should check for localized
384
366
        # dates once they do occur in output strings.
385
367
 
386
 
    def test_format_date_with_offset_in_original_timezone(self):
387
 
        self.assertEqual("Thu 1970-01-01 00:00:00 +0000",
388
 
            osutils.format_date_with_offset_in_original_timezone(0))
389
 
        self.assertEqual("Fri 1970-01-02 03:46:40 +0000",
390
 
            osutils.format_date_with_offset_in_original_timezone(100000))
391
 
        self.assertEqual("Fri 1970-01-02 05:46:40 +0200",
392
 
            osutils.format_date_with_offset_in_original_timezone(100000, 7200))
393
 
 
394
368
    def test_local_time_offset(self):
395
369
        """Test that local_time_offset() returns a sane value."""
396
370
        offset = osutils.local_time_offset()
472
446
    def test_canonical_relpath_simple(self):
473
447
        f = file('MixedCaseName', 'w')
474
448
        f.close()
475
 
        actual = osutils.canonical_relpath(self.test_base_dir, 'mixedcasename')
 
449
        # Watch out for tricky test dir (on OSX /tmp -> /private/tmp)
 
450
        real_base_dir = osutils.realpath(self.test_base_dir)
 
451
        actual = osutils.canonical_relpath(real_base_dir, 'mixedcasename')
476
452
        self.failUnlessEqual('work/MixedCaseName', actual)
477
453
 
478
454
    def test_canonical_relpath_missing_tail(self):
479
455
        os.mkdir('MixedCaseParent')
480
 
        actual = osutils.canonical_relpath(self.test_base_dir,
 
456
        # Watch out for tricky test dir (on OSX /tmp -> /private/tmp)
 
457
        real_base_dir = osutils.realpath(self.test_base_dir)
 
458
        actual = osutils.canonical_relpath(real_base_dir,
481
459
                                           'mixedcaseparent/nochild')
482
460
        self.failUnlessEqual('work/MixedCaseParent/nochild', actual)
483
461
 
484
462
 
485
 
class Test_CICPCanonicalRelpath(tests.TestCaseWithTransport):
486
 
 
487
 
    def assertRelpath(self, expected, base, path):
488
 
        actual = osutils._cicp_canonical_relpath(base, path)
489
 
        self.assertEqual(expected, actual)
490
 
 
491
 
    def test_simple(self):
492
 
        self.build_tree(['MixedCaseName'])
493
 
        base = osutils.realpath(self.get_transport('.').local_abspath('.'))
494
 
        self.assertRelpath('MixedCaseName', base, 'mixedcAsename')
495
 
 
496
 
    def test_subdir_missing_tail(self):
497
 
        self.build_tree(['MixedCaseParent/', 'MixedCaseParent/a_child'])
498
 
        base = osutils.realpath(self.get_transport('.').local_abspath('.'))
499
 
        self.assertRelpath('MixedCaseParent/a_child', base,
500
 
                           'MixedCaseParent/a_child')
501
 
        self.assertRelpath('MixedCaseParent/a_child', base,
502
 
                           'MixedCaseParent/A_Child')
503
 
        self.assertRelpath('MixedCaseParent/not_child', base,
504
 
                           'MixedCaseParent/not_child')
505
 
 
506
 
    def test_at_root_slash(self):
507
 
        # We can't test this on Windows, because it has a 'MIN_ABS_PATHLENGTH'
508
 
        # check...
509
 
        if osutils.MIN_ABS_PATHLENGTH > 1:
510
 
            raise tests.TestSkipped('relpath requires %d chars'
511
 
                                    % osutils.MIN_ABS_PATHLENGTH)
512
 
        self.assertRelpath('foo', '/', '/foo')
513
 
 
514
 
    def test_at_root_drive(self):
515
 
        if sys.platform != 'win32':
516
 
            raise tests.TestNotApplicable('we can only test drive-letter relative'
517
 
                                          ' paths on Windows where we have drive'
518
 
                                          ' letters.')
519
 
        # see bug #322807
520
 
        # The specific issue is that when at the root of a drive, 'abspath'
521
 
        # returns "C:/" or just "/". However, the code assumes that abspath
522
 
        # always returns something like "C:/foo" or "/foo" (no trailing slash).
523
 
        self.assertRelpath('foo', 'C:/', 'C:/foo')
524
 
        self.assertRelpath('foo', 'X:/', 'X:/foo')
525
 
        self.assertRelpath('foo', 'X:/', 'X://foo')
526
 
 
527
 
 
528
463
class TestPumpFile(tests.TestCase):
529
464
    """Test pumpfile method."""
530
465
 
690
625
        self.assertEqual("1234", output.getvalue())
691
626
 
692
627
 
693
 
class TestRelpath(tests.TestCase):
694
 
 
695
 
    def test_simple_relpath(self):
696
 
        cwd = osutils.getcwd()
697
 
        subdir = cwd + '/subdir'
698
 
        self.assertEqual('subdir', osutils.relpath(cwd, subdir))
699
 
 
700
 
    def test_deep_relpath(self):
701
 
        cwd = osutils.getcwd()
702
 
        subdir = cwd + '/sub/subsubdir'
703
 
        self.assertEqual('sub/subsubdir', osutils.relpath(cwd, subdir))
704
 
 
705
 
    def test_not_relative(self):
706
 
        self.assertRaises(errors.PathNotChild,
707
 
                          osutils.relpath, 'C:/path', 'H:/path')
708
 
        self.assertRaises(errors.PathNotChild,
709
 
                          osutils.relpath, 'C:/', 'H:/path')
710
 
 
711
 
 
712
628
class TestSafeUnicode(tests.TestCase):
713
629
 
714
630
    def test_from_ascii_string(self):
992
908
 
993
909
    def test_osutils_binding(self):
994
910
        from bzrlib.tests import test__chunks_to_lines
995
 
        if test__chunks_to_lines.compiled_chunkstolines_feature.available():
 
911
        if test__chunks_to_lines.CompiledChunksToLinesFeature.available():
996
912
            from bzrlib._chunks_to_lines_pyx import chunks_to_lines
997
913
        else:
998
914
            from bzrlib._chunks_to_lines_py import chunks_to_lines
1138
1054
            dirblock[:] = new_dirblock
1139
1055
 
1140
1056
    def _save_platform_info(self):
1141
 
        self.overrideAttr(win32utils, 'winver')
1142
 
        self.overrideAttr(osutils, '_fs_enc')
1143
 
        self.overrideAttr(osutils, '_selected_dir_reader')
 
1057
        cur_winver = win32utils.winver
 
1058
        cur_fs_enc = osutils._fs_enc
 
1059
        cur_dir_reader = osutils._selected_dir_reader
 
1060
        def restore():
 
1061
            win32utils.winver = cur_winver
 
1062
            osutils._fs_enc = cur_fs_enc
 
1063
            osutils._selected_dir_reader = cur_dir_reader
 
1064
        self.addCleanup(restore)
1144
1065
 
1145
1066
    def assertDirReaderIs(self, expected):
1146
1067
        """Assert the right implementation for _walkdirs_utf8 is chosen."""
1179
1100
 
1180
1101
    def test_force_walkdirs_utf8_nt(self):
1181
1102
        # Disabled because the thunk of the whole walkdirs api is disabled.
1182
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1103
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1183
1104
        self._save_platform_info()
1184
1105
        win32utils.winver = 'Windows NT'
1185
1106
        from bzrlib._walkdirs_win32 import Win32ReadDir
1186
1107
        self.assertDirReaderIs(Win32ReadDir)
1187
1108
 
1188
1109
    def test_force_walkdirs_utf8_98(self):
1189
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1110
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1190
1111
        self._save_platform_info()
1191
1112
        win32utils.winver = 'Windows 98'
1192
1113
        self.assertDirReaderIs(osutils.UnicodeDirReader)
1343
1264
        self.assertEqual(expected_dirblocks, result)
1344
1265
 
1345
1266
    def test__walkdirs_utf8_win32readdir(self):
1346
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1267
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1347
1268
        self.requireFeature(tests.UnicodeFilenameFeature)
1348
1269
        from bzrlib._walkdirs_win32 import Win32ReadDir
1349
1270
        self._save_platform_info()
1400
1321
 
1401
1322
    def test__walkdirs_utf_win32_find_file_stat_file(self):
1402
1323
        """make sure our Stat values are valid"""
1403
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1324
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1404
1325
        self.requireFeature(tests.UnicodeFilenameFeature)
1405
1326
        from bzrlib._walkdirs_win32 import Win32ReadDir
1406
1327
        name0u = u'0file-\xb6'
1424
1345
 
1425
1346
    def test__walkdirs_utf_win32_find_file_stat_directory(self):
1426
1347
        """make sure our Stat values are valid"""
1427
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1348
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1428
1349
        self.requireFeature(tests.UnicodeFilenameFeature)
1429
1350
        from bzrlib._walkdirs_win32 import Win32ReadDir
1430
1351
        name0u = u'0dir-\u062c\u0648'
1579
1500
        def cleanup():
1580
1501
            if 'BZR_TEST_ENV_VAR' in os.environ:
1581
1502
                del os.environ['BZR_TEST_ENV_VAR']
 
1503
 
1582
1504
        self.addCleanup(cleanup)
1583
1505
 
1584
1506
    def test_set(self):
1632
1554
        text = 'test\r\nwith\nall\rpossible line endings\r\n'
1633
1555
        self.build_tree_contents([('foo', text)])
1634
1556
        expected_sha = osutils.sha_string(text)
1635
 
        f = open('foo', 'rb')
 
1557
        f = open('foo')
1636
1558
        self.addCleanup(f.close)
1637
1559
        size, sha = osutils.size_sha_file(f)
1638
1560
        self.assertEqual(38, size)
1695
1617
 
1696
1618
    def setUp(self):
1697
1619
        tests.TestCaseInTempDir.setUp(self)
1698
 
        self.overrideAttr(osutils,
1699
 
                          '_selected_dir_reader', self._dir_reader_class())
 
1620
 
 
1621
        # Save platform specific info and reset it
 
1622
        cur_dir_reader = osutils._selected_dir_reader
 
1623
 
 
1624
        def restore():
 
1625
            osutils._selected_dir_reader = cur_dir_reader
 
1626
        self.addCleanup(restore)
 
1627
 
 
1628
        osutils._selected_dir_reader = self._dir_reader_class()
1700
1629
 
1701
1630
    def _get_ascii_tree(self):
1702
1631
        tree = [
1847
1776
 
1848
1777
class TestConcurrency(tests.TestCase):
1849
1778
 
1850
 
    def setUp(self):
1851
 
        super(TestConcurrency, self).setUp()
1852
 
        self.overrideAttr(osutils, '_cached_local_concurrency')
1853
 
 
1854
1779
    def test_local_concurrency(self):
1855
1780
        concurrency = osutils.local_concurrency()
1856
1781
        self.assertIsInstance(concurrency, int)
1857
 
 
1858
 
    def test_local_concurrency_environment_variable(self):
1859
 
        os.environ['BZR_CONCURRENCY'] = '2'
1860
 
        self.assertEqual(2, osutils.local_concurrency(use_cache=False))
1861
 
        os.environ['BZR_CONCURRENCY'] = '3'
1862
 
        self.assertEqual(3, osutils.local_concurrency(use_cache=False))
1863
 
        os.environ['BZR_CONCURRENCY'] = 'foo'
1864
 
        self.assertEqual(1, osutils.local_concurrency(use_cache=False))
1865
 
 
1866
 
    def test_option_concurrency(self):
1867
 
        os.environ['BZR_CONCURRENCY'] = '1'
1868
 
        self.run_bzr('rocks --concurrency 42')
1869
 
        # Command line overrides envrionment variable
1870
 
        self.assertEquals('42', os.environ['BZR_CONCURRENCY'])
1871
 
        self.assertEquals(42, osutils.local_concurrency(use_cache=False))
1872
 
 
1873
 
 
1874
 
class TestFailedToLoadExtension(tests.TestCase):
1875
 
 
1876
 
    def _try_loading(self):
1877
 
        try:
1878
 
            import bzrlib._fictional_extension_py
1879
 
        except ImportError, e:
1880
 
            osutils.failed_to_load_extension(e)
1881
 
            return True
1882
 
 
1883
 
    def setUp(self):
1884
 
        super(TestFailedToLoadExtension, self).setUp()
1885
 
        self.overrideAttr(osutils, '_extension_load_failures', [])
1886
 
 
1887
 
    def test_failure_to_load(self):
1888
 
        self._try_loading()
1889
 
        self.assertLength(1, osutils._extension_load_failures)
1890
 
        self.assertEquals(osutils._extension_load_failures[0],
1891
 
            "No module named _fictional_extension_py")
1892
 
 
1893
 
    def test_report_extension_load_failures_no_warning(self):
1894
 
        self.assertTrue(self._try_loading())
1895
 
        warnings, result = self.callCatchWarnings(osutils.report_extension_load_failures)
1896
 
        # it used to give a Python warning; it no longer does
1897
 
        self.assertLength(0, warnings)
1898
 
 
1899
 
    def test_report_extension_load_failures_message(self):
1900
 
        log = StringIO()
1901
 
        trace.push_log_file(log)
1902
 
        self.assertTrue(self._try_loading())
1903
 
        osutils.report_extension_load_failures()
1904
 
        self.assertContainsRe(
1905
 
            log.getvalue(),
1906
 
            r"bzr: warning: some compiled extensions could not be loaded; "
1907
 
            "see <https://answers\.launchpad\.net/bzr/\+faq/703>\n"
1908
 
            )
1909
 
 
1910
 
 
1911
 
class TestTerminalWidth(tests.TestCase):
1912
 
 
1913
 
    def replace_stdout(self, new):
1914
 
        self.overrideAttr(sys, 'stdout', new)
1915
 
 
1916
 
    def replace__terminal_size(self, new):
1917
 
        self.overrideAttr(osutils, '_terminal_size', new)
1918
 
 
1919
 
    def set_fake_tty(self):
1920
 
 
1921
 
        class I_am_a_tty(object):
1922
 
            def isatty(self):
1923
 
                return True
1924
 
 
1925
 
        self.replace_stdout(I_am_a_tty())
1926
 
 
1927
 
    def test_default_values(self):
1928
 
        self.assertEqual(80, osutils.default_terminal_width)
1929
 
 
1930
 
    def test_defaults_to_BZR_COLUMNS(self):
1931
 
        # BZR_COLUMNS is set by the test framework
1932
 
        self.assertNotEqual('12', os.environ['BZR_COLUMNS'])
1933
 
        os.environ['BZR_COLUMNS'] = '12'
1934
 
        self.assertEqual(12, osutils.terminal_width())
1935
 
 
1936
 
    def test_falls_back_to_COLUMNS(self):
1937
 
        del os.environ['BZR_COLUMNS']
1938
 
        self.assertNotEqual('42', os.environ['COLUMNS'])
1939
 
        self.set_fake_tty()
1940
 
        os.environ['COLUMNS'] = '42'
1941
 
        self.assertEqual(42, osutils.terminal_width())
1942
 
 
1943
 
    def test_tty_default_without_columns(self):
1944
 
        del os.environ['BZR_COLUMNS']
1945
 
        del os.environ['COLUMNS']
1946
 
 
1947
 
        def terminal_size(w, h):
1948
 
            return 42, 42
1949
 
 
1950
 
        self.set_fake_tty()
1951
 
        # We need to override the osutils definition as it depends on the
1952
 
        # running environment that we can't control (PQM running without a
1953
 
        # controlling terminal is one example).
1954
 
        self.replace__terminal_size(terminal_size)
1955
 
        self.assertEqual(42, osutils.terminal_width())
1956
 
 
1957
 
    def test_non_tty_default_without_columns(self):
1958
 
        del os.environ['BZR_COLUMNS']
1959
 
        del os.environ['COLUMNS']
1960
 
        self.replace_stdout(None)
1961
 
        self.assertEqual(None, osutils.terminal_width())
1962
 
 
1963
 
    def test_no_TIOCGWINSZ(self):
1964
 
        self.requireFeature(term_ios_feature)
1965
 
        termios = term_ios_feature.module
1966
 
        # bug 63539 is about a termios without TIOCGWINSZ attribute
1967
 
        try:
1968
 
            orig = termios.TIOCGWINSZ
1969
 
        except AttributeError:
1970
 
            # We won't remove TIOCGWINSZ, because it doesn't exist anyway :)
1971
 
            pass
1972
 
        else:
1973
 
            self.overrideAttr(termios, 'TIOCGWINSZ')
1974
 
            del termios.TIOCGWINSZ
1975
 
        del os.environ['BZR_COLUMNS']
1976
 
        del os.environ['COLUMNS']
1977
 
        # Whatever the result is, if we don't raise an exception, it's ok.
1978
 
        osutils.terminal_width()
1979
 
 
1980
 
class TestCreationOps(tests.TestCaseInTempDir):
1981
 
    _test_needs_features = [features.chown_feature]
1982
 
 
1983
 
    def setUp(self):
1984
 
        tests.TestCaseInTempDir.setUp(self)
1985
 
        self.overrideAttr(os, 'chown', self._dummy_chown)
1986
 
 
1987
 
        # params set by call to _dummy_chown
1988
 
        self.path = self.uid = self.gid = None
1989
 
 
1990
 
    def _dummy_chown(self, path, uid, gid):
1991
 
        self.path, self.uid, self.gid = path, uid, gid
1992
 
 
1993
 
    def test_mkdir_with_ownership_chown(self):
1994
 
        """Ensure that osutils.mkdir_with_ownership chowns correctly with ownership_src.
1995
 
        """
1996
 
        ownsrc = '/'
1997
 
        osutils.mkdir_with_ownership('foo', ownsrc)
1998
 
 
1999
 
        s = os.stat(ownsrc)
2000
 
        self.assertEquals(self.path, 'foo')
2001
 
        self.assertEquals(self.uid, s.st_uid)
2002
 
        self.assertEquals(self.gid, s.st_gid)
2003
 
 
2004
 
    def test_open_with_ownership_chown(self):
2005
 
        """Ensure that osutils.open_with_ownership chowns correctly with ownership_src.
2006
 
        """
2007
 
        ownsrc = '/'
2008
 
        f = osutils.open_with_ownership('foo', 'w', ownership_src=ownsrc)
2009
 
 
2010
 
        # do a test write and close
2011
 
        f.write('hello')
2012
 
        f.close()
2013
 
 
2014
 
        s = os.stat(ownsrc)
2015
 
        self.assertEquals(self.path, 'foo')
2016
 
        self.assertEquals(self.uid, s.st_uid)
2017
 
        self.assertEquals(self.gid, s.st_gid)
2018