← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_inv.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2011-03-08 16:59:36 UTC
  • mfrom: (5705.1.2 731240-range-parsing)
  • Revision ID: pqm@pqm.ubuntu.com-20110308165936-hp3voq41wvr83wnl
(vila) Correctly parse partial range specifiers in the HTTP test server.
 (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_inv.py
56
56
    # just creating trees.
57
57
    formats = set()
58
58
    for _, format in repository.format_registry.iteritems():
59
 
        if format.supports_full_versioned_files:
60
 
            scenarios.append((str(format.__name__), {
61
 
                'apply_delta':apply_inventory_Repository_add_inventory_by_delta,
62
 
                'format':format}))
 
59
        scenarios.append((str(format.__name__), {
 
60
            'apply_delta':apply_inventory_Repository_add_inventory_by_delta,
 
61
            'format':format}))
63
62
    for format in workingtree.format_registry._get_all():
64
 
        repo_fmt = format._matchingbzrdir.repository_format
65
 
        if not repo_fmt.supports_full_versioned_files:
66
 
            continue
67
63
        scenarios.append(
68
64
            (str(format.__class__.__name__) + ".update_basis_by_delta", {
69
65
            'apply_delta':apply_inventory_WT_basis,
83
79
            lines = []
84
80
        repo.texts.add_lines((ie.file_id, ie.revision), [], lines)
85
81
 
86
 
 
 
82
    
87
83
def apply_inventory_Inventory(self, basis, delta):
88
84
    """Apply delta to basis and return the result.
89
85
    
1223
1219
        self.assertEqual(('tree\xce\xa9name', 'tree-root-id', 'tree-rev-id'),
1224
1220
                         inv._bytes_to_utf8name_key(bytes))
1225
1221
 
1226
 
    def make_basic_utf8_inventory(self):
1227
 
        inv = Inventory()
1228
 
        inv.revision_id = "revid"
1229
 
        inv.root.revision = "rootrev"
1230
 
        root_id = inv.root.file_id
1231
 
        inv.add(InventoryFile("fileid", u'f\xefle', root_id))
1232
 
        inv["fileid"].revision = "filerev"
1233
 
        inv["fileid"].text_sha1 = "ffff"
1234
 
        inv["fileid"].text_size = 0
1235
 
        inv.add(InventoryDirectory("dirid", u'dir-\N{EURO SIGN}', root_id))
1236
 
        inv.add(InventoryFile("childid", u'ch\xefld', "dirid"))
1237
 
        inv["childid"].revision = "filerev"
1238
 
        inv["childid"].text_sha1 = "ffff"
1239
 
        inv["childid"].text_size = 0
1240
 
        chk_bytes = self.get_chk_bytes()
1241
 
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
1242
 
        bytes = ''.join(chk_inv.to_lines())
1243
 
        return CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
1244
 
 
1245
 
    def test__preload_handles_utf8(self):
1246
 
        new_inv = self.make_basic_utf8_inventory()
1247
 
        self.assertEqual({}, new_inv._fileid_to_entry_cache)
1248
 
        self.assertFalse(new_inv._fully_cached)
1249
 
        new_inv._preload_cache()
1250
 
        self.assertEqual(
1251
 
            sorted([new_inv.root_id, "fileid", "dirid", "childid"]),
1252
 
            sorted(new_inv._fileid_to_entry_cache.keys()))
1253
 
        ie_root = new_inv._fileid_to_entry_cache[new_inv.root_id]
1254
 
        self.assertEqual([u'dir-\N{EURO SIGN}', u'f\xefle'],
1255
 
                         sorted(ie_root._children.keys()))
1256
 
        ie_dir = new_inv._fileid_to_entry_cache['dirid']
1257
 
        self.assertEqual([u'ch\xefld'], sorted(ie_dir._children.keys()))
1258
 
 
1259
 
    def test__preload_populates_cache(self):
1260
 
        inv = Inventory()
1261
 
        inv.revision_id = "revid"
1262
 
        inv.root.revision = "rootrev"
1263
 
        root_id = inv.root.file_id
1264
 
        inv.add(InventoryFile("fileid", "file", root_id))
1265
 
        inv["fileid"].revision = "filerev"
1266
 
        inv["fileid"].executable = True
1267
 
        inv["fileid"].text_sha1 = "ffff"
1268
 
        inv["fileid"].text_size = 1
1269
 
        inv.add(InventoryDirectory("dirid", "dir", root_id))
1270
 
        inv.add(InventoryFile("childid", "child", "dirid"))
1271
 
        inv["childid"].revision = "filerev"
1272
 
        inv["childid"].executable = False
1273
 
        inv["childid"].text_sha1 = "dddd"
1274
 
        inv["childid"].text_size = 1
1275
 
        chk_bytes = self.get_chk_bytes()
1276
 
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
1277
 
        bytes = ''.join(chk_inv.to_lines())
1278
 
        new_inv = CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
1279
 
        self.assertEqual({}, new_inv._fileid_to_entry_cache)
1280
 
        self.assertFalse(new_inv._fully_cached)
1281
 
        new_inv._preload_cache()
1282
 
        self.assertEqual(
1283
 
            sorted([root_id, "fileid", "dirid", "childid"]),
1284
 
            sorted(new_inv._fileid_to_entry_cache.keys()))
1285
 
        self.assertTrue(new_inv._fully_cached)
1286
 
        ie_root = new_inv._fileid_to_entry_cache[root_id]
1287
 
        self.assertEqual(['dir', 'file'], sorted(ie_root._children.keys()))
1288
 
        ie_dir = new_inv._fileid_to_entry_cache['dirid']
1289
 
        self.assertEqual(['child'], sorted(ie_dir._children.keys()))
1290
 
 
1291
 
    def test__preload_handles_partially_evaluated_inventory(self):
1292
 
        new_inv = self.make_basic_utf8_inventory()
1293
 
        ie = new_inv[new_inv.root_id]
1294
 
        self.assertIs(None, ie._children)
1295
 
        self.assertEqual([u'dir-\N{EURO SIGN}', u'f\xefle'],
1296
 
                         sorted(ie.children.keys()))
1297
 
        # Accessing .children loads _children
1298
 
        self.assertEqual([u'dir-\N{EURO SIGN}', u'f\xefle'],
1299
 
                         sorted(ie._children.keys()))
1300
 
        new_inv._preload_cache()
1301
 
        # No change
1302
 
        self.assertEqual([u'dir-\N{EURO SIGN}', u'f\xefle'],
1303
 
                         sorted(ie._children.keys()))
1304
 
        ie_dir = new_inv["dirid"]
1305
 
        self.assertEqual([u'ch\xefld'],
1306
 
                         sorted(ie_dir._children.keys()))
1307
 
 
1308
1222
 
1309
1223
class TestCHKInventoryExpand(tests.TestCaseWithMemoryTransport):
1310
1224