← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_osutils.py

Merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_osutils.py
23
23
import sys
24
24
 
25
25
import bzrlib
 
26
from bzrlib import (
 
27
    errors,
 
28
    osutils,
 
29
    )
26
30
from bzrlib.errors import BzrBadParameterNotUnicode, InvalidURL
27
 
import bzrlib.osutils as osutils
28
31
from bzrlib.tests import (
29
32
        StringIOWrapper,
30
33
        TestCase, 
78
81
        self.assertEqual(type(result), str)
79
82
        self.assertContainsRe(result, r'^[a-z0-9]{100}$')
80
83
 
 
84
    def test_is_inside(self):
 
85
        is_inside = osutils.is_inside
 
86
        self.assertTrue(is_inside('src', 'src/foo.c'))
 
87
        self.assertFalse(is_inside('src', 'srccontrol'))
 
88
        self.assertTrue(is_inside('src', 'src/a/a/a/foo.c'))
 
89
        self.assertTrue(is_inside('foo.c', 'foo.c'))
 
90
        self.assertFalse(is_inside('foo.c', ''))
 
91
        self.assertTrue(is_inside('', 'foo.c'))
81
92
 
82
93
    def test_rmtree(self):
83
94
        # Check to remove tree with read-only files/dirs
150
161
        finally:
151
162
            os.umask(orig_umask)
152
163
 
 
164
    def assertFormatedDelta(self, expected, seconds):
 
165
        """Assert osutils.format_delta formats as expected"""
 
166
        actual = osutils.format_delta(seconds)
 
167
        self.assertEqual(expected, actual)
 
168
 
 
169
    def test_format_delta(self):
 
170
        self.assertFormatedDelta('0 seconds ago', 0)
 
171
        self.assertFormatedDelta('1 second ago', 1)
 
172
        self.assertFormatedDelta('10 seconds ago', 10)
 
173
        self.assertFormatedDelta('59 seconds ago', 59)
 
174
        self.assertFormatedDelta('89 seconds ago', 89)
 
175
        self.assertFormatedDelta('1 minute, 30 seconds ago', 90)
 
176
        self.assertFormatedDelta('3 minutes, 0 seconds ago', 180)
 
177
        self.assertFormatedDelta('3 minutes, 1 second ago', 181)
 
178
        self.assertFormatedDelta('10 minutes, 15 seconds ago', 615)
 
179
        self.assertFormatedDelta('30 minutes, 59 seconds ago', 1859)
 
180
        self.assertFormatedDelta('31 minutes, 0 seconds ago', 1860)
 
181
        self.assertFormatedDelta('60 minutes, 0 seconds ago', 3600)
 
182
        self.assertFormatedDelta('89 minutes, 59 seconds ago', 5399)
 
183
        self.assertFormatedDelta('1 hour, 30 minutes ago', 5400)
 
184
        self.assertFormatedDelta('2 hours, 30 minutes ago', 9017)
 
185
        self.assertFormatedDelta('10 hours, 0 minutes ago', 36000)
 
186
        self.assertFormatedDelta('24 hours, 0 minutes ago', 86400)
 
187
        self.assertFormatedDelta('35 hours, 59 minutes ago', 129599)
 
188
        self.assertFormatedDelta('36 hours, 0 minutes ago', 129600)
 
189
        self.assertFormatedDelta('36 hours, 0 minutes ago', 129601)
 
190
        self.assertFormatedDelta('36 hours, 1 minute ago', 129660)
 
191
        self.assertFormatedDelta('36 hours, 1 minute ago', 129661)
 
192
        self.assertFormatedDelta('84 hours, 10 minutes ago', 303002)
 
193
 
 
194
        # We handle when time steps the wrong direction because computers
 
195
        # don't have synchronized clocks.
 
196
        self.assertFormatedDelta('84 hours, 10 minutes in the future', -303002)
 
197
        self.assertFormatedDelta('1 second in the future', -1)
 
198
        self.assertFormatedDelta('2 seconds in the future', -2)
 
199
 
153
200
 
154
201
class TestSafeUnicode(TestCase):
155
202
 
275
322
        except (IOError, OSError), e:
276
323
            self.assertEqual(errno.ENOENT, e.errno)
277
324
 
 
325
    def test_splitpath(self):
 
326
        def check(expected, path):
 
327
            self.assertEqual(expected, osutils.splitpath(path))
 
328
 
 
329
        check(['a'], 'a')
 
330
        check(['a', 'b'], 'a/b')
 
331
        check(['a', 'b'], 'a/./b')
 
332
        check(['a', '.b'], 'a/.b')
 
333
        check(['a', '.b'], 'a\\.b')
 
334
 
 
335
        self.assertRaises(errors.BzrError, osutils.splitpath, 'a/../b')
 
336
 
278
337
 
279
338
class TestMacFuncsDirs(TestCaseInTempDir):
280
339
    """Test mac special functions that require directories."""
300
359
        os.chdir(u'Ba\u030agfors')
301
360
        self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
302
361
 
 
362
 
303
363
class TestSplitLines(TestCase):
304
364
 
305
365
    def test_split_unicode(self):
529
589
        # and in the worst case, use bzrlib.user_encoding
530
590
        self.assertEqual('user_encoding', osutils.get_terminal_encoding())
531
591
 
 
592
 
 
593
class TestSetUnsetEnv(TestCase):
 
594
    """Test updating the environment"""
 
595
 
 
596
    def setUp(self):
 
597
        super(TestSetUnsetEnv, self).setUp()
 
598
 
 
599
        self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'),
 
600
                         'Environment was not cleaned up properly.'
 
601
                         ' Variable BZR_TEST_ENV_VAR should not exist.')
 
602
        def cleanup():
 
603
            if 'BZR_TEST_ENV_VAR' in os.environ:
 
604
                del os.environ['BZR_TEST_ENV_VAR']
 
605
 
 
606
        self.addCleanup(cleanup)
 
607
 
 
608
    def test_set(self):
 
609
        """Test that we can set an env variable"""
 
610
        old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
 
611
        self.assertEqual(None, old)
 
612
        self.assertEqual('foo', os.environ.get('BZR_TEST_ENV_VAR'))
 
613
 
 
614
    def test_double_set(self):
 
615
        """Test that we get the old value out"""
 
616
        osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
 
617
        old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'bar')
 
618
        self.assertEqual('foo', old)
 
619
        self.assertEqual('bar', os.environ.get('BZR_TEST_ENV_VAR'))
 
620
 
 
621
    def test_unicode(self):
 
622
        """Environment can only contain plain strings
 
623
        
 
624
        So Unicode strings must be encoded.
 
625
        """
 
626
        # Try a few different characters, to see if we can get
 
627
        # one that will be valid in the user_encoding
 
628
        possible_vals = [u'm\xb5', u'\xe1', u'\u0410']
 
629
        for uni_val in possible_vals:
 
630
            try:
 
631
                env_val = uni_val.encode(bzrlib.user_encoding)
 
632
            except UnicodeEncodeError:
 
633
                # Try a different character
 
634
                pass
 
635
            else:
 
636
                break
 
637
        else:
 
638
            raise TestSkipped('Cannot find a unicode character that works in'
 
639
                              ' encoding %s' % (bzrlib.user_encoding,))
 
640
 
 
641
        old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', uni_val)
 
642
        self.assertEqual(env_val, os.environ.get('BZR_TEST_ENV_VAR'))
 
643
 
 
644
    def test_unset(self):
 
645
        """Test that passing None will remove the env var"""
 
646
        osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
 
647
        old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', None)
 
648
        self.assertEqual('foo', old)
 
649
        self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'))
 
650
        self.failIf('BZR_TEST_ENV_VAR' in os.environ)
 
651