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

  • Committer: John Arbash Meinel
  • Date: 2009-06-18 18:18:36 UTC
  • mto: This revision was merged to the branch mainline in revision 4461.
  • Revision ID: john@arbash-meinel.com-20090618181836-biodfkat9a8eyzjz
The new add_inventory_by_delta is returning a CHKInventory when mapping from NULL
Which is completely valid, but 'broke' one of the tests.
So to fix it, changed the test to use CHKInventories on both sides, and add an __eq__
member. The nice thing is that CHKInventory.__eq__ is fairly cheap, since it only
has to check the root keys.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_win32utils.py
 
1
# Copyright (C) 2007 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
import os
 
18
import sys
 
19
 
 
20
from bzrlib import osutils
 
21
from bzrlib.tests import TestCase, TestCaseInTempDir, TestSkipped, Feature
 
22
from bzrlib.win32utils import glob_expand, get_app_path
 
23
from bzrlib import win32utils
 
24
 
 
25
 
 
26
# Features
 
27
# --------
 
28
 
 
29
class _NeedsGlobExpansionFeature(Feature):
 
30
 
 
31
    def _probe(self):
 
32
        return sys.platform == 'win32'
 
33
 
 
34
    def feature_name(self):
 
35
        return 'Internally performed glob expansion'
 
36
 
 
37
NeedsGlobExpansionFeature = _NeedsGlobExpansionFeature()
 
38
 
 
39
 
 
40
class _RequiredModuleFeature(Feature):
 
41
 
 
42
    def __init__(self, mod_name):
 
43
        self.mod_name = mod_name
 
44
        super(_RequiredModuleFeature, self).__init__()
 
45
 
 
46
    def _probe(self):
 
47
        try:
 
48
            __import__(self.mod_name)
 
49
            return True
 
50
        except ImportError:
 
51
            return False
 
52
 
 
53
    def feature_name(self):
 
54
        return self.mod_name
 
55
 
 
56
Win32RegistryFeature = _RequiredModuleFeature('_winreg')
 
57
CtypesFeature = _RequiredModuleFeature('ctypes')
 
58
Win32comShellFeature = _RequiredModuleFeature('win32com.shell')
 
59
 
 
60
 
 
61
# Tests
 
62
# -----
 
63
 
 
64
class TestNeedsGlobExpansionFeature(TestCase):
 
65
 
 
66
    def test_available(self):
 
67
        self.assertEqual(sys.platform == 'win32',
 
68
                         NeedsGlobExpansionFeature.available())
 
69
 
 
70
    def test_str(self):
 
71
        self.assertTrue("performed" in str(NeedsGlobExpansionFeature))
 
72
 
 
73
 
 
74
class TestWin32UtilsGlobExpand(TestCaseInTempDir):
 
75
 
 
76
    _test_needs_features = [NeedsGlobExpansionFeature]
 
77
 
 
78
    def test_empty_tree(self):
 
79
        self.build_tree([])
 
80
        self._run_testset([
 
81
            [['a'], ['a']],
 
82
            [['?'], ['?']],
 
83
            [['*'], ['*']],
 
84
            [['a', 'a'], ['a', 'a']]])
 
85
 
 
86
    def test_tree_ascii(self):
 
87
        """Checks the glob expansion and path separation char
 
88
        normalization"""
 
89
        self.build_tree(['a', 'a1', 'a2', 'a11', 'a.1',
 
90
                         'b', 'b1', 'b2', 'b3',
 
91
                         'c/', 'c/c1', 'c/c2',
 
92
                         'd/', 'd/d1', 'd/d2', 'd/e/', 'd/e/e1'])
 
93
        self._run_testset([
 
94
            # no wildcards
 
95
            [[u'a'], [u'a']],
 
96
            [[u'a', u'a' ], [u'a', u'a']],
 
97
            [[u'A'], [u'A']],
 
98
 
 
99
            [[u'd'], [u'd']],
 
100
            [[u'd/'], [u'd/']],
 
101
            [[u'd\\'], [u'd/']],
 
102
 
 
103
            # wildcards
 
104
            [[u'a*'], [u'a', u'a1', u'a2', u'a11', u'a.1']],
 
105
            [[u'?'], [u'a', u'b', u'c', u'd']],
 
106
            [[u'a?'], [u'a1', u'a2']],
 
107
            [[u'a??'], [u'a11', u'a.1']],
 
108
            [[u'b[1-2]'], [u'b1', u'b2']],
 
109
            [[u'A?'], [u'a1', u'a2']],
 
110
 
 
111
            [[u'd/*'], [u'd/d1', u'd/d2', u'd/e']],
 
112
            [[u'd\\*'], [u'd/d1', u'd/d2', u'd/e']],
 
113
            [[u'?\\*'], [u'c/c1', u'c/c2', u'd/d1', u'd/d2', u'd/e']],
 
114
            [[u'*\\*'], [u'c/c1', u'c/c2', u'd/d1', u'd/d2', u'd/e']],
 
115
            [[u'*/'], [u'c/', u'd/']],
 
116
            [[u'*\\'], [u'c/', u'd/']]])
 
117
 
 
118
    def test_tree_unicode(self):
 
119
        """Checks behaviour with non-ascii filenames"""
 
120
        self.build_tree([u'\u1234', u'\u1234\u1234', u'\u1235/', u'\u1235/\u1235'])
 
121
        self._run_testset([
 
122
            # no wildcards
 
123
            [[u'\u1234'], [u'\u1234']],
 
124
            [[u'\u1235'], [u'\u1235']],
 
125
 
 
126
            [[u'\u1235/'], [u'\u1235/']],
 
127
            [[u'\u1235/\u1235'], [u'\u1235/\u1235']],
 
128
 
 
129
            # wildcards
 
130
            [[u'?'], [u'\u1234', u'\u1235']],
 
131
            [[u'*'], [u'\u1234', u'\u1234\u1234', u'\u1235']],
 
132
            [[u'\u1234*'], [u'\u1234', u'\u1234\u1234']],
 
133
 
 
134
            [[u'\u1235/?'], [u'\u1235/\u1235']],
 
135
            [[u'\u1235/*'], [u'\u1235/\u1235']],
 
136
            [[u'\u1235\\?'], [u'\u1235/\u1235']],
 
137
            [[u'\u1235\\*'], [u'\u1235/\u1235']],
 
138
            [[u'?/'], [u'\u1235/']],
 
139
            [[u'*/'], [u'\u1235/']],
 
140
            [[u'?\\'], [u'\u1235/']],
 
141
            [[u'*\\'], [u'\u1235/']],
 
142
            [[u'?/?'], [u'\u1235/\u1235']],
 
143
            [[u'*/*'], [u'\u1235/\u1235']],
 
144
            [[u'?\\?'], [u'\u1235/\u1235']],
 
145
            [[u'*\\*'], [u'\u1235/\u1235']]])
 
146
 
 
147
    def _run_testset(self, testset):
 
148
        for pattern, expected in testset:
 
149
            result = glob_expand(pattern)
 
150
            expected.sort()
 
151
            result.sort()
 
152
            self.assertEqual(expected, result, 'pattern %s' % pattern)
 
153
 
 
154
 
 
155
class TestAppPaths(TestCase):
 
156
 
 
157
    _test_needs_features = [Win32RegistryFeature]
 
158
 
 
159
    def test_iexplore(self):
 
160
        # typical windows users should have IE installed
 
161
        for a in ('iexplore', 'iexplore.exe'):
 
162
            p = get_app_path(a)
 
163
            d, b = os.path.split(p)
 
164
            self.assertEquals('iexplore.exe', b.lower())
 
165
            self.assertNotEquals('', d)
 
166
 
 
167
    def test_not_existing(self):
 
168
        p = get_app_path('not-existing')
 
169
        self.assertEquals('not-existing', p)
 
170
 
 
171
 
 
172
class TestLocationsCtypes(TestCase):
 
173
 
 
174
    _test_needs_features = [CtypesFeature]
 
175
 
 
176
    def assertPathsEqual(self, p1, p2):
 
177
        # TODO: The env var values in particular might return the "short"
 
178
        # version (ie, "C:\DOCUME~1\...").  Its even possible the returned
 
179
        # values will differ only by case - handle these situations as we
 
180
        # come across them.
 
181
        self.assertEquals(p1, p2)
 
182
 
 
183
    def test_appdata_not_using_environment(self):
 
184
        # Test that we aren't falling back to the environment
 
185
        first = win32utils.get_appdata_location()
 
186
        self._captureVar("APPDATA", None)
 
187
        self.assertPathsEqual(first, win32utils.get_appdata_location())
 
188
 
 
189
    def test_appdata_matches_environment(self):
 
190
        # Typically the APPDATA environment variable will match
 
191
        # get_appdata_location
 
192
        # XXX - See bug 262874, which asserts the correct encoding is 'mbcs',
 
193
        encoding = osutils.get_user_encoding()
 
194
        env_val = os.environ.get("APPDATA", None)
 
195
        if not env_val:
 
196
            raise TestSkipped("No APPDATA environment variable exists")
 
197
        self.assertPathsEqual(win32utils.get_appdata_location(),
 
198
                              env_val.decode(encoding))
 
199
 
 
200
    def test_local_appdata_not_using_environment(self):
 
201
        # Test that we aren't falling back to the environment
 
202
        first = win32utils.get_local_appdata_location()
 
203
        self._captureVar("LOCALAPPDATA", None)
 
204
        self.assertPathsEqual(first, win32utils.get_local_appdata_location())
 
205
 
 
206
    def test_local_appdata_matches_environment(self):
 
207
        # LOCALAPPDATA typically only exists on Vista, so we only attempt to
 
208
        # compare when it exists.
 
209
        lad = win32utils.get_local_appdata_location()
 
210
        env = os.environ.get("LOCALAPPDATA")
 
211
        if env:
 
212
            # XXX - See bug 262874, which asserts the correct encoding is 'mbcs'
 
213
            encoding = osutils.get_user_encoding()
 
214
            self.assertPathsEqual(lad, env.decode(encoding))
 
215
 
 
216
 
 
217
class TestLocationsPywin32(TestLocationsCtypes):
 
218
 
 
219
    _test_needs_features = [Win32comShellFeature]
 
220
 
 
221
    def setUp(self):
 
222
        super(TestLocationsPywin32, self).setUp()
 
223
        # We perform the exact same tests after disabling the use of ctypes.
 
224
        # This causes the implementation to fall back to pywin32.
 
225
        self.old_ctypes = win32utils.has_ctypes
 
226
        win32utils.has_ctypes = False
 
227
        self.addCleanup(self.restoreCtypes)
 
228
 
 
229
    def restoreCtypes(self):
 
230
        win32utils.has_ctypes = self.old_ctypes