/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_win32utils.py

  • Committer: John Arbash Meinel
  • Date: 2009-06-17 19:08:25 UTC
  • mto: This revision was merged to the branch mainline in revision 4460.
  • Revision ID: john@arbash-meinel.com-20090617190825-ktfk82li57rf2im6
It seems that fetch() no longer returns the number of revisions fetched.
It still does for *some* InterRepository fetch paths, but the generic one does not.
It is also not easy to get it to, since the Source and Sink are the ones
that would know how many keys were transmitted, and they are potentially 'remote'
objects.

This was also only tested to occur as a by-product in a random 'test_commit' test.
I assume if we really wanted the assurance, we would have a per_repo or interrepo
test for it.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_win32utils.py
1
 
# Copyright (C) 2007-2010 Canonical Ltd
 
1
# Copyright (C) 2007 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
17
17
import os
18
18
import sys
19
19
 
20
 
from bzrlib import (
21
 
    osutils,
22
 
    tests,
23
 
    win32utils,
24
 
    )
25
 
from bzrlib.tests import (
26
 
    Feature,
27
 
    TestCase,
28
 
    TestCaseInTempDir,
29
 
    TestSkipped,
30
 
    UnicodeFilenameFeature,
31
 
    )
 
20
from bzrlib import osutils
 
21
from bzrlib.tests import TestCase, TestCaseInTempDir, TestSkipped, Feature
32
22
from bzrlib.win32utils import glob_expand, get_app_path
33
 
 
34
 
 
35
 
class _BackslashDirSeparatorFeature(tests.Feature):
 
23
from bzrlib import win32utils
 
24
 
 
25
 
 
26
# Features
 
27
# --------
 
28
 
 
29
class _NeedsGlobExpansionFeature(Feature):
36
30
 
37
31
    def _probe(self):
38
 
        try:
39
 
            os.lstat(os.getcwd() + '\\')
40
 
        except OSError:
41
 
            return False
42
 
        else:
43
 
            return True
 
32
        return sys.platform == 'win32'
44
33
 
45
34
    def feature_name(self):
46
 
        return "Filesystem treats '\\' as a directory separator."
 
35
        return 'Internally performed glob expansion'
47
36
 
48
 
BackslashDirSeparatorFeature = _BackslashDirSeparatorFeature()
 
37
NeedsGlobExpansionFeature = _NeedsGlobExpansionFeature()
49
38
 
50
39
 
51
40
class _RequiredModuleFeature(Feature):
72
61
# Tests
73
62
# -----
74
63
 
 
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
 
75
74
class TestWin32UtilsGlobExpand(TestCaseInTempDir):
76
75
 
77
 
    _test_needs_features = []
 
76
    _test_needs_features = [NeedsGlobExpansionFeature]
78
77
 
79
78
    def test_empty_tree(self):
80
79
        self.build_tree([])
84
83
            [['*'], ['*']],
85
84
            [['a', 'a'], ['a', 'a']]])
86
85
 
87
 
    def build_ascii_tree(self):
 
86
    def test_tree_ascii(self):
 
87
        """Checks the glob expansion and path separation char
 
88
        normalization"""
88
89
        self.build_tree(['a', 'a1', 'a2', 'a11', 'a.1',
89
90
                         'b', 'b1', 'b2', 'b3',
90
91
                         'c/', 'c/c1', 'c/c2',
91
92
                         'd/', 'd/d1', 'd/d2', 'd/e/', 'd/e/e1'])
92
 
 
93
 
    def build_unicode_tree(self):
94
 
        self.requireFeature(UnicodeFilenameFeature)
95
 
        self.build_tree([u'\u1234', u'\u1234\u1234', u'\u1235/',
96
 
                         u'\u1235/\u1235'])
97
 
 
98
 
    def test_tree_ascii(self):
99
 
        """Checks the glob expansion and path separation char
100
 
        normalization"""
101
 
        self.build_ascii_tree()
102
93
        self._run_testset([
103
94
            # no wildcards
104
95
            [[u'a'], [u'a']],
105
96
            [[u'a', u'a' ], [u'a', u'a']],
 
97
            [[u'A'], [u'A']],
106
98
 
107
99
            [[u'd'], [u'd']],
108
100
            [[u'd/'], [u'd/']],
 
101
            [[u'd\\'], [u'd/']],
109
102
 
110
103
            # wildcards
111
104
            [[u'a*'], [u'a', u'a1', u'a2', u'a11', u'a.1']],
113
106
            [[u'a?'], [u'a1', u'a2']],
114
107
            [[u'a??'], [u'a11', u'a.1']],
115
108
            [[u'b[1-2]'], [u'b1', u'b2']],
 
109
            [[u'A?'], [u'a1', u'a2']],
116
110
 
117
111
            [[u'd/*'], [u'd/d1', u'd/d2', u'd/e']],
118
 
            [[u'?/*'], [u'c/c1', u'c/c2', u'd/d1', u'd/d2', u'd/e']],
119
 
            [[u'*/*'], [u'c/c1', u'c/c2', u'd/d1', u'd/d2', u'd/e']],
120
 
            [[u'*/'], [u'c/', u'd/']],
121
 
            ])
122
 
 
123
 
    def test_backslash_globbing(self):
124
 
        self.requireFeature(BackslashDirSeparatorFeature)
125
 
        self.build_ascii_tree()
126
 
        self._run_testset([
127
 
            [[u'd\\'], [u'd/']],
128
112
            [[u'd\\*'], [u'd/d1', u'd/d2', u'd/e']],
129
113
            [[u'?\\*'], [u'c/c1', u'c/c2', u'd/d1', u'd/d2', u'd/e']],
130
114
            [[u'*\\*'], [u'c/c1', u'c/c2', u'd/d1', u'd/d2', u'd/e']],
131
 
            [[u'*\\'], [u'c/', u'd/']],
132
 
            ])
133
 
 
134
 
    def test_case_insensitive_globbing(self):
135
 
        self.requireFeature(tests.CaseInsCasePresFilenameFeature)
136
 
        self.build_ascii_tree()
137
 
        self._run_testset([
138
 
            [[u'A'], [u'A']],
139
 
            [[u'A?'], [u'a1', u'a2']],
140
 
            ])
 
115
            [[u'*/'], [u'c/', u'd/']],
 
116
            [[u'*\\'], [u'c/', u'd/']]])
141
117
 
142
118
    def test_tree_unicode(self):
143
119
        """Checks behaviour with non-ascii filenames"""
144
 
        self.build_unicode_tree()
 
120
        self.build_tree([u'\u1234', u'\u1234\u1234', u'\u1235/', u'\u1235/\u1235'])
145
121
        self._run_testset([
146
122
            # no wildcards
147
123
            [[u'\u1234'], [u'\u1234']],
157
133
 
158
134
            [[u'\u1235/?'], [u'\u1235/\u1235']],
159
135
            [[u'\u1235/*'], [u'\u1235/\u1235']],
 
136
            [[u'\u1235\\?'], [u'\u1235/\u1235']],
 
137
            [[u'\u1235\\*'], [u'\u1235/\u1235']],
160
138
            [[u'?/'], [u'\u1235/']],
161
139
            [[u'*/'], [u'\u1235/']],
 
140
            [[u'?\\'], [u'\u1235/']],
 
141
            [[u'*\\'], [u'\u1235/']],
162
142
            [[u'?/?'], [u'\u1235/\u1235']],
163
143
            [[u'*/*'], [u'\u1235/\u1235']],
164
 
            ])
165
 
 
166
 
    def test_unicode_backslashes(self):
167
 
        self.requireFeature(BackslashDirSeparatorFeature)
168
 
        self.build_unicode_tree()
169
 
        self._run_testset([
170
 
            # no wildcards
171
 
            [[u'\u1235\\'], [u'\u1235/']],
172
 
            [[u'\u1235\\\u1235'], [u'\u1235/\u1235']],
173
 
            [[u'\u1235\\?'], [u'\u1235/\u1235']],
174
 
            [[u'\u1235\\*'], [u'\u1235/\u1235']],
175
 
            [[u'?\\'], [u'\u1235/']],
176
 
            [[u'*\\'], [u'\u1235/']],
177
144
            [[u'?\\?'], [u'\u1235/\u1235']],
178
 
            [[u'*\\*'], [u'\u1235/\u1235']],
179
 
            ])
 
145
            [[u'*\\*'], [u'\u1235/\u1235']]])
180
146
 
181
147
    def _run_testset(self, testset):
182
148
        for pattern, expected in testset:
198
164
            self.assertEquals('iexplore.exe', b.lower())
199
165
            self.assertNotEquals('', d)
200
166
 
201
 
    def test_wordpad(self):
202
 
        # typical windows users should have wordpad in the system
203
 
        # but there is problem: its path has the format REG_EXPAND_SZ
204
 
        # so naive attempt to get the path is not working
205
 
        for a in ('wordpad', 'wordpad.exe'):
206
 
            p = get_app_path(a)
207
 
            d, b = os.path.split(p)
208
 
            self.assertEquals('wordpad.exe', b.lower())
209
 
            self.assertNotEquals('', d)
210
 
 
211
167
    def test_not_existing(self):
212
168
        p = get_app_path('not-existing')
213
169
        self.assertEquals('not-existing', p)
266
222
        super(TestLocationsPywin32, self).setUp()
267
223
        # We perform the exact same tests after disabling the use of ctypes.
268
224
        # This causes the implementation to fall back to pywin32.
269
 
        self.overrideAttr(win32utils, 'has_ctypes', False)
270
 
        # FIXME: this should be done by parametrization -- vila 100123
271
 
 
272
 
 
273
 
class TestSetHidden(TestCaseInTempDir):
274
 
 
275
 
    def test_unicode_dir(self):
276
 
        # we should handle unicode paths without errors
277
 
        self.requireFeature(UnicodeFilenameFeature)
278
 
        os.mkdir(u'\u1234')
279
 
        win32utils.set_file_attr_hidden(u'\u1234')
280
 
 
281
 
    def test_dot_bzr_in_unicode_dir(self):
282
 
        # we should not raise traceback if we try to set hidden attribute
283
 
        # on .bzr directory below unicode path
284
 
        self.requireFeature(UnicodeFilenameFeature)
285
 
        os.makedirs(u'\u1234\\.bzr')
286
 
        path = osutils.abspath(u'\u1234\\.bzr')
287
 
        win32utils.set_file_attr_hidden(path)
288
 
 
289
 
 
290
 
 
291
 
 
292
 
class Test_CommandLineToArgv(tests.TestCaseInTempDir):
293
 
 
294
 
    def assertCommandLine(self, expected, line, single_quotes_allowed=False):
295
 
        # Strictly speaking we should respect parameter order versus glob
296
 
        # expansions, but it's not really worth the effort here
297
 
        argv = win32utils._command_line_to_argv(line,
298
 
                single_quotes_allowed=single_quotes_allowed)
299
 
        self.assertEqual(expected, sorted(argv))
300
 
 
301
 
    def test_glob_paths(self):
302
 
        self.build_tree(['a/', 'a/b.c', 'a/c.c', 'a/c.h'])
303
 
        self.assertCommandLine([u'a/b.c', u'a/c.c'], 'a/*.c')
304
 
        self.build_tree(['b/', 'b/b.c', 'b/d.c', 'b/d.h'])
305
 
        self.assertCommandLine([u'a/b.c', u'b/b.c'], '*/b.c')
306
 
        self.assertCommandLine([u'a/b.c', u'a/c.c', u'b/b.c', u'b/d.c'],
307
 
                               '*/*.c')
308
 
        # Bash style, just pass through the argument if nothing matches
309
 
        self.assertCommandLine([u'*/*.qqq'], '*/*.qqq')
310
 
 
311
 
    def test_quoted_globs(self):
312
 
        self.build_tree(['a/', 'a/b.c', 'a/c.c', 'a/c.h'])
313
 
        self.assertCommandLine([u'a/*.c'], '"a/*.c"')
314
 
        self.assertCommandLine([u"'a/*.c'"], "'a/*.c'")
315
 
        self.assertCommandLine([u'a/*.c'], "'a/*.c'",
316
 
            single_quotes_allowed=True)
317
 
 
318
 
    def test_slashes_changed(self):
319
 
        # Quoting doesn't change the supplied args
320
 
        self.assertCommandLine([u'a\\*.c'], '"a\\*.c"')
321
 
        self.assertCommandLine([u'a\\*.c'], "'a\\*.c'",
322
 
            single_quotes_allowed=True)
323
 
        # Expands the glob, but nothing matches, swaps slashes
324
 
        self.assertCommandLine([u'a/*.c'], 'a\\*.c')
325
 
        self.assertCommandLine([u'a/?.c'], 'a\\?.c')
326
 
        # No glob, doesn't touch slashes
327
 
        self.assertCommandLine([u'a\\foo.c'], 'a\\foo.c')
328
 
 
329
 
    def test_single_quote_support(self):
330
 
        self.assertCommandLine(["add", "let's-do-it.txt"],
331
 
            "add let's-do-it.txt")
332
 
        self.assertCommandLine(["add", "lets do it.txt"],
333
 
            "add 'lets do it.txt'", single_quotes_allowed=True)
334
 
 
335
 
    def test_case_insensitive_globs(self):
336
 
        self.requireFeature(tests.CaseInsCasePresFilenameFeature)
337
 
        self.build_tree(['a/', 'a/b.c', 'a/c.c', 'a/c.h'])
338
 
        self.assertCommandLine([u'A/b.c'], 'A/B*')
339
 
 
340
 
    def test_backslashes(self):
341
 
        self.requireFeature(BackslashDirSeparatorFeature)
342
 
        self.build_tree(['a/', 'a/b.c', 'a/c.c', 'a/c.h'])
343
 
        self.assertCommandLine([u'a/b.c'], 'a\\b*')
 
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