← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_workingtree.py

  • Committer: Martin Pool
  • Date: 2006-05-23 10:57:02 UTC
  • mfrom: (1725 +trunk)
  • mto: This revision was merged to the branch mainline in revision 1726.
  • Revision ID: mbp@sourcefrog.net-20060523105702-e5de4664cfdb4e8d
[merge] bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_workingtree.py
234
234
        os.mkdir('lala.OTHER')
235
235
        expected = ContentsConflict('lala', file_id='lala-id')
236
236
        self.assertEqual(list(tree.conflicts()), [expected])
 
237
 
 
238
 
 
239
class TestNonFormatSpecificCode(TestCaseWithTransport):
 
240
    """This class contains tests of workingtree that are not format specific."""
 
241
 
 
242
    
 
243
    def test_gen_file_id(self):
 
244
        self.assertStartsWith(bzrlib.workingtree.gen_file_id('bar'), 'bar-')
 
245
        self.assertStartsWith(bzrlib.workingtree.gen_file_id('Mwoo oof\t m'), 'Mwoooofm-')
 
246
        self.assertStartsWith(bzrlib.workingtree.gen_file_id('..gam.py'), 'gam.py-')
 
247
        self.assertStartsWith(bzrlib.workingtree.gen_file_id('..Mwoo oof\t m'), 'Mwoooofm-')
 
248
 
 
249
    def test_next_id_suffix(self):
 
250
        bzrlib.workingtree._gen_id_suffix = None
 
251
        bzrlib.workingtree._next_id_suffix()
 
252
        self.assertNotEqual(None, bzrlib.workingtree._gen_id_suffix)
 
253
        bzrlib.workingtree._gen_id_suffix = "foo-"
 
254
        bzrlib.workingtree._gen_id_serial = 1
 
255
        self.assertEqual("foo-2", bzrlib.workingtree._next_id_suffix())
 
256
        self.assertEqual("foo-3", bzrlib.workingtree._next_id_suffix())
 
257
        self.assertEqual("foo-4", bzrlib.workingtree._next_id_suffix())
 
258
        self.assertEqual("foo-5", bzrlib.workingtree._next_id_suffix())
 
259
        self.assertEqual("foo-6", bzrlib.workingtree._next_id_suffix())
 
260
        self.assertEqual("foo-7", bzrlib.workingtree._next_id_suffix())
 
261
        self.assertEqual("foo-8", bzrlib.workingtree._next_id_suffix())
 
262
        self.assertEqual("foo-9", bzrlib.workingtree._next_id_suffix())
 
263
        self.assertEqual("foo-10", bzrlib.workingtree._next_id_suffix())
 
264
 
 
265
    def test__translate_ignore_rule(self):
 
266
        tree = self.make_branch_and_tree('.')
 
267
        # translation should return the regex, the number of groups in it,
 
268
        # and the original rule in a tuple.
 
269
        # there are three sorts of ignore rules:
 
270
        # root only - regex is the rule itself without the leading ./
 
271
        self.assertEqual(
 
272
            "(rootdirrule$)", 
 
273
            tree._translate_ignore_rule("./rootdirrule"))
 
274
        # full path - regex is the rule itself
 
275
        self.assertEqual(
 
276
            "(path\\/to\\/file$)",
 
277
            tree._translate_ignore_rule("path/to/file"))
 
278
        # basename only rule - regex is a rule that ignores everything up
 
279
        # to the last / in the filename
 
280
        self.assertEqual(
 
281
            "((?:.*/)?(?!.*/)basenamerule$)",
 
282
            tree._translate_ignore_rule("basenamerule"))
 
283
 
 
284
    def test__combine_ignore_rules(self):
 
285
        tree = self.make_branch_and_tree('.')
 
286
        # the combined ignore regexs need the outer group indices
 
287
        # placed in a dictionary with the rules that were combined.
 
288
        # an empty set of rules
 
289
        # this is returned as a list of combined regex,rule sets, because
 
290
        # python has a limit of 100 combined regexes.
 
291
        compiled_rules = tree._combine_ignore_rules([])
 
292
        self.assertEqual([], compiled_rules)
 
293
        # one of each type of rule.
 
294
        compiled_rules = tree._combine_ignore_rules(
 
295
            ["rule1", "rule/two", "./three"])[0]
 
296
        # what type *is* the compiled regex to do an isinstance of ?
 
297
        self.assertEqual(3, compiled_rules[0].groups)
 
298
        self.assertEqual(
 
299
            {0:"rule1",1:"rule/two",2:"./three"},
 
300
            compiled_rules[1])
 
301
 
 
302
    def test__combine_ignore_rules_grouping(self):
 
303
        tree = self.make_branch_and_tree('.')
 
304
        # when there are too many rules, the output is split into groups of 100
 
305
        rules = []
 
306
        for index in range(198):
 
307
            rules.append('foo')
 
308
        self.assertEqual(2, len(tree._combine_ignore_rules(rules)))
 
309
 
 
310
    def test__get_ignore_rules_as_regex(self):
 
311
        tree = self.make_branch_and_tree('.')
 
312
        # test against the default rules.
 
313
        reference_output = tree._combine_ignore_rules(bzrlib.DEFAULT_IGNORE)[0]
 
314
        regex_rules = tree._get_ignore_rules_as_regex()[0]
 
315
        self.assertEqual(len(reference_output[1]), regex_rules[0].groups)
 
316
        self.assertEqual(reference_output[1], regex_rules[1])