← 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: Andrew Bennetts
  • Date: 2010-10-08 08:15:14 UTC
  • mto: This revision was merged to the branch mainline in revision 5498.
  • Revision ID: andrew.bennetts@canonical.com-20101008081514-dviqzrdfwyzsqbz2
Split NEWS into per-release doc/en/release-notes/bzr-*.txt

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-2010 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
"""Tests for win32utils."""
18
18
 
19
19
import os
 
20
import sys
20
21
 
21
22
from bzrlib import (
22
23
    osutils,
23
 
    symbol_versioning,
24
24
    tests,
25
25
    win32utils,
26
26
    )
27
27
from bzrlib.tests import (
 
28
    Feature,
28
29
    TestCase,
29
30
    TestCaseInTempDir,
30
31
    TestSkipped,
 
32
    UnicodeFilenameFeature,
31
33
    )
32
34
from bzrlib.tests.features import backslashdir_feature
33
35
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') 
 
36
 
 
37
 
 
38
class _RequiredModuleFeature(Feature):
 
39
 
 
40
    def __init__(self, mod_name):
 
41
        self.mod_name = mod_name
 
42
        super(_RequiredModuleFeature, self).__init__()
 
43
 
 
44
    def _probe(self):
 
45
        try:
 
46
            __import__(self.mod_name)
 
47
            return True
 
48
        except ImportError:
 
49
            return False
 
50
 
 
51
    def feature_name(self):
 
52
        return self.mod_name
 
53
 
 
54
Win32RegistryFeature = _RequiredModuleFeature('_winreg')
 
55
CtypesFeature = _RequiredModuleFeature('ctypes')
 
56
Win32comShellFeature = _RequiredModuleFeature('win32com.shell')
 
57
Win32ApiFeature = _RequiredModuleFeature('win32api') 
43
58
 
44
59
 
45
60
# Tests
64
79
                         'd/', 'd/d1', 'd/d2', 'd/e/', 'd/e/e1'])
65
80
 
66
81
    def build_unicode_tree(self):
67
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
82
        self.requireFeature(UnicodeFilenameFeature)
68
83
        self.build_tree([u'\u1234', u'\u1234\u1234', u'\u1235/',
69
84
                         u'\u1235/\u1235'])
70
85
 
105
120
            ])
106
121
 
107
122
    def test_case_insensitive_globbing(self):
108
 
        if os.path.normcase("AbC") == "AbC":
109
 
            self.skip("Test requires case insensitive globbing function")
 
123
        self.requireFeature(tests.CaseInsCasePresFilenameFeature)
110
124
        self.build_ascii_tree()
111
125
        self._run_testset([
112
126
            [[u'A'], [u'A']],
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
249
218
        first = win32utils.get_appdata_location()
250
 
        self.overrideEnv("APPDATA", None)
 
219
        self._captureVar("APPDATA", None)
251
220
        self.assertPathsEqual(first, win32utils.get_appdata_location())
252
221
 
253
222
    def test_appdata_matches_environment(self):
264
233
    def test_local_appdata_not_using_environment(self):
265
234
        # Test that we aren't falling back to the environment
266
235
        first = win32utils.get_local_appdata_location()
267
 
        self.overrideEnv("LOCALAPPDATA", None)
 
236
        self._captureVar("LOCALAPPDATA", None)
268
237
        self.assertPathsEqual(first, win32utils.get_local_appdata_location())
269
238
 
270
239
    def test_local_appdata_matches_environment(self):
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)
357
326
            single_quotes_allowed=True)
358
327
 
359
328
    def test_case_insensitive_globs(self):
360
 
        if os.path.normcase("AbC") == "AbC":
361
 
            self.skip("Test requires case insensitive globbing function")
 
329
        self.requireFeature(tests.CaseInsCasePresFilenameFeature)
362
330
        self.build_tree(['a/', 'a/b.c', 'a/c.c', 'a/c.h'])
363
331
        self.assertCommandLine([u'A/b.c'], 'A/B*')
364
332
 
374
342
        self.assertCommandLine([u"rm", u"x*"], "-m pdb rm x*", ["rm", u"x*"])
375
343
        self.assertCommandLine([u"add", u"d/f1", u"d/f2"], "-m pdb add d/*",
376
344
            ["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)