Skip to content

Commit e519482

Browse files
joriszwartjoriszwart
committed
Blob I/O: correct usage of raw connection
1 parent 7df73e0 commit e519482

File tree

1 file changed

+147
-141
lines changed

1 file changed

+147
-141
lines changed

‎blob_io_test.go‎

Lines changed: 147 additions & 141 deletions
Original file line numberDiff line numberDiff line change
@@ -22,15 +22,17 @@ var _ io.Writer = &SQLiteBlob{}
2222
var _ io.Seeker = &SQLiteBlob{}
2323
var _ io.Closer = &SQLiteBlob{}
2424

25-
func blobTestData(dbname string, rowid int64, blob []byte) (*sql.DB, *SQLiteConn, error) {
25+
type driverConnCallback func(*testing.T, *SQLiteConn)
26+
27+
func blobTestData(t *testing.T, dbname string, rowid int64, blob []byte, c driverConnCallback) error {
2628
db, err := sql.Open("sqlite3", "file:"+dbname+"?mode=memory&cache=shared")
2729
if err != nil {
28-
return nil, nil, err
30+
return err
2931
}
3032

3133
conn, err := db.Conn(context.Background())
3234
if err != nil {
33-
return nil, nil, err
35+
return err
3436
}
3537
defer conn.Close()
3638

@@ -40,8 +42,9 @@ func blobTestData(dbname string, rowid int64, blob []byte) (*sql.DB, *SQLiteConn
4042
return nil
4143
})
4244
if err != nil {
43-
return nil, nil, err
45+
return err
4446
}
47+
defer driverConn.Close()
4548

4649
query := `
4750
CREATE TABLE data (
@@ -54,65 +57,67 @@ func blobTestData(dbname string, rowid int64, blob []byte) (*sql.DB, *SQLiteConn
5457

5558
_, err = db.Exec(query, sql.Named("rowid", rowid), sql.Named("value", blob))
5659
if err != nil {
57-
return nil, nil, err
60+
return err
5861
}
5962

60-
return db, driverConn, nil
63+
c(t, driverConn)
64+
65+
return nil
6166
}
6267

6368
func TestBlobRead(t *testing.T) {
6469
rowid := int64(6581)
6570
expected := []byte("I ❤️ SQLite in \x00\x01\x02…")
6671

67-
db, driverConn, err := blobTestData("testblobread", rowid, expected)
68-
if err != nil {
69-
t.Fatal("Failed to get raw connection:", err)
70-
}
71-
defer driverConn.Close()
72-
defer db.Close()
72+
err := blobTestData(t, "testblobread", rowid, expected, func(t *testing.T, driverConn *SQLiteConn) {
7373

74-
// Open blob
75-
blob, err := driverConn.Blob("main", "data", "value", rowid, 0)
76-
if err != nil {
77-
t.Error("failed", err)
78-
}
79-
defer blob.Close()
74+
// Open blob
75+
blob, err := driverConn.Blob("main", "data", "value", rowid, 0)
76+
if err != nil {
77+
t.Error("failed", err)
78+
}
79+
defer blob.Close()
8080

81-
// Read blob incrementally
82-
middle := len(expected) / 2
83-
first := expected[:middle]
84-
second := expected[middle:]
81+
// Read blob incrementally
82+
middle := len(expected) / 2
83+
first := expected[:middle]
84+
second := expected[middle:]
8585

86-
// Read part Ⅰ
87-
b1 := make([]byte, len(first))
88-
n1, err := blob.Read(b1)
86+
// Read part Ⅰ
87+
b1 := make([]byte, len(first))
88+
n1, err := blob.Read(b1)
8989

90-
if err != nil || n1 != len(b1) {
91-
t.Errorf("Failed to read %d bytes", n1)
92-
}
90+
if err != nil || n1 != len(b1) {
91+
t.Errorf("Failed to read %d bytes", n1)
92+
}
9393

94-
if bytes.Compare(first, b1) != 0 {
95-
t.Error("Expected\n", first, "got\n", b1)
96-
}
94+
if bytes.Compare(first, b1) != 0 {
95+
t.Error("Expected\n", first, "got\n", b1)
96+
}
9797

98-
// Read part Ⅱ
99-
b2 := make([]byte, len(second))
100-
n2, err := blob.Read(b2)
98+
// Read part Ⅱ
99+
b2 := make([]byte, len(second))
100+
n2, err := blob.Read(b2)
101101

102-
if err != nil || n2 != len(b2) {
103-
t.Errorf("Failed to read %d bytes", n2)
104-
}
102+
if err != nil || n2 != len(b2) {
103+
t.Errorf("Failed to read %d bytes", n2)
104+
}
105105

106-
if bytes.Compare(second, b2) != 0 {
107-
t.Error("Expected\n", second, "got\n", b2)
108-
}
106+
if bytes.Compare(second, b2) != 0 {
107+
t.Error("Expected\n", second, "got\n", b2)
108+
}
109+
110+
// EOF
111+
b3 := make([]byte, 10)
112+
n3, err := blob.Read(b3)
109113

110-
// EOF
111-
b3 := make([]byte, 10)
112-
n3, err := blob.Read(b3)
114+
if err != io.EOF || n3 != 0 {
115+
t.Error("Expected EOF", err)
116+
}
117+
})
113118

114-
if err != io.EOF || n3 != 0 {
115-
t.Error("Expected EOF", err)
119+
if err != nil {
120+
t.Fatal("Failed to get raw connection:", err)
116121
}
117122
}
118123

@@ -126,126 +131,127 @@ func TestBlobWrite(t *testing.T) {
126131

127132
// Allocate a zero blob
128133
data := make([]byte, len(expected))
129-
db, driverConn, err := blobTestData("testblobwrite", rowid, data)
130-
if err != nil {
131-
t.Fatal("Failed to get raw connection:", err)
132-
}
133-
defer driverConn.Close()
134-
defer db.Close()
134+
err := blobTestData(t, "testblobwrite", rowid, data, func(t *testing.T, driverConn *SQLiteConn) {
135135

136-
// Open blob for read/write
137-
blob, err := driverConn.Blob("main", "data", "value", rowid, 1)
138-
if err != nil {
139-
t.Error("failed", err)
140-
}
141-
defer blob.Close()
136+
// Open blob for read/write
137+
blob, err := driverConn.Blob("main", "data", "value", rowid, 1)
138+
if err != nil {
139+
t.Error("failed", err)
140+
}
141+
defer blob.Close()
142142

143-
// Write blob incrementally
144-
middle := len(expected) / 2
145-
first := expected[:middle]
146-
second := expected[middle:]
143+
// Write blob incrementally
144+
middle := len(expected) / 2
145+
first := expected[:middle]
146+
second := expected[middle:]
147147

148-
// Write part Ⅰ
149-
n1, err := blob.Write(first)
148+
// Write part Ⅰ
149+
n1, err := blob.Write(first)
150150

151-
if err != nil || n1 != len(first) {
152-
t.Errorf("Failed to write %d bytes", n1)
153-
}
151+
if err != nil || n1 != len(first) {
152+
t.Errorf("Failed to write %d bytes", n1)
153+
}
154154

155-
// Write part Ⅱ
156-
n2, err := blob.Write(second)
155+
// Write part Ⅱ
156+
n2, err := blob.Write(second)
157157

158-
if err != nil || n2 != len(second) {
159-
t.Errorf("Failed to write %d bytes", n2)
160-
}
158+
if err != nil || n2 != len(second) {
159+
t.Errorf("Failed to write %d bytes", n2)
160+
}
161161

162-
// EOF
163-
b3 := make([]byte, 10)
164-
n3, err := blob.Write(b3)
162+
// EOF
163+
b3 := make([]byte, 10)
164+
n3, err := blob.Write(b3)
165165

166-
if err != io.EOF || n3 != 0 {
167-
t.Error("Expected EOF", err)
168-
}
166+
if err != io.EOF || n3 != 0 {
167+
t.Error("Expected EOF", err)
168+
}
169169

170-
// Verify written data
171-
_, err = blob.Seek(0, io.SeekStart)
172-
if err != nil {
173-
t.Fatal("Failed to seek:", err)
174-
}
170+
// Verify written data
171+
_, err = blob.Seek(0, io.SeekStart)
172+
if err != nil {
173+
t.Fatal("Failed to seek:", err)
174+
}
175175

176-
b4 := make([]byte, len(expected))
177-
n4, err := blob.Read(b4)
176+
b4 := make([]byte, len(expected))
177+
n4, err := blob.Read(b4)
178178

179-
if err != nil || n4 != len(b4) {
180-
t.Errorf("Failed to read %d bytes", n4)
181-
}
179+
if err != nil || n4 != len(b4) {
180+
t.Errorf("Failed to read %d bytes", n4)
181+
}
182+
183+
if bytes.Compare(expected, b4) != 0 {
184+
t.Error("Expected\n", expected, "got\n", b4)
185+
}
182186

183-
if bytes.Compare(expected, b4) != 0 {
184-
t.Error("Expected\n", expected, "got\n", b4)
187+
})
188+
if err != nil {
189+
t.Fatal("Failed to get raw connection:", err)
185190
}
186191
}
187192

188193
func TestBlobSeek(t *testing.T) {
189194
rowid := int64(6510)
190195
data := make([]byte, 1000)
191196

192-
db, driverConn, err := blobTestData("testblobseek", rowid, data)
193-
if err != nil {
194-
t.Fatal("Failed to get raw connection:", err)
195-
}
196-
defer driverConn.Close()
197-
defer db.Close()
198-
199-
// Open blob
200-
blob, err := driverConn.Blob("main", "data", "value", rowid, 0)
201-
if err != nil {
202-
t.Error("failed", err)
203-
}
204-
defer blob.Close()
205-
206-
// Test data
207-
begin := int64(0)
208-
middle := int64(len(data) / 2)
209-
end := int64(len(data) - 1)
210-
eof := int64(len(data))
211-
212-
tests := []struct {
213-
offset int64
214-
whence int
215-
expected int64
216-
}{
217-
{offset: begin, whence: io.SeekStart, expected: begin},
218-
{offset: middle, whence: io.SeekStart, expected: middle},
219-
{offset: end, whence: io.SeekStart, expected: end},
220-
{offset: eof, whence: io.SeekStart, expected: eof},
221-
222-
{offset: -1, whence: io.SeekCurrent, expected: middle - 1},
223-
{offset: 0, whence: io.SeekCurrent, expected: middle},
224-
{offset: 1, whence: io.SeekCurrent, expected: middle + 1},
225-
{offset: -middle, whence: io.SeekCurrent, expected: begin},
226-
227-
{offset: -2, whence: io.SeekEnd, expected: end - 1},
228-
{offset: -1, whence: io.SeekEnd, expected: end},
229-
{offset: 0, whence: io.SeekEnd, expected: eof},
230-
{offset: 1, whence: io.SeekEnd, expected: eof + 1},
231-
{offset: -eof, whence: io.SeekEnd, expected: begin},
232-
}
197+
err := blobTestData(t, "testblobseek", rowid, data, func(t *testing.T, driverConn *SQLiteConn) {
233198

234-
for _, tc := range tests {
235-
// Start in the middle
236-
_, err := blob.Seek(middle, io.SeekStart)
199+
// Open blob
200+
blob, err := driverConn.Blob("main", "data", "value", rowid, 0)
237201
if err != nil {
238-
t.Fatal("Failed to seek:", err)
202+
t.Error("failed", err)
239203
}
240-
241-
// Test
242-
got, err := blob.Seek(tc.offset, tc.whence)
243-
if err != nil {
244-
t.Fatal("Failed to seek:", err)
204+
defer blob.Close()
205+
206+
// Test data
207+
begin := int64(0)
208+
middle := int64(len(data) / 2)
209+
end := int64(len(data) - 1)
210+
eof := int64(len(data))
211+
212+
tests := []struct {
213+
offset int64
214+
whence int
215+
expected int64
216+
}{
217+
{offset: begin, whence: io.SeekStart, expected: begin},
218+
{offset: middle, whence: io.SeekStart, expected: middle},
219+
{offset: end, whence: io.SeekStart, expected: end},
220+
{offset: eof, whence: io.SeekStart, expected: eof},
221+
222+
{offset: -1, whence: io.SeekCurrent, expected: middle - 1},
223+
{offset: 0, whence: io.SeekCurrent, expected: middle},
224+
{offset: 1, whence: io.SeekCurrent, expected: middle + 1},
225+
{offset: -middle, whence: io.SeekCurrent, expected: begin},
226+
227+
{offset: -2, whence: io.SeekEnd, expected: end - 1},
228+
{offset: -1, whence: io.SeekEnd, expected: end},
229+
{offset: 0, whence: io.SeekEnd, expected: eof},
230+
{offset: 1, whence: io.SeekEnd, expected: eof + 1},
231+
{offset: -eof, whence: io.SeekEnd, expected: begin},
245232
}
246233

247-
if tc.expected != got {
248-
t.Error("For", tc, "expected", tc.expected, "got", got)
234+
for _, tc := range tests {
235+
// Start in the middle
236+
_, err := blob.Seek(middle, io.SeekStart)
237+
if err != nil {
238+
t.Fatal("Failed to seek:", err)
239+
}
240+
241+
// Test
242+
got, err := blob.Seek(tc.offset, tc.whence)
243+
if err != nil {
244+
t.Fatal("Failed to seek:", err)
245+
}
246+
247+
if tc.expected != got {
248+
t.Error("For", tc, "expected", tc.expected, "got", got)
249+
}
249250
}
251+
252+
})
253+
254+
if err != nil {
255+
t.Fatal("Failed to get raw connection:", err)
250256
}
251257
}

0 commit comments

Comments
 (0)