← 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: 2011-05-11 15:04:23 UTC
  • mfrom: (5848.1.1 2.4-cython-first)
  • Revision ID: pqm@pqm.ubuntu.com-20110511150423-tpm1ablukqalkvim
(jameinel) Default to using Cython for compiling code,
 rather than Pyrex. (John A Meinel)

Show diffs side-by-side

added added

removed removed

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