Debian Codegraph @

cram/cram_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 ©2017 The bíogo Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
4
5 package cram
6
7 import (
8 "bytes"
9 "errors"
10 "fmt"
11 "io"
12 "net/http"
13 "reflect"
14 "testing"
15
16 "github.com/kortschak/utter"
17 )
18
19 func TestReadDefinition(t *testing.T) {
20 tests := []struct {
21 bytes [26]byte
22 want definition
23 err error
24 }{
25 {
26 bytes: [26]byte{
27 'C', 'R', 'A', 'M',
28 3,
29 0,
30 's', 'h', 'a', '1', '-', '0',
31 },
32 want: definition{
33 Magic: [4]byte{'C', 'R', 'A', 'M'},
34 Version: [2]byte{3, 0},
35 ID: [20]byte{'s', 'h', 'a', '1', '-', '0'},
36 },
37 err: nil,
38 },
39 {
40 bytes: [26]byte{
41 'B', 'A', 'M', 0x1,
42 3,
43 0,
44 's', 'h', 'a', '1', '-', '0',
45 },
46 want: definition{
47 Magic: [4]byte{'B', 'A', 'M', 0x1},
48 Version: [2]byte{3, 0},
49 ID: [20]byte{'s', 'h', 'a', '1', '-', '0'},
50 },
51 err: errors.New(`cram: not a cram file: magic bytes "BAM\x01"`),
52 },
53 }
54 for _, test := range tests {
55 var got definition
56 err := got.readFrom(bytes.NewReader(test.bytes[:]))
57 if fmt.Sprint(err) != fmt.Sprint(test.err) {
58 t.Errorf("unexpected error return: got: %q want: %q", err, test.err)
59 }
60
61 if got != test.want {
62 t.Errorf("unexpected cram definition value:\ngot: %#v\nwant:%#v", got, test.want)
63 }
64 }
65 }
66
67 func TestReadEOFContainer(t *testing.T) {
68 var c Container
69 err := c.readFrom(bytes.NewReader(cramEOFmarker))
70 if err != nil {
71 t.Errorf("failed to read container: %v\n%#v", err, c)
72 }
73 var b Block
74 err = b.readFrom(c.blockData)
75 if err != nil {
76 t.Errorf("failed to read block: %v\n%#v", err, b)
77 }
78
79 c.blockData = nil
80 wantContainer := Container{
81 blockLen: 15,
82 refID: -1,
83 start: 4542278,
84 span: 0,
85 nRec: 0,
86 recCount: 0,
87 bases: 0,
88 blocks: 1,
89 landmarks: nil,
90 crc32: 0x4fd9bd05,
91 }
92 if !reflect.DeepEqual(c, wantContainer) {
93 t.Errorf("unexpected EOF container value:\ngot: %#v\nwant:%#v", c, wantContainer)
94 }
95
96 wantBlock := Block{
97 method: rawMethod,
98 typ: compressionHeader,
99 contentID: 0,
100 compressedSize: 6,
101 rawSize: 6,
102 blockData: []byte{0x01, 0x00, 0x01, 0x00, 0x01, 0x00},
103 crc32: 0x4b0163ee,
104 }
105 if !reflect.DeepEqual(b, wantBlock) {
106 t.Errorf("unexpected EOF block value:\ngot: %#v\nwant:%#v", b, wantBlock)
107 }
108 }
109
110 func TestHasEOF(t *testing.T) {
111 r, err := get(`https://github.com/samtools/htslib/blob/develop/test/ce%235b_java.cram?raw=true`)
112 if err != nil {
113 t.Fatalf("failed to open test file: %v", err)
114 }
115 hasEOF, err := HasEOF(r)
116 if err != nil {
117 t.Fatalf("failed to read EOF: %v", err)
118 }
119 if !hasEOF {
120 t.Error("failed to identify known EOF block")
121 }
122 }
123
124 func TestRead(t *testing.T) {
125 utter.Config.BytesWidth = 8
126
127 r, err := get(`https://github.com/samtools/htslib/blob/develop/test/ce%235b_java.cram?raw=true`)
128 if err != nil {
129 t.Fatalf("failed to open test file: %v", err)
130 }
131
132 cr, err := NewReader(r)
133 if err != nil {
134 t.Fatalf("failed to read definition: %v\n%#v", err, cr.d)
135 }
136 wantDefinition := definition{
137 Magic: [4]uint8{
138 0x43, 0x52, 0x41, 0x4d, // |CRAM|
139 },
140 Version: [2]byte{3, 0},
141 ID: [20]byte{
142 0x63, 0x65, 0x23, 0x35, 0x62, 0x2e, 0x73, 0x61, // |ce#5b.sa|
143 0x6d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // |m.......|
144 0x00, 0x00, 0x00, 0x00, /* */ // |....|
145 },
146 }
147 t.Log(utter.Sdump(cr.d))
148 if cr.d != wantDefinition {
149 t.Errorf("unexpected cram definition:\ngot: %#v\nwant:%#v", cr.d, wantDefinition)
150 }
151
152 for cr.Next() {
153 c := cr.Container()
154 blockData := c.blockData
155 c.blockData = nil
156 t.Log(utter.Sdump(c))
157 c.blockData = blockData
158
159 for c.Next() {
160 v, err := c.Block().Value()
161 if err != nil {
162 t.Errorf("failed to get value: %v", err)
163 }
164 t.Log(utter.Sdump(v))
165 }
166 if c.Err() != nil {
167 t.Errorf("failed to read block: %v\n%#v", err, c.block)
168 }
169 }
170 if cr.Err() != nil {
171 t.Fatalf("failed to read container: %v\n%#v", err, cr.c)
172 }
173 }
174
175 func get(url string) (*bytes.Reader, error) {
176 resp, err := http.Get(url)
177 if err != nil {
178 return nil, err
179 }
180 defer resp.Body.Close()
181 b, err := io.ReadAll(resp.Body)
182 if err != nil {
183 return nil, err
184 }
185 return bytes.NewReader(b), nil
186 }