← 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: 2011-12-16 16:40:10 UTC
  • mto: This revision was merged to the branch mainline in revision 6391.
  • Revision ID: jelmer@samba.org-20111216164010-z3hy00xrnclnkf7a
Update tests.

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-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
17
17
"""Tests for win32utils."""
18
18
 
19
19
import os
20
 
import sys
21
20
 
22
21
from bzrlib import (
23
22
    osutils,
25
24
    win32utils,
26
25
    )
27
26
from bzrlib.tests import (
28
 
    Feature,
29
27
    TestCase,
30
28
    TestCaseInTempDir,
31
29
    TestSkipped,
32
 
    UnicodeFilenameFeature,
33
30
    )
34
31
from bzrlib.tests.features import backslashdir_feature
35
32
from bzrlib.win32utils import glob_expand, get_app_path
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') 
 
33
from bzrlib.tests import (
 
34
    features,
 
35
    )
 
36
 
 
37
 
 
38
Win32RegistryFeature = features.ModuleAvailableFeature('_winreg')
 
39
CtypesFeature = features.ModuleAvailableFeature('ctypes')
 
40
Win32comShellFeature = features.ModuleAvailableFeature('win32com.shell')
 
41
Win32ApiFeature = features.ModuleAvailableFeature('win32api') 
58
42
 
59
43
 
60
44
# Tests
79
63
                         'd/', 'd/d1', 'd/d2', 'd/e/', 'd/e/e1'])
80
64
 
81
65
    def build_unicode_tree(self):
82
 
        self.requireFeature(UnicodeFilenameFeature)
 
66
        self.requireFeature(features.UnicodeFilenameFeature)
83
67
        self.build_tree([u'\u1234', u'\u1234\u1234', u'\u1235/',
84
68
                         u'\u1235/\u1235'])
85
69
 
120
104
            ])
121
105
 
122
106
    def test_case_insensitive_globbing(self):
123
 
        self.requireFeature(tests.CaseInsCasePresFilenameFeature)
 
107
        if os.path.normcase("AbC") == "AbC":
 
108
            self.skip("Test requires case insensitive globbing function")
124
109
        self.build_ascii_tree()
125
110
        self._run_testset([
126
111
            [[u'A'], [u'A']],
216
201
    def test_appdata_not_using_environment(self):
217
202
        # Test that we aren't falling back to the environment
218
203
        first = win32utils.get_appdata_location()
219
 
        self._captureVar("APPDATA", None)
 
204
        self.overrideEnv("APPDATA", None)
220
205
        self.assertPathsEqual(first, win32utils.get_appdata_location())
221
206
 
222
207
    def test_appdata_matches_environment(self):
233
218
    def test_local_appdata_not_using_environment(self):
234
219
        # Test that we aren't falling back to the environment
235
220
        first = win32utils.get_local_appdata_location()
236
 
        self._captureVar("LOCALAPPDATA", None)
 
221
        self.overrideEnv("LOCALAPPDATA", None)
237
222
        self.assertPathsEqual(first, win32utils.get_local_appdata_location())
238
223
 
239
224
    def test_local_appdata_matches_environment(self):
263
248
 
264
249
    def test_unicode_dir(self):
265
250
        # we should handle unicode paths without errors
266
 
        self.requireFeature(UnicodeFilenameFeature)
 
251
        self.requireFeature(features.UnicodeFilenameFeature)
267
252
        os.mkdir(u'\u1234')
268
253
        win32utils.set_file_attr_hidden(u'\u1234')
269
254
 
270
255
    def test_dot_bzr_in_unicode_dir(self):
271
256
        # we should not raise traceback if we try to set hidden attribute
272
257
        # on .bzr directory below unicode path
273
 
        self.requireFeature(UnicodeFilenameFeature)
 
258
        self.requireFeature(features.UnicodeFilenameFeature)
274
259
        os.makedirs(u'\u1234\\.bzr')
275
260
        path = osutils.abspath(u'\u1234\\.bzr')
276
261
        win32utils.set_file_attr_hidden(path)
326
311
            single_quotes_allowed=True)
327
312
 
328
313
    def test_case_insensitive_globs(self):
329
 
        self.requireFeature(tests.CaseInsCasePresFilenameFeature)
 
314
        if os.path.normcase("AbC") == "AbC":
 
315
            self.skip("Test requires case insensitive globbing function")
330
316
        self.build_tree(['a/', 'a/b.c', 'a/c.c', 'a/c.h'])
331
317
        self.assertCommandLine([u'A/b.c'], 'A/B*')
332
318
 
342
328
        self.assertCommandLine([u"rm", u"x*"], "-m pdb rm x*", ["rm", u"x*"])
343
329
        self.assertCommandLine([u"add", u"d/f1", u"d/f2"], "-m pdb add d/*",
344
330
            ["add", u"d/*"])
 
331
 
 
332
 
 
333
class TestGetEnvironUnicode(tests.TestCase):
 
334
    """Tests for accessing the environment via the windows wide api"""
 
335
 
 
336
    _test_needs_features = [CtypesFeature, features.win32_feature]
 
337
 
 
338
    def setUp(self):
 
339
        super(TestGetEnvironUnicode, self).setUp()
 
340
        self.overrideEnv("TEST", "1")
 
341
 
 
342
    def test_get(self):
 
343
        """In the normal case behaves the same as os.environ access"""
 
344
        self.assertEqual("1", win32utils.get_environ_unicode("TEST"))
 
345
 
 
346
    def test_unset(self):
 
347
        """A variable not present in the environment gives None by default"""
 
348
        del os.environ["TEST"]
 
349
        self.assertIs(None, win32utils.get_environ_unicode("TEST"))
 
350
 
 
351
    def test_unset_default(self):
 
352
        """A variable not present in the environment gives passed default"""
 
353
        del os.environ["TEST"]
 
354
        self.assertIs("a", win32utils.get_environ_unicode("TEST", "a"))
 
355
 
 
356
    def test_unicode(self):
 
357
        """A non-ascii variable is returned as unicode"""
 
358
        unicode_val = u"\xa7" # non-ascii character present in many encodings
 
359
        try:
 
360
            bytes_val = unicode_val.encode(osutils.get_user_encoding())
 
361
        except UnicodeEncodeError:
 
362
            self.skip("Couldn't encode non-ascii string to place in environ")
 
363
        os.environ["TEST"] = bytes_val
 
364
        self.assertEqual(unicode_val, win32utils.get_environ_unicode("TEST"))
 
365
 
 
366
    def test_long(self):
 
367
        """A variable bigger than heuristic buffer size is still accessible"""
 
368
        big_val = "x" * (2<<10)
 
369
        os.environ["TEST"] = big_val
 
370
        self.assertEqual(big_val, win32utils.get_environ_unicode("TEST"))
 
371
 
 
372
    def test_unexpected_error(self):
 
373
        """An error from the underlying platform function is propogated"""
 
374
        ERROR_INVALID_PARAMETER = 87
 
375
        SetLastError = win32utils.ctypes.windll.kernel32.SetLastError
 
376
        def failer(*args, **kwargs):
 
377
            SetLastError(ERROR_INVALID_PARAMETER)
 
378
            return 0
 
379
        self.overrideAttr(win32utils.get_environ_unicode, "_c_function",
 
380
            failer)
 
381
        e = self.assertRaises(WindowsError,
 
382
            win32utils.get_environ_unicode, "TEST")
 
383
        self.assertEqual(e.winerror, ERROR_INVALID_PARAMETER)