func testCodec(t *testing.T, codec pkm.Codec) {
if len(codec.Name()) == 0 {
t.Errorf("Name: expected non-empty name")
}
size := 1024
err := errors.New("reader error")
testIO(t, codec, "real size", &dummyIO{buf: make([]byte, 12), now: false, err: nil})
testIO(t, codec, "real size; now", &dummyIO{buf: make([]byte, 12), now: true, err: nil})
testIO(t, codec, "real size; error", &dummyIO{buf: make([]byte, 12), now: false, err: err})
testIO(t, codec, "real size; error now", &dummyIO{buf: make([]byte, 12), now: true, err: err})
testIO(t, codec, "half size", &dummyIO{buf: make([]byte, size/2), now: false, err: nil})
testIO(t, codec, "half size; now", &dummyIO{buf: make([]byte, size/2), now: true, err: nil})
testIO(t, codec, "half size; error", &dummyIO{buf: make([]byte, size/2), now: false, err: err})
testIO(t, codec, "half size; error now", &dummyIO{buf: make([]byte, size/2), now: true, err: err})
testIO(t, codec, "full size", &dummyIO{buf: make([]byte, size), now: false, err: nil})
testIO(t, codec, "full size; now", &dummyIO{buf: make([]byte, size), now: true, err: nil})
testIO(t, codec, "full size; error", &dummyIO{buf: make([]byte, size), now: false, err: err})
testIO(t, codec, "full size; error now", &dummyIO{buf: make([]byte, size), now: true, err: err})
testIO(t, codec, "full+half size", &dummyIO{buf: make([]byte, size+size/2), now: false, err: nil})
testIO(t, codec, "full+half size; now", &dummyIO{buf: make([]byte, size+size/2), now: true, err: nil})
testIO(t, codec, "full+half size; error", &dummyIO{buf: make([]byte, size+size/2), now: false, err: err})
testIO(t, codec, "full+half size; error now", &dummyIO{buf: make([]byte, size+size/2), now: true, err: err})
testIO(t, codec, "double size", &dummyIO{buf: make([]byte, size*2), now: false, err: nil})
testIO(t, codec, "double size; now", &dummyIO{buf: make([]byte, size*2), now: true, err: nil})
testIO(t, codec, "double size; error", &dummyIO{buf: make([]byte, size*2), now: false, err: err})
testIO(t, codec, "double size; error now", &dummyIO{buf: make([]byte, size*2), now: true, err: err})
content := []byte("Test Data 1234 \uF000\uF080\uF0FF")
testIO(t, codec, "real content", &dummyIO{buf: content, now: false, err: nil})
testIO(t, codec, "real content; now", &dummyIO{buf: content, now: true, err: nil})
testIO(t, codec, "real content; error", &dummyIO{buf: content, now: false, err: err})
testIO(t, codec, "real content; error now", &dummyIO{buf: content, now: true, err: err})
}
func testReencode(t *testing.T, codec pkm.Codec) {
content := make([]byte, 256)
for i := range content {
content[i] = byte(i)
}
var decodedbuf bytes.Buffer
var resultbuf bytes.Buffer
n, err := codec.Decode(&decodedbuf, bytes.NewReader(content))
if err != nil {
t.Errorf("Re-encode test: Decode: unexpected error '%s'", err)
return
}
decoded := decodedbuf.Bytes()[:n]
n, err = codec.Encode(&resultbuf, bytes.NewReader(decoded))
if err != nil {
t.Errorf("Re-encode test: Encode: unexpected error '%s'", err)
return
}
result := resultbuf.Bytes()[:n]
if !bytes.Equal(content, result) {
var n int
if len(content) < len(result) {
n = len(content)
} else {
n = len(result)
}
for i := 0; i < n; i++ {
if result[i] != content[i] {
t.Errorf("Re-encode test: result does not match original (@%d: 0x%02X != 0x%02X)", i, result[i], content[i])
return
}
}
t.Errorf("Re-encode test: result length does not match original length (%d != %d)", len(result), len(content))
}
}
func testIO(t *testing.T, codec pkm.Codec, testName string, readerTmpl *dummyIO) {
var reader *dummyIO
var writer *dummyIO
var n int
var err error
// Test codec.Decode.
writer = &dummyIO{}
reader = readerTmpl.Copy()
n, err = codec.Decode(writer, reader)
// Check if the correct number of bytes were returned.
if writer.writeCalled && n != writer.writtenBytes {
t.Errorf("test writer decode: '%s' failed: expected %d bytes written, got %d", testName, writer.writtenBytes, n)
} else if !writer.writeCalled && n != 0 {
t.Errorf("test writer decode: '%s' failed: expected %d bytes written, got %d", testName, 0, n)
}
// Check if an error expected from the reader is returned.
if reader.err != nil && err == nil {
t.Errorf("test reader decode: '%s' failed: expected error", testName)
} else if reader.err == nil && err != nil {
t.Errorf("test reader decode: '%s' failed: expected no error, got '%s'", testName, err)
}
// Test codec.Encode.
writer = &dummyIO{}
reader = readerTmpl.Copy()
n, err = codec.Encode(writer, reader)
// Check if the correct number of bytes were returned.
if writer.writeCalled && n != writer.writtenBytes {
t.Errorf("test writer encode: '%s' failed: expected %d bytes written, got %d", testName, writer.writtenBytes, n)
} else if !writer.writeCalled && n != 0 {
t.Errorf("test writer encode: '%s' failed: expected %d bytes written, got %d", testName, 0, n)
}
// Check if an error expected from the reader is returned.
if reader.err != nil && err == nil {
t.Errorf("test reader decode: '%s' failed: expected error", testName)
} else if reader.err == nil && err != nil {
t.Errorf("test reader decode: '%s' failed: expected no error, got '%s'", testName, err)
}
// Test codec.Decode with an erroring writer.
writer = &dummyIO{err: errors.New("writer error")}
reader = readerTmpl.Copy()
n, err = codec.Decode(writer, reader)
// Check if the correct number of bytes were returned.
if writer.writeCalled && n != writer.writtenBytes {
t.Errorf("test error writer decode: '%s' failed: expected %d bytes written, got %d", testName, writer.writtenBytes, n)
} else if !writer.writeCalled && n != 0 {
t.Errorf("test error writer decode: '%s' failed: expected %d bytes written, got %d", testName, 0, n)
}
// Check if an error expected from the writer is returned.
if reader.err == nil && writer.writeCalled && err == nil {
t.Errorf("test error writer decode: '%s' failed: expected error", testName)
} else if reader.err != nil && writer.writeCalled && err == nil {
t.Errorf("test error writer decode: '%s' failed: expected reader error", testName)
}
// Test codec.Encode with an erroring writer.
writer = &dummyIO{err: errors.New("writer error")}
reader = readerTmpl.Copy()
n, err = codec.Encode(writer, reader)
// Check if the correct number of bytes were returned.
if writer.writeCalled && n != writer.writtenBytes {
t.Errorf("test error writer encode: '%s' failed: expected %d bytes written, got %d", testName, writer.writtenBytes, n)
} else if !writer.writeCalled && n != 0 {
t.Errorf("test error writer encode: '%s' failed: expected %d bytes written, got %d", testName, 0, n)
}
// Check if an error expected from the writer is returned.
if reader.err == nil && writer.writeCalled && err == nil {
t.Errorf("test error writer encode: '%s' failed: expected error", testName)
} else if reader.err != nil && writer.writeCalled && err == nil {
t.Errorf("test error writer encode: '%s' failed: expected reader error", testName)
}
}