~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/versionedfile.py

  • Committer: Robert Collins
  • Date: 2006-04-07 08:32:26 UTC
  • mto: (1654.1.5 integration)
  • mto: This revision was merged to the branch mainline in revision 1661.
  • Revision ID: robertc@robertcollins.net-20060407083226-2e8f48b8a7a16cf4
Change knit index files to be robust in the presence of partial writes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005 by Canonical Ltd
 
2
#
 
3
# Authors:
 
4
#   Johan Rydberg <jrydberg@gnu.org>
 
5
#
 
6
# This program is free software; you can redistribute it and/or modify
 
7
# it under the terms of the GNU General Public License as published by
 
8
# the Free Software Foundation; either version 2 of the License, or
 
9
# (at your option) any later version.
 
10
 
 
11
# This program is distributed in the hope that it will be useful,
 
12
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
# GNU General Public License for more details.
 
15
 
 
16
# You should have received a copy of the GNU General Public License
 
17
# along with this program; if not, write to the Free Software
 
18
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
19
 
 
20
# Remaing to do is to figure out if get_graph should return a simple
 
21
# map, or a graph object of some kind.
 
22
 
 
23
 
 
24
"""Versioned text file storage api."""
 
25
 
 
26
 
 
27
from copy import deepcopy
 
28
from unittest import TestSuite
 
29
 
 
30
 
 
31
import bzrlib.errors as errors
 
32
from bzrlib.inter import InterObject
 
33
from bzrlib.symbol_versioning import *
 
34
from bzrlib.transport.memory import MemoryTransport
 
35
from bzrlib.tsort import topo_sort
 
36
from bzrlib import ui
 
37
 
 
38
 
 
39
class VersionedFile(object):
 
40
    """Versioned text file storage.
 
41
    
 
42
    A versioned file manages versions of line-based text files,
 
43
    keeping track of the originating version for each line.
 
44
 
 
45
    To clients the "lines" of the file are represented as a list of
 
46
    strings. These strings will typically have terminal newline
 
47
    characters, but this is not required.  In particular files commonly
 
48
    do not have a newline at the end of the file.
 
49
 
 
50
    Texts are identified by a version-id string.
 
51
    """
 
52
 
 
53
    def __init__(self, access_mode):
 
54
        self.finished = False
 
55
        self._access_mode = access_mode
 
56
 
 
57
    def copy_to(self, name, transport):
 
58
        """Copy this versioned file to name on transport."""
 
59
        raise NotImplementedError(self.copy_to)
 
60
    
 
61
    @deprecated_method(zero_eight)
 
62
    def names(self):
 
63
        """Return a list of all the versions in this versioned file.
 
64
 
 
65
        Please use versionedfile.versions() now.
 
66
        """
 
67
        return self.versions()
 
68
 
 
69
    def versions(self):
 
70
        """Return a unsorted list of versions."""
 
71
        raise NotImplementedError(self.versions)
 
72
 
 
73
    def has_ghost(self, version_id):
 
74
        """Returns whether version is present as a ghost."""
 
75
        raise NotImplementedError(self.has_ghost)
 
76
 
 
77
    def has_version(self, version_id):
 
78
        """Returns whether version is present."""
 
79
        raise NotImplementedError(self.has_version)
 
80
 
 
81
    def add_delta(self, version_id, parents, delta_parent, sha1, noeol, delta):
 
82
        """Add a text to the versioned file via a pregenerated delta.
 
83
 
 
84
        :param version_id: The version id being added.
 
85
        :param parents: The parents of the version_id.
 
86
        :param delta_parent: The parent this delta was created against.
 
87
        :param sha1: The sha1 of the full text.
 
88
        :param delta: The delta instructions. See get_delta for details.
 
89
        """
 
90
        self._check_write_ok()
 
91
        if self.has_version(version_id):
 
92
            raise errors.RevisionAlreadyPresent(version_id, self)
 
93
        return self._add_delta(version_id, parents, delta_parent, sha1, noeol, delta)
 
94
 
 
95
    def _add_delta(self, version_id, parents, delta_parent, sha1, noeol, delta):
 
96
        """Class specific routine to add a delta.
 
97
 
 
98
        This generic version simply applies the delta to the delta_parent and
 
99
        then inserts it.
 
100
        """
 
101
        # strip annotation from delta
 
102
        new_delta = []
 
103
        for start, stop, delta_len, delta_lines in delta:
 
104
            new_delta.append((start, stop, delta_len, [text for origin, text in delta_lines]))
 
105
        if delta_parent is not None:
 
106
            parent_full = self.get_lines(delta_parent)
 
107
        else:
 
108
            parent_full = []
 
109
        new_full = self._apply_delta(parent_full, new_delta)
 
110
        # its impossible to have noeol on an empty file
 
111
        if noeol and new_full[-1][-1] == '\n':
 
112
            new_full[-1] = new_full[-1][:-1]
 
113
        self.add_lines(version_id, parents, new_full)
 
114
 
 
115
    def add_lines(self, version_id, parents, lines, parent_texts=None):
 
116
        """Add a single text on top of the versioned file.
 
117
 
 
118
        Must raise RevisionAlreadyPresent if the new version is
 
119
        already present in file history.
 
120
 
 
121
        Must raise RevisionNotPresent if any of the given parents are
 
122
        not present in file history.
 
123
        :param parent_texts: An optional dictionary containing the opaque 
 
124
             representations of some or all of the parents of 
 
125
             version_id to allow delta optimisations. 
 
126
             VERY IMPORTANT: the texts must be those returned
 
127
             by add_lines or data corruption can be caused.
 
128
        :return: An opaque representation of the inserted version which can be
 
129
                 provided back to future add_lines calls in the parent_texts
 
130
                 dictionary.
 
131
        """
 
132
        self._check_write_ok()
 
133
        return self._add_lines(version_id, parents, lines, parent_texts)
 
134
 
 
135
    def _add_lines(self, version_id, parents, lines, parent_texts):
 
136
        """Helper to do the class specific add_lines."""
 
137
        raise NotImplementedError(self.add_lines)
 
138
 
 
139
    def add_lines_with_ghosts(self, version_id, parents, lines,
 
140
                              parent_texts=None):
 
141
        """Add lines to the versioned file, allowing ghosts to be present.
 
142
        
 
143
        This takes the same parameters as add_lines.
 
144
        """
 
145
        self._check_write_ok()
 
146
        return self._add_lines_with_ghosts(version_id, parents, lines,
 
147
                                           parent_texts)
 
148
 
 
149
    def _add_lines_with_ghosts(self, version_id, parents, lines, parent_texts):
 
150
        """Helper to do class specific add_lines_with_ghosts."""
 
151
        raise NotImplementedError(self.add_lines_with_ghosts)
 
152
 
 
153
    def check(self, progress_bar=None):
 
154
        """Check the versioned file for integrity."""
 
155
        raise NotImplementedError(self.check)
 
156
 
 
157
    def _check_write_ok(self):
 
158
        """Is the versioned file marked as 'finished' ? Raise if it is."""
 
159
        if self.finished:
 
160
            raise errors.OutSideTransaction()
 
161
        if self._access_mode != 'w':
 
162
            raise errors.ReadOnlyObjectDirtiedError(self)
 
163
 
 
164
    def clear_cache(self):
 
165
        """Remove any data cached in the versioned file object."""
 
166
 
 
167
    def clone_text(self, new_version_id, old_version_id, parents):
 
168
        """Add an identical text to old_version_id as new_version_id.
 
169
 
 
170
        Must raise RevisionNotPresent if the old version or any of the
 
171
        parents are not present in file history.
 
172
 
 
173
        Must raise RevisionAlreadyPresent if the new version is
 
174
        already present in file history."""
 
175
        self._check_write_ok()
 
176
        return self._clone_text(new_version_id, old_version_id, parents)
 
177
 
 
178
    def _clone_text(self, new_version_id, old_version_id, parents):
 
179
        """Helper function to do the _clone_text work."""
 
180
        raise NotImplementedError(self.clone_text)
 
181
 
 
182
    def create_empty(self, name, transport, mode=None):
 
183
        """Create a new versioned file of this exact type.
 
184
 
 
185
        :param name: the file name
 
186
        :param transport: the transport
 
187
        :param mode: optional file mode.
 
188
        """
 
189
        raise NotImplementedError(self.create_empty)
 
190
 
 
191
    def fix_parents(self, version, new_parents):
 
192
        """Fix the parents list for version.
 
193
        
 
194
        This is done by appending a new version to the index
 
195
        with identical data except for the parents list.
 
196
        the parents list must be a superset of the current
 
197
        list.
 
198
        """
 
199
        self._check_write_ok()
 
200
        return self._fix_parents(version, new_parents)
 
201
 
 
202
    def _fix_parents(self, version, new_parents):
 
203
        """Helper for fix_parents."""
 
204
        raise NotImplementedError(self.fix_parents)
 
205
 
 
206
    def get_delta(self, version):
 
207
        """Get a delta for constructing version from some other version.
 
208
        
 
209
        :return: (delta_parent, sha1, noeol, delta)
 
210
        Where delta_parent is a version id or None to indicate no parent.
 
211
        """
 
212
        raise NotImplementedError(self.get_delta)
 
213
 
 
214
    def get_deltas(self, versions):
 
215
        """Get multiple deltas at once for constructing versions.
 
216
        
 
217
        :return: dict(version_id:(delta_parent, sha1, noeol, delta))
 
218
        Where delta_parent is a version id or None to indicate no parent, and
 
219
        version_id is the version_id created by that delta.
 
220
        """
 
221
        result = {}
 
222
        for version in versions:
 
223
            result[version] = self.get_delta(version)
 
224
        return result
 
225
 
 
226
    def get_suffixes(self):
 
227
        """Return the file suffixes associated with this versioned file."""
 
228
        raise NotImplementedError(self.get_suffixes)
 
229
    
 
230
    def get_text(self, version_id):
 
231
        """Return version contents as a text string.
 
232
 
 
233
        Raises RevisionNotPresent if version is not present in
 
234
        file history.
 
235
        """
 
236
        return ''.join(self.get_lines(version_id))
 
237
    get_string = get_text
 
238
 
 
239
    def get_lines(self, version_id):
 
240
        """Return version contents as a sequence of lines.
 
241
 
 
242
        Raises RevisionNotPresent if version is not present in
 
243
        file history.
 
244
        """
 
245
        raise NotImplementedError(self.get_lines)
 
246
 
 
247
    def get_ancestry(self, version_ids):
 
248
        """Return a list of all ancestors of given version(s). This
 
249
        will not include the null revision.
 
250
 
 
251
        Must raise RevisionNotPresent if any of the given versions are
 
252
        not present in file history."""
 
253
        if isinstance(version_ids, basestring):
 
254
            version_ids = [version_ids]
 
255
        raise NotImplementedError(self.get_ancestry)
 
256
        
 
257
    def get_ancestry_with_ghosts(self, version_ids):
 
258
        """Return a list of all ancestors of given version(s). This
 
259
        will not include the null revision.
 
260
 
 
261
        Must raise RevisionNotPresent if any of the given versions are
 
262
        not present in file history.
 
263
        
 
264
        Ghosts that are known about will be included in ancestry list,
 
265
        but are not explicitly marked.
 
266
        """
 
267
        raise NotImplementedError(self.get_ancestry_with_ghosts)
 
268
        
 
269
    def get_graph(self):
 
270
        """Return a graph for the entire versioned file.
 
271
        
 
272
        Ghosts are not listed or referenced in the graph.
 
273
        """
 
274
        result = {}
 
275
        for version in self.versions():
 
276
            result[version] = self.get_parents(version)
 
277
        return result
 
278
 
 
279
    def get_graph_with_ghosts(self):
 
280
        """Return a graph for the entire versioned file.
 
281
        
 
282
        Ghosts are referenced in parents list but are not
 
283
        explicitly listed.
 
284
        """
 
285
        raise NotImplementedError(self.get_graph_with_ghosts)
 
286
 
 
287
    @deprecated_method(zero_eight)
 
288
    def parent_names(self, version):
 
289
        """Return version names for parents of a version.
 
290
        
 
291
        See get_parents for the current api.
 
292
        """
 
293
        return self.get_parents(version)
 
294
 
 
295
    def get_parents(self, version_id):
 
296
        """Return version names for parents of a version.
 
297
 
 
298
        Must raise RevisionNotPresent if version is not present in
 
299
        file history.
 
300
        """
 
301
        raise NotImplementedError(self.get_parents)
 
302
 
 
303
    def get_parents_with_ghosts(self, version_id):
 
304
        """Return version names for parents of version_id.
 
305
 
 
306
        Will raise RevisionNotPresent if version_id is not present
 
307
        in the history.
 
308
 
 
309
        Ghosts that are known about will be included in the parent list,
 
310
        but are not explicitly marked.
 
311
        """
 
312
        raise NotImplementedError(self.get_parents_with_ghosts)
 
313
 
 
314
    def annotate_iter(self, version_id):
 
315
        """Yield list of (version-id, line) pairs for the specified
 
316
        version.
 
317
 
 
318
        Must raise RevisionNotPresent if any of the given versions are
 
319
        not present in file history.
 
320
        """
 
321
        raise NotImplementedError(self.annotate_iter)
 
322
 
 
323
    def annotate(self, version_id):
 
324
        return list(self.annotate_iter(version_id))
 
325
 
 
326
    def _apply_delta(self, lines, delta):
 
327
        """Apply delta to lines."""
 
328
        lines = list(lines)
 
329
        offset = 0
 
330
        for start, end, count, delta_lines in delta:
 
331
            lines[offset+start:offset+end] = delta_lines
 
332
            offset = offset + (start - end) + count
 
333
        return lines
 
334
 
 
335
    def join(self, other, pb=None, msg=None, version_ids=None,
 
336
             ignore_missing=False):
 
337
        """Integrate versions from other into this versioned file.
 
338
 
 
339
        If version_ids is None all versions from other should be
 
340
        incorporated into this versioned file.
 
341
 
 
342
        Must raise RevisionNotPresent if any of the specified versions
 
343
        are not present in the other files history unless ignore_missing
 
344
        is supplied when they are silently skipped.
 
345
        """
 
346
        self._check_write_ok()
 
347
        return InterVersionedFile.get(other, self).join(
 
348
            pb,
 
349
            msg,
 
350
            version_ids,
 
351
            ignore_missing)
 
352
 
 
353
    def iter_lines_added_or_present_in_versions(self, version_ids=None):
 
354
        """Iterate over the lines in the versioned file from version_ids.
 
355
 
 
356
        This may return lines from other versions, and does not return the
 
357
        specific version marker at this point. The api may be changed
 
358
        during development to include the version that the versioned file
 
359
        thinks is relevant, but given that such hints are just guesses,
 
360
        its better not to have it if we dont need it.
 
361
 
 
362
        NOTES: Lines are normalised: they will all have \n terminators.
 
363
               Lines are returned in arbitrary order.
 
364
        """
 
365
        raise NotImplementedError(self.iter_lines_added_or_present_in_versions)
 
366
 
 
367
    def transaction_finished(self):
 
368
        """The transaction that this file was opened in has finished.
 
369
 
 
370
        This records self.finished = True and should cause all mutating
 
371
        operations to error.
 
372
        """
 
373
        self.finished = True
 
374
 
 
375
    @deprecated_method(zero_eight)
 
376
    def walk(self, version_ids=None):
 
377
        """Walk the versioned file as a weave-like structure, for
 
378
        versions relative to version_ids.  Yields sequence of (lineno,
 
379
        insert, deletes, text) for each relevant line.
 
380
 
 
381
        Must raise RevisionNotPresent if any of the specified versions
 
382
        are not present in the file history.
 
383
 
 
384
        :param version_ids: the version_ids to walk with respect to. If not
 
385
                            supplied the entire weave-like structure is walked.
 
386
 
 
387
        walk is deprecated in favour of iter_lines_added_or_present_in_versions
 
388
        """
 
389
        raise NotImplementedError(self.walk)
 
390
 
 
391
    @deprecated_method(zero_eight)
 
392
    def iter_names(self):
 
393
        """Walk the names list."""
 
394
        return iter(self.versions())
 
395
 
 
396
    def plan_merge(self, ver_a, ver_b):
 
397
        """Return pseudo-annotation indicating how the two versions merge.
 
398
 
 
399
        This is computed between versions a and b and their common
 
400
        base.
 
401
 
 
402
        Weave lines present in none of them are skipped entirely.
 
403
        """
 
404
        inc_a = set(self.get_ancestry([ver_a]))
 
405
        inc_b = set(self.get_ancestry([ver_b]))
 
406
        inc_c = inc_a & inc_b
 
407
 
 
408
        for lineno, insert, deleteset, line in self.walk([ver_a, ver_b]):
 
409
            if deleteset & inc_c:
 
410
                # killed in parent; can't be in either a or b
 
411
                # not relevant to our work
 
412
                yield 'killed-base', line
 
413
            elif insert in inc_c:
 
414
                # was inserted in base
 
415
                killed_a = bool(deleteset & inc_a)
 
416
                killed_b = bool(deleteset & inc_b)
 
417
                if killed_a and killed_b:
 
418
                    yield 'killed-both', line
 
419
                elif killed_a:
 
420
                    yield 'killed-a', line
 
421
                elif killed_b:
 
422
                    yield 'killed-b', line
 
423
                else:
 
424
                    yield 'unchanged', line
 
425
            elif insert in inc_a:
 
426
                if deleteset & inc_a:
 
427
                    yield 'ghost-a', line
 
428
                else:
 
429
                    # new in A; not in B
 
430
                    yield 'new-a', line
 
431
            elif insert in inc_b:
 
432
                if deleteset & inc_b:
 
433
                    yield 'ghost-b', line
 
434
                else:
 
435
                    yield 'new-b', line
 
436
            else:
 
437
                # not in either revision
 
438
                yield 'irrelevant', line
 
439
 
 
440
        yield 'unchanged', ''           # terminator
 
441
 
 
442
    def weave_merge(self, plan, a_marker='<<<<<<< \n', b_marker='>>>>>>> \n'):
 
443
        lines_a = []
 
444
        lines_b = []
 
445
        ch_a = ch_b = False
 
446
        # TODO: Return a structured form of the conflicts (e.g. 2-tuples for
 
447
        # conflicted regions), rather than just inserting the markers.
 
448
        # 
 
449
        # TODO: Show some version information (e.g. author, date) on 
 
450
        # conflicted regions.
 
451
        
 
452
        # We previously considered either 'unchanged' or 'killed-both' lines
 
453
        # to be possible places to resynchronize.  However, assuming agreement
 
454
        # on killed-both lines may be too agressive. -- mbp 20060324
 
455
        for state, line in plan:
 
456
            if state == 'unchanged':
 
457
                # resync and flush queued conflicts changes if any
 
458
                if not lines_a and not lines_b:
 
459
                    pass
 
460
                elif ch_a and not ch_b:
 
461
                    # one-sided change:                    
 
462
                    for l in lines_a: yield l
 
463
                elif ch_b and not ch_a:
 
464
                    for l in lines_b: yield l
 
465
                elif lines_a == lines_b:
 
466
                    for l in lines_a: yield l
 
467
                else:
 
468
                    yield a_marker
 
469
                    for l in lines_a: yield l
 
470
                    yield '=======\n'
 
471
                    for l in lines_b: yield l
 
472
                    yield b_marker
 
473
 
 
474
                del lines_a[:]
 
475
                del lines_b[:]
 
476
                ch_a = ch_b = False
 
477
                
 
478
            if state == 'unchanged':
 
479
                if line:
 
480
                    yield line
 
481
            elif state == 'killed-a':
 
482
                ch_a = True
 
483
                lines_b.append(line)
 
484
            elif state == 'killed-b':
 
485
                ch_b = True
 
486
                lines_a.append(line)
 
487
            elif state == 'new-a':
 
488
                ch_a = True
 
489
                lines_a.append(line)
 
490
            elif state == 'new-b':
 
491
                ch_b = True
 
492
                lines_b.append(line)
 
493
            else:
 
494
                assert state in ('irrelevant', 'ghost-a', 'ghost-b', 'killed-base',
 
495
                                 'killed-both'), \
 
496
                       state
 
497
 
 
498
 
 
499
class InterVersionedFile(InterObject):
 
500
    """This class represents operations taking place between two versionedfiles..
 
501
 
 
502
    Its instances have methods like join, and contain
 
503
    references to the source and target versionedfiles these operations can be 
 
504
    carried out on.
 
505
 
 
506
    Often we will provide convenience methods on 'versionedfile' which carry out
 
507
    operations with another versionedfile - they will always forward to
 
508
    InterVersionedFile.get(other).method_name(parameters).
 
509
    """
 
510
 
 
511
    _optimisers = set()
 
512
    """The available optimised InterVersionedFile types."""
 
513
 
 
514
    def join(self, pb=None, msg=None, version_ids=None, ignore_missing=False):
 
515
        """Integrate versions from self.source into self.target.
 
516
 
 
517
        If version_ids is None all versions from source should be
 
518
        incorporated into this versioned file.
 
519
 
 
520
        Must raise RevisionNotPresent if any of the specified versions
 
521
        are not present in the other files history unless ignore_missing is 
 
522
        supplied when they are silently skipped.
 
523
        """
 
524
        # the default join: 
 
525
        # - if the target is empty, just add all the versions from 
 
526
        #   source to target, otherwise:
 
527
        # - make a temporary versioned file of type target
 
528
        # - insert the source content into it one at a time
 
529
        # - join them
 
530
        if not self.target.versions():
 
531
            target = self.target
 
532
        else:
 
533
            # Make a new target-format versioned file. 
 
534
            temp_source = self.target.create_empty("temp", MemoryTransport())
 
535
            target = temp_source
 
536
        graph = self.source.get_graph()
 
537
        order = topo_sort(graph.items())
 
538
        pb = ui.ui_factory.nested_progress_bar()
 
539
        parent_texts = {}
 
540
        try:
 
541
            # TODO for incremental cross-format work:
 
542
            # make a versioned file with the following content:
 
543
            # all revisions we have been asked to join
 
544
            # all their ancestors that are *not* in target already.
 
545
            # the immediate parents of the above two sets, with 
 
546
            # empty parent lists - these versions are in target already
 
547
            # and the incorrect version data will be ignored.
 
548
            # TODO: for all ancestors that are present in target already,
 
549
            # check them for consistent data, this requires moving sha1 from
 
550
            # 
 
551
            # TODO: remove parent texts when they are not relevant any more for 
 
552
            # memory pressure reduction. RBC 20060313
 
553
            # pb.update('Converting versioned data', 0, len(order))
 
554
            # deltas = self.source.get_deltas(order)
 
555
            for index, version in enumerate(order):
 
556
                pb.update('Converting versioned data', index, len(order))
 
557
                parent_text = target.add_lines(version,
 
558
                                               self.source.get_parents(version),
 
559
                                               self.source.get_lines(version),
 
560
                                               parent_texts=parent_texts)
 
561
                parent_texts[version] = parent_text
 
562
                #delta_parent, sha1, noeol, delta = deltas[version]
 
563
                #target.add_delta(version,
 
564
                #                 self.source.get_parents(version),
 
565
                #                 delta_parent,
 
566
                #                 sha1,
 
567
                #                 noeol,
 
568
                #                 delta)
 
569
                #target.get_lines(version)
 
570
            
 
571
            # this should hit the native code path for target
 
572
            if target is not self.target:
 
573
                return self.target.join(temp_source,
 
574
                                        pb,
 
575
                                        msg,
 
576
                                        version_ids,
 
577
                                        ignore_missing)
 
578
        finally:
 
579
            pb.finished()
 
580
 
 
581
 
 
582
class InterVersionedFileTestProviderAdapter(object):
 
583
    """A tool to generate a suite testing multiple inter versioned-file classes.
 
584
 
 
585
    This is done by copying the test once for each interversionedfile provider
 
586
    and injecting the transport_server, transport_readonly_server,
 
587
    versionedfile_factory and versionedfile_factory_to classes into each copy.
 
588
    Each copy is also given a new id() to make it easy to identify.
 
589
    """
 
590
 
 
591
    def __init__(self, transport_server, transport_readonly_server, formats):
 
592
        self._transport_server = transport_server
 
593
        self._transport_readonly_server = transport_readonly_server
 
594
        self._formats = formats
 
595
    
 
596
    def adapt(self, test):
 
597
        result = TestSuite()
 
598
        for (interversionedfile_class,
 
599
             versionedfile_factory,
 
600
             versionedfile_factory_to) in self._formats:
 
601
            new_test = deepcopy(test)
 
602
            new_test.transport_server = self._transport_server
 
603
            new_test.transport_readonly_server = self._transport_readonly_server
 
604
            new_test.interversionedfile_class = interversionedfile_class
 
605
            new_test.versionedfile_factory = versionedfile_factory
 
606
            new_test.versionedfile_factory_to = versionedfile_factory_to
 
607
            def make_new_test_id():
 
608
                new_id = "%s(%s)" % (new_test.id(), interversionedfile_class.__name__)
 
609
                return lambda: new_id
 
610
            new_test.id = make_new_test_id()
 
611
            result.addTest(new_test)
 
612
        return result
 
613
 
 
614
    @staticmethod
 
615
    def default_test_list():
 
616
        """Generate the default list of interversionedfile permutations to test."""
 
617
        from bzrlib.weave import WeaveFile
 
618
        from bzrlib.knit import KnitVersionedFile
 
619
        result = []
 
620
        # test the fallback InterVersionedFile from weave to annotated knits
 
621
        result.append((InterVersionedFile, 
 
622
                       WeaveFile,
 
623
                       KnitVersionedFile))
 
624
        for optimiser in InterVersionedFile._optimisers:
 
625
            result.append((optimiser,
 
626
                           optimiser._matching_file_factory,
 
627
                           optimiser._matching_file_factory
 
628
                           ))
 
629
        # if there are specific combinations we want to use, we can add them 
 
630
        # here.
 
631
        return result