~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2005, 2006, 2007 Canonical Ltd

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

import bzrlib

from bzrlib.errors import BzrBadParameterNotUnicode, InvalidURL

from bzrlib.osutils import (

        is_inside_any,

        is_inside_or_parent_of_any,

        pathjoin,

        pumpfile,

        pump_string_file,

        )

        adapt_tests,

        Feature,

        probe_unicode_in_user_encoding,

        split_suite_by_re,

        StringIOWrapper,

        SymlinkFeature,

        TestCase,

        TestCaseInTempDir,

        TestScenarioApplier,

        TestSkipped,

        )

from bzrlib.tests.file_utils import (

    FakeReadFile,

from bzrlib.tests.test__walkdirs_win32 import WalkdirsWin32Feature

 

 

def load_tests(standard_tests, module, loader):

    """Parameterize readdir tests."""

    to_adapt, result = split_suite_by_re(standard_tests, "readdir")

    adapter = TestScenarioApplier()

    from bzrlib import _readdir_py

    adapter.scenarios = [('python', {'read_dir': _readdir_py.read_dir})]

    if ReadDirFeature.available():

        adapter.scenarios.append(('pyrex',

            {'read_dir': ReadDirFeature.read_dir}))

    adapt_tests(to_adapt, adapter, result)

    return result

 

 

class _ReadDirFeature(Feature):

            self.read_dir = _readdir_pyx.read_dir

ReadDirFeature = _ReadDirFeature()

 

 

class TestOSUtils(TestCaseInTempDir):

        def rename(a, b):

            osutils.fancy_rename(a, b,

                    rename_func=os.rename,

                    unlink_func=os.unlink)

 

        open('a', 'wb').write('something in a\n')

        rename('a', 'b')

        open('a', 'wb').write('new something in a\n')

        rename('b', 'a')

        open('a', 'wb').write('something in a\n')

        open('a', 'wb').write('new something in a\n')

        SRC_FOO_C = pathjoin('src', 'foo.c')

            self.assert_(is_inside_any(dirs, fn))

            self.assertFalse(is_inside_any(dirs, fn))

            self.assert_(is_inside_or_parent_of_any(dirs, fn))

            

            self.assertFalse(is_inside_or_parent_of_any(dirs, fn))

        

        self.assertEqual(osutils.kind_marker('file'), '')

        self.assertEqual(osutils.kind_marker('directory'), '/')

        self.assertEqual(osutils.kind_marker('symlink'), '@')

        self.assertEqual(osutils.kind_marker('tree-reference'), '+')

        try:

            os.umask(0222)

            self.assertEqual(0222, osutils.get_umask())

            os.umask(0022)

            self.assertEqual(0022, osutils.get_umask())

            os.umask(0002)

            self.assertEqual(0002, osutils.get_umask())

            os.umask(0027)

            self.assertEqual(0027, osutils.get_umask())

        finally:

            os.umask(orig_umask)

        self.requireFeature(SymlinkFeature)

        

    def test_kind_marker(self):

        self.assertEqual("", osutils.kind_marker("file"))

        self.assertEqual("/", osutils.kind_marker(osutils._directory_kind))

        self.assertEqual("@", osutils.kind_marker("symlink"))

        self.assertRaises(errors.BzrError, osutils.kind_marker, "unknown")

 

class TestPumpFile(TestCase):

        from_file = FakeReadFile(self.test_data)

        pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)

        pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)

        pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)

        pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)

        from_file = FakeReadFile(self.test_data)

        pumpfile(from_file, to_file, self.test_data_len, self.block_size)

        from_file = FakeReadFile(self.test_data)

        pumpfile(from_file, to_file, -1, self.block_size)

        from_file = FakeReadFile(self.test_data)

        pumpfile(from_file, to_file)

 

class TestPumpStringFile(TestCase):

        pump_string_file("", output)

        pump_string_file("123456789", output, 2)

        pump_string_file("12", output, 2)

        pump_string_file("1234", output, 2)

class TestSafeUnicode(TestCase):

        self.assertRaises(BzrBadParameterNotUnicode,

class TestSafeUtf8(TestCase):

        self.assertRaises(BzrBadParameterNotUnicode,

class TestSafeRevisionId(TestCase):

class TestSafeFileId(TestCase):

class TestWin32Funcs(TestCase):

    """Test that the _win32 versions of os utilities return appropriate paths."""

        self.assertEqual('path/to/foo', osutils._win32_pathjoin('path', 'to', 'foo'))

        self.assertEqual('C:/foo', osutils._win32_pathjoin('path\\to', 'C:\\foo'))

        self.assertEqual('C:/foo', osutils._win32_pathjoin('path/to', 'C:/foo'))

        self.assertEqual('path/to/foo', osutils._win32_pathjoin('path/to/', 'foo'))

        self.assertEqual('/foo', osutils._win32_pathjoin('C:/path/to/', '/foo'))

        self.assertEqual('/foo', osutils._win32_pathjoin('C:\\path\\to\\', '\\foo'))

        self.assertEqual('path/to/foo', osutils._win32_normpath(r'path\\from\..\to\.\foo'))

        self.assertEqual('path/to/foo', osutils._win32_normpath('path//from/../to/./foo'))

class TestWin32FuncsDirs(TestCaseInTempDir):

    

        if win32utils.winver == 'Windows 98':

            raise TestSkipped('Windows 98 cannot handle unicode filenames')

        # Make sure getcwd can handle unicode filenames

        try:

            os.mkdir(u'mu-\xb5')

        except UnicodeError:

            raise TestSkipped("Unable to create Unicode filename")

 

class TestMacFuncsDirs(TestCaseInTempDir):

        # On Mac, this will actually create Ba\u030agfors

        # but chdir will still work, because it accepts both paths

        try:

            os.mkdir(u'B\xe5gfors')

        except UnicodeError:

            raise TestSkipped("Unable to create Unicode filename")

 

        try:

            os.mkdir(u'Ba\u030agfors')

        except UnicodeError:

            raise TestSkipped("Unable to create Unicode filename")

 

class TestSplitLines(TestCase):

class TestWalkDirs(TestCaseInTempDir):

 

    def test_readdir(self):

        tree = [

            '.bzr/',

            '0file',

            '1dir/',

            '1dir/0file',

            '1dir/1dir/',

            '2file'

            ]

        self.build_tree(tree)

        expected_names = ['.bzr', '0file', '1dir', '2file']

        # read_dir returns pairs, which form a table with either None in all

        # the first columns, or a sort key to get best on-disk-read order, 

        # and the disk path name in utf-8 encoding in the second column.

        read_result = self.read_dir('.')

        # The second column is always the names, and every name except "." and

        # ".." should be present.

        names = sorted([row[1] for row in read_result])

        self.assertEqual(expected_names, names)

        expected_sort_key = None

        if read_result[0][0] is None:

            # No sort key returned - all keys must None

            operator = self.assertEqual

        else:

            # A sort key in the first row implies sort keys in the other rows.

            operator = self.assertNotEqual

        for row in read_result: