331 lines
6.7 KiB
Go
331 lines
6.7 KiB
Go
package buffer_test
|
|
|
|
import (
|
|
"code.squareroundforest.org/arpio/buffer"
|
|
"errors"
|
|
"io"
|
|
"testing"
|
|
)
|
|
|
|
func TestContent(t *testing.T) {
|
|
t.Run("eof", func(t *testing.T) {
|
|
c := buffer.ContentFunc(func(w io.Writer) (int64, error) {
|
|
var n int64
|
|
for i := 0; i < 4; i++ {
|
|
ni, err := w.Write([]byte("123456789012")[i*3 : i*3+3])
|
|
n += int64(ni)
|
|
if err != nil {
|
|
return n, err
|
|
}
|
|
}
|
|
|
|
return n, nil
|
|
})
|
|
|
|
p := &fakePool{allocSize: 2}
|
|
o := buffer.Options{BufferPool: p}
|
|
r := buffer.BufferedContent(c, o)
|
|
b := make([]byte, 3)
|
|
exp := []byte("123456789012")
|
|
for i := 0; i < 8; i++ {
|
|
n, err := r.Read(b)
|
|
if n != 2-i%2 || err != nil {
|
|
t.Fatal(i, n, err)
|
|
}
|
|
|
|
if string(b[:n]) != string(exp[:n]) {
|
|
t.Fatal(i, string(b[:n]), string(exp[:n]))
|
|
}
|
|
|
|
exp = exp[n:]
|
|
}
|
|
|
|
n, err := r.Read(b)
|
|
if n != 0 || !errors.Is(err, io.EOF) {
|
|
t.Fatal(n, err)
|
|
}
|
|
})
|
|
|
|
t.Run("eof right away", func(t *testing.T) {
|
|
c := buffer.ContentFunc(func(w io.Writer) (int64, error) {
|
|
return 0, nil
|
|
})
|
|
|
|
p := &fakePool{allocSize: 2}
|
|
o := buffer.Options{BufferPool: p}
|
|
r := buffer.BufferedContent(c, o)
|
|
b := make([]byte, 3)
|
|
n, err := r.Read(b)
|
|
if n != 0 || !errors.Is(err, io.EOF) {
|
|
t.Fatal(n, err)
|
|
}
|
|
})
|
|
|
|
t.Run("writer error", func(t *testing.T) {
|
|
c := buffer.ContentFunc(func(w io.Writer) (int64, error) {
|
|
var n int64
|
|
for i := 0; i < 4; i++ {
|
|
ni, err := w.Write([]byte("123456789012")[i*3 : i*3+3])
|
|
n += int64(ni)
|
|
if err != nil {
|
|
return n, err
|
|
}
|
|
}
|
|
|
|
return n, errTest
|
|
})
|
|
|
|
p := &fakePool{allocSize: 2}
|
|
o := buffer.Options{BufferPool: p}
|
|
r := buffer.BufferedContent(c, o)
|
|
b := make([]byte, 3)
|
|
exp := []byte("123456789012")
|
|
for i := 0; i < 8; i++ {
|
|
n, err := r.Read(b)
|
|
if n != 2-i%2 || err != nil {
|
|
t.Fatal(i, n, err)
|
|
}
|
|
|
|
if string(b[:n]) != string(exp[:n]) {
|
|
t.Fatal(string(b))
|
|
}
|
|
|
|
exp = exp[n:]
|
|
}
|
|
|
|
n, err := r.Read(b)
|
|
if n != 0 || !errors.Is(err, errTest) {
|
|
t.Fatal(n, err)
|
|
}
|
|
})
|
|
|
|
t.Run("writer error right away", func(t *testing.T) {
|
|
c := buffer.ContentFunc(func(w io.Writer) (int64, error) {
|
|
return 0, errTest
|
|
})
|
|
|
|
p := &fakePool{allocSize: 2}
|
|
o := buffer.Options{BufferPool: p}
|
|
r := buffer.BufferedContent(c, o)
|
|
b := make([]byte, 3)
|
|
n, err := r.Read(b)
|
|
if n != 0 || !errors.Is(err, errTest) {
|
|
t.Fatal(n, err)
|
|
}
|
|
})
|
|
|
|
t.Run("abort", func(t *testing.T) {
|
|
c := buffer.ContentFunc(func(w io.Writer) (int64, error) {
|
|
var n int64
|
|
for i := 0; i < 3; i++ {
|
|
ni, err := w.Write([]byte("123456789")[i*3 : i*3+3])
|
|
n += int64(ni)
|
|
if err != nil {
|
|
return n, err
|
|
}
|
|
}
|
|
|
|
return n, nil
|
|
})
|
|
|
|
p := &fakePool{
|
|
allocSize: 2,
|
|
errAfter: []int{1},
|
|
}
|
|
|
|
o := buffer.Options{BufferPool: p}
|
|
r := buffer.BufferedContent(c, o)
|
|
b, err := r.ReadBytes([]byte("67"), 12)
|
|
if len(b) != 0 || err != nil {
|
|
t.Fatal(string(b), err)
|
|
}
|
|
|
|
b, err = r.ReadBytes([]byte("67"), 12)
|
|
if len(b) != 0 || err != nil {
|
|
t.Fatal(string(b), err)
|
|
}
|
|
})
|
|
|
|
t.Run("abort right away", func(t *testing.T) {
|
|
c := buffer.ContentFunc(func(w io.Writer) (int64, error) {
|
|
var n int64
|
|
for i := 0; i < 3; i++ {
|
|
ni, err := w.Write([]byte("123456789")[i*3 : i*3+3])
|
|
n += int64(ni)
|
|
if err != nil {
|
|
return n, err
|
|
}
|
|
}
|
|
|
|
return n, nil
|
|
})
|
|
|
|
p := &fakePool{
|
|
allocSize: 2,
|
|
errAfter: []int{0},
|
|
}
|
|
|
|
o := buffer.Options{BufferPool: p}
|
|
r := buffer.BufferedContent(c, o)
|
|
b, err := r.ReadBytes([]byte("67"), 12)
|
|
if len(b) != 0 || !errors.Is(err, errTest) {
|
|
t.Fatal(string(b), err)
|
|
}
|
|
})
|
|
|
|
t.Run("close when implementation ignores writer errors", func(t *testing.T) {
|
|
c := buffer.ContentFunc(func(w io.Writer) (int64, error) {
|
|
w.Write([]byte("123"))
|
|
w.Write([]byte("456"))
|
|
w.Write([]byte("123"))
|
|
return 0, nil
|
|
})
|
|
|
|
p := &fakePool{
|
|
allocSize: 2,
|
|
errAfter: []int{1},
|
|
}
|
|
|
|
o := buffer.Options{BufferPool: p}
|
|
r := buffer.BufferedContent(c, o)
|
|
b, err := r.ReadBytes([]byte("67"), 12)
|
|
if len(b) != 0 || err != nil {
|
|
t.Fatal(string(b), err)
|
|
}
|
|
|
|
b, err = r.ReadBytes([]byte("67"), 12)
|
|
if len(b) != 0 || err != nil {
|
|
t.Fatal(string(b), err)
|
|
}
|
|
})
|
|
|
|
t.Run("zero write", func(t *testing.T) {
|
|
c := buffer.ContentFunc(func(w io.Writer) (int64, error) {
|
|
w.Write([]byte("123"))
|
|
w.Write(nil)
|
|
w.Write([]byte("456"))
|
|
w.Write([]byte("789"))
|
|
w.Write([]byte("012"))
|
|
return 0, nil
|
|
})
|
|
|
|
p := &fakePool{allocSize: 2}
|
|
o := buffer.Options{BufferPool: p}
|
|
r := buffer.BufferedContent(c, o)
|
|
b := make([]byte, 3)
|
|
exp := []byte("123456789012")
|
|
for i := 0; i < 8; i++ {
|
|
n, err := r.Read(b)
|
|
if n != 2-i%2 || err != nil {
|
|
t.Fatal(n, err)
|
|
}
|
|
|
|
if string(b[:n]) != string(exp[:n]) {
|
|
t.Fatal(string(b[:n]))
|
|
}
|
|
|
|
exp = exp[n:]
|
|
}
|
|
|
|
n, err := r.Read(b)
|
|
if n != 0 || !errors.Is(err, io.EOF) {
|
|
t.Fatal(n, err)
|
|
}
|
|
})
|
|
|
|
t.Run("zero write right away", func(t *testing.T) {
|
|
c := buffer.ContentFunc(func(w io.Writer) (int64, error) {
|
|
w.Write(nil)
|
|
w.Write([]byte("123"))
|
|
w.Write([]byte("456"))
|
|
w.Write([]byte("789"))
|
|
w.Write([]byte("012"))
|
|
return 0, nil
|
|
})
|
|
|
|
p := &fakePool{allocSize: 2}
|
|
o := buffer.Options{BufferPool: p}
|
|
r := buffer.BufferedContent(c, o)
|
|
b := make([]byte, 3)
|
|
exp := []byte("123456789012")
|
|
for i := 0; i < 8; i++ {
|
|
n, err := r.Read(b)
|
|
if n != 2-i%2 || err != nil {
|
|
t.Fatal(n, err)
|
|
}
|
|
|
|
if string(b[:n]) != string(exp[:n]) {
|
|
t.Fatal(string(b))
|
|
}
|
|
|
|
exp = exp[n:]
|
|
}
|
|
|
|
n, err := r.Read(b)
|
|
if n != 0 || !errors.Is(err, io.EOF) {
|
|
t.Fatal(n, err)
|
|
}
|
|
})
|
|
|
|
t.Run("custom error", func(t *testing.T) {
|
|
c := buffer.ContentFunc(func(w io.Writer) (int64, error) {
|
|
var n int64
|
|
for i := 0; i < 3; i++ {
|
|
ni, err := w.Write([]byte("123456789")[i*3 : i*3+3])
|
|
n += int64(ni)
|
|
if err != nil {
|
|
return n, err
|
|
}
|
|
}
|
|
|
|
return n, errTest
|
|
})
|
|
|
|
p := &fakePool{allocSize: 3}
|
|
o := buffer.Options{BufferPool: p}
|
|
r := buffer.BufferedContent(c, o)
|
|
b := make([]byte, 3)
|
|
for i := 0; i < 3; i++ {
|
|
n, err := r.Read(b)
|
|
if n != 3 || err != nil {
|
|
t.Fatal(n, err)
|
|
}
|
|
|
|
if string(b) != "123456789"[i*3:i*3+3] {
|
|
t.Fatal(string(b))
|
|
}
|
|
}
|
|
|
|
n, err := r.Read(b)
|
|
if n != 0 || !errors.Is(err, errTest) {
|
|
t.Fatal(n, err)
|
|
}
|
|
})
|
|
|
|
t.Run("custom error with pool error", func(t *testing.T) {
|
|
c := buffer.ContentFunc(func(w io.Writer) (int64, error) {
|
|
w.Write([]byte("123"))
|
|
w.Write([]byte("456"))
|
|
w.Write([]byte("123"))
|
|
return 0, errTest2
|
|
})
|
|
|
|
p := &fakePool{
|
|
allocSize: 2,
|
|
errAfter: []int{1},
|
|
}
|
|
|
|
o := buffer.Options{BufferPool: p}
|
|
r := buffer.BufferedContent(c, o)
|
|
b, err := r.ReadBytes([]byte("67"), 12)
|
|
if len(b) != 0 || err != nil {
|
|
t.Fatal(string(b), err)
|
|
}
|
|
|
|
b, err = r.ReadBytes([]byte("67"), 12)
|
|
if len(b) != 0 || err != nil {
|
|
t.Fatal(string(b), err)
|
|
}
|
|
})
|
|
}
|