← 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: John Arbash Meinel
  • Date: 2010-02-17 17:11:16 UTC
  • mfrom: (4797.2.17 2.1)
  • mto: (4797.2.18 2.1)
  • mto: This revision was merged to the branch mainline in revision 5055.
  • Revision ID: john@arbash-meinel.com-20100217171116-h7t9223ystbnx5h8
merge bzr.2.1 in preparation for NEWS entry.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_win32utils.py
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
 
 
19
17
import os
20
18
import sys
21
19
 
31
29
    TestSkipped,
32
30
    UnicodeFilenameFeature,
33
31
    )
34
 
from bzrlib.tests.features import backslashdir_feature
35
32
from bzrlib.win32utils import glob_expand, get_app_path
36
33
 
37
34
 
 
35
class _BackslashDirSeparatorFeature(tests.Feature):
 
36
 
 
37
    def _probe(self):
 
38
        try:
 
39
            os.lstat(os.getcwd() + '\\')
 
40
        except OSError:
 
41
            return False
 
42
        else:
 
43
            return True
 
44
 
 
45
    def feature_name(self):
 
46
        return "Filesystem treats '\\' as a directory separator."
 
47
 
 
48
BackslashDirSeparatorFeature = _BackslashDirSeparatorFeature()
 
49
 
 
50
 
38
51
class _RequiredModuleFeature(Feature):
39
52
 
40
53
    def __init__(self, mod_name):
54
67
Win32RegistryFeature = _RequiredModuleFeature('_winreg')
55
68
CtypesFeature = _RequiredModuleFeature('ctypes')
56
69
Win32comShellFeature = _RequiredModuleFeature('win32com.shell')
57
 
Win32ApiFeature = _RequiredModuleFeature('win32api') 
58
70
 
59
71
 
60
72
# Tests
109
121
            ])
110
122
 
111
123
    def test_backslash_globbing(self):
112
 
        self.requireFeature(backslashdir_feature)
 
124
        self.requireFeature(BackslashDirSeparatorFeature)
113
125
        self.build_ascii_tree()
114
126
        self._run_testset([
115
127
            [[u'd\\'], [u'd/']],
152
164
            ])
153
165
 
154
166
    def test_unicode_backslashes(self):
155
 
        self.requireFeature(backslashdir_feature)
 
167
        self.requireFeature(BackslashDirSeparatorFeature)
156
168
        self.build_unicode_tree()
157
169
        self._run_testset([
158
170
            # no wildcards
190
202
        # typical windows users should have wordpad in the system
191
203
        # but there is problem: its path has the format REG_EXPAND_SZ
192
204
        # so naive attempt to get the path is not working
193
 
        self.requireFeature(Win32ApiFeature)
194
205
        for a in ('wordpad', 'wordpad.exe'):
195
206
            p = get_app_path(a)
196
207
            d, b = os.path.split(p)
255
266
        super(TestLocationsPywin32, self).setUp()
256
267
        # We perform the exact same tests after disabling the use of ctypes.
257
268
        # This causes the implementation to fall back to pywin32.
258
 
        self.overrideAttr(win32utils, 'has_ctypes', False)
259
 
        # FIXME: this should be done by parametrization -- vila 100123
 
269
        self.old_ctypes = win32utils.has_ctypes
 
270
        win32utils.has_ctypes = False
 
271
        self.addCleanup(self.restoreCtypes)
 
272
 
 
273
    def restoreCtypes(self):
 
274
        win32utils.has_ctypes = self.old_ctypes
260
275
 
261
276
 
262
277
class TestSetHidden(TestCaseInTempDir):
276
291
        win32utils.set_file_attr_hidden(path)
277
292
 
278
293
 
 
294
 
 
295
class TestUnicodeShlex(tests.TestCase):
 
296
 
 
297
    def assertAsTokens(self, expected, line):
 
298
        s = win32utils.UnicodeShlex(line)
 
299
        self.assertEqual(expected, list(s))
 
300
 
 
301
    def test_simple(self):
 
302
        self.assertAsTokens([(False, u'foo'), (False, u'bar'), (False, u'baz')],
 
303
                            u'foo bar baz')
 
304
 
 
305
    def test_ignore_multiple_spaces(self):
 
306
        self.assertAsTokens([(False, u'foo'), (False, u'bar')], u'foo  bar')
 
307
 
 
308
    def test_ignore_leading_space(self):
 
309
        self.assertAsTokens([(False, u'foo'), (False, u'bar')], u'  foo bar')
 
310
 
 
311
    def test_ignore_trailing_space(self):
 
312
        self.assertAsTokens([(False, u'foo'), (False, u'bar')], u'foo bar  ')
 
313
 
 
314
    def test_posix_quotations(self):
 
315
        self.assertAsTokens([(True, u'foo bar')], u'"foo bar"')
 
316
        self.assertAsTokens([(False, u"'fo''o"), (False, u"b''ar'")],
 
317
            u"'fo''o b''ar'")
 
318
        self.assertAsTokens([(True, u'foo bar')], u'"fo""o b""ar"')
 
319
        self.assertAsTokens([(True, u"fo'o"), (True, u"b'ar")],
 
320
            u'"fo"\'o b\'"ar"')
 
321
 
 
322
    def test_nested_quotations(self):
 
323
        self.assertAsTokens([(True, u'foo"" bar')], u"\"foo\\\"\\\" bar\"")
 
324
        self.assertAsTokens([(True, u'foo\'\' bar')], u"\"foo'' bar\"")
 
325
 
 
326
    def test_empty_result(self):
 
327
        self.assertAsTokens([], u'')
 
328
        self.assertAsTokens([], u'    ')
 
329
 
 
330
    def test_quoted_empty(self):
 
331
        self.assertAsTokens([(True, '')], u'""')
 
332
        self.assertAsTokens([(False, u"''")], u"''")
 
333
 
 
334
    def test_unicode_chars(self):
 
335
        self.assertAsTokens([(False, u'f\xb5\xee'), (False, u'\u1234\u3456')],
 
336
                             u'f\xb5\xee \u1234\u3456')
 
337
 
 
338
    def test_newline_in_quoted_section(self):
 
339
        self.assertAsTokens([(True, u'foo\nbar\nbaz\n')], u'"foo\nbar\nbaz\n"')
 
340
 
 
341
    def test_escape_chars(self):
 
342
        self.assertAsTokens([(False, u'foo\\bar')], u'foo\\bar')
 
343
 
 
344
    def test_escape_quote(self):
 
345
        self.assertAsTokens([(True, u'foo"bar')], u'"foo\\"bar"')
 
346
 
 
347
    def test_double_escape(self):
 
348
        self.assertAsTokens([(True, u'foo\\bar')], u'"foo\\\\bar"')
 
349
        self.assertAsTokens([(False, u'foo\\\\bar')], u"foo\\\\bar")
 
350
 
 
351
 
279
352
class Test_CommandLineToArgv(tests.TestCaseInTempDir):
280
353
 
281
 
    def assertCommandLine(self, expected, line, argv=None,
282
 
            single_quotes_allowed=False):
 
354
    def assertCommandLine(self, expected, line):
283
355
        # Strictly speaking we should respect parameter order versus glob
284
356
        # 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))
 
357
        self.assertEqual(expected,
 
358
                         sorted(win32utils._command_line_to_argv(line)))
290
359
 
291
360
    def test_glob_paths(self):
292
361
        self.build_tree(['a/', 'a/b.c', 'a/c.c', 'a/c.h'])
302
371
        self.build_tree(['a/', 'a/b.c', 'a/c.c', 'a/c.h'])
303
372
        self.assertCommandLine([u'a/*.c'], '"a/*.c"')
304
373
        self.assertCommandLine([u"'a/*.c'"], "'a/*.c'")
305
 
        self.assertCommandLine([u'a/*.c'], "'a/*.c'",
306
 
            single_quotes_allowed=True)
307
374
 
308
375
    def test_slashes_changed(self):
309
376
        # Quoting doesn't change the supplied args
310
377
        self.assertCommandLine([u'a\\*.c'], '"a\\*.c"')
311
 
        self.assertCommandLine([u'a\\*.c'], "'a\\*.c'",
312
 
            single_quotes_allowed=True)
313
378
        # Expands the glob, but nothing matches, swaps slashes
314
379
        self.assertCommandLine([u'a/*.c'], 'a\\*.c')
315
380
        self.assertCommandLine([u'a/?.c'], 'a\\?.c')
316
381
        # No glob, doesn't touch slashes
317
382
        self.assertCommandLine([u'a\\foo.c'], 'a\\foo.c')
318
383
 
319
 
    def test_single_quote_support(self):
 
384
    def test_no_single_quote_supported(self):
320
385
        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)
 
386
            "add let's-do-it.txt")
327
387
 
328
388
    def test_case_insensitive_globs(self):
329
389
        self.requireFeature(tests.CaseInsCasePresFilenameFeature)
331
391
        self.assertCommandLine([u'A/b.c'], 'A/B*')
332
392
 
333
393
    def test_backslashes(self):
334
 
        self.requireFeature(backslashdir_feature)
 
394
        self.requireFeature(BackslashDirSeparatorFeature)
335
395
        self.build_tree(['a/', 'a/b.c', 'a/c.c', 'a/c.h'])
336
396
        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/*"])