← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_versionedfile.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-02-27 22:08:46 UTC
  • mfrom: (2227.4.1 bzr.78026)
  • Revision ID: pqm@pqm.ubuntu.com-20070227220846-8cce3b2986915092
Capitalize rocks output

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_versionedfile.py
140
140
        except NotImplementedError:
141
141
            pass
142
142
 
 
143
    def test_add_reserved(self):
 
144
        vf = self.get_file()
 
145
        self.assertRaises(errors.ReservedId,
 
146
            vf.add_lines, 'a:', [], ['a\n', 'b\n', 'c\n'])
 
147
 
 
148
        self.assertRaises(errors.ReservedId,
 
149
            vf.add_delta, 'a:', [], None, 'sha1', False, ((0, 0, 0, []),))
 
150
 
 
151
    def test_get_reserved(self):
 
152
        vf = self.get_file()
 
153
        self.assertRaises(errors.ReservedId, vf.get_delta, 'b:')
 
154
        self.assertRaises(errors.ReservedId, vf.get_texts, ['b:'])
 
155
        self.assertRaises(errors.ReservedId, vf.get_lines, 'b:')
 
156
        self.assertRaises(errors.ReservedId, vf.get_text, 'b:')
 
157
 
143
158
    def test_get_delta(self):
144
159
        f = self.get_file()
145
160
        sha1s = self._setup_for_deltas(f)
198
213
        self.assertEqual(expected_delta, deltas['noeol'])
199
214
        # smoke tests for eol support - two noeol in a row same content
200
215
        expected_deltas = (('noeol', '3ad7ee82dbd8f29ecba073f96e43e414b3f70a4d', True, 
201
 
                          [(0, 1, 2, [(u'noeolsecond', 'line\n'), (u'noeolsecond', 'line\n')])]),
 
216
                          [(0, 1, 2, [('noeolsecond', 'line\n'), ('noeolsecond', 'line\n')])]),
202
217
                          ('noeol', '3ad7ee82dbd8f29ecba073f96e43e414b3f70a4d', True, 
203
218
                           [(0, 0, 1, [('noeolsecond', 'line\n')]), (1, 1, 0, [])]))
204
219
        self.assertEqual(['line\n', 'line'], f.get_lines('noeolsecond'))
205
220
        self.assertTrue(deltas['noeolsecond'] in expected_deltas)
206
221
        # two no-eol in a row, different content
207
222
        expected_delta = ('noeolsecond', '8bb553a84e019ef1149db082d65f3133b195223b', True, 
208
 
                          [(1, 2, 1, [(u'noeolnotshared', 'phone\n')])])
 
223
                          [(1, 2, 1, [('noeolnotshared', 'phone\n')])])
209
224
        self.assertEqual(['line\n', 'phone'], f.get_lines('noeolnotshared'))
210
225
        self.assertEqual(expected_delta, deltas['noeolnotshared'])
211
226
        # eol folling a no-eol with content change
212
227
        expected_delta = ('noeol', 'a61f6fb6cfc4596e8d88c34a308d1e724caf8977', False, 
213
 
                          [(0, 1, 1, [(u'eol', 'phone\n')])])
 
228
                          [(0, 1, 1, [('eol', 'phone\n')])])
214
229
        self.assertEqual(['phone\n'], f.get_lines('eol'))
215
230
        self.assertEqual(expected_delta, deltas['eol'])
216
231
        # eol folling a no-eol with content change
217
232
        expected_delta = ('noeol', '6bfa09d82ce3e898ad4641ae13dd4fdb9cf0d76b', False, 
218
 
                          [(0, 1, 1, [(u'eolline', 'line\n')])])
 
233
                          [(0, 1, 1, [('eolline', 'line\n')])])
219
234
        self.assertEqual(['line\n'], f.get_lines('eolline'))
220
235
        self.assertEqual(expected_delta, deltas['eolline'])
221
236
        # eol with no parents
222
237
        expected_delta = (None, '264f39cab871e4cfd65b3a002f7255888bb5ed97', True, 
223
 
                          [(0, 0, 1, [(u'noeolbase', 'line\n')])])
 
238
                          [(0, 0, 1, [('noeolbase', 'line\n')])])
224
239
        self.assertEqual(['line'], f.get_lines('noeolbase'))
225
240
        self.assertEqual(expected_delta, deltas['noeolbase'])
226
241
        # eol with two parents, in inverse insertion order
227
242
        expected_deltas = (('noeolbase', '264f39cab871e4cfd65b3a002f7255888bb5ed97', True,
228
 
                            [(0, 1, 1, [(u'eolbeforefirstparent', 'line\n')])]),
 
243
                            [(0, 1, 1, [('eolbeforefirstparent', 'line\n')])]),
229
244
                           ('noeolbase', '264f39cab871e4cfd65b3a002f7255888bb5ed97', True,
230
 
                            [(0, 1, 1, [(u'eolbeforefirstparent', 'line\n')])]))
 
245
                            [(0, 1, 1, [('eolbeforefirstparent', 'line\n')])]))
231
246
        self.assertEqual(['line'], f.get_lines('eolbeforefirstparent'))
232
247
        #self.assertTrue(deltas['eolbeforefirstparent'] in expected_deltas)
233
248
 
586
601
            if []!= progress.updates: 
587
602
                self.assertEqual(expected, progress.updates)
588
603
            return lines
589
 
        lines = iter_with_versions(['child', 'otherchild'], 
590
 
                                   [('Walking content.', 0, 2), 
591
 
                                    ('Walking content.', 0, 2), 
592
 
                                    ('Walking content.', 3, 2), 
 
604
        lines = iter_with_versions(['child', 'otherchild'],
 
605
                                   [('Walking content.', 0, 2),
 
606
                                    ('Walking content.', 1, 2),
593
607
                                    ('Walking content.', 2, 2)])
594
608
        # we must see child and otherchild
595
609
        self.assertTrue(lines['child\n'] > 0)
597
611
        # we dont care if we got more than that.
598
612
        
599
613
        # test all lines
600
 
        lines = iter_with_versions(None, [('Walking content.', 0, 5), 
601
 
                                          ('Walking content.', 0, 5), 
602
 
                                          ('Walking content.', 1, 5), 
603
 
                                          ('Walking content.', 2, 5), 
604
 
                                          ('Walking content.', 2, 5), 
605
 
                                          ('Walking content.', 3, 5), 
 
614
        lines = iter_with_versions(None, [('Walking content.', 0, 5),
 
615
                                          ('Walking content.', 1, 5),
 
616
                                          ('Walking content.', 2, 5),
 
617
                                          ('Walking content.', 3, 5),
 
618
                                          ('Walking content.', 4, 5),
606
619
                                          ('Walking content.', 5, 5)])
607
620
        # all lines must be seen at least once
608
621
        self.assertTrue(lines['base\n'] > 0)
655
668
        # add_lines_with_ghosts api.
656
669
        vf = self.get_file()
657
670
        # add a revision with ghost parents
 
671
        # The preferred form is utf8, but we should translate when needed
 
672
        parent_id_unicode = u'b\xbfse'
 
673
        parent_id_utf8 = parent_id_unicode.encode('utf8')
658
674
        try:
659
 
            vf.add_lines_with_ghosts(u'notbxbfse', [u'b\xbfse'], [])
 
675
            vf.add_lines_with_ghosts(u'notbxbfse', [parent_id_utf8], [])
660
676
        except NotImplementedError:
661
677
            # check the other ghost apis are also not implemented
662
678
            self.assertRaises(NotImplementedError, vf.has_ghost, 'foo')
664
680
            self.assertRaises(NotImplementedError, vf.get_parents_with_ghosts, 'foo')
665
681
            self.assertRaises(NotImplementedError, vf.get_graph_with_ghosts)
666
682
            return
 
683
        vf = self.reopen_file()
667
684
        # test key graph related apis: getncestry, _graph, get_parents
668
685
        # has_version
669
686
        # - these are ghost unaware and must not be reflect ghosts
670
 
        self.assertEqual([u'notbxbfse'], vf.get_ancestry(u'notbxbfse'))
671
 
        self.assertEqual([], vf.get_parents(u'notbxbfse'))
672
 
        self.assertEqual({u'notbxbfse':[]}, vf.get_graph())
673
 
        self.assertFalse(vf.has_version(u'b\xbfse'))
 
687
        self.assertEqual(['notbxbfse'], vf.get_ancestry('notbxbfse'))
 
688
        self.assertEqual([], vf.get_parents('notbxbfse'))
 
689
        self.assertEqual({'notbxbfse':[]}, vf.get_graph())
 
690
        self.assertFalse(vf.has_version(parent_id_unicode))
 
691
        self.assertFalse(vf.has_version(parent_id_utf8))
674
692
        # we have _with_ghost apis to give us ghost information.
675
 
        self.assertEqual([u'b\xbfse', u'notbxbfse'], vf.get_ancestry_with_ghosts([u'notbxbfse']))
676
 
        self.assertEqual([u'b\xbfse'], vf.get_parents_with_ghosts(u'notbxbfse'))
677
 
        self.assertEqual({u'notbxbfse':[u'b\xbfse']}, vf.get_graph_with_ghosts())
678
 
        self.assertTrue(vf.has_ghost(u'b\xbfse'))
 
693
        self.assertEqual([parent_id_utf8, 'notbxbfse'], vf.get_ancestry_with_ghosts(['notbxbfse']))
 
694
        self.assertEqual([parent_id_utf8], vf.get_parents_with_ghosts('notbxbfse'))
 
695
        self.assertEqual({'notbxbfse':[parent_id_utf8]}, vf.get_graph_with_ghosts())
 
696
        self.assertTrue(vf.has_ghost(parent_id_unicode))
 
697
        self.assertTrue(vf.has_ghost(parent_id_utf8))
679
698
        # if we add something that is a ghost of another, it should correct the
680
699
        # results of the prior apis
681
 
        vf.add_lines(u'b\xbfse', [], [])
682
 
        self.assertEqual([u'b\xbfse', u'notbxbfse'], vf.get_ancestry([u'notbxbfse']))
683
 
        self.assertEqual([u'b\xbfse'], vf.get_parents(u'notbxbfse'))
684
 
        self.assertEqual({u'b\xbfse':[],
685
 
                          u'notbxbfse':[u'b\xbfse'],
 
700
        vf.add_lines(parent_id_unicode, [], [])
 
701
        self.assertEqual([parent_id_utf8, 'notbxbfse'], vf.get_ancestry(['notbxbfse']))
 
702
        self.assertEqual([parent_id_utf8], vf.get_parents('notbxbfse'))
 
703
        self.assertEqual({parent_id_utf8:[],
 
704
                          'notbxbfse':[parent_id_utf8],
686
705
                          },
687
706
                         vf.get_graph())
688
 
        self.assertTrue(vf.has_version(u'b\xbfse'))
 
707
        self.assertTrue(vf.has_version(parent_id_unicode))
 
708
        self.assertTrue(vf.has_version(parent_id_utf8))
689
709
        # we have _with_ghost apis to give us ghost information.
690
 
        self.assertEqual([u'b\xbfse', u'notbxbfse'], vf.get_ancestry_with_ghosts([u'notbxbfse']))
691
 
        self.assertEqual([u'b\xbfse'], vf.get_parents_with_ghosts(u'notbxbfse'))
692
 
        self.assertEqual({u'b\xbfse':[],
693
 
                          u'notbxbfse':[u'b\xbfse'],
 
710
        self.assertEqual([parent_id_utf8, 'notbxbfse'], vf.get_ancestry_with_ghosts(['notbxbfse']))
 
711
        self.assertEqual([parent_id_utf8], vf.get_parents_with_ghosts('notbxbfse'))
 
712
        self.assertEqual({parent_id_utf8:[],
 
713
                          'notbxbfse':[parent_id_utf8],
694
714
                          },
695
715
                         vf.get_graph_with_ghosts())
696
 
        self.assertFalse(vf.has_ghost(u'b\xbfse'))
 
716
        self.assertFalse(vf.has_ghost(parent_id_unicode))
 
717
        self.assertFalse(vf.has_ghost(parent_id_utf8))
697
718
 
698
719
    def test_add_lines_with_ghosts_after_normal_revs(self):
699
720
        # some versioned file formats allow lines to be added with parent