Debian Codegraph @

bgzf/bgzf_test.go

raw ◀ ▶
Source reconstructed at patch state 0 of 1 — not the installed (fully patched) source.
1 Debian patch touch this file
1 // Copyright 2009 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the Go LICENSE file.
4
5 // Changes copyright ©2012 The bíogo Authors. All rights reserved.
6 // Use of this source code is governed by a BSD-style
7 // license that can be found in the LICENSE file.
8
9 package bgzf_test
10
11 import (
12 "bytes"
13 "compress/gzip"
14 "errors"
15 "flag"
16 "fmt"
17 "io"
18 "os"
19 "path/filepath"
20 "runtime"
21 "strings"
22 "sync"
23 "testing"
24 "time"
25
26 . "github.com/biogo/hts/bgzf"
27 "github.com/biogo/hts/bgzf/cache"
28 )
29
30 var (
31 conc = flag.Int("conc", 1, "sets the level of concurrency for compression")
32 file = flag.String("bench.file", "", "bgzf file to read for benchmarking decompression")
33 )
34
35 type countWriter struct {
36 bytes int64
37 w io.Writer
38 }
39
40 func (cw *countWriter) Write(p []byte) (n int, err error) {
41 n, err = cw.w.Write(p)
42 cw.bytes += int64(n)
43 return
44 }
45
46 // TestEmpty tests that an empty payload still forms a valid GZIP stream.
47 func TestEmpty(t *testing.T) {
48 buf := new(bytes.Buffer)
49
50 if err := NewWriter(buf, *conc).Close(); err != nil {
51 t.Fatalf("Writer.Close: %v", err)
52 }
53
54 r, err := NewReader(buf, *conc)
55 if err != nil {
56 t.Fatalf("NewReader: %v", err)
57 }
58 b, err := io.ReadAll(r)
59 if err != nil {
60 t.Fatalf("ReadAll: %v", err)
61 }
62 if len(b) != 0 {
63 t.Fatalf("got %d bytes, want 0", len(b))
64 }
65 if err := r.Close(); err != nil {
66 t.Fatalf("Reader.Close: %v", err)
67 }
68 }
69
70 type crippledReaderAt struct {
71 r *bytes.Reader
72 }
73
74 func (r crippledReaderAt) ReadAt(b []byte, off int64) (int, error) {
75 return r.r.ReadAt(b, off)
76 }
77
78 // TestEOF tests HasEOF can find the EOF magic block.
79 func TestEOF(t *testing.T) {
80 f, err := os.Create(filepath.Join(t.TempDir(), "data"))
81 if err != nil {
82 t.Fatalf("Create temp file: %v", err)
83 }
84 fname := f.Name()
85
86 if err := NewWriter(f, *conc).Close(); err != nil {
87 t.Fatalf("Writer.Close: %v", err)
88 }
89
90 if err := f.Close(); err != nil {
91 t.Fatalf("f.Close: %v", err)
92 }
93
94 f, err = os.Open(fname)
95 if err != nil {
96 t.Fatalf("Open temp file: %v", err)
97 }
98 ok, err := HasEOF(f)
99 if err != nil {
100 t.Errorf("HasEOF: %v", err)
101 }
102 if !ok {
103 t.Error("Expected EOF in os.File: not found.")
104 }
105 if err := f.Close(); err != nil {
106 t.Fatalf("f.Close: %v", err)
107 }
108
109 if runtime.GOOS != "windows" {
110 // NOTE: on Windows, os.Open is not allowed for directories.
111 f, err = os.Open(t.TempDir())
112 if err != nil {
113 t.Fatalf("Open temp dir: %v", err)
114 }
115 ok, err = HasEOF(f)
116 if want := "read " + t.TempDir() + ": is a directory"; err.Error() != want {
117 t.Errorf("Expected error:%s got:%v", want, err)
118 }
119 if ok {
120 t.Error("Unexpected EOF in os.File IsDir: found.")
121 }
122 if err := f.Close(); err != nil {
123 t.Fatalf("f.Close: %v", err)
124 }
125 }
126
127 // {bytes,strings}.Reader cases
128 var buf bytes.Buffer
129 if err := NewWriter(&buf, *conc).Close(); err != nil {
130 t.Fatalf("Writer.Close: %v", err)
131 }
132
133 ok, err = HasEOF(bytes.NewReader(buf.Bytes()))
134 if err != nil {
135 t.Errorf("HasEOF: %v", err)
136 }
137 if !ok {
138 t.Error("Expected EOF in []byte: not found.")
139 }
140
141 ok, err = HasEOF(strings.NewReader(buf.String()))
142 if err != nil {
143 t.Errorf("HasEOF: %v", err)
144 }
145 if !ok {
146 t.Error("Expected EOF in string: not found.")
147 }
148
149 ok, err = HasEOF(crippledReaderAt{bytes.NewReader(buf.Bytes())})
150 if err != ErrNoEnd {
151 t.Errorf("Expected error:%s got:%v", ErrNoEnd, err)
152 }
153 if ok {
154 t.Error("Unexpected EOF in crippled ReaderAt: found.")
155 }
156 }
157
158 // TestRoundTrip tests that bgzipping and then bgunzipping is the identity
159 // function.
160 func TestRoundTrip(t *testing.T) {
161 for _, reader := range []struct {
162 name string
163 readAll func(*Reader) ([]byte, error)
164 }{
165 {"io.Reader", readAllWrapper},
166 {"io.ByteReader", readAllByByte},
167 } {
168 buf := new(bytes.Buffer)
169
170 w := NewWriter(buf, *conc)
171 w.Comment = "comment"
172 w.Extra = []byte("extra")
173 w.ModTime = time.Unix(1e8, 0)
174 w.Name = "name"
175 if _, err := w.Write([]byte("payload")); err != nil {
176 t.Fatalf("Write: %v", err)
177 }
178 if err := w.Close(); err != nil {
179 t.Fatalf("Writer.Close: %v", err)
180 }
181 // FIXME(kortschak) The magic block is written on close,
182 // so we need to discount that until we have the capacity
183 // to see every header again.
184 wbl := buf.Len() - len(MagicBlock)
185
186 r, err := NewReader(buf, *conc)
187 if err != nil {
188 t.Fatalf("NewReader: %v", err)
189 }
190
191 if bl := ExpectedMemberSize(r.Header); bl != wbl {
192 t.Errorf("expectedMemberSize is %d, want %d", bl, wbl)
193 }
194 blEnc := string([]byte{byte(wbl - 1), byte((wbl - 1) >> 8)})
195 if string(r.Extra) != "BC\x02\x00"+blEnc+"extra" {
196 t.Errorf("extra is %q, want %q", r.Extra, "BC\x02\x00"+blEnc+"extra")
197 }
198 b, err := reader.readAll(r)
199 if err != nil {
200 t.Fatalf("%s readAll: %v", reader.name, err)
201 }
202 if string(b) != "payload" {
203 t.Fatalf("%s payload is %q, want %q", reader.name, string(b), "payload")
204 }
205 if r.Comment != "comment" {
206 t.Errorf("comment is %q, want %q", r.Comment, "comment")
207 }
208 if bl := ExpectedMemberSize(r.Header); bl != len(MagicBlock) {
209 t.Errorf("expectedMemberSize is %d, want %d", bl, len(MagicBlock))
210 }
211 if string(r.Extra) != "BC\x02\x00\x1b\x00" {
212 t.Errorf("extra is %q, want %q", r.Extra, "BC\x02\x00\x1b\x00")
213 }
214 if r.ModTime.Unix() != 1e8 {
215 t.Errorf("mtime is %d, want %d", r.ModTime.Unix(), uint32(1e8))
216 }
217 if r.Name != "name" {
218 t.Errorf("name is %q, want %q", r.Name, "name")
219 }
220 if r.OS != 0xff {
221 t.Errorf("os is %x, want %x", r.OS, 0xff)
222 }
223 if err := r.Close(); err != nil {
224 t.Errorf("Reader.Close: %v", err)
225 }
226 }
227 }
228
229 func readAllWrapper(r *Reader) ([]byte, error) {
230 return io.ReadAll(r)
231 }
232
233 func readAllByByte(r *Reader) ([]byte, error) {
234 var (
235 buf []byte
236 err error
237 b byte
238 )
239 for {
240 b, err = r.ReadByte()
241 if err != nil {
242 break
243 }
244 buf = append(buf, b)
245 }
246 if err == io.EOF {
247 err = nil
248 }
249 return buf, err
250 }
251
252 // TestRoundTripMulti tests that bgzipping and then bgunzipping is the identity
253 // function for a multiple member bgzf.
254 func TestRoundTripMulti(t *testing.T) {
255 for _, reader := range []struct {
256 name string
257 read func(*Reader, []byte) (int, error)
258 }{
259 {"io.Reader", readWrapper},
260 {"io.ByteReader", readByByte},
261 } {
262 var wbl [2]int
263 buf := new(bytes.Buffer)
264
265 w := NewWriter(buf, *conc)
266 w.Comment = "comment"
267 w.Extra = []byte("extra")
268 w.ModTime = time.Unix(1e8, 0)
269 w.Name = "name"
270 if _, err := w.Write([]byte("payload1")); err != nil {
271 t.Fatalf("Write: %v", err)
272 }
273 if err := w.Flush(); err != nil {
274 t.Fatalf("Flush: %v", err)
275 }
276 if err := w.Wait(); err != nil {
277 t.Fatalf("Wait: %v", err)
278 }
279 wbl[0] = buf.Len()
280 if _, err := w.Write([]byte("payloadTwo")); err != nil {
281 t.Fatalf("Write: %v", err)
282 }
283 if err := w.Close(); err != nil {
284 t.Fatalf("Writer.Close: %v", err)
285 }
286 wbl[1] = buf.Len() - wbl[0] - len(MagicBlock)
287
288 var (
289 b []byte
290 bl, n int
291 err error
292 )
293 r, err := NewReader(buf, *conc)
294 if err != nil {
295 t.Fatalf("NewReader: %v", err)
296 }
297
298 if r.Comment != "comment" {
299 t.Errorf("comment is %q, want %q", r.Comment, "comment")
300 }
301 blEnc := string([]byte{byte(wbl[0] - 1), byte((wbl[0] - 1) >> 8)})
302 if string(r.Extra) != "BC\x02\x00"+blEnc+"extra" {
303 t.Errorf("extra is %q, want %q", r.Extra, "BC\x02\x00"+blEnc+"extra")
304 }
305 if r.ModTime.Unix() != 1e8 {
306 t.Errorf("mtime is %d, want %d", r.ModTime.Unix(), uint32(1e8))
307 }
308 if r.Name != "name" {
309 t.Errorf("name is %q, want %q", r.Name, "name")
310 }
311
312 bl = ExpectedMemberSize(r.Header)
313 if bl != wbl[0] {
314 t.Errorf("expectedMemberSize is %d, want %d", bl, wbl[0])
315 }
316 b = make([]byte, len("payload1payloadTwo"))
317 n, err = reader.read(r, b)
318 if string(b[:n]) != "payload1payloadTwo" {
319 t.Errorf("%s payload is %q, want %q", reader.name, string(b[:n]), "payload1payloadTwo")
320 }
321 if err != nil {
322 t.Errorf("%s read: %v", reader.name, err)
323 }
324
325 bl = ExpectedMemberSize(r.Header)
326 if bl != wbl[1] {
327 t.Errorf("expectedMemberSize is %d, want %d", bl, wbl[1])
328 }
329 b = make([]byte, 1)
330 n, err = reader.read(r, b)
331 if string(b[:n]) != "" {
332 t.Errorf("%s payload is %q, want %q", reader.name, string(b[:n]), "")
333 }
334 if err != io.EOF {
335 t.Errorf("%s read: %v", reader.name, err)
336 }
337 r.Close()
338 }
339 }
340
341 func readWrapper(r *Reader, buf []byte) (int, error) {
342 return r.Read(buf)
343 }
344
345 func readByByte(r *Reader, buf []byte) (n int, err error) {
346 for range buf {
347 buf[n], err = r.ReadByte()
348 if err != nil {
349 break
350 }
351 n++
352 }
353 return n, err
354 }
355
356 // See https://github.com/biogo/hts/issues/57
357 func TestHeaderIssue57(t *testing.T) {
358 var stamp time.Time
359
360 var buf bytes.Buffer
361 bg := NewWriter(&buf, *conc)
362 bg.ModTime = stamp
363 bg.OS = 0xff
364 err := bg.Close()
365 if err != nil {
366 t.Fatal("error closing Writer")
367 }
368 got := buf.Bytes()[:16]
369 want := []byte(MagicBlock[:16])
370 if !bytes.Equal(got, want) {
371 t.Fatalf("unexpected header:\ngot: %0#2v\nwant:%0#2v", got, want)
372 }
373 }
374
375 // TestRoundTripMultiSeek tests that bgzipping and then bgunzipping is the identity
376 // function for a multiple member bgzf with an underlying Seeker.
377 func TestRoundTripMultiSeek(t *testing.T) {
378 f, err := os.Create(filepath.Join(t.TempDir(), "data"))
379 if err != nil {
380 t.Fatalf("Create temp file: %v", err)
381 }
382 fname := f.Name()
383
384 var wbl [2]int
385 cw := &countWriter{w: f}
386 w := NewWriter(cw, *conc)
387 w.Comment = "comment"
388 w.Extra = []byte("extra")
389 w.ModTime = time.Unix(1e8, 0)
390 w.Name = "name"
391 if _, err := w.Write([]byte("payload1")); err != nil {
392 t.Fatalf("Write: %v", err)
393 }
394 if err := w.Flush(); err != nil {
395 t.Fatalf("Flush: %v", err)
396 }
397 if err := w.Wait(); err != nil {
398 t.Fatalf("Wait: %v", err)
399 }
400 offset := cw.bytes
401 wbl[0] = int(offset)
402 if _, err := w.Write([]byte("payloadTwo")); err != nil {
403 t.Fatalf("Write: %v", err)
404 }
405 if err := w.Close(); err != nil {
406 t.Fatalf("Writer.Close: %v", err)
407 }
408 if err := f.Close(); err != nil {
409 t.Fatalf("os.File.Close: %v", err)
410 }
411 wbl[1] = int(cw.bytes-offset) - len(MagicBlock)
412
413 var (
414 b []byte
415 bl, n int
416 )
417
418 f, err = os.Open(fname)
419 if err != nil {
420 t.Fatalf("Reopen temp file: %v", err)
421 }
422 r, err := NewReader(f, *conc)
423 if err != nil {
424 t.Fatalf("NewReader: %v", err)
425 }
426
427 // Insert a HasEOF to ensure it does not corrupt subsequent reads.
428 HasEOF(f)
429
430 if r.Comment != "comment" {
431 t.Errorf("comment is %q, want %q", r.Comment, "comment")
432 }
433 blEnc := string([]byte{byte(wbl[0] - 1), byte((wbl[0] - 1) >> 8)})
434 if string(r.Extra) != "BC\x02\x00"+blEnc+"extra" {
435 t.Errorf("extra is %q, want %q", r.Extra, "BC\x02\x00"+blEnc+"extra")
436 }
437 if r.ModTime.Unix() != 1e8 {
438 t.Errorf("mtime is %d, want %d", r.ModTime.Unix(), uint32(1e8))
439 }
440 if r.Name != "name" {
441 t.Errorf("name is %q, want %q", r.Name, "name")
442 }
443 bl = ExpectedMemberSize(r.Header)
444 if bl != wbl[0] {
445 t.Errorf("expectedMemberSize is %d, want %d", bl, wbl[0])
446 }
447 b = make([]byte, len("payload1payloadTwo")+1)
448 n, err = r.Read(b)
449 if err != io.EOF {
450 t.Errorf("Read: %v", err)
451 }
452 if bl := ExpectedMemberSize(r.Header); bl != len(MagicBlock) {
453 t.Errorf("expectedMemberSize is %d, want %d", bl, len(MagicBlock))
454 }
455 if string(r.Extra) != "BC\x02\x00\x1b\x00" {
456 t.Errorf("extra is %q, want %q", r.Extra, "BC\x02\x00\x1b\x00")
457 }
458 if string(b[:n]) != "payload1payloadTwo" {
459 t.Errorf("payload is %q, want %q", string(b[:n]), "payload1payloadTwo")
460 }
461 if err := r.Seek(Offset{}); err != nil {
462 t.Errorf("Seek: %v", err)
463 }
464 n, err = r.Read(b)
465 if err != io.EOF {
466 t.Errorf("Read: %v", err)
467 }
468 if string(b[:n]) != "payload1payloadTwo" {
469 t.Errorf("payload is %q, want %q", string(b[:n]), "payload1payloadTwo")
470 }
471 if err := r.Seek(Offset{File: offset}); err != nil {
472 t.Fatalf("Seek: %v", err)
473 }
474 bl = ExpectedMemberSize(r.Header)
475 if bl != wbl[1] {
476 t.Errorf("expectedMemberSize is %d, want %d", bl, wbl[1])
477 }
478 b = make([]byte, bl+1)
479 n, err = r.Read(b)
480 if err != io.EOF {
481 t.Errorf("Read: %v", err)
482 }
483 if err := r.Close(); err != nil {
484 t.Errorf("r.Close: %v", err)
485 }
486 if err := f.Close(); err != nil {
487 t.Errorf("f.Close: %v", err)
488 }
489 if string(b[:n]) != "payloadTwo" {
490 t.Errorf("payload is %q, want %q", string(b[:n]), "payloadTwo")
491 }
492 }
493
494 type errorReadSeeker struct {
495 r io.ReadSeeker
496 err error
497 }
498
499 func (r errorReadSeeker) Read(p []byte) (int, error) {
500 n, err := r.r.Read(p)
501 if err == nil && r.err != nil {
502 err = r.err
503 }
504 return n, err
505 }
506
507 func (r errorReadSeeker) Seek(offset int64, whence int) (int64, error) {
508 n, err := r.r.Seek(offset, whence)
509 if r.err != nil {
510 err = r.err
511 }
512 return n, err
513 }
514
515 func TestSeekErrorDeadlock(t *testing.T) {
516 buf := new(bytes.Buffer)
517
518 w := NewWriter(buf, *conc)
519 w.Comment = "comment"
520 w.Extra = []byte("extra")
521 w.ModTime = time.Unix(1e8, 0)
522 w.Name = "name"
523 if _, err := w.Write([]byte("payload")); err != nil {
524 t.Fatalf("Write: %v", err)
525 }
526 if err := w.Close(); err != nil {
527 t.Fatalf("Writer.Close: %v", err)
528 }
529 e := &errorReadSeeker{r: bytes.NewReader(buf.Bytes())}
530 r, err := NewReader(e, *conc)
531 if err != nil {
532 t.Fatalf("NewReader: %v", err)
533 }
534 r.Seek(Offset{File: 0})
535 e.err = errors.New("bad seek error")
536 err = r.Seek(Offset{File: 1})
537 if err == nil {
538 t.Error("Expected error.", err)
539 }
540 r.Close()
541 }
542
543 type countReadSeeker struct {
544 mu sync.Mutex
545 r io.ReadSeeker
546 _didSeek bool
547 n int64
548 }
549
550 func (r *countReadSeeker) offset() int64 {
551 r.mu.Lock()
552 defer r.mu.Unlock()
553
554 return r.n
555 }
556
557 func (r *countReadSeeker) didSeek() bool {
558 r.mu.Lock()
559 defer r.mu.Unlock()
560
561 return r._didSeek
562 }
563
564 func (r *countReadSeeker) Read(p []byte) (int, error) {
565 r.mu.Lock()
566 defer r.mu.Unlock()
567
568 r._didSeek = false
569 n, err := r.r.Read(p)
570 r.n += int64(n)
571 return n, err
572 }
573
574 func (r *countReadSeeker) Seek(offset int64, whence int) (int64, error) {
575 r.mu.Lock()
576 defer r.mu.Unlock()
577
578 r._didSeek = true
579 return r.r.Seek(offset, whence)
580 }
581
582 func TestSeekFast(t *testing.T) {
583 // Under these conditions we cannot guarantee that a worker
584 // will not read bytes after a Seek call has been made.
585 if *conc != 1 && runtime.GOMAXPROCS(0) > 1 {
586 return
587 }
588 const (
589 infix = "payload"
590 blocks = 10
591 )
592
593 // Use different caches.
594 for _, cache := range []Cache{
595 nil, // Explicitly nil.
596
597 cache.NewLRU(0), // Functionally nil.
598 cache.NewLRU(1),
599 cache.NewLRU(blocks / 2),
600 cache.NewLRU(blocks),
601 cache.NewLRU(blocks + 1),
602
603 cache.NewRandom(0), // Functionally nil.
604 cache.NewRandom(1),
605 cache.NewRandom(blocks / 2),
606 cache.NewRandom(blocks),
607 cache.NewRandom(blocks + 1),
608 } {
609 var (
610 buf bytes.Buffer
611 offsets = []int{0}
612 )
613 w := NewWriter(&buf, 1)
614 for i := 0; i < blocks; i++ {
615 if _, err := fmt.Fprintf(w, "%d%[2]s%[1]d", i, infix); err != nil {
616 t.Fatalf("Write: %v", err)
617 }
618 if err := w.Flush(); err != nil {
619 t.Fatalf("Flush: %v", err)
620 }
621 if err := w.Wait(); err != nil {
622 t.Fatalf("Wait: %v", err)
623 }
624 offsets = append(offsets, buf.Len())
625 }
626 w.Close()
627 offsets = offsets[:len(offsets)-1]
628
629 c := &countReadSeeker{r: bytes.NewReader(buf.Bytes())}
630
631 // Insert a HasEOF to ensure it does not corrupt subsequent reads.
632 HasEOF(bytes.NewReader(buf.Bytes()))
633
634 r, err := NewReader(c, *conc)
635 if err != nil {
636 t.Fatalf("NewReader: %v", err)
637 }
638
639 r.SetCache(cache)
640 p := make([]byte, len(infix)+2)
641
642 func() {
643 defer func() {
644 r := recover()
645 if r != nil {
646 t.Fatalf("Seek on unread reader panicked: %v", r)
647 }
648 }()
649 err := r.Seek(Offset{})
650 if err != nil {
651 t.Fatalf("Seek: %v", err)
652 }
653 }()
654
655 // Standard read through of the data.
656 for i := range offsets {
657 n, err := r.Read(p)
658 if n != len(p) {
659 t.Fatalf("Unexpected read length: got:%d want:%d", n, len(p))
660 }
661 if err != nil {
662 t.Fatalf("Read: %v", err)
663 }
664 got := string(p)
665 want := fmt.Sprintf("%d%[2]s%[1]d", i, infix)
666 if got != want {
667 t.Errorf("Unexpected result: got:%q want:%q", got, want)
668 }
669 }
670
671 // Seek to each block in turn
672 for i, o := range offsets {
673 err := r.Seek(Offset{File: int64(o)})
674 if err != nil {
675 t.Fatalf("Seek: %v", err)
676 }
677 n, err := r.Read(p)
678 if n != len(p) {
679 t.Errorf("Unexpected read length: got:%d want:%d", n, len(p))
680 }
681 if err != nil {
682 t.Fatalf("Read: %v", err)
683 }
684 got := string(p)
685 want := fmt.Sprintf("%d%[2]s%[1]d", i, infix)
686 if got != want {
687 t.Errorf("Unexpected result: got:%q want:%q", got, want)
688 }
689 }
690
691 // Seek to each block in turn, but read the infix and then the first 2 bytes.
692 for i, o := range offsets {
693 if err := r.Seek(Offset{File: int64(o), Block: 1}); err != nil {
694 t.Fatalf("Seek: %v", err)
695 }
696 p = p[:len(infix)]
697 n, err := r.Read(p)
698 if n != len(p) {
699 t.Fatalf("Unexpected read length: got:%d want:%d", n, len(p))
700 }
701 if err != nil {
702 t.Fatalf("Read: %v", err)
703 }
704 got := string(p)
705 want := infix
706 if got != want {
707 t.Fatalf("Unexpected result: got:%q want:%q", got, want)
708 }
709
710 // Check whether the underlying reader was seeked or read.
711 hasRead := c.offset()
712 if err = r.Seek(Offset{File: int64(o), Block: 0}); err != nil {
713 t.Fatalf("Seek: %v", err)
714 }
715 if b := c.offset() - hasRead; b != 0 {
716 t.Errorf("Seek performed unexpected read: %d bytes", b)
717 }
718 if c.didSeek() {
719 t.Error("Seek caused underlying Seek.")
720 }
721
722 p = p[:2]
723 n, err = r.Read(p)
724 if n != len(p) {
725 t.Fatalf("Unexpected read length: got:%d want:%d", n, len(p))
726 }
727 if err != nil {
728 t.Fatalf("Read: %v", err)
729 }
730 got = string(p)
731 want = fmt.Sprintf("%dp", i)
732 if got != want {
733 t.Fatalf("Unexpected result: got:%q want:%q", got, want)
734 }
735 }
736 r.Close()
737 }
738 }
739
740 func TestCache(t *testing.T) {
741 // Under these conditions we cannot guarantee that the order of
742 // blocks returned by nextBlock work will not result in additional
743 // cache puts.
744 if *conc != 1 {
745 return
746 }
747 const (
748 infix = "payload"
749 blocks = 10
750 )
751
752 // Each pattern is a series of seek-and-read (when the element >= 0)
753 // or read (when the element < 0). Each read is exactly one block
754 // worth of data.
755 type opPair struct{ seekBlock, blockID int }
756 patterns := []struct {
757 ops []opPair
758
759 // One for each cache case below. If new caches are added to the
760 // test list, stats must be added here.
761 expectedStats []cache.Stats
762 }{
763 {
764 ops: []opPair{
765 {seekBlock: -1, blockID: 0},
766 {seekBlock: -1, blockID: 1},
767 {seekBlock: -1, blockID: 2},
768 {seekBlock: +0, blockID: 0},
769 {seekBlock: -1, blockID: 1},
770 {seekBlock: -1, blockID: 2},
771 {seekBlock: -1, blockID: 3},
772 {seekBlock: -1, blockID: 4},
773 },
774 expectedStats: []cache.Stats{
775 {}, // nil cache.
776 {}, // nil cache: LRU(0)
777 {Gets: 7, Misses: 7, Puts: 7, Retains: 7, Evictions: 6}, // LRU(1)
778 {Gets: 7, Misses: 4, Puts: 7, Retains: 7, Evictions: 0}, // LRU(5)
779 {Gets: 7, Misses: 4, Puts: 7, Retains: 7, Evictions: 0}, // LRU(10)
780 {Gets: 7, Misses: 4, Puts: 7, Retains: 7, Evictions: 0}, // LRU(11)
781 {}, // nil cache: FIFO(0)
782 {Gets: 7, Misses: 7, Puts: 7, Retains: 7, Evictions: 6}, // FIFO(1)
783 {Gets: 7, Misses: 4, Puts: 7, Retains: 4, Evictions: 0}, // FIFO(5)
784 {Gets: 7, Misses: 4, Puts: 7, Retains: 4, Evictions: 0}, // FIFO(10)
785 {Gets: 7, Misses: 4, Puts: 7, Retains: 4, Evictions: 0}, // FIFO(11)
786 {}, // nil cache: Random(0)
787 {Gets: 7, Misses: 7, Puts: 7, Retains: 7, Evictions: 6}, // Random(1)
788 {Gets: 7, Misses: 4, Puts: 7, Retains: 7, Evictions: 0}, // Random(5)
789 {Gets: 7, Misses: 4, Puts: 7, Retains: 7, Evictions: 0}, // Random(10)
790 {Gets: 7, Misses: 4, Puts: 7, Retains: 7, Evictions: 0}, // Random(11)
791 },
792 },
793 {
794 ops: []opPair{
795 {seekBlock: -1, blockID: 0},
796 {seekBlock: -1, blockID: 1},
797 {seekBlock: -1, blockID: 2},
798 {seekBlock: +1, blockID: 1},
799 {seekBlock: -1, blockID: 2},
800 {seekBlock: -1, blockID: 3},
801 {seekBlock: -1, blockID: 4},
802 {seekBlock: -1, blockID: 5},
803 },
804 expectedStats: []cache.Stats{
805 {}, // nil cache.
806 {}, // nil cache.
807 {Gets: 7, Misses: 5, Puts: 7, Retains: 7, Evictions: 4}, // LRU(1)
808 {Gets: 7, Misses: 5, Puts: 7, Retains: 7, Evictions: 0}, // LRU(5)
809 {Gets: 7, Misses: 5, Puts: 7, Retains: 7, Evictions: 0}, // LRU(10)
810 {Gets: 7, Misses: 5, Puts: 7, Retains: 7, Evictions: 0}, // LRU(11)
811 {}, // nil cache: FIFO(0)
812 {Gets: 7, Misses: 5, Puts: 7, Retains: 7, Evictions: 6}, // FIFO(1)
813 {Gets: 7, Misses: 5, Puts: 7, Retains: 5, Evictions: 0}, // FIFO(5)
814 {Gets: 7, Misses: 5, Puts: 7, Retains: 5, Evictions: 0}, // FIFO(10)
815 {Gets: 7, Misses: 5, Puts: 7, Retains: 5, Evictions: 0}, // FIFO(11)
816 {}, // nil cache: Random(0)
817 {Gets: 7, Misses: 5, Puts: 7, Retains: 7, Evictions: 4}, // Random(1)
818 {Gets: 7, Misses: 5, Puts: 7, Retains: 7, Evictions: 0}, // Random(5)
819 {Gets: 7, Misses: 5, Puts: 7, Retains: 7, Evictions: 0}, // Random(10)
820 {Gets: 7, Misses: 5, Puts: 7, Retains: 7, Evictions: 0}, // Random(11)
821 },
822 },
823 {
824 ops: []opPair{
825 {seekBlock: -1, blockID: 0},
826 {seekBlock: -1, blockID: 1},
827 {seekBlock: -1, blockID: 2},
828 {seekBlock: +2, blockID: 2},
829 {seekBlock: -1, blockID: 3},
830 {seekBlock: -1, blockID: 4},
831 {seekBlock: -1, blockID: 5},
832 {seekBlock: -1, blockID: 6},
833 },
834 // Re-reading the same block avoids a cache look-up.
835 expectedStats: []cache.Stats{
836 {}, // nil cache.
837 {}, // nil cache.
838 {Gets: 6, Misses: 6, Puts: 6, Retains: 6, Evictions: 5}, // LRU(1)
839 {Gets: 6, Misses: 6, Puts: 6, Retains: 6, Evictions: 1}, // LRU(5)
840 {Gets: 6, Misses: 6, Puts: 6, Retains: 6, Evictions: 0}, // LRU(10)
841 {Gets: 6, Misses: 6, Puts: 6, Retains: 6, Evictions: 0}, // LRU(11)
842 {}, // nil cache: FIFO(0)
843 {Gets: 6, Misses: 6, Puts: 6, Retains: 6, Evictions: 5}, // FIFO(1)
844 {Gets: 6, Misses: 6, Puts: 6, Retains: 6, Evictions: 1}, // FIFO(5)
845 {Gets: 6, Misses: 6, Puts: 6, Retains: 6, Evictions: 0}, // FIFO(10)
846 {Gets: 6, Misses: 6, Puts: 6, Retains: 6, Evictions: 0}, // FIFO(11)
847 {}, // nil cache: Random(0)
848 {Gets: 6, Misses: 6, Puts: 6, Retains: 6, Evictions: 5}, // Random(1)
849 {Gets: 6, Misses: 6, Puts: 6, Retains: 6, Evictions: 1}, // Random(5)
850 {Gets: 6, Misses: 6, Puts: 6, Retains: 6, Evictions: 0}, // Random(10)
851 {Gets: 6, Misses: 6, Puts: 6, Retains: 6, Evictions: 0}, // Random(11)
852 },
853 },
854 {
855 ops: []opPair{
856 {seekBlock: -1, blockID: 0},
857 {seekBlock: -1, blockID: 1},
858 {seekBlock: -1, blockID: 2},
859 {seekBlock: +3, blockID: 3},
860 {seekBlock: -1, blockID: 4},
861 {seekBlock: -1, blockID: 5},
862 {seekBlock: -1, blockID: 6},
863 {seekBlock: -1, blockID: 7},
864 },
865 expectedStats: []cache.Stats{
866 {}, // nil cache.
867 {}, // nil cache.
868 {Gets: 7, Misses: 7, Puts: 7, Retains: 7, Evictions: 6}, // LRU(1)
869 {Gets: 7, Misses: 7, Puts: 7, Retains: 7, Evictions: 2}, // LRU(5)
870 {Gets: 7, Misses: 7, Puts: 7, Retains: 7, Evictions: 0}, // LRU(10)
871 {Gets: 7, Misses: 7, Puts: 7, Retains: 7, Evictions: 0}, // LRU(11)
872 {}, // nil cache: FIFO(0)
873 {Gets: 7, Misses: 7, Puts: 7, Retains: 7, Evictions: 6}, // FIFO(1)
874 {Gets: 7, Misses: 7, Puts: 7, Retains: 7, Evictions: 2}, // FIFO(5)
875 {Gets: 7, Misses: 7, Puts: 7, Retains: 7, Evictions: 0}, // FIFO(10)
876 {Gets: 7, Misses: 7, Puts: 7, Retains: 7, Evictions: 0}, // FIFO(11)
877 {}, // nil cache: Random(0)
878 {Gets: 7, Misses: 7, Puts: 7, Retains: 7, Evictions: 6}, // Random(1)
879 {Gets: 7, Misses: 7, Puts: 7, Retains: 7, Evictions: 2}, // Random(5)
880 {Gets: 7, Misses: 7, Puts: 7, Retains: 7, Evictions: 0}, // Random(10)
881 {Gets: 7, Misses: 7, Puts: 7, Retains: 7, Evictions: 0}, // Random(11)
882 },
883 },
884 {
885 ops: []opPair{
886 {seekBlock: -1, blockID: 0},
887 {seekBlock: -1, blockID: 1},
888 {seekBlock: -1, blockID: 2},
889 {seekBlock: +4, blockID: 4},
890 {seekBlock: -1, blockID: 5},
891 {seekBlock: -1, blockID: 6},
892 {seekBlock: -1, blockID: 7},
893 {seekBlock: -1, blockID: 8},
894 },
895 expectedStats: []cache.Stats{
896 {}, // nil cache.
897 {}, // nil cache.
898 {Gets: 7, Misses: 7, Puts: 7, Retains: 7, Evictions: 6}, // LRU(1)
899 {Gets: 7, Misses: 7, Puts: 7, Retains: 7, Evictions: 2}, // LRU(5)
900 {Gets: 7, Misses: 7, Puts: 7, Retains: 7, Evictions: 0}, // LRU(10)
901 {Gets: 7, Misses: 7, Puts: 7, Retains: 7, Evictions: 0}, // LRU(11)
902 {}, // nil cache: FIFO(0)
903 {Gets: 7, Misses: 7, Puts: 7, Retains: 7, Evictions: 6}, // FIFO(1)
904 {Gets: 7, Misses: 7, Puts: 7, Retains: 7, Evictions: 2}, // FIFO(5)
905 {Gets: 7, Misses: 7, Puts: 7, Retains: 7, Evictions: 0}, // FIFO(10)
906 {Gets: 7, Misses: 7, Puts: 7, Retains: 7, Evictions: 0}, // FIFO(11)
907 {}, // nil cache: Random(0)
908 {Gets: 7, Misses: 7, Puts: 7, Retains: 7, Evictions: 6}, // Random(1)
909 {Gets: 7, Misses: 7, Puts: 7, Retains: 7, Evictions: 2}, // Random(5)
910 {Gets: 7, Misses: 7, Puts: 7, Retains: 7, Evictions: 0}, // Random(10)
911 {Gets: 7, Misses: 7, Puts: 7, Retains: 7, Evictions: 0}, // Random(11)
912 },
913 },
914 {
915 ops: []opPair{
916 {seekBlock: -1, blockID: 0},
917 {seekBlock: -1, blockID: 1},
918 {seekBlock: -1, blockID: 2},
919 {seekBlock: +1, blockID: 1},
920 {seekBlock: +2, blockID: 2},
921 {seekBlock: +1, blockID: 1},
922 {seekBlock: +1, blockID: 1},
923 {seekBlock: -1, blockID: 2},
924 {seekBlock: +7, blockID: 7},
925 {seekBlock: -1, blockID: 8},
926 {seekBlock: -1, blockID: 9},
927 },
928 expectedStats: []cache.Stats{
929 {}, // nil cache.
930 {}, // nil cache.
931 {Gets: 9, Misses: 5, Puts: 9, Retains: 9, Evictions: 4}, // LRU(1)
932 {Gets: 9, Misses: 5, Puts: 9, Retains: 9, Evictions: 0}, // LRU(5)
933 {Gets: 9, Misses: 5, Puts: 9, Retains: 9, Evictions: 0}, // LRU(10)
934 {Gets: 9, Misses: 5, Puts: 9, Retains: 9, Evictions: 0}, // LRU(11)
935 {}, // nil cache: FIFO(0)
936 {Gets: 9, Misses: 5, Puts: 9, Retains: 9, Evictions: 8}, // FIFO(1)
937 {Gets: 9, Misses: 5, Puts: 9, Retains: 5, Evictions: 0}, // FIFO(5)
938 {Gets: 9, Misses: 5, Puts: 9, Retains: 5, Evictions: 0}, // FIFO(10)
939 {Gets: 9, Misses: 5, Puts: 9, Retains: 5, Evictions: 0}, // FIFO(11)
940 {}, // nil cache: Random(0)
941 {Gets: 9, Misses: 5, Puts: 9, Retains: 9, Evictions: 4}, // Random(1)
942 {Gets: 9, Misses: 5, Puts: 9, Retains: 9, Evictions: 0}, // Random(5)
943 {Gets: 9, Misses: 5, Puts: 9, Retains: 9, Evictions: 0}, // Random(10)
944 {Gets: 9, Misses: 5, Puts: 9, Retains: 9, Evictions: 0}, // Random(11)
945 },
946 },
947 }
948
949 for k, pat := range patterns {
950 // Use different caches.
951 for j, s := range []Cache{
952 nil, // Explicitly nil.
953
954 cache.NewLRU(0), // Functionally nil.
955 cache.NewLRU(1),
956 cache.NewLRU(blocks / 2),
957 cache.NewLRU(blocks),
958 cache.NewLRU(blocks + 1),
959
960 cache.NewFIFO(0), // Functionally nil.
961 cache.NewFIFO(1),
962 cache.NewFIFO(blocks / 2),
963 cache.NewFIFO(blocks),
964 cache.NewFIFO(blocks + 1),
965
966 cache.NewRandom(0), // Functionally nil.
967 cache.NewRandom(1),
968 cache.NewRandom(blocks / 2),
969 cache.NewRandom(blocks),
970 cache.NewRandom(blocks + 1),
971 } {
972 var (
973 buf bytes.Buffer
974 offsets = []int{0}
975 )
976 w := NewWriter(&buf, 1)
977 for i := 0; i < blocks; i++ {
978 if _, err := fmt.Fprintf(w, "%d%[2]s%[1]d", i, infix); err != nil {
979 t.Fatalf("Write: %v", err)
980 }
981 if err := w.Flush(); err != nil {
982 t.Fatalf("Flush: %v", err)
983 }
984 if err := w.Wait(); err != nil {
985 t.Fatalf("Wait: %v", err)
986 }
987 offsets = append(offsets, buf.Len())
988 }
989 w.Close()
990 offsets = offsets[:len(offsets)-1]
991
992 br := bytes.NewReader(buf.Bytes())
993 // Insert a HasEOF to ensure it does not corrupt subsequent reads.
994 HasEOF(br)
995
996 r, err := NewReader(br, *conc)
997 if err != nil {
998 t.Fatalf("NewReader: %v", err)
999 }
1000 var stats *cache.StatsRecorder
1001 if s != nil {
1002 stats = &cache.StatsRecorder{Cache: s}
1003 s = stats
1004 }
1005 r.SetCache(s)
1006 p := make([]byte, len(infix)+2)
1007
1008 for _, op := range pat.ops {
1009 if op.seekBlock >= 0 {
1010 err := r.Seek(Offset{File: int64(offsets[op.seekBlock])})
1011 if err != nil {
1012 t.Fatalf("Seek: %v", err)
1013 }
1014 }
1015 n, err := r.Read(p)
1016 if n != len(p) {
1017 t.Errorf("Unexpected read length: got:%d want:%d", n, len(p))
1018 }
1019 if err != nil {
1020 t.Fatalf("Read: %v", err)
1021 }
1022 got := string(p)
1023 want := fmt.Sprintf("%d%[2]s%[1]d", op.blockID, infix)
1024 if got != want {
1025 t.Errorf("Unexpected result: got:%q want:%q", got, want)
1026 }
1027 }
1028 if stats != nil && stats.Stats() != pat.expectedStats[j] {
1029 t.Errorf("Unexpected result for cache %d pattern %d: got:%+v want:%+v", j, k, stats.Stats(), pat.expectedStats[j])
1030 }
1031 r.Close()
1032 }
1033 }
1034 }
1035
1036 func TestBlocked(t *testing.T) {
1037 const (
1038 infix = "payload"
1039 blocks = 10
1040 )
1041
1042 for _, blocked := range []bool{false, true} {
1043 var (
1044 buf bytes.Buffer
1045 want bytes.Buffer
1046 )
1047 w := NewWriter(&buf, 1)
1048 for i := 0; i < blocks; i++ {
1049 if _, err := fmt.Fprintf(w, "%d%[2]s%[1]d\n", i, infix); err != nil {
1050 t.Fatalf("Write: %v", err)
1051 }
1052 if err := w.Flush(); err != nil {
1053 t.Fatalf("Flush: %v", err)
1054 }
1055 if _, err := fmt.Fprintf(&want, "%d%[2]s%[1]d\n", i, infix); err != nil {
1056 t.Fatalf("Write: %v", err)
1057 }
1058 }
1059 err := w.Close()
1060 if err != nil {
1061 t.Fatalf("unexpected error on Close: %v", err)
1062 }
1063
1064 r, err := NewReader(bytes.NewReader(buf.Bytes()), *conc)
1065 if err != nil {
1066 t.Fatalf("NewReader: %v", err)
1067 }
1068 r.Blocked = blocked
1069
1070 p := make([]byte, len(infix))
1071 var (
1072 got []byte
1073 gotBlocks int
1074 )
1075 for {
1076 n, err := r.Read(p)
1077 got = append(got, p[:n]...)
1078 if err != nil {
1079 if err == io.EOF && n != 0 {
1080 gotBlocks++
1081 continue
1082 }
1083 break
1084 }
1085 }
1086 if !blocked && gotBlocks != 1 {
1087 t.Errorf("unexpected number of blocks:\n\tgot:%d\n\twant:%d", gotBlocks, 1)
1088 }
1089 if blocked && gotBlocks != blocks {
1090 t.Errorf("unexpected number of blocks:\n\tgot:%d\n\twant:%d", gotBlocks, blocks)
1091 }
1092 if !bytes.Equal(got, want.Bytes()) {
1093 t.Errorf("unexpected result:\n\tgot:%q\n\twant:%q", got, want.Bytes())
1094 }
1095 r.Close()
1096 }
1097 }
1098
1099 var fuzzCrashers = []string{
1100 // Invalid block size.
1101 "\x1f\x8b\bu0000000\x0000000000" +
1102 "000000000BC\x02\x000\x0000000" +
1103 "00000000000000000000" +
1104 "00000000000000000000" +
1105 "000000000000000000\x00",
1106 "\x1f\x8b\b\xc4000000V\x0000000000" +
1107 "00000000000000000000" +
1108 "00000000000000000000" +
1109 "00000000000000000000" +
1110 "000000000000BC\x02\x00w\x00\x030" +
1111 "\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x8b\bu000000\x00\x00" +
1112 "\x1f\x8b\bu000000\b\x00BC\x02\x00\x00\x0000" +
1113 "\x00",
1114
1115 // Zero block size.
1116 "\x1f\x8b\bu000000V\x0000000000" +
1117 "00000000000000000000" +
1118 "00000000000000000000" +
1119 "00000000000000000000" +
1120 "000000000000BC\x02\x00k\x0000" +
1121 "0000000\x00",
1122 "\x1f\x8b\bu\xe8k\x15k\x00sV\x00bcdefghi" +
1123 "jklmnxpq\xc49\xbf\x1f\x8b\x0f\a/\x85\xba\xb0Q" +
1124 "\xef (\x01\xbd\xbf\xefrde\a/\x85fghmjt\x00" +
1125 "\xff\x00\x00v\x97x\x92zB\x80\x00142261869" +
1126 "48039093abxdBC\x02\x00i\x00sV" +
1127 "\xbbghmj\x00\x00",
1128 }
1129
1130 func TestFuzzCrashers(t *testing.T) {
1131 for i, test := range fuzzCrashers {
1132 func() {
1133 i := i
1134 defer func() {
1135 r := recover()
1136 if r != nil {
1137 t.Errorf("unexpected panic for crasher %d: %v", i, r)
1138 }
1139 }()
1140 r, err := NewReader(strings.NewReader(test), 0)
1141 switch err {
1142 case nil:
1143 // Pass through.
1144 case io.EOF, io.ErrUnexpectedEOF, ErrCorrupt:
1145 return
1146 default:
1147 t.Fatalf("unexpected error creating reader: %v", err)
1148 }
1149 tmp := make([]byte, 1024)
1150 for {
1151 _, err := r.Read(tmp)
1152 if err != nil {
1153 break
1154 }
1155 }
1156 }()
1157 }
1158 }
1159
1160 func TestZeroNonZero(t *testing.T) {
1161 const wrote = "second block"
1162 buf := bytes.NewBuffer([]byte(MagicBlock))
1163 w := NewWriter(buf, 1)
1164 _, err := w.Write([]byte(wrote))
1165 if err != nil {
1166 w.Close()
1167 t.Fatalf("unexpected error writing second block: %v", err)
1168 }
1169 err = w.Close()
1170 if err != nil {
1171 t.Fatalf("unexpected error closing writer: %v", err)
1172 }
1173 r, err := NewReader(buf, 1)
1174 if err != nil {
1175 t.Fatalf("unexpected error opening reader: %v", err)
1176 }
1177 defer r.Close()
1178 var b [1024]byte
1179 var got []byte
1180 for {
1181 n, err := r.Read(b[:])
1182 got = append(got, b[:n]...)
1183 if err != nil {
1184 break
1185 }
1186 }
1187 if string(got) != wrote {
1188 t.Errorf("unexpected round trip: got:%q want:%q", got, wrote)
1189 }
1190 }
1191
1192 type zero struct{}
1193
1194 func (z zero) Read(p []byte) (int, error) {
1195 for i := range p {
1196 p[i] = 0
1197 }
1198 return len(p), nil
1199 }
1200
1201 func TestWriteByteCount(t *testing.T) {
1202 cw, _ := NewWriterLevel(io.Discard, gzip.BestCompression, 4)
1203 defer cw.Close()
1204 n, err := io.Copy(cw, &io.LimitedReader{R: new(zero), N: 100000})
1205 if n != 100000 {
1206 t.Errorf("Unexpected number of bytes, got:%d, want:%d", n, 100000)
1207 }
1208 if err != nil {
1209 t.Errorf("Unexpected error got:%v", err)
1210 }
1211 }
1212
1213 func TestSeekCacheReadahead(t *testing.T) {
1214 // Check that we see the correct behavior when seeking to the block at the
1215 // head of the readahead queue with caching and readahead enabled.
1216 // See https://github.com/biogo/hts/issues/159.
1217 fh, err := os.Open("testdata/dbscSNV_sample.gz")
1218 if err != nil {
1219 t.Fatalf("Open() error:%v", err)
1220 }
1221 rd, err := NewReader(fh, 2)
1222 if err != nil {
1223 t.Fatalf("NewReader() error:%v", err)
1224 }
1225 rd.SetCache(cache.NewLRU(32))
1226 buf := make([]byte, 2)
1227 // Wait for readahead.
1228 time.Sleep(100 * time.Millisecond)
1229 // Seek to the beginning of the second block.
1230 off := Offset{File: 9395, Block: 0}
1231 err = rd.Seek(off)
1232 if err != nil {
1233 t.Fatalf("Seek() error:%v", err)
1234 }
1235 _, err = rd.Read(buf)
1236 if err != nil {
1237 t.Fatalf("Read() error:%v", err)
1238 }
1239 if !bytes.Equal(buf, []byte{'O', 'X'}) {
1240 t.Errorf("Expected 'OX', got '%s'", buf)
1241 }
1242 if rd.LastChunk().Begin != off {
1243 t.Errorf("Incorrect position: expected %+v, got %+v", off, rd.LastChunk().Begin)
1244 }
1245 }
1246
1247 func BenchmarkWrite(b *testing.B) {
1248 bg := NewWriter(io.Discard, *conc)
1249 block := bytes.Repeat([]byte("repeated"), 50)
1250 for i := 0; i < b.N; i++ {
1251 for j := 0; j < 1000000; j++ {
1252 bg.Write(block)
1253 }
1254 bg.Wait()
1255 }
1256 }
1257
1258 func BenchmarkRead(b *testing.B) {
1259 if *file == "" {
1260 b.Skip("no bgzf file specified")
1261 }
1262 f, err := os.Open(*file)
1263 if err != nil {
1264 b.Fatalf("file open failed: %v", err)
1265 }
1266 defer f.Close()
1267
1268 buf := make([]byte, 16384)
1269 b.ResetTimer()
1270
1271 for i := 0; i < b.N; i++ {
1272 f.Seek(0, io.SeekStart)
1273 bg, err := NewReader(f, *conc)
1274 if err != nil {
1275 b.Fatalf("bgzf open failed: %v", err)
1276 }
1277 for {
1278 _, err = bg.Read(buf)
1279 if err == io.EOF {
1280 break
1281 }
1282 if err != nil {
1283 b.Fatalf("bgzf read failed: %v", err)
1284 }
1285 }
1286 bg.Close()
1287 }
1288 }