← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_win32utils.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-09-01 08:02:42 UTC
  • mfrom: (5390.3.3 faster-revert-593560)
  • Revision ID: pqm@pqm.ubuntu.com-20100901080242-esg62ody4frwmy66
(spiv) Avoid repeatedly calling self.target.all_file_ids() in
 InterTree.iter_changes. (Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_win32utils.py
1
 
# Copyright (C) 2007 Canonical Ltd
 
1
# Copyright (C) 2007-2010 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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
"""Tests for win32utils."""
 
18
 
17
19
import os
18
20
import sys
19
21
 
20
 
from bzrlib import osutils
21
 
from bzrlib.tests import TestCase, TestCaseInTempDir, TestSkipped, Feature
 
22
from bzrlib import (
 
23
    osutils,
 
24
    tests,
 
25
    win32utils,
 
26
    )
 
27
from bzrlib.tests import (
 
28
    Feature,
 
29
    TestCase,
 
30
    TestCaseInTempDir,
 
31
    TestSkipped,
 
32
    UnicodeFilenameFeature,
 
33
    )
 
34
from bzrlib.tests.features import backslashdir_feature
22
35
from bzrlib.win32utils import glob_expand, get_app_path
23
 
from bzrlib import win32utils
24
 
 
25
 
 
26
 
# Features
27
 
# --------
28
 
 
29
 
class _NeedsGlobExpansionFeature(Feature):
30
 
 
31
 
    def _probe(self):
32
 
        return sys.platform == 'win32'
33
 
 
34
 
    def feature_name(self):
35
 
        return 'Internally performed glob expansion'
36
 
 
37
 
NeedsGlobExpansionFeature = _NeedsGlobExpansionFeature()
38
36
 
39
37
 
40
38
class _RequiredModuleFeature(Feature):
56
54
Win32RegistryFeature = _RequiredModuleFeature('_winreg')
57
55
CtypesFeature = _RequiredModuleFeature('ctypes')
58
56
Win32comShellFeature = _RequiredModuleFeature('win32com.shell')
 
57
Win32ApiFeature = _RequiredModuleFeature('win32api') 
59
58
 
60
59
 
61
60
# Tests
62
61
# -----
63
62
 
64
 
class TestNeedsGlobExpansionFeature(TestCase):
65
 
 
66
 
    def test_available(self):
67
 
        self.assertEqual(sys.platform == 'win32',
68
 
                         NeedsGlobExpansionFeature.available())
69
 
 
70
 
    def test_str(self):
71
 
        self.assertTrue("performed" in str(NeedsGlobExpansionFeature))
72
 
 
73
 
 
74
63
class TestWin32UtilsGlobExpand(TestCaseInTempDir):
75
64
 
76
 
    _test_needs_features = [NeedsGlobExpansionFeature]
 
65
    _test_needs_features = []
77
66
 
78
67
    def test_empty_tree(self):
79
68
        self.build_tree([])
83
72
            [['*'], ['*']],
84
73
            [['a', 'a'], ['a', 'a']]])
85
74
 
86
 
    def test_tree_ascii(self):
87
 
        """Checks the glob expansion and path separation char
88
 
        normalization"""
 
75
    def build_ascii_tree(self):
89
76
        self.build_tree(['a', 'a1', 'a2', 'a11', 'a.1',
90
77
                         'b', 'b1', 'b2', 'b3',
91
78
                         'c/', 'c/c1', 'c/c2',
92
79
                         'd/', 'd/d1', 'd/d2', 'd/e/', 'd/e/e1'])
 
80
 
 
81
    def build_unicode_tree(self):
 
82
        self.requireFeature(UnicodeFilenameFeature)
 
83
        self.build_tree([u'\u1234', u'\u1234\u1234', u'\u1235/',
 
84
                         u'\u1235/\u1235'])
 
85
 
 
86
    def test_tree_ascii(self):
 
87
        """Checks the glob expansion and path separation char
 
88
        normalization"""
 
89
        self.build_ascii_tree()
93
90
        self._run_testset([
94
91
            # no wildcards
95
92
            [[u'a'], [u'a']],
96
93
            [[u'a', u'a' ], [u'a', u'a']],
97
 
            [[u'A'], [u'A']],
98
94
 
99
95
            [[u'd'], [u'd']],
100
96
            [[u'd/'], [u'd/']],
101
 
            [[u'd\\'], [u'd/']],
102
97
 
103
98
            # wildcards
104
99
            [[u'a*'], [u'a', u'a1', u'a2', u'a11', u'a.1']],
106
101
            [[u'a?'], [u'a1', u'a2']],
107
102
            [[u'a??'], [u'a11', u'a.1']],
108
103
            [[u'b[1-2]'], [u'b1', u'b2']],
109
 
            [[u'A?'], [u'a1', u'a2']],
110
104
 
111
105
            [[u'd/*'], [u'd/d1', u'd/d2', u'd/e']],
 
106
            [[u'?/*'], [u'c/c1', u'c/c2', u'd/d1', u'd/d2', u'd/e']],
 
107
            [[u'*/*'], [u'c/c1', u'c/c2', u'd/d1', u'd/d2', u'd/e']],
 
108
            [[u'*/'], [u'c/', u'd/']],
 
109
            ])
 
110
 
 
111
    def test_backslash_globbing(self):
 
112
        self.requireFeature(backslashdir_feature)
 
113
        self.build_ascii_tree()
 
114
        self._run_testset([
 
115
            [[u'd\\'], [u'd/']],
112
116
            [[u'd\\*'], [u'd/d1', u'd/d2', u'd/e']],
113
117
            [[u'?\\*'], [u'c/c1', u'c/c2', u'd/d1', u'd/d2', u'd/e']],
114
118
            [[u'*\\*'], [u'c/c1', u'c/c2', u'd/d1', u'd/d2', u'd/e']],
115
 
            [[u'*/'], [u'c/', u'd/']],
116
 
            [[u'*\\'], [u'c/', u'd/']]])
 
119
            [[u'*\\'], [u'c/', u'd/']],
 
120
            ])
 
121
 
 
122
    def test_case_insensitive_globbing(self):
 
123
        self.requireFeature(tests.CaseInsCasePresFilenameFeature)
 
124
        self.build_ascii_tree()
 
125
        self._run_testset([
 
126
            [[u'A'], [u'A']],
 
127
            [[u'A?'], [u'a1', u'a2']],
 
128
            ])
117
129
 
118
130
    def test_tree_unicode(self):
119
131
        """Checks behaviour with non-ascii filenames"""
120
 
        self.build_tree([u'\u1234', u'\u1234\u1234', u'\u1235/', u'\u1235/\u1235'])
 
132
        self.build_unicode_tree()
121
133
        self._run_testset([
122
134
            # no wildcards
123
135
            [[u'\u1234'], [u'\u1234']],
133
145
 
134
146
            [[u'\u1235/?'], [u'\u1235/\u1235']],
135
147
            [[u'\u1235/*'], [u'\u1235/\u1235']],
 
148
            [[u'?/'], [u'\u1235/']],
 
149
            [[u'*/'], [u'\u1235/']],
 
150
            [[u'?/?'], [u'\u1235/\u1235']],
 
151
            [[u'*/*'], [u'\u1235/\u1235']],
 
152
            ])
 
153
 
 
154
    def test_unicode_backslashes(self):
 
155
        self.requireFeature(backslashdir_feature)
 
156
        self.build_unicode_tree()
 
157
        self._run_testset([
 
158
            # no wildcards
 
159
            [[u'\u1235\\'], [u'\u1235/']],
 
160
            [[u'\u1235\\\u1235'], [u'\u1235/\u1235']],
136
161
            [[u'\u1235\\?'], [u'\u1235/\u1235']],
137
162
            [[u'\u1235\\*'], [u'\u1235/\u1235']],
138
 
            [[u'?/'], [u'\u1235/']],
139
 
            [[u'*/'], [u'\u1235/']],
140
163
            [[u'?\\'], [u'\u1235/']],
141
164
            [[u'*\\'], [u'\u1235/']],
142
 
            [[u'?/?'], [u'\u1235/\u1235']],
143
 
            [[u'*/*'], [u'\u1235/\u1235']],
144
165
            [[u'?\\?'], [u'\u1235/\u1235']],
145
 
            [[u'*\\*'], [u'\u1235/\u1235']]])
 
166
            [[u'*\\*'], [u'\u1235/\u1235']],
 
167
            ])
146
168
 
147
169
    def _run_testset(self, testset):
148
170
        for pattern, expected in testset:
164
186
            self.assertEquals('iexplore.exe', b.lower())
165
187
            self.assertNotEquals('', d)
166
188
 
 
189
    def test_wordpad(self):
 
190
        # typical windows users should have wordpad in the system
 
191
        # but there is problem: its path has the format REG_EXPAND_SZ
 
192
        # so naive attempt to get the path is not working
 
193
        self.requireFeature(Win32ApiFeature)
 
194
        for a in ('wordpad', 'wordpad.exe'):
 
195
            p = get_app_path(a)
 
196
            d, b = os.path.split(p)
 
197
            self.assertEquals('wordpad.exe', b.lower())
 
198
            self.assertNotEquals('', d)
 
199
 
167
200
    def test_not_existing(self):
168
201
        p = get_app_path('not-existing')
169
202
        self.assertEquals('not-existing', p)
222
255
        super(TestLocationsPywin32, self).setUp()
223
256
        # We perform the exact same tests after disabling the use of ctypes.
224
257
        # This causes the implementation to fall back to pywin32.
225
 
        self.old_ctypes = win32utils.has_ctypes
226
 
        win32utils.has_ctypes = False
227
 
        self.addCleanup(self.restoreCtypes)
228
 
 
229
 
    def restoreCtypes(self):
230
 
        win32utils.has_ctypes = self.old_ctypes
 
258
        self.overrideAttr(win32utils, 'has_ctypes', False)
 
259
        # FIXME: this should be done by parametrization -- vila 100123
 
260
 
 
261
 
 
262
class TestSetHidden(TestCaseInTempDir):
 
263
 
 
264
    def test_unicode_dir(self):
 
265
        # we should handle unicode paths without errors
 
266
        self.requireFeature(UnicodeFilenameFeature)
 
267
        os.mkdir(u'\u1234')
 
268
        win32utils.set_file_attr_hidden(u'\u1234')
 
269
 
 
270
    def test_dot_bzr_in_unicode_dir(self):
 
271
        # we should not raise traceback if we try to set hidden attribute
 
272
        # on .bzr directory below unicode path
 
273
        self.requireFeature(UnicodeFilenameFeature)
 
274
        os.makedirs(u'\u1234\\.bzr')
 
275
        path = osutils.abspath(u'\u1234\\.bzr')
 
276
        win32utils.set_file_attr_hidden(path)
 
277
 
 
278
 
 
279
class Test_CommandLineToArgv(tests.TestCaseInTempDir):
 
280
 
 
281
    def assertCommandLine(self, expected, line, argv=None,
 
282
            single_quotes_allowed=False):
 
283
        # Strictly speaking we should respect parameter order versus glob
 
284
        # expansions, but it's not really worth the effort here
 
285
        if argv is None:
 
286
            argv = [line]
 
287
        argv = win32utils._command_line_to_argv(line, argv,
 
288
                single_quotes_allowed=single_quotes_allowed)
 
289
        self.assertEqual(expected, sorted(argv))
 
290
 
 
291
    def test_glob_paths(self):
 
292
        self.build_tree(['a/', 'a/b.c', 'a/c.c', 'a/c.h'])
 
293
        self.assertCommandLine([u'a/b.c', u'a/c.c'], 'a/*.c')
 
294
        self.build_tree(['b/', 'b/b.c', 'b/d.c', 'b/d.h'])
 
295
        self.assertCommandLine([u'a/b.c', u'b/b.c'], '*/b.c')
 
296
        self.assertCommandLine([u'a/b.c', u'a/c.c', u'b/b.c', u'b/d.c'],
 
297
                               '*/*.c')
 
298
        # Bash style, just pass through the argument if nothing matches
 
299
        self.assertCommandLine([u'*/*.qqq'], '*/*.qqq')
 
300
 
 
301
    def test_quoted_globs(self):
 
302
        self.build_tree(['a/', 'a/b.c', 'a/c.c', 'a/c.h'])
 
303
        self.assertCommandLine([u'a/*.c'], '"a/*.c"')
 
304
        self.assertCommandLine([u"'a/*.c'"], "'a/*.c'")
 
305
        self.assertCommandLine([u'a/*.c'], "'a/*.c'",
 
306
            single_quotes_allowed=True)
 
307
 
 
308
    def test_slashes_changed(self):
 
309
        # Quoting doesn't change the supplied args
 
310
        self.assertCommandLine([u'a\\*.c'], '"a\\*.c"')
 
311
        self.assertCommandLine([u'a\\*.c'], "'a\\*.c'",
 
312
            single_quotes_allowed=True)
 
313
        # Expands the glob, but nothing matches, swaps slashes
 
314
        self.assertCommandLine([u'a/*.c'], 'a\\*.c')
 
315
        self.assertCommandLine([u'a/?.c'], 'a\\?.c')
 
316
        # No glob, doesn't touch slashes
 
317
        self.assertCommandLine([u'a\\foo.c'], 'a\\foo.c')
 
318
 
 
319
    def test_single_quote_support(self):
 
320
        self.assertCommandLine(["add", "let's-do-it.txt"],
 
321
            "add let's-do-it.txt",
 
322
            ["add", "let's-do-it.txt"])
 
323
        self.expectFailure("Using single quotes breaks trimming from argv",
 
324
            self.assertCommandLine, ["add", "lets do it.txt"],
 
325
            "add 'lets do it.txt'", ["add", "'lets", "do", "it.txt'"],
 
326
            single_quotes_allowed=True)
 
327
 
 
328
    def test_case_insensitive_globs(self):
 
329
        self.requireFeature(tests.CaseInsCasePresFilenameFeature)
 
330
        self.build_tree(['a/', 'a/b.c', 'a/c.c', 'a/c.h'])
 
331
        self.assertCommandLine([u'A/b.c'], 'A/B*')
 
332
 
 
333
    def test_backslashes(self):
 
334
        self.requireFeature(backslashdir_feature)
 
335
        self.build_tree(['a/', 'a/b.c', 'a/c.c', 'a/c.h'])
 
336
        self.assertCommandLine([u'a/b.c'], 'a\\b*')
 
337
 
 
338
    def test_with_pdb(self):
 
339
        """Check stripping Python arguments before bzr script per lp:587868"""
 
340
        self.assertCommandLine([u"rocks"], "-m pdb rocks", ["rocks"])
 
341
        self.build_tree(['d/', 'd/f1', 'd/f2'])
 
342
        self.assertCommandLine([u"rm", u"x*"], "-m pdb rm x*", ["rm", u"x*"])
 
343
        self.assertCommandLine([u"add", u"d/f1", u"d/f2"], "-m pdb add d/*",
 
344
            ["add", u"d/*"])