/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 breezy/tests/test_win32utils.py

  • Committer: Breezy landing bot
  • Author(s): Colin Watson
  • Date: 2020-11-16 21:47:08 UTC
  • mfrom: (7521.1.1 remove-lp-workaround)
  • Revision ID: breezy.the.bot@gmail.com-20201116214708-jos209mgxi41oy15
Remove breezy.git workaround for bazaar.launchpad.net.

Merged from https://code.launchpad.net/~cjwatson/brz/remove-lp-workaround/+merge/393710

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_win32utils.py
1
 
# Copyright (C) 2007-2011 Canonical Ltd
 
1
# Copyright (C) 2007-2011, 2016 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
18
18
 
19
19
import os
20
20
 
21
 
from bzrlib import (
 
21
from .. import (
22
22
    osutils,
23
 
    symbol_versioning,
24
23
    tests,
25
24
    win32utils,
26
25
    )
27
 
from bzrlib.tests import (
 
26
from . import (
28
27
    TestCase,
29
28
    TestCaseInTempDir,
30
29
    TestSkipped,
31
30
    )
32
 
from bzrlib.tests.features import backslashdir_feature
33
 
from bzrlib.win32utils import glob_expand, get_app_path
34
 
from bzrlib.tests import (
 
31
from .features import backslashdir_feature
 
32
from ..win32utils import glob_expand, get_app_path
 
33
from . import (
35
34
    features,
36
35
    )
37
36
 
38
37
 
39
38
Win32RegistryFeature = features.ModuleAvailableFeature('_winreg')
40
 
CtypesFeature = features.ModuleAvailableFeature('ctypes')
41
 
Win32comShellFeature = features.ModuleAvailableFeature('win32com.shell')
42
 
Win32ApiFeature = features.ModuleAvailableFeature('win32api') 
43
 
 
44
 
 
45
 
# Tests
46
 
# -----
 
39
 
47
40
 
48
41
class TestWin32UtilsGlobExpand(TestCaseInTempDir):
49
42
 
75
68
        self._run_testset([
76
69
            # no wildcards
77
70
            [[u'a'], [u'a']],
78
 
            [[u'a', u'a' ], [u'a', u'a']],
 
71
            [[u'a', u'a'], [u'a', u'a']],
79
72
 
80
73
            [[u'd'], [u'd']],
81
74
            [[u'd/'], [u'd/']],
106
99
 
107
100
    def test_case_insensitive_globbing(self):
108
101
        if os.path.normcase("AbC") == "AbC":
109
 
            self.skip("Test requires case insensitive globbing function")
 
102
            self.skipTest("Test requires case insensitive globbing function")
110
103
        self.build_ascii_tree()
111
104
        self._run_testset([
112
105
            [[u'A'], [u'A']],
169
162
        for a in ('iexplore', 'iexplore.exe'):
170
163
            p = get_app_path(a)
171
164
            d, b = os.path.split(p)
172
 
            self.assertEquals('iexplore.exe', b.lower())
173
 
            self.assertNotEquals('', d)
 
165
            self.assertEqual('iexplore.exe', b.lower())
 
166
            self.assertNotEqual('', d)
174
167
 
175
168
    def test_wordpad(self):
176
169
        # typical windows users should have wordpad in the system
180
173
        for a in ('wordpad', 'wordpad.exe'):
181
174
            p = get_app_path(a)
182
175
            d, b = os.path.split(p)
183
 
            self.assertEquals('wordpad.exe', b.lower())
184
 
            self.assertNotEquals('', d)
 
176
            self.assertEqual('wordpad.exe', b.lower())
 
177
            self.assertNotEqual('', d)
185
178
 
186
179
    def test_not_existing(self):
187
180
        p = get_app_path('not-existing')
188
 
        self.assertEquals('not-existing', p)
 
181
        self.assertEqual('not-existing', p)
189
182
 
190
183
 
191
184
class TestLocations(TestCase):
192
 
    """Tests for windows specific path and name retrieving functions"""
193
 
 
194
 
    def test__ensure_unicode_deprecated(self):
195
 
        s = "text"
196
 
        u1 = self.applyDeprecated(symbol_versioning.deprecated_in((2, 5, 0)),
197
 
            win32utils._ensure_unicode, s)
198
 
        self.assertEqual(s, u1)
199
 
        self.assertIsInstance(u1, unicode)
200
 
        u2 = self.applyDeprecated(symbol_versioning.deprecated_in((2, 5, 0)),
201
 
            win32utils._ensure_unicode, u1)
202
 
        self.assertIs(u1, u2)
203
 
    
204
 
    def test_appdata_unicode_deprecated(self):
205
 
        self.overrideEnv("APPDATA", "fakepath")
206
 
        s = win32utils.get_appdata_location()
207
 
        u = self.applyDeprecated(symbol_versioning.deprecated_in((2, 5, 0)),
208
 
            win32utils.get_appdata_location_unicode)
209
 
        self.assertEqual(s, u)
210
 
        self.assertIsInstance(s, unicode)
211
 
 
212
 
    def test_home_unicode_deprecated(self):
213
 
        s = win32utils.get_home_location()
214
 
        u = self.applyDeprecated(symbol_versioning.deprecated_in((2, 5, 0)),
215
 
            win32utils.get_home_location_unicode)
216
 
        self.assertEqual(s, u)
217
 
        self.assertIsInstance(s, unicode)
218
 
 
219
 
    def test_user_unicode_deprecated(self):
220
 
        self.overrideEnv("USERNAME", "alien")
221
 
        s = win32utils.get_user_name()
222
 
        u = self.applyDeprecated(symbol_versioning.deprecated_in((2, 5, 0)),
223
 
            win32utils.get_user_name_unicode)
224
 
        self.assertEqual(s, u)
225
 
        self.assertIsInstance(s, unicode)
226
 
 
227
 
    def test_host_unicode_deprecated(self):
228
 
        self.overrideEnv("COMPUTERNAME", "alienbox")
229
 
        s = win32utils.get_host_name()
230
 
        u = self.applyDeprecated(symbol_versioning.deprecated_in((2, 5, 0)),
231
 
            win32utils.get_host_name_unicode)
232
 
        self.assertEqual(s, u)
233
 
        self.assertIsInstance(s, unicode)
234
 
 
235
 
 
236
 
class TestLocationsCtypes(TestCase):
237
 
 
238
 
    _test_needs_features = [CtypesFeature]
 
185
 
 
186
    _test_needs_features = [features.win32_feature]
239
187
 
240
188
    def assertPathsEqual(self, p1, p2):
241
189
        # TODO: The env var values in particular might return the "short"
242
190
        # version (ie, "C:\DOCUME~1\...").  Its even possible the returned
243
191
        # values will differ only by case - handle these situations as we
244
192
        # come across them.
245
 
        self.assertEquals(p1, p2)
 
193
        self.assertEqual(p1, p2)
246
194
 
247
195
    def test_appdata_not_using_environment(self):
248
196
        # Test that we aren't falling back to the environment
273
221
        lad = win32utils.get_local_appdata_location()
274
222
        env = os.environ.get("LOCALAPPDATA")
275
223
        if env:
276
 
            # XXX - See bug 262874, which asserts the correct encoding is 'mbcs'
 
224
            # XXX - See bug 262874, which asserts the correct encoding is
 
225
            # 'mbcs'
277
226
            encoding = osutils.get_user_encoding()
278
227
            self.assertPathsEqual(lad, env.decode(encoding))
279
228
 
280
229
 
281
 
class TestLocationsPywin32(TestLocationsCtypes):
282
 
 
283
 
    _test_needs_features = [Win32comShellFeature]
284
 
 
285
 
    def setUp(self):
286
 
        super(TestLocationsPywin32, self).setUp()
287
 
        # We perform the exact same tests after disabling the use of ctypes.
288
 
        # This causes the implementation to fall back to pywin32.
289
 
        self.overrideAttr(win32utils, 'has_ctypes', False)
290
 
        # FIXME: this should be done by parametrization -- vila 100123
291
 
 
292
 
 
293
230
class TestSetHidden(TestCaseInTempDir):
294
231
 
 
232
    _test_needs_features = [features.win32_feature]
 
233
 
295
234
    def test_unicode_dir(self):
296
235
        # we should handle unicode paths without errors
297
236
        self.requireFeature(features.UnicodeFilenameFeature)
310
249
class Test_CommandLineToArgv(tests.TestCaseInTempDir):
311
250
 
312
251
    def assertCommandLine(self, expected, line, argv=None,
313
 
            single_quotes_allowed=False):
 
252
                          single_quotes_allowed=False):
314
253
        # Strictly speaking we should respect parameter order versus glob
315
254
        # expansions, but it's not really worth the effort here
316
255
        if argv is None:
317
256
            argv = [line]
318
 
        argv = win32utils._command_line_to_argv(line, argv,
319
 
                single_quotes_allowed=single_quotes_allowed)
 
257
        argv = win32utils._command_line_to_argv(
 
258
            line, argv, single_quotes_allowed=single_quotes_allowed)
320
259
        self.assertEqual(expected, sorted(argv))
321
260
 
322
261
    def test_glob_paths(self):
334
273
        self.assertCommandLine([u'a/*.c'], '"a/*.c"')
335
274
        self.assertCommandLine([u"'a/*.c'"], "'a/*.c'")
336
275
        self.assertCommandLine([u'a/*.c'], "'a/*.c'",
337
 
            single_quotes_allowed=True)
 
276
                               single_quotes_allowed=True)
338
277
 
339
278
    def test_slashes_changed(self):
340
279
        # Quoting doesn't change the supplied args
341
280
        self.assertCommandLine([u'a\\*.c'], '"a\\*.c"')
342
281
        self.assertCommandLine([u'a\\*.c'], "'a\\*.c'",
343
 
            single_quotes_allowed=True)
 
282
                               single_quotes_allowed=True)
344
283
        # Expands the glob, but nothing matches, swaps slashes
345
284
        self.assertCommandLine([u'a/*.c'], 'a\\*.c')
346
285
        self.assertCommandLine([u'a/?.c'], 'a\\?.c')
349
288
 
350
289
    def test_single_quote_support(self):
351
290
        self.assertCommandLine(["add", "let's-do-it.txt"],
352
 
            "add let's-do-it.txt",
353
 
            ["add", "let's-do-it.txt"])
 
291
                               "add let's-do-it.txt",
 
292
                               ["add", "let's-do-it.txt"])
354
293
        self.expectFailure("Using single quotes breaks trimming from argv",
355
 
            self.assertCommandLine, ["add", "lets do it.txt"],
356
 
            "add 'lets do it.txt'", ["add", "'lets", "do", "it.txt'"],
357
 
            single_quotes_allowed=True)
 
294
                           self.assertCommandLine, ["add", "lets do it.txt"],
 
295
                           "add 'lets do it.txt'", [
 
296
                               "add", "'lets", "do", "it.txt'"],
 
297
                           single_quotes_allowed=True)
358
298
 
359
299
    def test_case_insensitive_globs(self):
360
300
        if os.path.normcase("AbC") == "AbC":
361
 
            self.skip("Test requires case insensitive globbing function")
 
301
            self.skipTest("Test requires case insensitive globbing function")
362
302
        self.build_tree(['a/', 'a/b.c', 'a/c.c', 'a/c.h'])
363
303
        self.assertCommandLine([u'A/b.c'], 'A/B*')
364
304
 
373
313
        self.build_tree(['d/', 'd/f1', 'd/f2'])
374
314
        self.assertCommandLine([u"rm", u"x*"], "-m pdb rm x*", ["rm", u"x*"])
375
315
        self.assertCommandLine([u"add", u"d/f1", u"d/f2"], "-m pdb add d/*",
376
 
            ["add", u"d/*"])
377
 
 
378
 
 
379
 
class TestGetEnvironUnicode(tests.TestCase):
380
 
    """Tests for accessing the environment via the windows wide api"""
381
 
 
382
 
    _test_needs_features = [CtypesFeature, features.win32_feature]
383
 
 
384
 
    def setUp(self):
385
 
        super(TestGetEnvironUnicode, self).setUp()
386
 
        self.overrideEnv("TEST", "1")
387
 
 
388
 
    def test_get(self):
389
 
        """In the normal case behaves the same as os.environ access"""
390
 
        self.assertEqual("1", win32utils.get_environ_unicode("TEST"))
391
 
 
392
 
    def test_unset(self):
393
 
        """A variable not present in the environment gives None by default"""
394
 
        del os.environ["TEST"]
395
 
        self.assertIs(None, win32utils.get_environ_unicode("TEST"))
396
 
 
397
 
    def test_unset_default(self):
398
 
        """A variable not present in the environment gives passed default"""
399
 
        del os.environ["TEST"]
400
 
        self.assertIs("a", win32utils.get_environ_unicode("TEST", "a"))
401
 
 
402
 
    def test_unicode(self):
403
 
        """A non-ascii variable is returned as unicode"""
404
 
        unicode_val = u"\xa7" # non-ascii character present in many encodings
405
 
        try:
406
 
            bytes_val = unicode_val.encode(osutils.get_user_encoding())
407
 
        except UnicodeEncodeError:
408
 
            self.skip("Couldn't encode non-ascii string to place in environ")
409
 
        os.environ["TEST"] = bytes_val
410
 
        self.assertEqual(unicode_val, win32utils.get_environ_unicode("TEST"))
411
 
 
412
 
    def test_long(self):
413
 
        """A variable bigger than heuristic buffer size is still accessible"""
414
 
        big_val = "x" * (2<<10)
415
 
        os.environ["TEST"] = big_val
416
 
        self.assertEqual(big_val, win32utils.get_environ_unicode("TEST"))
417
 
 
418
 
    def test_unexpected_error(self):
419
 
        """An error from the underlying platform function is propogated"""
420
 
        ERROR_INVALID_PARAMETER = 87
421
 
        SetLastError = win32utils.ctypes.windll.kernel32.SetLastError
422
 
        def failer(*args, **kwargs):
423
 
            SetLastError(ERROR_INVALID_PARAMETER)
424
 
            return 0
425
 
        self.overrideAttr(win32utils.get_environ_unicode, "_c_function",
426
 
            failer)
427
 
        e = self.assertRaises(WindowsError,
428
 
            win32utils.get_environ_unicode, "TEST")
429
 
        self.assertEqual(e.winerror, ERROR_INVALID_PARAMETER)
 
316
                               ["add", u"d/*"])
 
317