Show More
@@ -79,11 +79,11 b' class datapacktestsbase(object):' | |||
|
79 | 79 | revisions = [(filename, node, nullid, content)] |
|
80 | 80 | pack = self.createPack(revisions) |
|
81 | 81 | if self.paramsavailable: |
|
82 |
self.assertEqual |
|
|
82 | self.assertEqual(pack.params.fanoutprefix, | |
|
83 | 83 |
|
|
84 | 84 | |
|
85 | 85 | chain = pack.getdeltachain(filename, node) |
|
86 |
self.assertEqual |
|
|
86 | self.assertEqual(content, chain[0][4]) | |
|
87 | 87 | |
|
88 | 88 | def testAddSingle(self): |
|
89 | 89 | self._testAddSingle('') |
@@ -106,10 +106,10 b' class datapacktestsbase(object):' | |||
|
106 | 106 | |
|
107 | 107 | for filename, node, base, content in revisions: |
|
108 | 108 | entry = pack.getdelta(filename, node) |
|
109 |
self.assertEqual |
|
|
109 | self.assertEqual((content, filename, base, {}), entry) | |
|
110 | 110 | |
|
111 | 111 | chain = pack.getdeltachain(filename, node) |
|
112 |
self.assertEqual |
|
|
112 | self.assertEqual(content, chain[0][4]) | |
|
113 | 113 | |
|
114 | 114 | def testAddDeltas(self): |
|
115 | 115 | """Test putting multiple delta blobs into a pack and read the chain. |
@@ -127,13 +127,13 b' class datapacktestsbase(object):' | |||
|
127 | 127 | |
|
128 | 128 | entry = pack.getdelta(filename, revisions[0][1]) |
|
129 | 129 | realvalue = (revisions[0][3], filename, revisions[0][2], {}) |
|
130 |
self.assertEqual |
|
|
130 | self.assertEqual(entry, realvalue) | |
|
131 | 131 | |
|
132 | 132 | # Test that the chain for the final entry has all the others |
|
133 | 133 | chain = pack.getdeltachain(filename, node) |
|
134 | 134 | for i in range(10): |
|
135 | 135 | content = "abcdef%s" % i |
|
136 |
self.assertEqual |
|
|
136 | self.assertEqual(content, chain[-i - 1][4]) | |
|
137 | 137 | |
|
138 | 138 | def testPackMany(self): |
|
139 | 139 | """Pack many related and unrelated objects. |
@@ -162,7 +162,7 b' class datapacktestsbase(object):' | |||
|
162 | 162 | chain = pack.getdeltachain(filename, node) |
|
163 | 163 | for entry in chain: |
|
164 | 164 | expectedcontent = blobs[(entry[0], entry[1], entry[3])] |
|
165 |
self.assertEqual |
|
|
165 | self.assertEqual(entry[4], expectedcontent) | |
|
166 | 166 | |
|
167 | 167 | def testPackMetadata(self): |
|
168 | 168 | revisions = [] |
@@ -181,7 +181,7 b' class datapacktestsbase(object):' | |||
|
181 | 181 | # flag == 0 should be optimized out |
|
182 | 182 | if origmeta[constants.METAKEYFLAG] == 0: |
|
183 | 183 | del origmeta[constants.METAKEYFLAG] |
|
184 |
self.assertEqual |
|
|
184 | self.assertEqual(parsedmeta, origmeta) | |
|
185 | 185 | |
|
186 | 186 | def testGetMissing(self): |
|
187 | 187 | """Test the getmissing() api. |
@@ -206,7 +206,7 b' class datapacktestsbase(object):' | |||
|
206 | 206 | |
|
207 | 207 | fakenode = self.getFakeHash() |
|
208 | 208 | missing = pack.getmissing([("foo", revisions[0][1]), ("foo", fakenode)]) |
|
209 |
self.assertEqual |
|
|
209 | self.assertEqual(missing, [("foo", fakenode)]) | |
|
210 | 210 | |
|
211 | 211 | def testAddThrows(self): |
|
212 | 212 | pack = self.createPack() |
@@ -238,7 +238,7 b' class datapacktestsbase(object):' | |||
|
238 | 238 | revisions = [("filename", fakenode, self.getFakeHash(), "content")] |
|
239 | 239 | pack = self.createPack(revisions) |
|
240 | 240 | chain = pack.getdeltachain("filename", fakenode) |
|
241 |
self.assertEqual |
|
|
241 | self.assertEqual(len(chain), 1) | |
|
242 | 242 | |
|
243 | 243 | def testLargePack(self): |
|
244 | 244 | """Test creating and reading from a large pack with over X entries. |
@@ -255,12 +255,12 b' class datapacktestsbase(object):' | |||
|
255 | 255 | |
|
256 | 256 | pack = self.createPack(revisions) |
|
257 | 257 | if self.paramsavailable: |
|
258 |
self.assertEqual |
|
|
258 | self.assertEqual(pack.params.fanoutprefix, | |
|
259 | 259 |
|
|
260 | 260 | |
|
261 | 261 | for (filename, node), content in blobs.iteritems(): |
|
262 | 262 | actualcontent = pack.getdeltachain(filename, node)[0][4] |
|
263 |
self.assertEqual |
|
|
263 | self.assertEqual(actualcontent, content) | |
|
264 | 264 | |
|
265 | 265 | def testPacksCache(self): |
|
266 | 266 | """Test that we remember the most recent packs while fetching the delta |
@@ -300,12 +300,12 b' class datapacktestsbase(object):' | |||
|
300 | 300 | chain = store.getdeltachain(revision[0], revision[1]) |
|
301 | 301 | |
|
302 | 302 | mostrecentpack = next(iter(store.packs), None) |
|
303 |
self.assertEqual |
|
|
303 | self.assertEqual( | |
|
304 | 304 | mostrecentpack.getdeltachain(revision[0], revision[1]), |
|
305 | 305 | chain |
|
306 | 306 | ) |
|
307 | 307 | |
|
308 |
self.assertEqual |
|
|
308 | self.assertEqual(randomchain.index(revision) + 1, len(chain)) | |
|
309 | 309 | |
|
310 | 310 | # perf test off by default since it's slow |
|
311 | 311 | def _testIndexPerf(self): |
@@ -78,9 +78,9 b' class histpacktests(unittest.TestCase):' | |||
|
78 | 78 | pack = self.createPack(revisions) |
|
79 | 79 | |
|
80 | 80 | actual = pack.getancestors(filename, node)[node] |
|
81 |
self.assertEqual |
|
|
82 |
self.assertEqual |
|
|
83 |
self.assertEqual |
|
|
81 | self.assertEqual(p1, actual[0]) | |
|
82 | self.assertEqual(p2, actual[1]) | |
|
83 | self.assertEqual(linknode, actual[2]) | |
|
84 | 84 | |
|
85 | 85 | def testAddMultiple(self): |
|
86 | 86 | """Test putting multiple unrelated revisions into a pack and reading |
@@ -99,10 +99,10 b' class histpacktests(unittest.TestCase):' | |||
|
99 | 99 | |
|
100 | 100 | for filename, node, p1, p2, linknode, copyfrom in revisions: |
|
101 | 101 | actual = pack.getancestors(filename, node)[node] |
|
102 |
self.assertEqual |
|
|
103 |
self.assertEqual |
|
|
104 |
self.assertEqual |
|
|
105 |
self.assertEqual |
|
|
102 | self.assertEqual(p1, actual[0]) | |
|
103 | self.assertEqual(p2, actual[1]) | |
|
104 | self.assertEqual(linknode, actual[2]) | |
|
105 | self.assertEqual(copyfrom, actual[3]) | |
|
106 | 106 | |
|
107 | 107 | def testAddAncestorChain(self): |
|
108 | 108 | """Test putting multiple revisions in into a pack and read the ancestor |
@@ -124,10 +124,10 b' class histpacktests(unittest.TestCase):' | |||
|
124 | 124 | ancestors = pack.getancestors(revisions[0][0], revisions[0][1]) |
|
125 | 125 | for filename, node, p1, p2, linknode, copyfrom in revisions: |
|
126 | 126 | ap1, ap2, alinknode, acopyfrom = ancestors[node] |
|
127 |
self.assertEqual |
|
|
128 |
self.assertEqual |
|
|
129 |
self.assertEqual |
|
|
130 |
self.assertEqual |
|
|
127 | self.assertEqual(ap1, p1) | |
|
128 | self.assertEqual(ap2, p2) | |
|
129 | self.assertEqual(alinknode, linknode) | |
|
130 | self.assertEqual(acopyfrom, copyfrom) | |
|
131 | 131 | |
|
132 | 132 | def testPackMany(self): |
|
133 | 133 | """Pack many related and unrelated ancestors. |
@@ -163,14 +163,14 b' class histpacktests(unittest.TestCase):' | |||
|
163 | 163 | # Verify the pack contents |
|
164 | 164 | for (filename, node), (p1, p2, lastnode) in allentries.items(): |
|
165 | 165 | ancestors = pack.getancestors(filename, node) |
|
166 |
self.assertEqual |
|
|
166 | self.assertEqual(ancestorcounts[(filename, node)], | |
|
167 | 167 |
|
|
168 | 168 | for anode, (ap1, ap2, alinknode, copyfrom) in ancestors.items(): |
|
169 | 169 | ep1, ep2, elinknode = allentries[(filename, anode)] |
|
170 |
self.assertEqual |
|
|
171 |
self.assertEqual |
|
|
172 |
self.assertEqual |
|
|
173 |
self.assertEqual |
|
|
170 | self.assertEqual(ap1, ep1) | |
|
171 | self.assertEqual(ap2, ep2) | |
|
172 | self.assertEqual(alinknode, elinknode) | |
|
173 | self.assertEqual(copyfrom, None) | |
|
174 | 174 | |
|
175 | 175 | def testGetNodeInfo(self): |
|
176 | 176 | revisions = [] |
@@ -186,10 +186,10 b' class histpacktests(unittest.TestCase):' | |||
|
186 | 186 | # Test that getnodeinfo returns the expected results |
|
187 | 187 | for filename, node, p1, p2, linknode, copyfrom in revisions: |
|
188 | 188 | ap1, ap2, alinknode, acopyfrom = pack.getnodeinfo(filename, node) |
|
189 |
self.assertEqual |
|
|
190 |
self.assertEqual |
|
|
191 |
self.assertEqual |
|
|
192 |
self.assertEqual |
|
|
189 | self.assertEqual(ap1, p1) | |
|
190 | self.assertEqual(ap2, p2) | |
|
191 | self.assertEqual(alinknode, linknode) | |
|
192 | self.assertEqual(acopyfrom, copyfrom) | |
|
193 | 193 | |
|
194 | 194 | def testGetMissing(self): |
|
195 | 195 | """Test the getmissing() api. |
@@ -215,11 +215,11 b' class histpacktests(unittest.TestCase):' | |||
|
215 | 215 | fakenode = self.getFakeHash() |
|
216 | 216 | missing = pack.getmissing([(filename, revisions[0][1]), |
|
217 | 217 | (filename, fakenode)]) |
|
218 |
self.assertEqual |
|
|
218 | self.assertEqual(missing, [(filename, fakenode)]) | |
|
219 | 219 | |
|
220 | 220 | # Test getmissing on a non-existant filename |
|
221 | 221 | missing = pack.getmissing([("bar", fakenode)]) |
|
222 |
self.assertEqual |
|
|
222 | self.assertEqual(missing, [("bar", fakenode)]) | |
|
223 | 223 | |
|
224 | 224 | def testAddThrows(self): |
|
225 | 225 | pack = self.createPack() |
@@ -260,14 +260,14 b' class histpacktests(unittest.TestCase):' | |||
|
260 | 260 | revisions.append((filename, node, p1, p2, linknode, None)) |
|
261 | 261 | |
|
262 | 262 | pack = self.createPack(revisions) |
|
263 |
self.assertEqual |
|
|
263 | self.assertEqual(pack.params.fanoutprefix, basepack.LARGEFANOUTPREFIX) | |
|
264 | 264 | |
|
265 | 265 | for filename, node, p1, p2, linknode, copyfrom in revisions: |
|
266 | 266 | actual = pack.getancestors(filename, node)[node] |
|
267 |
self.assertEqual |
|
|
268 |
self.assertEqual |
|
|
269 |
self.assertEqual |
|
|
270 |
self.assertEqual |
|
|
267 | self.assertEqual(p1, actual[0]) | |
|
268 | self.assertEqual(p2, actual[1]) | |
|
269 | self.assertEqual(linknode, actual[2]) | |
|
270 | self.assertEqual(copyfrom, actual[3]) | |
|
271 | 271 | # TODO: |
|
272 | 272 | # histpack store: |
|
273 | 273 | # - repack two packs into one |
General Comments 0
You need to be logged in to leave comments.
Login now