← 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: Jelmer Vernooij
  • Date: 2016-04-03 16:32:31 UTC
  • mto: This revision was merged to the branch mainline in revision 6617.
  • Revision ID: jelmer@jelmer.uk-20160403163231-h72bo0uyek2gikw0
https://launchpad.net/bugs/1565503
Don't put French text in doc/en/user-reference when LANGUAGE=fr_CH.UTF_8.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/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
20
20
 
21
21
from bzrlib import (
22
22
    osutils,
 
23
    symbol_versioning,
23
24
    tests,
24
25
    win32utils,
25
26
    )
26
27
from bzrlib.tests import (
27
 
    Feature,
28
28
    TestCase,
29
29
    TestCaseInTempDir,
30
30
    TestSkipped,
31
 
    UnicodeFilenameFeature,
32
31
    )
33
32
from bzrlib.tests.features import backslashdir_feature
34
33
from bzrlib.win32utils import glob_expand, get_app_path
35
 
 
36
 
 
37
 
class _RequiredModuleFeature(Feature):
38
 
 
39
 
    def __init__(self, mod_name):
40
 
        self.mod_name = mod_name
41
 
        super(_RequiredModuleFeature, self).__init__()
42
 
 
43
 
    def _probe(self):
44
 
        try:
45
 
            __import__(self.mod_name)
46
 
            return True
47
 
        except ImportError:
48
 
            return False
49
 
 
50
 
    def feature_name(self):
51
 
        return self.mod_name
52
 
 
53
 
Win32RegistryFeature = _RequiredModuleFeature('_winreg')
54
 
CtypesFeature = _RequiredModuleFeature('ctypes')
55
 
Win32comShellFeature = _RequiredModuleFeature('win32com.shell')
56
 
Win32ApiFeature = _RequiredModuleFeature('win32api') 
 
34
from bzrlib.tests import (
 
35
    features,
 
36
    )
 
37
 
 
38
 
 
39
Win32RegistryFeature = features.ModuleAvailableFeature('_winreg')
 
40
CtypesFeature = features.ModuleAvailableFeature('ctypes')
 
41
Win32comShellFeature = features.ModuleAvailableFeature('win32com.shell')
 
42
Win32ApiFeature = features.ModuleAvailableFeature('win32api') 
57
43
 
58
44
 
59
45
# Tests
78
64
                         'd/', 'd/d1', 'd/d2', 'd/e/', 'd/e/e1'])
79
65
 
80
66
    def build_unicode_tree(self):
81
 
        self.requireFeature(UnicodeFilenameFeature)
 
67
        self.requireFeature(features.UnicodeFilenameFeature)
82
68
        self.build_tree([u'\u1234', u'\u1234\u1234', u'\u1235/',
83
69
                         u'\u1235/\u1235'])
84
70
 
183
169
        for a in ('iexplore', 'iexplore.exe'):
184
170
            p = get_app_path(a)
185
171
            d, b = os.path.split(p)
186
 
            self.assertEquals('iexplore.exe', b.lower())
187
 
            self.assertNotEquals('', d)
 
172
            self.assertEqual('iexplore.exe', b.lower())
 
173
            self.assertNotEqual('', d)
188
174
 
189
175
    def test_wordpad(self):
190
176
        # typical windows users should have wordpad in the system
194
180
        for a in ('wordpad', 'wordpad.exe'):
195
181
            p = get_app_path(a)
196
182
            d, b = os.path.split(p)
197
 
            self.assertEquals('wordpad.exe', b.lower())
198
 
            self.assertNotEquals('', d)
 
183
            self.assertEqual('wordpad.exe', b.lower())
 
184
            self.assertNotEqual('', d)
199
185
 
200
186
    def test_not_existing(self):
201
187
        p = get_app_path('not-existing')
202
 
        self.assertEquals('not-existing', p)
 
188
        self.assertEqual('not-existing', p)
 
189
 
 
190
 
 
191
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)
203
234
 
204
235
 
205
236
class TestLocationsCtypes(TestCase):
211
242
        # version (ie, "C:\DOCUME~1\...").  Its even possible the returned
212
243
        # values will differ only by case - handle these situations as we
213
244
        # come across them.
214
 
        self.assertEquals(p1, p2)
 
245
        self.assertEqual(p1, p2)
215
246
 
216
247
    def test_appdata_not_using_environment(self):
217
248
        # Test that we aren't falling back to the environment
263
294
 
264
295
    def test_unicode_dir(self):
265
296
        # we should handle unicode paths without errors
266
 
        self.requireFeature(UnicodeFilenameFeature)
 
297
        self.requireFeature(features.UnicodeFilenameFeature)
267
298
        os.mkdir(u'\u1234')
268
299
        win32utils.set_file_attr_hidden(u'\u1234')
269
300
 
270
301
    def test_dot_bzr_in_unicode_dir(self):
271
302
        # we should not raise traceback if we try to set hidden attribute
272
303
        # on .bzr directory below unicode path
273
 
        self.requireFeature(UnicodeFilenameFeature)
 
304
        self.requireFeature(features.UnicodeFilenameFeature)
274
305
        os.makedirs(u'\u1234\\.bzr')
275
306
        path = osutils.abspath(u'\u1234\\.bzr')
276
307
        win32utils.set_file_attr_hidden(path)
343
374
        self.assertCommandLine([u"rm", u"x*"], "-m pdb rm x*", ["rm", u"x*"])
344
375
        self.assertCommandLine([u"add", u"d/f1", u"d/f2"], "-m pdb add d/*",
345
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)