← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_win32utils.py

Initial commit for russian version of documents.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_win32utils.py
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
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
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
import os
18
18
import sys
19
19
 
20
20
from bzrlib import osutils
21
 
from bzrlib.tests import (
22
 
    Feature,
23
 
    TestCase,
24
 
    TestCaseInTempDir,
25
 
    TestSkipped,
26
 
    UnicodeFilenameFeature,
27
 
    )
 
21
from bzrlib.tests import TestCase, TestCaseInTempDir, Feature
28
22
from bzrlib.win32utils import glob_expand, get_app_path
29
 
from bzrlib import win32utils
30
23
 
31
24
 
32
25
# Features
43
36
NeedsGlobExpansionFeature = _NeedsGlobExpansionFeature()
44
37
 
45
38
 
46
 
class _RequiredModuleFeature(Feature):
47
 
 
48
 
    def __init__(self, mod_name):
49
 
        self.mod_name = mod_name
50
 
        super(_RequiredModuleFeature, self).__init__()
 
39
class _Win32RegistryFeature(Feature):
51
40
 
52
41
    def _probe(self):
53
42
        try:
54
 
            __import__(self.mod_name)
 
43
            import _winreg
55
44
            return True
56
45
        except ImportError:
57
46
            return False
58
47
 
59
48
    def feature_name(self):
60
 
        return self.mod_name
 
49
        return '_winreg'
61
50
 
62
 
Win32RegistryFeature = _RequiredModuleFeature('_winreg')
63
 
CtypesFeature = _RequiredModuleFeature('ctypes')
64
 
Win32comShellFeature = _RequiredModuleFeature('win32com.shell')
 
51
Win32RegistryFeature = _Win32RegistryFeature()
65
52
 
66
53
 
67
54
# Tests
68
55
# -----
69
56
 
70
57
class TestNeedsGlobExpansionFeature(TestCase):
71
 
 
 
58
    
72
59
    def test_available(self):
73
 
        self.assertEqual(sys.platform == 'win32',
 
60
        self.assertEqual(sys.platform == 'win32', 
74
61
                         NeedsGlobExpansionFeature.available())
75
 
 
 
62
        
76
63
    def test_str(self):
77
64
        self.assertTrue("performed" in str(NeedsGlobExpansionFeature))
78
65
 
80
67
class TestWin32UtilsGlobExpand(TestCaseInTempDir):
81
68
 
82
69
    _test_needs_features = [NeedsGlobExpansionFeature]
83
 
 
 
70
   
84
71
    def test_empty_tree(self):
85
72
        self.build_tree([])
86
73
        self._run_testset([
88
75
            [['?'], ['?']],
89
76
            [['*'], ['*']],
90
77
            [['a', 'a'], ['a', 'a']]])
91
 
 
 
78
        
92
79
    def test_tree_ascii(self):
93
80
        """Checks the glob expansion and path separation char
94
81
        normalization"""
95
82
        self.build_tree(['a', 'a1', 'a2', 'a11', 'a.1',
96
83
                         'b', 'b1', 'b2', 'b3',
97
 
                         'c/', 'c/c1', 'c/c2',
 
84
                         'c/', 'c/c1', 'c/c2', 
98
85
                         'd/', 'd/d1', 'd/d2', 'd/e/', 'd/e/e1'])
99
86
        self._run_testset([
100
87
            # no wildcards
101
88
            [[u'a'], [u'a']],
102
89
            [[u'a', u'a' ], [u'a', u'a']],
103
90
            [[u'A'], [u'A']],
104
 
 
 
91
                
105
92
            [[u'd'], [u'd']],
106
93
            [[u'd/'], [u'd/']],
107
94
            [[u'd\\'], [u'd/']],
108
 
 
 
95
            
109
96
            # wildcards
110
97
            [[u'a*'], [u'a', u'a1', u'a2', u'a11', u'a.1']],
111
98
            [[u'?'], [u'a', u'b', u'c', u'd']],
113
100
            [[u'a??'], [u'a11', u'a.1']],
114
101
            [[u'b[1-2]'], [u'b1', u'b2']],
115
102
            [[u'A?'], [u'a1', u'a2']],
116
 
 
 
103
               
117
104
            [[u'd/*'], [u'd/d1', u'd/d2', u'd/e']],
118
105
            [[u'd\\*'], [u'd/d1', u'd/d2', u'd/e']],
119
106
            [[u'?\\*'], [u'c/c1', u'c/c2', u'd/d1', u'd/d2', u'd/e']],
120
107
            [[u'*\\*'], [u'c/c1', u'c/c2', u'd/d1', u'd/d2', u'd/e']],
121
108
            [[u'*/'], [u'c/', u'd/']],
122
109
            [[u'*\\'], [u'c/', u'd/']]])
123
 
 
 
110
        
124
111
    def test_tree_unicode(self):
125
112
        """Checks behaviour with non-ascii filenames"""
126
113
        self.build_tree([u'\u1234', u'\u1234\u1234', u'\u1235/', u'\u1235/\u1235'])
128
115
            # no wildcards
129
116
            [[u'\u1234'], [u'\u1234']],
130
117
            [[u'\u1235'], [u'\u1235']],
131
 
 
 
118
         
132
119
            [[u'\u1235/'], [u'\u1235/']],
133
120
            [[u'\u1235/\u1235'], [u'\u1235/\u1235']],
134
 
 
 
121
            
135
122
            # wildcards
136
123
            [[u'?'], [u'\u1234', u'\u1235']],
137
124
            [[u'*'], [u'\u1234', u'\u1234\u1234', u'\u1235']],
138
125
            [[u'\u1234*'], [u'\u1234', u'\u1234\u1234']],
139
 
 
 
126
            
140
127
            [[u'\u1235/?'], [u'\u1235/\u1235']],
141
128
            [[u'\u1235/*'], [u'\u1235/\u1235']],
142
129
            [[u'\u1235\\?'], [u'\u1235/\u1235']],
170
157
            self.assertEquals('iexplore.exe', b.lower())
171
158
            self.assertNotEquals('', d)
172
159
 
173
 
    def test_wordpad(self):
174
 
        # typical windows users should have wordpad in the system
175
 
        # but there is problem: its path has the format REG_EXPAND_SZ
176
 
        # so naive attempt to get the path is not working
177
 
        for a in ('wordpad', 'wordpad.exe'):
178
 
            p = get_app_path(a)
179
 
            d, b = os.path.split(p)
180
 
            self.assertEquals('wordpad.exe', b.lower())
181
 
            self.assertNotEquals('', d)
182
 
 
183
160
    def test_not_existing(self):
184
161
        p = get_app_path('not-existing')
185
162
        self.assertEquals('not-existing', p)
186
 
 
187
 
 
188
 
class TestLocationsCtypes(TestCase):
189
 
 
190
 
    _test_needs_features = [CtypesFeature]
191
 
 
192
 
    def assertPathsEqual(self, p1, p2):
193
 
        # TODO: The env var values in particular might return the "short"
194
 
        # version (ie, "C:\DOCUME~1\...").  Its even possible the returned
195
 
        # values will differ only by case - handle these situations as we
196
 
        # come across them.
197
 
        self.assertEquals(p1, p2)
198
 
 
199
 
    def test_appdata_not_using_environment(self):
200
 
        # Test that we aren't falling back to the environment
201
 
        first = win32utils.get_appdata_location()
202
 
        self._captureVar("APPDATA", None)
203
 
        self.assertPathsEqual(first, win32utils.get_appdata_location())
204
 
 
205
 
    def test_appdata_matches_environment(self):
206
 
        # Typically the APPDATA environment variable will match
207
 
        # get_appdata_location
208
 
        # XXX - See bug 262874, which asserts the correct encoding is 'mbcs',
209
 
        encoding = osutils.get_user_encoding()
210
 
        env_val = os.environ.get("APPDATA", None)
211
 
        if not env_val:
212
 
            raise TestSkipped("No APPDATA environment variable exists")
213
 
        self.assertPathsEqual(win32utils.get_appdata_location(),
214
 
                              env_val.decode(encoding))
215
 
 
216
 
    def test_local_appdata_not_using_environment(self):
217
 
        # Test that we aren't falling back to the environment
218
 
        first = win32utils.get_local_appdata_location()
219
 
        self._captureVar("LOCALAPPDATA", None)
220
 
        self.assertPathsEqual(first, win32utils.get_local_appdata_location())
221
 
 
222
 
    def test_local_appdata_matches_environment(self):
223
 
        # LOCALAPPDATA typically only exists on Vista, so we only attempt to
224
 
        # compare when it exists.
225
 
        lad = win32utils.get_local_appdata_location()
226
 
        env = os.environ.get("LOCALAPPDATA")
227
 
        if env:
228
 
            # XXX - See bug 262874, which asserts the correct encoding is 'mbcs'
229
 
            encoding = osutils.get_user_encoding()
230
 
            self.assertPathsEqual(lad, env.decode(encoding))
231
 
 
232
 
 
233
 
class TestLocationsPywin32(TestLocationsCtypes):
234
 
 
235
 
    _test_needs_features = [Win32comShellFeature]
236
 
 
237
 
    def setUp(self):
238
 
        super(TestLocationsPywin32, self).setUp()
239
 
        # We perform the exact same tests after disabling the use of ctypes.
240
 
        # This causes the implementation to fall back to pywin32.
241
 
        self.old_ctypes = win32utils.has_ctypes
242
 
        win32utils.has_ctypes = False
243
 
        self.addCleanup(self.restoreCtypes)
244
 
 
245
 
    def restoreCtypes(self):
246
 
        win32utils.has_ctypes = self.old_ctypes
247
 
 
248
 
 
249
 
class TestSetHidden(TestCaseInTempDir):
250
 
 
251
 
    def test_unicode_dir(self):
252
 
        # we should handle unicode paths without errors
253
 
        self.requireFeature(UnicodeFilenameFeature)
254
 
        os.mkdir(u'\u1234')
255
 
        win32utils.set_file_attr_hidden(u'\u1234')
256
 
 
257
 
    def test_dot_bzr_in_unicode_dir(self):
258
 
        # we should not raise traceback if we try to set hidden attribute
259
 
        # on .bzr directory below unicode path
260
 
        self.requireFeature(UnicodeFilenameFeature)
261
 
        os.makedirs(u'\u1234\\.bzr')
262
 
        path = osutils.abspath(u'\u1234\\.bzr')
263
 
        win32utils.set_file_attr_hidden(path)