← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_win32utils.py

Split the win32 globbing tests up a bit.

They were testing both that case-insensitive globbing worked
for 'A*' matching 'a1', and that '/' was supported as a 
directory separator. Which doesn't apply on all platforms.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_win32utils.py
69
69
            [['*'], ['*']],
70
70
            [['a', 'a'], ['a', 'a']]])
71
71
 
72
 
    def test_tree_ascii(self):
73
 
        """Checks the glob expansion and path separation char
74
 
        normalization"""
 
72
    def build_ascii_tree(self):
75
73
        self.build_tree(['a', 'a1', 'a2', 'a11', 'a.1',
76
74
                         'b', 'b1', 'b2', 'b3',
77
75
                         'c/', 'c/c1', 'c/c2',
78
76
                         'd/', 'd/d1', 'd/d2', 'd/e/', 'd/e/e1'])
 
77
 
 
78
    def build_unicode_tree(self):
 
79
        self.requireFeature(UnicodeFilenameFeature)
 
80
        self.build_tree([u'\u1234', u'\u1234\u1234', u'\u1235/',
 
81
                         u'\u1235/\u1235'])
 
82
 
 
83
    def test_tree_ascii(self):
 
84
        """Checks the glob expansion and path separation char
 
85
        normalization"""
 
86
        self.build_ascii_tree()
79
87
        self._run_testset([
80
88
            # no wildcards
81
89
            [[u'a'], [u'a']],
82
90
            [[u'a', u'a' ], [u'a', u'a']],
83
 
            [[u'A'], [u'A']],
84
91
 
85
92
            [[u'd'], [u'd']],
86
93
            [[u'd/'], [u'd/']],
87
 
            [[u'd\\'], [u'd/']],
88
94
 
89
95
            # wildcards
90
96
            [[u'a*'], [u'a', u'a1', u'a2', u'a11', u'a.1']],
92
98
            [[u'a?'], [u'a1', u'a2']],
93
99
            [[u'a??'], [u'a11', u'a.1']],
94
100
            [[u'b[1-2]'], [u'b1', u'b2']],
95
 
            [[u'A?'], [u'a1', u'a2']],
96
101
 
97
102
            [[u'd/*'], [u'd/d1', u'd/d2', u'd/e']],
 
103
            [[u'?/*'], [u'c/c1', u'c/c2', u'd/d1', u'd/d2', u'd/e']],
 
104
            [[u'*/*'], [u'c/c1', u'c/c2', u'd/d1', u'd/d2', u'd/e']],
 
105
            [[u'*/'], [u'c/', u'd/']],
 
106
            ])
 
107
 
 
108
    def test_backslash_globbing(self):
 
109
        self.build_ascii_tree()
 
110
        try:
 
111
            os.lstat('d\\d2')
 
112
        except OSError:
 
113
            raise tests.TestNotApplicable("filesystem doesn't treat"
 
114
                " \\ as a directory separator")
 
115
        self._run_testset([
 
116
            [[u'd\\'], [u'd/']],
98
117
            [[u'd\\*'], [u'd/d1', u'd/d2', u'd/e']],
99
118
            [[u'?\\*'], [u'c/c1', u'c/c2', u'd/d1', u'd/d2', u'd/e']],
100
119
            [[u'*\\*'], [u'c/c1', u'c/c2', u'd/d1', u'd/d2', u'd/e']],
101
 
            [[u'*/'], [u'c/', u'd/']],
102
 
            [[u'*\\'], [u'c/', u'd/']]])
 
120
            [[u'*\\'], [u'c/', u'd/']],
 
121
            ])
 
122
 
 
123
    def test_case_insensitive_globbing(self):
 
124
        self.requireFeature(tests.CaseInsensitiveFilesystemFeature)
 
125
        self.build_ascii_tree()
 
126
        self._run_testset([
 
127
            [[u'A'], [u'A']],
 
128
            [[u'A?'], [u'a1', u'a2']],
 
129
            ])
103
130
 
104
131
    def test_tree_unicode(self):
105
132
        """Checks behaviour with non-ascii filenames"""
106
 
        self.requireFeature(UnicodeFilenameFeature)
107
 
        self.build_tree([u'\u1234', u'\u1234\u1234', u'\u1235/',
108
 
                         u'\u1235/\u1235'])
 
133
        self.build_unicode_tree()
109
134
        self._run_testset([
110
135
            # no wildcards
111
136
            [[u'\u1234'], [u'\u1234']],
121
146
 
122
147
            [[u'\u1235/?'], [u'\u1235/\u1235']],
123
148
            [[u'\u1235/*'], [u'\u1235/\u1235']],
 
149
            [[u'?/'], [u'\u1235/']],
 
150
            [[u'*/'], [u'\u1235/']],
 
151
            [[u'?/?'], [u'\u1235/\u1235']],
 
152
            [[u'*/*'], [u'\u1235/\u1235']],
 
153
            ])
 
154
 
 
155
    def test_unicode_backslashes(self):
 
156
        self.build_unicode_tree()
 
157
        try:
 
158
            os.lstat('\u1235\\\u1235')
 
159
        except OSError:
 
160
            raise tests.TestNotApplicable("filesystem doesn't treat"
 
161
                " \\ as a directory separator")
 
162
        self._run_testset([
 
163
            # no wildcards
 
164
            [[u'\u1235\\'], [u'\u1235\\']],
 
165
            [[u'\u1235\\\u1235'], [u'\u1235\\\u1235']],
124
166
            [[u'\u1235\\?'], [u'\u1235/\u1235']],
125
167
            [[u'\u1235\\*'], [u'\u1235/\u1235']],
126
 
            [[u'?/'], [u'\u1235/']],
127
 
            [[u'*/'], [u'\u1235/']],
128
168
            [[u'?\\'], [u'\u1235/']],
129
169
            [[u'*\\'], [u'\u1235/']],
130
 
            [[u'?/?'], [u'\u1235/\u1235']],
131
 
            [[u'*/*'], [u'\u1235/\u1235']],
132
170
            [[u'?\\?'], [u'\u1235/\u1235']],
133
 
            [[u'*\\*'], [u'\u1235/\u1235']]])
 
171
            [[u'*\\*'], [u'\u1235/\u1235']],
 
172
            ])
134
173
 
135
174
    def _run_testset(self, testset):
136
175
        for pattern, expected in testset: