sdk/python/tests/test_arvfile.py

   1 #!/usr/bin/env python
   2
   3 import bz2
   4 import gzip
   5 import io
   6 import mock
   7 import os
   8 import unittest
   9 import hashlib
  10
  11 import arvados
  12 from arvados import ArvadosFile, ArvadosFileReader, Range, import_manifest, export_manifest
  13
  14 import arvados_testutil as tutil
  15 from test_stream import StreamFileReaderTestCase
  16
  17 class ArvadosFileWriterTestCase(unittest.TestCase):
  18     class MockKeep(object):
  19         def __init__(self, blocks):
  20             self.blocks = blocks
  21             self.requests = []
  22         def get(self, locator, num_retries=0, cache_only=False):
  23             self.requests.append(locator)
  24             return self.blocks.get(locator)
  25         def put(self, data):
  26             pdh = "%s+%i" % (hashlib.md5(data).hexdigest(), len(data))
  27             self.blocks[pdh] = str(data)
  28             return pdh
  29
  30     class MockApi(object):
  31         def __init__(self, b, r):
  32             self.b = b
  33             self.r = r
  34         class MockCollections(object):
  35             def __init__(self, b, r):
  36                 self.b = b
  37                 self.r = r
  38             class Execute(object):
  39                 def __init__(self, r):
  40                     self.r = r
  41                 def execute(self, num_retries=None):
  42                     return self.r
  43             def create(self, ensure_unique_name=False, body=None):
  44                 if body != self.b:
  45                     raise Exception("Body %s does not match expectation %s" % (body, self.b))
  46                 return ArvadosFileWriterTestCase.MockApi.MockCollections.Execute(self.r)
  47             def update(self, uuid=None, body=None):
  48                 return ArvadosFileWriterTestCase.MockApi.MockCollections.Execute(self.r)
  49         def collections(self):
  50             return ArvadosFileWriterTestCase.MockApi.MockCollections(self.b, self.r)
  51
  52
  53     def test_truncate(self):
  54         keep = ArvadosFileWriterTestCase.MockKeep({"781e5e245d69b566979b86e28d23f2c7+10": "0123456789"})
  55         api = ArvadosFileWriterTestCase.MockApi({"name":"test_truncate",
  56                                                  "manifest_text":". 781e5e245d69b566979b86e28d23f2c7+10 0:8:count.txt\n"},
  57                                                 {"uuid":"zzzzz-4zz18-mockcollection0"})
  58         with import_manifest('. 781e5e245d69b566979b86e28d23f2c7+10 0:10:count.txt\n',
  59                              api_client=api, keep=keep) as c:
  60             writer = c.open("count.txt", "r+")
  61             self.assertEqual(writer.size(), 10)
  62             writer.seek(5)
  63             self.assertEqual("56789", writer.read(8))
  64             writer.truncate(8)
  65             writer.seek(5, os.SEEK_SET)
  66             self.assertEqual("567", writer.read(8))
  67
  68             self.assertEqual(None, c._manifest_locator)
  69             self.assertEqual(True, c.modified())
  70             c.save_as("test_truncate")
  71             self.assertEqual("zzzzz-4zz18-mockcollection0", c._manifest_locator)
  72             self.assertEqual(False, c.modified())
  73
  74     def test_append(self):
  75         keep = ArvadosFileWriterTestCase.MockKeep({"781e5e245d69b566979b86e28d23f2c7+10": "0123456789"})
  76         api = ArvadosFileWriterTestCase.MockApi({"name":"test_append",
  77                                                  "manifest_text": ". 781e5e245d69b566979b86e28d23f2c7+10 acbd18db4cc2f85cedef654fccc4a4d8+3 0:13:count.txt\n"},
  78                                                 {"uuid":"zzzzz-4zz18-mockcollection0"})
  79         with import_manifest('. 781e5e245d69b566979b86e28d23f2c7+10 0:10:count.txt\n',
  80                              api_client=api, keep=keep) as c:
  81             writer = c.open("count.txt", "r+")
  82             writer.seek(5, os.SEEK_SET)
  83             self.assertEqual("56789", writer.read(8))
  84             writer.seek(10, os.SEEK_SET)
  85             writer.write("foo")
  86             self.assertEqual(writer.size(), 13)
  87             writer.seek(5, os.SEEK_SET)
  88             self.assertEqual("56789foo", writer.read(8))
  89
  90             self.assertEqual(None, c._manifest_locator)
  91             self.assertEqual(True, c.modified())
  92             self.assertEqual(None, keep.get("acbd18db4cc2f85cedef654fccc4a4d8+3"))
  93             c.save_as("test_append")
  94             self.assertEqual("zzzzz-4zz18-mockcollection0", c._manifest_locator)
  95             self.assertEqual(False, c.modified())
  96             self.assertEqual("foo", keep.get("acbd18db4cc2f85cedef654fccc4a4d8+3"))
  97
  98     def test_write0(self):
  99         keep = ArvadosFileWriterTestCase.MockKeep({"781e5e245d69b566979b86e28d23f2c7+10": "0123456789"})
 100         with import_manifest('. 781e5e245d69b566979b86e28d23f2c7+10 0:10:count.txt\n',
 101                              keep=keep) as c:
 102             writer = c.open("count.txt", "r+")
 103             self.assertEqual("0123456789", writer.readfrom(0, 13))
 104             writer.seek(0, os.SEEK_SET)
 105             writer.write("foo")
 106             self.assertEqual(writer.size(), 10)
 107             self.assertEqual("foo3456789", writer.readfrom(0, 13))
 108             self.assertEqual(". acbd18db4cc2f85cedef654fccc4a4d8+3 781e5e245d69b566979b86e28d23f2c7+10 0:3:count.txt 6:7:count.txt\n", export_manifest(c))
 109
 110     def test_write1(self):
 111         keep = ArvadosFileWriterTestCase.MockKeep({"781e5e245d69b566979b86e28d23f2c7+10": "0123456789"})
 112         with import_manifest('. 781e5e245d69b566979b86e28d23f2c7+10 0:10:count.txt\n',
 113                              keep=keep) as c:
 114             writer = c.open("count.txt", "r+")
 115             self.assertEqual("0123456789", writer.readfrom(0, 13))
 116             writer.seek(3, os.SEEK_SET)
 117             writer.write("foo")
 118             self.assertEqual(writer.size(), 10)
 119             self.assertEqual("012foo6789", writer.readfrom(0, 13))
 120             self.assertEqual(". 781e5e245d69b566979b86e28d23f2c7+10 acbd18db4cc2f85cedef654fccc4a4d8+3 0:3:count.txt 10:3:count.txt 6:4:count.txt\n", export_manifest(c))
 121
 122     def test_write2(self):
 123         keep = ArvadosFileWriterTestCase.MockKeep({"781e5e245d69b566979b86e28d23f2c7+10": "0123456789"})
 124         with import_manifest('. 781e5e245d69b566979b86e28d23f2c7+10 0:10:count.txt\n',
 125                              keep=keep) as c:
 126             writer = c.open("count.txt", "r+")
 127             self.assertEqual("0123456789", writer.readfrom(0, 13))
 128             writer.seek(7, os.SEEK_SET)
 129             writer.write("foo")
 130             self.assertEqual(writer.size(), 10)
 131             self.assertEqual("0123456foo", writer.readfrom(0, 13))
 132             self.assertEqual(". 781e5e245d69b566979b86e28d23f2c7+10 acbd18db4cc2f85cedef654fccc4a4d8+3 0:7:count.txt 10:3:count.txt\n", export_manifest(c))
 133
 134     def test_write3(self):
 135         keep = ArvadosFileWriterTestCase.MockKeep({"781e5e245d69b566979b86e28d23f2c7+10": "0123456789"})
 136         with import_manifest('. 781e5e245d69b566979b86e28d23f2c7+10 0:10:count.txt 0:10:count.txt\n',
 137                              keep=keep) as c:
 138             writer = c.open("count.txt", "r+")
 139             self.assertEqual("012345678901234", writer.readfrom(0, 15))
 140             writer.seek(7, os.SEEK_SET)
 141             writer.write("foobar")
 142             self.assertEqual(writer.size(), 20)
 143             self.assertEqual("0123456foobar34", writer.readfrom(0, 15))
 144             self.assertEqual(". 781e5e245d69b566979b86e28d23f2c7+10 3858f62230ac3c915f300c664312c63f+6 0:7:count.txt 10:6:count.txt 3:7:count.txt\n", export_manifest(c))
 145
 146     def test_write4(self):
 147         keep = ArvadosFileWriterTestCase.MockKeep({"781e5e245d69b566979b86e28d23f2c7+10": "0123456789"})
 148         with import_manifest('. 781e5e245d69b566979b86e28d23f2c7+10 0:4:count.txt 0:4:count.txt 0:4:count.txt',
 149                              keep=keep) as c:
 150             writer = c.open("count.txt", "r+")
 151             self.assertEqual("012301230123", writer.readfrom(0, 15))
 152             writer.seek(2, os.SEEK_SET)
 153             writer.write("abcdefg")
 154             self.assertEqual(writer.size(), 12)
 155             self.assertEqual("01abcdefg123", writer.readfrom(0, 15))
 156             self.assertEqual(". 781e5e245d69b566979b86e28d23f2c7+10 7ac66c0f148de9519b8bd264312c4d64+7 0:2:count.txt 10:7:count.txt 1:3:count.txt\n", export_manifest(c))
 157
 158     def test_write_large(self):
 159         keep = ArvadosFileWriterTestCase.MockKeep({})
 160         api = ArvadosFileWriterTestCase.MockApi({"name":"test_write_large",
 161                                                  "manifest_text": ". a5de24f4417cfba9d5825eadc2f4ca49+67108000 598cc1a4ccaef8ab6e4724d87e675d78+32892000 0:100000000:count.txt\n"},
 162                                                 {"uuid":"zzzzz-4zz18-mockcollection0"})
 163         with import_manifest('. ' + arvados.config.EMPTY_BLOCK_LOCATOR + ' 0:0:count.txt',
 164                              api_client=api, keep=keep) as c:
 165             writer = c.open("count.txt", "r+")
 166             text = ''.join(["0123456789" for a in xrange(0, 100)])
 167             for b in xrange(0, 100000):
 168                 writer.write(text)
 169             self.assertEqual(writer.size(), 100000000)
 170
 171             self.assertEqual(None, c._manifest_locator)
 172             self.assertEqual(True, c.modified())
 173             c.save_as("test_write_large")
 174             self.assertEqual("zzzzz-4zz18-mockcollection0", c._manifest_locator)
 175             self.assertEqual(False, c.modified())
 176
 177     def test_write_rewrite0(self):
 178         keep = ArvadosFileWriterTestCase.MockKeep({})
 179         with import_manifest('. ' + arvados.config.EMPTY_BLOCK_LOCATOR + ' 0:0:count.txt',
 180                              keep=keep) as c:
 181             writer = c.open("count.txt", "r+")
 182             for b in xrange(0, 10):
 183                 writer.seek(0, os.SEEK_SET)
 184                 writer.write("0123456789")
 185             writer.arvadosfile._repack_writes()
 186             self.assertEqual(writer.size(), 10)
 187             self.assertEqual("0123456789", writer.readfrom(0, 20))
 188             self.assertEqual(". 781e5e245d69b566979b86e28d23f2c7+10 0:10:count.txt\n", export_manifest(c))
 189
 190     def test_write_rewrite1(self):
 191         keep = ArvadosFileWriterTestCase.MockKeep({"781e5e245d69b566979b86e28d23f2c7+10": "0123456789"})
 192         with import_manifest('. 781e5e245d69b566979b86e28d23f2c7+10 0:10:count.txt',
 193                              keep=keep) as c:
 194             writer = c.open("count.txt", "r+")
 195             for b in xrange(0, 10):
 196                 writer.seek(10, os.SEEK_SET)
 197                 writer.write("abcdefghij")
 198             writer.arvadosfile._repack_writes()
 199             self.assertEqual(writer.size(), 20)
 200             self.assertEqual("0123456789abcdefghij", writer.readfrom(0, 20))
 201             self.assertEqual(". 781e5e245d69b566979b86e28d23f2c7+10 a925576942e94b2ef57a066101b48876+10 0:20:count.txt\n", export_manifest(c))
 202
 203     def test_write_rewrite2(self):
 204         keep = ArvadosFileWriterTestCase.MockKeep({"781e5e245d69b566979b86e28d23f2c7+10": "0123456789"})
 205         with import_manifest('. 781e5e245d69b566979b86e28d23f2c7+10 0:10:count.txt',
 206                              keep=keep) as c:
 207             writer = c.open("count.txt", "r+")
 208             for b in xrange(0, 10):
 209                 writer.seek(5, os.SEEK_SET)
 210                 writer.write("abcdefghij")
 211             writer.arvadosfile._repack_writes()
 212             self.assertEqual(writer.size(), 15)
 213             self.assertEqual("01234abcdefghij", writer.readfrom(0, 20))
 214             self.assertEqual(". 781e5e245d69b566979b86e28d23f2c7+10 a925576942e94b2ef57a066101b48876+10 0:5:count.txt 10:10:count.txt\n", export_manifest(c))
 215
 216     def test_write_large_rewrite0(self):
 217         keep = ArvadosFileWriterTestCase.MockKeep({})
 218         api = ArvadosFileWriterTestCase.MockApi({"name":"test_write_large",
 219                                                  "manifest_text": ". 37400a68af9abdd76ca5bf13e819e42a+32892003 a5de24f4417cfba9d5825eadc2f4ca49+67108000 32892000:3:count.txt 32892006:67107997:count.txt 0:32892000:count.txt\n"},
 220                                                 {"uuid":"zzzzz-4zz18-mockcollection0"})
 221         with import_manifest('. ' + arvados.config.EMPTY_BLOCK_LOCATOR + ' 0:0:count.txt',
 222                              api_client=api, keep=keep) as c:
 223             writer = c.open("count.txt", "r+")
 224             text = ''.join(["0123456789" for a in xrange(0, 100)])
 225             for b in xrange(0, 100000):
 226                 writer.write(text)
 227             writer.seek(0, os.SEEK_SET)
 228             writer.write("foo")
 229             self.assertEqual(writer.size(), 100000000)
 230
 231             self.assertEqual(None, c._manifest_locator)
 232             self.assertEqual(True, c.modified())
 233             c.save_as("test_write_large")
 234             self.assertEqual("zzzzz-4zz18-mockcollection0", c._manifest_locator)
 235             self.assertEqual(False, c.modified())
 236
 237     def test_create(self):
 238         keep = ArvadosFileWriterTestCase.MockKeep({})
 239         api = ArvadosFileWriterTestCase.MockApi({"name":"test_create",
 240                                                  "manifest_text":". 2e9ec317e197819358fbc43afca7d837+8 0:8:count.txt\n"},
 241                                                 {"uuid":"zzzzz-4zz18-mockcollection0"})
 242         with arvados.Collection(api_client=api, keep_client=keep) as c:
 243             writer = c.open("count.txt", "w+")
 244             self.assertEqual(writer.size(), 0)
 245             writer.write("01234567")
 246             self.assertEqual(writer.size(), 8)
 247
 248             self.assertEqual(None, c._manifest_locator)
 249             self.assertEqual(True, c.modified())
 250             self.assertEqual(None, keep.get("2e9ec317e197819358fbc43afca7d837+8"))
 251             c.save_as("test_create")
 252             self.assertEqual("zzzzz-4zz18-mockcollection0", c._manifest_locator)
 253             self.assertEqual(False, c.modified())
 254             self.assertEqual("01234567", keep.get("2e9ec317e197819358fbc43afca7d837+8"))
 255
 256
 257     def test_create_subdir(self):
 258         keep = ArvadosFileWriterTestCase.MockKeep({})
 259         api = ArvadosFileWriterTestCase.MockApi({"name":"test_create",
 260                                                  "manifest_text":"./foo/bar 2e9ec317e197819358fbc43afca7d837+8 0:8:count.txt\n"},
 261                                                 {"uuid":"zzzzz-4zz18-mockcollection0"})
 262         with arvados.Collection(api_client=api, keep_client=keep) as c:
 263             writer = c.open("foo/bar/count.txt", "w+")
 264             writer.write("01234567")
 265             c.save_as("test_create")
 266
 267     def test_overwrite(self):
 268         keep = ArvadosFileWriterTestCase.MockKeep({"781e5e245d69b566979b86e28d23f2c7+10": "0123456789"})
 269         api = ArvadosFileWriterTestCase.MockApi({"name":"test_overwrite",
 270                                                  "manifest_text":". 2e9ec317e197819358fbc43afca7d837+8 0:8:count.txt\n"},
 271                                                 {"uuid":"zzzzz-4zz18-mockcollection0"})
 272         with import_manifest('. 781e5e245d69b566979b86e28d23f2c7+10 0:10:count.txt\n',
 273                              api_client=api, keep=keep) as c:
 274             writer = c.open("count.txt", "w+")
 275             self.assertEqual(writer.size(), 0)
 276             writer.write("01234567")
 277             self.assertEqual(writer.size(), 8)
 278
 279             self.assertEqual(None, c._manifest_locator)
 280             self.assertEqual(True, c.modified())
 281             c.save_as("test_overwrite")
 282             self.assertEqual("zzzzz-4zz18-mockcollection0", c._manifest_locator)
 283             self.assertEqual(False, c.modified())
 284
 285     def test_file_not_found(self):
 286         with import_manifest('. 781e5e245d69b566979b86e28d23f2c7+10 0:10:count.txt\n') as c:
 287             with self.assertRaises(IOError):
 288                 writer = c.open("nocount.txt", "r")
 289
 290     def test_cannot_open_directory(self):
 291         with import_manifest('. 781e5e245d69b566979b86e28d23f2c7+10 0:10:count.txt\n') as c:
 292             with self.assertRaises(IOError):
 293                 writer = c.open(".", "r")
 294
 295     def test_create_multiple(self):
 296         keep = ArvadosFileWriterTestCase.MockKeep({})
 297         api = ArvadosFileWriterTestCase.MockApi({"name":"test_create_multiple",
 298                                                  "manifest_text":". 2e9ec317e197819358fbc43afca7d837+8 e8dc4081b13434b45189a720b77b6818+8 0:8:count1.txt 8:8:count2.txt\n"},
 299                                                 {"uuid":"zzzzz-4zz18-mockcollection0"})
 300         with arvados.Collection(api_client=api, keep_client=keep) as c:
 301             w1 = c.open("count1.txt", "w")
 302             w2 = c.open("count2.txt", "w")
 303             w1.write("01234567")
 304             w2.write("abcdefgh")
 305             self.assertEqual(w1.size(), 8)
 306             self.assertEqual(w2.size(), 8)
 307
 308             self.assertEqual(None, c._manifest_locator)
 309             self.assertEqual(True, c.modified())
 310             self.assertEqual(None, keep.get("2e9ec317e197819358fbc43afca7d837+8"))
 311             c.save_as("test_create_multiple")
 312             self.assertEqual("zzzzz-4zz18-mockcollection0", c._manifest_locator)
 313             self.assertEqual(False, c.modified())
 314             self.assertEqual("01234567", keep.get("2e9ec317e197819358fbc43afca7d837+8"))
 315
 316     def test_remove(self):
 317         with import_manifest('. 781e5e245d69b566979b86e28d23f2c7+10 0:10:count1.txt 0:10:count2.txt\n') as c:
 318             self.assertEqual(". 781e5e245d69b566979b86e28d23f2c7+10 0:10:count1.txt 0:10:count2.txt\n", export_manifest(c))
 319             self.assertTrue("count1.txt" in c)
 320             c.remove("count1.txt")
 321             self.assertFalse("count1.txt" in c)
 322             self.assertEqual(". 781e5e245d69b566979b86e28d23f2c7+10 0:10:count2.txt\n", export_manifest(c))
 323
 324     def test_remove_in_subdir(self):
 325         with import_manifest('. 781e5e245d69b566979b86e28d23f2c7+10 0:10:count1.txt\n./foo 781e5e245d69b566979b86e28d23f2c7+10 0:10:count2.txt\n') as c:
 326             c.remove("foo/count2.txt")
 327             self.assertEqual(". 781e5e245d69b566979b86e28d23f2c7+10 0:10:count1.txt\n", export_manifest(c))
 328
 329     def test_remove_subdir(self):
 330         with import_manifest('. 781e5e245d69b566979b86e28d23f2c7+10 0:10:count1.txt\n./foo 781e5e245d69b566979b86e28d23f2c7+10 0:10:count2.txt\n') as c:
 331             c.remove("foo")
 332             self.assertEqual(". 781e5e245d69b566979b86e28d23f2c7+10 0:10:count1.txt\n", export_manifest(c))
 333
 334     def test_prefetch(self):
 335         keep = ArvadosFileWriterTestCase.MockKeep({"2e9ec317e197819358fbc43afca7d837+8": "01234567", "e8dc4081b13434b45189a720b77b6818+8": "abcdefgh"})
 336         with import_manifest(". 2e9ec317e197819358fbc43afca7d837+8 e8dc4081b13434b45189a720b77b6818+8 0:16:count.txt\n", keep=keep) as c:
 337             r = c.open("count.txt", "r")
 338             self.assertEqual("0123", r.read(4))
 339         self.assertEqual(["2e9ec317e197819358fbc43afca7d837+8", "2e9ec317e197819358fbc43afca7d837+8", "e8dc4081b13434b45189a720b77b6818+8"], keep.requests)
 340
 341
 342 class ArvadosFileReaderTestCase(StreamFileReaderTestCase):
 343     class MockParent(object):
 344         class MockBlockMgr(object):
 345             def __init__(self, blocks, nocache):
 346                 self.blocks = blocks
 347                 self.nocache = nocache
 348
 349             def block_prefetch(self, loc):
 350                 pass
 351
 352             def get_block(self, loc, num_retries=0, cache_only=False):
 353                 if self.nocache and cache_only:
 354                     return None
 355                 return self.blocks[loc]
 356
 357         def __init__(self, blocks, nocache):
 358             self.blocks = blocks
 359             self.nocache = nocache
 360
 361         def _my_block_manager(self):
 362             return ArvadosFileReaderTestCase.MockParent.MockBlockMgr(self.blocks, self.nocache)
 363
 364     def make_count_reader(self, nocache=False):
 365         stream = []
 366         n = 0
 367         blocks = {}
 368         for d in ['01234', '34567', '67890']:
 369             loc = '{}+{}'.format(hashlib.md5(d).hexdigest(), len(d))
 370             blocks[loc] = d
 371             stream.append(Range(loc, n, len(d)))
 372             n += len(d)
 373         af = ArvadosFile(ArvadosFileReaderTestCase.MockParent(blocks, nocache), stream=stream, segments=[Range(1, 0, 3), Range(6, 3, 3), Range(11, 6, 3)])
 374         return ArvadosFileReader(af, "count.txt")
 375
 376     def test_read_returns_first_block(self):
 377         # read() calls will be aligned on block boundaries - see #3663.
 378         sfile = self.make_count_reader(nocache=True)
 379         self.assertEqual('123', sfile.read(10))
 380
 381     def test_successive_reads(self):
 382         sfile = self.make_count_reader(nocache=True)
 383         for expect in ['123', '456', '789', '']:
 384             self.assertEqual(expect, sfile.read(10))
 385
 386     def test_tell_after_block_read(self):
 387         sfile = self.make_count_reader(nocache=True)
 388         sfile.read(5)
 389         self.assertEqual(3, sfile.tell())
 390
 391 # class StreamReaderTestCase(unittest.TestCase, StreamRetryTestMixin):
 392 #     def reader_for(self, coll_name, **kwargs):
 393 #         return StreamReader(self.manifest_for(coll_name).split(),
 394 #                             self.keep_client(), **kwargs)
 395
 396 #     def read_for_test(self, reader, byte_count, **kwargs):
 397 #         return reader.readfrom(0, byte_count, **kwargs)
 398
 399 #     def test_manifest_text_without_keep_client(self):
 400 #         mtext = self.manifest_for('multilevel_collection_1')
 401 #         for line in mtext.rstrip('\n').split('\n'):
 402 #             reader = StreamReader(line.split())
 403 #             self.assertEqual(line + '\n', reader.manifest_text())
 404
 405
 406 # class StreamFileReadTestCase(unittest.TestCase, StreamRetryTestMixin):
 407 #     def reader_for(self, coll_name, **kwargs):
 408 #         return StreamReader(self.manifest_for(coll_name).split(),
 409 #                             self.keep_client(), **kwargs).all_files()[0]
 410
 411 #     def read_for_test(self, reader, byte_count, **kwargs):
 412 #         return reader.read(byte_count, **kwargs)
 413
 414
 415 # class StreamFileReadFromTestCase(StreamFileReadTestCase):
 416 #     def read_for_test(self, reader, byte_count, **kwargs):
 417 #         return reader.readfrom(0, byte_count, **kwargs)
 418
 419
 420 # class StreamFileReadAllTestCase(StreamFileReadTestCase):
 421 #     def read_for_test(self, reader, byte_count, **kwargs):
 422 #         return ''.join(reader.readall(**kwargs))
 423
 424
 425 # class StreamFileReadAllDecompressedTestCase(StreamFileReadTestCase):
 426 #     def read_for_test(self, reader, byte_count, **kwargs):
 427 #         return ''.join(reader.readall_decompressed(**kwargs))
 428
 429
 430 # class StreamFileReadlinesTestCase(StreamFileReadTestCase):
 431 #     def read_for_test(self, reader, byte_count, **kwargs):
 432 #         return ''.join(reader.readlines(**kwargs))