OrgGo/unipdf
1
0
Fork 0
mirror of https://github.com/unidoc/unipdf.git synced 2025-04-26 13:48:55 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
unipdf/internal/ccittfax/decode_test.go
Adrian-George Bostan c64812093d Remmove pdf folder and move packages up one level (#2)
2019-05-16 20:44:51 +00:00

3785 lines
69 KiB
Go
Raw Blame History

/*
* This file is subject to the terms and conditions defined in
* file 'LICENSE.md', which is part of this source code package.
*/
package ccittfax
import (
"image"
"image/png"
"io/ioutil"
"os"
"testing"
)
const (
testDataPath = "./testdata/"
)
func TestDecodeNextRunLen(t *testing.T) {
type testResult struct {
PixelsRow []byte
BitPos int
Err error
}
type testData struct {
Encoded []byte
PixelsRow []byte
BitPos int
IsWhite bool
Want testResult
}
// Calculated test data based on the reference documentation.
tests := []testData{
{
Encoded: []byte{1, 28, 2},
PixelsRow: []byte{},
BitPos: 16,
IsWhite: true,
Want: testResult{
PixelsRow: []byte{white, white, white, white, white, white, white, white, white, white,
white, white, white, white, white, white, white, white, white, white, white, white,
white, white, white, white, white, white, white},
BitPos: 24,
Err: nil,
},
},
{
Encoded: []byte{1, 28, 2, 0, 0, 0},
PixelsRow: []byte{},
BitPos: 16,
IsWhite: true,
Want: testResult{
PixelsRow: []byte{white, white, white, white, white, white, white, white, white, white,
white, white, white, white, white, white, white, white, white, white, white, white,
white, white, white, white, white, white, white},
BitPos: 24,
Err: nil,
},
},
{
Encoded: []byte{1, 28, 40, 56},
PixelsRow: []byte{},
BitPos: 21,
IsWhite: false,
Want: testResult{
PixelsRow: []byte{black, black, black, black, black, black, black, black, black, black, black,
black, black, black},
BitPos: 29,
Err: nil,
},
},
{
Encoded: []byte{1, 28, 40, 56, 0, 0, 0},
PixelsRow: []byte{},
BitPos: 21,
IsWhite: false,
Want: testResult{
PixelsRow: []byte{black, black, black, black, black, black, black, black, black, black, black,
black, black, black},
BitPos: 29,
Err: nil,
},
},
{
Encoded: []byte{1, 28, 40, 154, 80},
PixelsRow: []byte{},
BitPos: 23,
IsWhite: true,
Want: testResult{
PixelsRow: drawPixels(nil, true, 1624),
BitPos: 39,
Err: nil,
},
},
{
Encoded: []byte{1, 28, 40, 154, 80, 0, 0},
PixelsRow: []byte{},
BitPos: 23,
IsWhite: true,
Want: testResult{
PixelsRow: drawPixels(nil, true, 1624),
BitPos: 39,
Err: nil,
},
},
{
Encoded: []byte{1, 28, 40, 29, 67, 128},
PixelsRow: nil,
BitPos: 21,
IsWhite: false,
Want: testResult{
PixelsRow: drawPixels(nil, false, 1100),
BitPos: 41,
Err: nil,
},
},
{
Encoded: []byte{1, 28, 40, 29, 67, 128, 0, 0, 0},
PixelsRow: nil,
BitPos: 21,
IsWhite: false,
Want: testResult{
PixelsRow: drawPixels(nil, false, 1100),
BitPos: 41,
Err: nil,
},
},
{
Encoded: []byte{1, 28, 40, 9, 166, 188},
PixelsRow: nil,
BitPos: 21,
IsWhite: true,
Want: testResult{
PixelsRow: drawPixels(nil, true, 3655),
BitPos: 46,
Err: nil,
},
},
{
Encoded: []byte{1, 28, 40, 9, 166, 188, 0, 0, 0},
PixelsRow: nil,
BitPos: 21,
IsWhite: true,
Want: testResult{
PixelsRow: drawPixels(nil, true, 3655),
BitPos: 46,
Err: nil,
},
},
{
Encoded: []byte{1, 28, 40, 15, 129, 200, 21, 128},
PixelsRow: nil,
BitPos: 21,
IsWhite: false,
Want: testResult{
PixelsRow: drawPixels(nil, false, 3502),
BitPos: 58,
Err: nil,
},
},
{
Encoded: []byte{1, 28, 40, 15, 129, 200, 21, 128, 0, 0, 0},
PixelsRow: nil,
BitPos: 21,
IsWhite: false,
Want: testResult{
PixelsRow: drawPixels(nil, false, 3502),
BitPos: 58,
Err: nil,
},
},
{
Encoded: []byte{0, 0, 0, 0, 0},
PixelsRow: nil,
BitPos: 0,
IsWhite: true,
Want: testResult{
PixelsRow: nil,
BitPos: 0,
Err: errWrongCodeInHorizontalMode,
},
},
{
Encoded: []byte{0, 0, 0, 0, 0},
PixelsRow: nil,
BitPos: 2,
IsWhite: true,
Want: testResult{
PixelsRow: nil,
BitPos: 2,
Err: errWrongCodeInHorizontalMode,
},
},
{
Encoded: []byte{0, 0, 0, 0, 0},
PixelsRow: nil,
BitPos: 0,
IsWhite: false,
Want: testResult{
PixelsRow: nil,
BitPos: 0,
Err: errWrongCodeInHorizontalMode,
},
},
{
Encoded: []byte{0, 0, 0, 0, 0},
PixelsRow: nil,
BitPos: 2,
IsWhite: false,
Want: testResult{
PixelsRow: nil,
BitPos: 2,
Err: errWrongCodeInHorizontalMode,
},
},
{
Encoded: []byte{},
PixelsRow: nil,
BitPos: 0,
IsWhite: true,
Want: testResult{
PixelsRow: nil,
BitPos: 0,
Err: errWrongCodeInHorizontalMode,
},
},
{
Encoded: []byte{},
PixelsRow: nil,
BitPos: 2,
IsWhite: true,
Want: testResult{
PixelsRow: nil,
BitPos: 2,
Err: errWrongCodeInHorizontalMode,
},
},
{
Encoded: []byte{},
PixelsRow: nil,
BitPos: 0,
IsWhite: false,
Want: testResult{
PixelsRow: nil,
BitPos: 0,
Err: errWrongCodeInHorizontalMode,
},
},
{
Encoded: []byte{},
PixelsRow: nil,
BitPos: 2,
IsWhite: false,
Want: testResult{
PixelsRow: nil,
BitPos: 2,
Err: errWrongCodeInHorizontalMode,
},
},
{
Encoded: nil,
PixelsRow: nil,
BitPos: 0,
IsWhite: true,
Want: testResult{
PixelsRow: nil,
BitPos: 0,
Err: errWrongCodeInHorizontalMode,
},
},
{
Encoded: nil,
PixelsRow: nil,
BitPos: 2,
IsWhite: true,
Want: testResult{
PixelsRow: nil,
BitPos: 2,
Err: errWrongCodeInHorizontalMode,
},
},
{
Encoded: nil,
PixelsRow: nil,
BitPos: 0,
IsWhite: false,
Want: testResult{
PixelsRow: nil,
BitPos: 0,
Err: errWrongCodeInHorizontalMode,
},
},
{
Encoded: nil,
PixelsRow: nil,
BitPos: 2,
IsWhite: false,
Want: testResult{
PixelsRow: nil,
BitPos: 2,
Err: errWrongCodeInHorizontalMode,
},
},
}
for _, test := range tests {
gotPixelsRow, gotBitPos, gotErr := decodeNextRunLen(test.Encoded, test.PixelsRow, test.BitPos, test.IsWhite)
if len(gotPixelsRow) != len(test.Want.PixelsRow) {
t.Errorf("Wrong pixels row len. Got %v, want %v\n", len(gotPixelsRow), len(test.Want.PixelsRow))
} else {
for i := range gotPixelsRow {
if gotPixelsRow[i] != test.Want.PixelsRow[i] {
t.Errorf("Wrong pixel at %v. Got %v, want %v\n",
i, gotPixelsRow[i], test.Want.PixelsRow[i])
}
}
}
if gotBitPos != test.Want.BitPos {
t.Errorf("Wrong bit pos. Got %v, want %v\n", gotBitPos, test.Want.BitPos)
}
if gotErr != test.Want.Err {
t.Errorf("Wrong err. Got %v, want %v\n", gotErr, test.Want.Err)
}
}
}
func TestDecodeHorizontalMode(t *testing.T) {
type testResult struct {
PixelsRow []byte
BitPos int
A0 int
Err error
}
type testData struct {
Encoded []byte
PixelsRow []byte
BitPos int
IsWhite bool
A0 int
Want testResult
}
tests := []testData{
{
Encoded: []byte{1, 28, 2, 192},
PixelsRow: []byte{},
BitPos: 16,
IsWhite: true,
A0: 0,
Want: testResult{
PixelsRow: []byte{white, white, white, white, white, white, white, white, white, white,
white, white, white, white, white, white, white, white, white, white, white, white,
white, white, white, white, white, white, white, black, black},
BitPos: 26,
A0: 31,
Err: nil,
},
},
{
Encoded: []byte{1, 28, 2, 192, 0, 0, 0},
PixelsRow: []byte{},
BitPos: 16,
IsWhite: true,
A0: 7,
Want: testResult{
PixelsRow: []byte{white, white, white, white, white, white, white, white, white, white,
white, white, white, white, white, white, white, white, white, white, white, white,
white, white, white, white, white, white, white, black, black},
BitPos: 26,
A0: 31,
Err: nil,
},
},
{
Encoded: []byte{1, 28, 40, 56, 224},
PixelsRow: []byte{},
BitPos: 21,
IsWhite: false,
A0: 0,
Want: testResult{
PixelsRow: []byte{black, black, black, black, black, black, black, black, black, black, black,
black, black, black, white},
BitPos: 35,
A0: 15,
Err: nil,
},
},
{
Encoded: []byte{1, 28, 40, 56, 224, 0, 0, 0},
PixelsRow: []byte{},
BitPos: 21,
IsWhite: false,
A0: 10,
Want: testResult{
PixelsRow: []byte{black, black, black, black, black, black, black, black, black, black, black,
black, black, black, white},
BitPos: 35,
A0: 15,
Err: nil,
},
},
{
Encoded: []byte{0, 0, 0, 0, 0},
PixelsRow: nil,
BitPos: 0,
IsWhite: true,
A0: 0,
Want: testResult{
PixelsRow: nil,
BitPos: 0,
A0: 0,
Err: errWrongCodeInHorizontalMode,
},
},
{
Encoded: []byte{0, 0, 0, 0, 0},
PixelsRow: nil,
BitPos: 2,
IsWhite: true,
A0: 120,
Want: testResult{
PixelsRow: nil,
BitPos: 2,
A0: 120,
Err: errWrongCodeInHorizontalMode,
},
},
{
Encoded: []byte{0, 0, 0, 0, 0},
PixelsRow: nil,
BitPos: 0,
IsWhite: false,
A0: 10,
Want: testResult{
PixelsRow: nil,
BitPos: 0,
A0: 10,
Err: errWrongCodeInHorizontalMode,
},
},
{
Encoded: []byte{0, 0, 0, 0, 0},
PixelsRow: nil,
BitPos: 2,
IsWhite: false,
A0: 13,
Want: testResult{
PixelsRow: nil,
BitPos: 2,
A0: 13,
Err: errWrongCodeInHorizontalMode,
},
},
{
Encoded: []byte{},
PixelsRow: nil,
BitPos: 0,
IsWhite: true,
A0: 23,
Want: testResult{
PixelsRow: nil,
BitPos: 0,
A0: 23,
Err: errWrongCodeInHorizontalMode,
},
},
{
Encoded: []byte{},
PixelsRow: nil,
BitPos: 2,
IsWhite: true,
A0: 34,
Want: testResult{
PixelsRow: nil,
BitPos: 2,
A0: 34,
Err: errWrongCodeInHorizontalMode,
},
},
{
Encoded: []byte{},
PixelsRow: nil,
BitPos: 0,
IsWhite: false,
A0: 134,
Want: testResult{
PixelsRow: nil,
BitPos: 0,
A0: 134,
Err: errWrongCodeInHorizontalMode,
},
},
{
Encoded: []byte{},
PixelsRow: nil,
BitPos: 2,
IsWhite: false,
A0: 35,
Want: testResult{
PixelsRow: nil,
BitPos: 2,
A0: 35,
Err: errWrongCodeInHorizontalMode,
},
},
{
Encoded: nil,
PixelsRow: nil,
BitPos: 0,
IsWhite: true,
A0: 876,
Want: testResult{
PixelsRow: nil,
BitPos: 0,
A0: 876,
Err: errWrongCodeInHorizontalMode,
},
},
{
Encoded: nil,
PixelsRow: nil,
BitPos: 2,
IsWhite: true,
A0: 738,
Want: testResult{
PixelsRow: nil,
BitPos: 2,
A0: 738,
Err: errWrongCodeInHorizontalMode,
},
},
{
Encoded: nil,
PixelsRow: nil,
BitPos: 0,
IsWhite: false,
A0: 283,
Want: testResult{
PixelsRow: nil,
BitPos: 0,
A0: 283,
Err: errWrongCodeInHorizontalMode,
},
},
{
Encoded: nil,
PixelsRow: nil,
BitPos: 2,
IsWhite: false,
A0: 29,
Want: testResult{
PixelsRow: nil,
BitPos: 2,
A0: 29,
Err: errWrongCodeInHorizontalMode,
},
},
{
Encoded: []byte{1, 28, 2, 0, 0, 0, 0, 0},
PixelsRow: nil,
BitPos: 16,
IsWhite: true,
A0: 0,
Want: testResult{
PixelsRow: []byte{white, white, white, white, white, white, white, white, white, white, white, white,
white, white, white, white, white, white, white, white, white, white, white, white, white, white,
white, white, white},
BitPos: 16,
A0: 0,
Err: errWrongCodeInHorizontalMode,
},
},
}
resultingPixelsRow1 := drawPixels(nil, true, 1624)
resultingPixelsRow1 = drawPixels(resultingPixelsRow1, false, 1728)
tests = append(tests, testData{
Encoded: []byte{1, 28, 40, 154, 80, 6, 80, 220},
PixelsRow: []byte{},
BitPos: 23,
IsWhite: true,
A0: 0,
Want: testResult{
PixelsRow: resultingPixelsRow1,
BitPos: 62,
A0: 3352,
Err: nil,
},
})
tests = append(tests, testData{
Encoded: []byte{1, 28, 40, 154, 80, 6, 80, 220, 0, 0, 0},
PixelsRow: []byte{},
BitPos: 23,
IsWhite: true,
A0: 112,
Want: testResult{
PixelsRow: resultingPixelsRow1,
BitPos: 62,
A0: 3352,
Err: nil,
},
})
resultingPixelsRow2 := drawPixels(nil, false, 1100)
resultingPixelsRow2 = drawPixels(resultingPixelsRow2, true, 1027)
tests = append(tests, testData{
Encoded: []byte{1, 28, 40, 29, 67, 181, 96},
PixelsRow: nil,
BitPos: 21,
IsWhite: false,
A0: 0,
Want: testResult{
PixelsRow: resultingPixelsRow2,
BitPos: 54,
A0: 2127,
Err: nil,
},
})
tests = append(tests, testData{
Encoded: []byte{1, 28, 40, 29, 67, 181, 96, 0, 0, 0},
PixelsRow: nil,
BitPos: 21,
IsWhite: false,
A0: 109,
Want: testResult{
PixelsRow: resultingPixelsRow2,
BitPos: 54,
A0: 2127,
Err: nil,
},
})
resultingPixelsRow3 := drawPixels(nil, true, 3655)
resultingPixelsRow3 = drawPixels(resultingPixelsRow3, false, 3547)
tests = append(tests, testData{
Encoded: []byte{1, 28, 40, 9, 166, 188, 7, 192, 230, 25, 96},
PixelsRow: nil,
BitPos: 21,
IsWhite: true,
A0: 0,
Want: testResult{
PixelsRow: resultingPixelsRow3,
BitPos: 83,
A0: 7202,
Err: nil,
},
})
tests = append(tests, testData{
Encoded: []byte{1, 28, 40, 9, 166, 188, 7, 192, 230, 25, 96, 0, 0, 0},
PixelsRow: nil,
BitPos: 21,
IsWhite: true,
A0: 1121,
Want: testResult{
PixelsRow: resultingPixelsRow3,
BitPos: 83,
A0: 7202,
Err: nil,
},
})
resultingPixelsRow4 := drawPixels(nil, false, 3502)
resultingPixelsRow4 = drawPixels(resultingPixelsRow4, true, 3488)
tests = append(tests, testData{
Encoded: []byte{1, 28, 40, 15, 129, 200, 21, 128, 125, 166, 54},
PixelsRow: nil,
BitPos: 21,
IsWhite: false,
A0: 0,
Want: testResult{
PixelsRow: resultingPixelsRow4,
BitPos: 87,
A0: 6990,
Err: nil,
},
})
tests = append(tests, testData{
Encoded: []byte{1, 28, 40, 15, 129, 200, 21, 128, 125, 166, 54, 0, 0, 0},
PixelsRow: nil,
BitPos: 21,
IsWhite: false,
A0: 2148,
Want: testResult{
PixelsRow: resultingPixelsRow4,
BitPos: 87,
A0: 6990,
Err: nil,
},
})
for _, test := range tests {
gotPixelsRow, gotBitPos, gotA0, gotErr := decodeHorizontalMode(test.Encoded, test.PixelsRow,
test.BitPos, test.IsWhite, test.A0)
if len(gotPixelsRow) != len(test.Want.PixelsRow) {
t.Errorf("Wrong pixels row len. Got %v, want %v\n", len(gotPixelsRow), len(test.Want.PixelsRow))
} else {
for i := range gotPixelsRow {
if gotPixelsRow[i] != test.Want.PixelsRow[i] {
t.Errorf("Wrong pixel at %v. Got %v, want %v\n",
i, gotPixelsRow[i], test.Want.PixelsRow[i])
}
}
}
if gotBitPos != test.Want.BitPos {
t.Errorf("Wrong bit pos. Got %v, want %v\n", gotBitPos, test.Want.BitPos)
}
if gotA0 != test.Want.A0 {
t.Errorf("Wrong A0. Got %v, want %v\n", gotA0, test.Want.A0)
}
if gotErr != test.Want.Err {
t.Errorf("Wrong err. Got %v, want %v\n", gotErr, test.Want.Err)
}
}
}
func TestDecodePassMode(t *testing.T) {
type testResult struct {
PixelsRow []byte
A0 int
}
type testData struct {
Pixels [][]byte
PixelsRow []byte
IsWhite bool
A0 int
Want testResult
}
tests := []testData{
{
Pixels: [][]byte{
{white, white, white, white, white},
},
PixelsRow: nil,
IsWhite: true,
A0: -1,
Want: testResult{
PixelsRow: []byte{white, white, white, white, white},
A0: 5,
},
},
{
Pixels: [][]byte{
{black, black, black, black, black},
{white, white, white, white, white},
},
PixelsRow: []byte{black},
IsWhite: true,
A0: 1,
Want: testResult{
PixelsRow: []byte{black, white, white, white, white},
A0: 5,
},
},
{
Pixels: [][]byte{
{black, black, black, black, black},
{white, white, white, white, white},
},
PixelsRow: []byte{},
IsWhite: false,
A0: 0,
Want: testResult{
PixelsRow: []byte{black, black, black, black, black},
A0: 5,
},
},
}
for _, test := range tests {
gotPixelsRow, gotA0 := decodePassMode(test.Pixels, test.PixelsRow, test.IsWhite, test.A0)
if len(gotPixelsRow) != len(test.Want.PixelsRow) {
t.Errorf("Wrong pixels row len. Got %v, want %v\n", len(gotPixelsRow), len(test.Want.PixelsRow))
} else {
for i := range gotPixelsRow {
if gotPixelsRow[i] != test.Want.PixelsRow[i] {
t.Errorf("Wrong pixel at %v. Got %v, want %v\n",
i, gotPixelsRow[i], test.Want.PixelsRow[i])
}
}
}
if gotA0 != test.Want.A0 {
t.Errorf("Wrong a0. Got %v, want %v\n", gotA0, test.Want.A0)
}
}
}
func TestDecode(t *testing.T) {
type testResult struct {
Pixels [][]byte
Err error
}
type testData struct {
Encoder *Encoder
InputFilePath string
Want testResult
}
image.RegisterFormat("png", "png", png.Decode, png.DecodeConfig)
wantPixels, err := getPixels(testDataPath + "p3_0.png")
if err != nil {
t.Fatalf("Error reading image: %v\n", err)
}
tests := []testData{
{
Encoder: &Encoder{
K: 0,
Columns: 2560,
Rows: 3295,
},
InputFilePath: testDataPath + "K0-Columns2560-Rows3295.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
K: 0,
Columns: 2560,
EndOfLine: true,
Rows: 3295,
},
InputFilePath: testDataPath + "K0-Columns2560-EOL-Rows3295.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
K: 0,
Columns: 2560,
EndOfLine: true,
EndOfBlock: true,
},
InputFilePath: testDataPath + "K0-Columns2560-EOL-EOFB.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
K: 0,
Columns: 2560,
EndOfLine: true,
EncodedByteAlign: true,
Rows: 3295,
},
InputFilePath: testDataPath + "K0-Columns2560-EOL-Aligned-Rows3295.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
K: 0,
Columns: 2560,
EndOfLine: true,
EncodedByteAlign: true,
EndOfBlock: true,
},
InputFilePath: testDataPath + "K0-Columns2560-EOL-Aligned-EOFB.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
K: 0,
Columns: 2560,
EndOfBlock: true,
},
InputFilePath: testDataPath + "K0-Columns2560-EOFB.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
K: 0,
Columns: 2560,
EncodedByteAlign: true,
Rows: 3295,
},
InputFilePath: testDataPath + "K0-Columns2560-Aligned-Rows3295.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
K: 0,
Columns: 2560,
EncodedByteAlign: true,
EndOfBlock: true,
},
InputFilePath: testDataPath + "K0-Columns2560-Aligned-EOFB.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
K: 4,
Columns: 2560,
Rows: 3295,
},
InputFilePath: testDataPath + "K4-Columns2560-Rows3295.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
K: 4,
Columns: 2560,
EndOfLine: true,
Rows: 3295,
},
InputFilePath: testDataPath + "K4-Columns2560-EOL-Rows3295.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
K: 4,
Columns: 2560,
EndOfLine: true,
EndOfBlock: true,
},
InputFilePath: testDataPath + "K4-Columns2560-EOL-EOFB.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
K: 4,
Columns: 2560,
EndOfLine: true,
EncodedByteAlign: true,
Rows: 3295,
},
InputFilePath: testDataPath + "K4-Columns2560-EOL-Aligned-Rows3295.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
K: 4,
Columns: 2560,
EndOfLine: true,
EncodedByteAlign: true,
EndOfBlock: true,
},
InputFilePath: testDataPath + "K4-Columns2560-EOL-Aligned-EOFB.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
K: 4,
Columns: 2560,
EndOfBlock: true,
},
InputFilePath: testDataPath + "K4-Columns2560-EOFB.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
K: 4,
Columns: 2560,
EncodedByteAlign: true,
Rows: 3295,
},
InputFilePath: testDataPath + "K4-Columns2560-Aligned-Rows3295.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
K: 4,
Columns: 2560,
EncodedByteAlign: true,
EndOfBlock: true,
},
InputFilePath: testDataPath + "K4-Columns2560-Aligned-EOFB.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
K: -1,
Columns: 2560,
Rows: 3295,
},
InputFilePath: testDataPath + "K-1-Columns2560-Rows3295.gr4",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
K: -1,
Columns: 2560,
EndOfLine: true,
Rows: 3295,
},
InputFilePath: testDataPath + "K-1-Columns2560-EOL-Rows3295.gr4",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
K: -1,
Columns: 2560,
EndOfLine: true,
EndOfBlock: true,
},
InputFilePath: testDataPath + "K-1-Columns2560-EOL-EOFB.gr4",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
K: -1,
Columns: 2560,
EndOfLine: true,
EncodedByteAlign: true,
Rows: 3295,
},
InputFilePath: testDataPath + "K-1-Columns2560-EOL-Aligned-Rows3295.gr4",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
K: -1,
Columns: 2560,
EndOfLine: true,
EncodedByteAlign: true,
EndOfBlock: true,
},
InputFilePath: testDataPath + "K-1-Columns2560-EOL-Aligned-EOFB.gr4",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
K: -1,
Columns: 2560,
EndOfBlock: true,
},
InputFilePath: testDataPath + "K-1-Columns2560-EOFB.gr4",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
K: -1,
Columns: 2560,
EncodedByteAlign: true,
Rows: 3295,
},
InputFilePath: testDataPath + "K-1-Columns2560-Aligned-Rows3295.gr4",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
K: -1,
Columns: 2560,
EncodedByteAlign: true,
EndOfBlock: true,
},
InputFilePath: testDataPath + "K-1-Columns2560-Aligned-EOFB.gr4",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
BlackIs1: true,
K: 0,
Columns: 2560,
Rows: 3295,
},
InputFilePath: testDataPath + "BlackIs1-K0-Columns2560-Rows3295.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
BlackIs1: true,
K: 0,
Columns: 2560,
EndOfLine: true,
Rows: 3295,
},
InputFilePath: testDataPath + "BlackIs1-K0-Columns2560-EOL-Rows3295.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
BlackIs1: true,
K: 0,
Columns: 2560,
EndOfLine: true,
EndOfBlock: true,
},
InputFilePath: testDataPath + "BlackIs1-K0-Columns2560-EOL-EOFB.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
BlackIs1: true,
K: 0,
Columns: 2560,
EndOfLine: true,
EncodedByteAlign: true,
Rows: 3295,
},
InputFilePath: testDataPath + "BlackIs1-K0-Columns2560-EOL-Aligned-Rows3295.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
BlackIs1: true,
K: 0,
Columns: 2560,
EndOfLine: true,
EncodedByteAlign: true,
EndOfBlock: true,
},
InputFilePath: testDataPath + "BlackIs1-K0-Columns2560-EOL-Aligned-EOFB.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
BlackIs1: true,
K: 0,
Columns: 2560,
EndOfBlock: true,
},
InputFilePath: testDataPath + "BlackIs1-K0-Columns2560-EOFB.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
BlackIs1: true,
K: 0,
Columns: 2560,
EncodedByteAlign: true,
Rows: 3295,
},
InputFilePath: testDataPath + "BlackIs1-K0-Columns2560-Aligned-Rows3295.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
BlackIs1: true,
K: 0,
Columns: 2560,
EncodedByteAlign: true,
EndOfBlock: true,
},
InputFilePath: testDataPath + "BlackIs1-K0-Columns2560-Aligned-EOFB.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
BlackIs1: true,
K: 4,
Columns: 2560,
Rows: 3295,
},
InputFilePath: testDataPath + "BlackIs1-K4-Columns2560-Rows3295.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
BlackIs1: true,
K: 4,
Columns: 2560,
EndOfLine: true,
Rows: 3295,
},
InputFilePath: testDataPath + "BlackIs1-K4-Columns2560-EOL-Rows3295.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
BlackIs1: true,
K: 4,
Columns: 2560,
EndOfLine: true,
EndOfBlock: true,
},
InputFilePath: testDataPath + "BlackIs1-K4-Columns2560-EOL-EOFB.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
BlackIs1: true,
K: 4,
Columns: 2560,
EndOfLine: true,
EncodedByteAlign: true,
Rows: 3295,
},
InputFilePath: testDataPath + "BlackIs1-K4-Columns2560-EOL-Aligned-Rows3295.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
BlackIs1: true,
K: 4,
Columns: 2560,
EndOfLine: true,
EncodedByteAlign: true,
EndOfBlock: true,
},
InputFilePath: testDataPath + "BlackIs1-K4-Columns2560-EOL-Aligned-EOFB.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
BlackIs1: true,
K: 4,
Columns: 2560,
EndOfBlock: true,
},
InputFilePath: testDataPath + "BlackIs1-K4-Columns2560-EOFB.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
BlackIs1: true,
K: 4,
Columns: 2560,
EncodedByteAlign: true,
Rows: 3295,
},
InputFilePath: testDataPath + "BlackIs1-K4-Columns2560-Aligned-Rows3295.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
BlackIs1: true,
K: 4,
Columns: 2560,
EncodedByteAlign: true,
EndOfBlock: true,
},
InputFilePath: testDataPath + "BlackIs1-K4-Columns2560-Aligned-EOFB.gr3",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
BlackIs1: true,
K: -1,
Columns: 2560,
Rows: 3295,
},
InputFilePath: testDataPath + "BlackIs1-K-1-Columns2560-Rows3295.gr4",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
BlackIs1: true,
K: -1,
Columns: 2560,
EndOfLine: true,
Rows: 3295,
},
InputFilePath: testDataPath + "BlackIs1-K-1-Columns2560-EOL-Rows3295.gr4",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
BlackIs1: true,
K: -1,
Columns: 2560,
EndOfLine: true,
EndOfBlock: true,
},
InputFilePath: testDataPath + "BlackIs1-K-1-Columns2560-EOL-EOFB.gr4",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
BlackIs1: true,
K: -1,
Columns: 2560,
EndOfLine: true,
EncodedByteAlign: true,
Rows: 3295,
},
InputFilePath: testDataPath + "BlackIs1-K-1-Columns2560-EOL-Aligned-Rows3295.gr4",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
BlackIs1: true,
K: -1,
Columns: 2560,
EndOfLine: true,
EncodedByteAlign: true,
EndOfBlock: true,
},
InputFilePath: testDataPath + "BlackIs1-K-1-Columns2560-EOL-Aligned-EOFB.gr4",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
BlackIs1: true,
K: -1,
Columns: 2560,
EndOfBlock: true,
},
InputFilePath: testDataPath + "BlackIs1-K-1-Columns2560-EOFB.gr4",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
BlackIs1: true,
K: -1,
Columns: 2560,
EncodedByteAlign: true,
Rows: 3295,
},
InputFilePath: testDataPath + "BlackIs1-K-1-Columns2560-Aligned-Rows3295.gr4",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
{
Encoder: &Encoder{
BlackIs1: true,
K: -1,
Columns: 2560,
EncodedByteAlign: true,
EndOfBlock: true,
},
InputFilePath: testDataPath + "BlackIs1-K-1-Columns2560-Aligned-EOFB.gr4",
Want: testResult{
Pixels: wantPixels,
Err: nil,
},
},
}
for _, test := range tests {
f, err := os.Open(test.InputFilePath)
if err != nil {
t.Fatalf("Error opening encoded file: %v\n", err)
}
encodedData, err := ioutil.ReadAll(f)
if err != nil {
t.Fatalf("Error reading encoded data from file: %v\n", err)
}
gotPixels, gotErr := test.Encoder.Decode(encodedData)
if gotErr != test.Want.Err {
t.Errorf("Wrong err. Got %v, want %v\n", gotErr, test.Want.Err)
} else {
if len(gotPixels) != len(test.Want.Pixels) {
t.Errorf("Wrong pixels len. Got %v, want %v\n",
len(gotPixels), len(test.Want.Pixels))
} else {
for i := range gotPixels {
for j := range gotPixels[i] {
if gotPixels[i][j] != test.Want.Pixels[i][j] {
t.Errorf("Wrong pixel at %v:%v. Got %v, want %v\n",
i, j, gotPixels[i][j], test.Want.Pixels[i][j])
}
}
}
}
}
}
}
func getPixels(imagePath string) ([][]byte, error) {
file, err := os.Open(imagePath)
if err != nil {
return nil, err
}
defer file.Close()
img, _, err := image.Decode(file)
if err != nil {
return nil, err
}
bounds := img.Bounds()
w, h := bounds.Max.X, bounds.Max.Y
var pixels [][]byte
for y := 0; y < h; y++ {
var row []byte
for x := 0; x < w; x++ {
r, g, b, _ := img.At(x, y).RGBA()
if r == 65535 && g == 65535 && b == 65535 {
// append white
row = append(row, 1)
} else {
row = append(row, 0)
}
}
pixels = append(pixels, row)
}
return pixels, nil
}
func TestDecodeVerticalMode(t *testing.T) {
type testResult struct {
PixelsRow []byte
A0 int
}
type testData struct {
Pixels [][]byte
PixelsRow []byte
IsWhite bool
A0 int
Shift int
Want testResult
}
tests := []testData{
{
Pixels: [][]byte{
{white, white, white, white, white},
},
PixelsRow: nil,
IsWhite: true,
A0: -1,
Shift: 0,
Want: testResult{
PixelsRow: []byte{white, white, white, white, white},
A0: 5,
},
},
{
Pixels: [][]byte{
{black, black, black, black, black},
{white, white, white, white, white},
},
PixelsRow: []byte{white},
IsWhite: false,
A0: 1,
Shift: -1,
Want: testResult{
PixelsRow: []byte{white, black, black, black},
A0: 4,
},
},
{
Pixels: [][]byte{
{black, black, black, black, black},
{white, white, white, white, white},
},
PixelsRow: []byte{},
IsWhite: true,
A0: -1,
Shift: -2,
Want: testResult{
PixelsRow: []byte{white, white, white},
A0: 3,
},
},
{
Pixels: [][]byte{
{black, black, black, black, black},
{white, white, white, white, white},
},
PixelsRow: nil,
IsWhite: true,
A0: -1,
Shift: -3,
Want: testResult{
PixelsRow: []byte{white, white},
A0: 2,
},
},
{
Pixels: [][]byte{
{black, black, black, black, black, black, black, black},
{white, black, white, black, black, black, black, black},
},
PixelsRow: []byte{black},
IsWhite: true,
A0: 1,
Shift: -1,
Want: testResult{
PixelsRow: []byte{black, white},
A0: 2,
},
},
{
Pixels: [][]byte{
{black, black, black, black, black, black, black, black},
{white, black, white, black, black, black, black, black},
},
PixelsRow: []byte{black},
IsWhite: true,
A0: 1,
Shift: 0,
Want: testResult{
PixelsRow: []byte{black, white, white},
A0: 3,
},
},
{
Pixels: [][]byte{
{black, black, black, black, black, black, black, black},
{white, black, white, black, black, black, black, black},
},
PixelsRow: []byte{black},
IsWhite: true,
A0: 1,
Shift: 1,
Want: testResult{
PixelsRow: []byte{black, white, white, white},
A0: 4,
},
},
{
Pixels: [][]byte{
{black, black, black, black, black, black, black, black},
{white, black, white, black, black, black, black, black},
},
PixelsRow: []byte{black},
IsWhite: true,
A0: 1,
Shift: 2,
Want: testResult{
PixelsRow: []byte{black, white, white, white, white},
A0: 5,
},
},
{
Pixels: [][]byte{
{black, black, black, black, black, black, black, black},
{white, black, white, black, black, black, black, black},
},
PixelsRow: []byte{black},
IsWhite: true,
A0: 1,
Shift: 3,
Want: testResult{
PixelsRow: []byte{black, white, white, white, white, white},
A0: 6,
},
},
}
for _, test := range tests {
gotPixelsRow, gotA0 := decodeVerticalMode(test.Pixels, test.PixelsRow, test.IsWhite, test.A0, test.Shift)
if len(gotPixelsRow) != len(test.Want.PixelsRow) {
t.Errorf("Wrong pixels row len. Got %v, want %v\n",
len(gotPixelsRow), len(test.Want.PixelsRow))
} else {
for i := range gotPixelsRow {
if gotPixelsRow[i] != test.Want.PixelsRow[i] {
t.Errorf("Wrong pixel at %v. Got %v, want %v\n",
i, gotPixelsRow[i], test.Want.PixelsRow[i])
}
}
}
if gotA0 != test.Want.A0 {
t.Errorf("Wrong a0. Got %v, want %v\n", gotA0, test.Want.A0)
}
}
}
func TestDecodeRow1D(t *testing.T) {
type testResult struct {
PixelsRow []byte
BitPos int
}
type testData struct {
Encoder *Encoder
Encoded []byte
BitPos int
Want testResult
}
tests := []testData{
{
Encoder: &Encoder{
Columns: 17,
},
Encoded: []byte{160, 199},
BitPos: 0,
Want: testResult{
PixelsRow: []byte{white, white, white, white, white, white, white, white, white,
black, black, black, black, black, black, black, white},
BitPos: 16,
},
},
{
Encoder: &Encoder{
Columns: 17,
},
Encoded: []byte{40, 49, 192},
BitPos: 2,
Want: testResult{
PixelsRow: []byte{white, white, white, white, white, white, white, white, white,
black, black, black, black, black, black, black, white},
BitPos: 18,
},
},
{
Encoder: &Encoder{
Columns: 17,
},
Encoded: []byte{40, 49, 192, 0},
BitPos: 2,
Want: testResult{
PixelsRow: []byte{white, white, white, white, white, white, white, white, white,
black, black, black, black, black, black, black, white},
BitPos: 18,
},
},
{
Encoder: &Encoder{
Columns: 17,
},
Encoded: []byte{160, 199, 0},
BitPos: 0,
Want: testResult{
PixelsRow: []byte{white, white, white, white, white, white, white, white, white,
black, black, black, black, black, black, black, white},
BitPos: 16,
},
},
{
Encoder: &Encoder{
Columns: 17,
},
Encoded: []byte{160, 199, 7},
BitPos: 0,
Want: testResult{
PixelsRow: []byte{white, white, white, white, white, white, white, white, white,
black, black, black, black, black, black, black, white},
BitPos: 16,
},
},
{
Encoder: &Encoder{
Columns: 17,
},
Encoded: []byte{40, 49, 193, 192},
BitPos: 2,
Want: testResult{
PixelsRow: []byte{white, white, white, white, white, white, white, white, white,
black, black, black, black, black, black, black, white},
BitPos: 18,
},
},
{
Encoder: &Encoder{
Columns: 31,
},
Encoded: []byte{40, 49, 193, 192},
BitPos: 2,
Want: testResult{
PixelsRow: []byte{white, white, white, white, white, white, white, white, white,
black, black, black, black, black, black, black, white, black, black, black,
black, black, black, black, black, black, black, black, black, black, black},
BitPos: 26,
},
},
{
Encoder: &Encoder{
Columns: 31,
},
Encoded: []byte{160, 199, 7},
BitPos: 0,
Want: testResult{
PixelsRow: []byte{white, white, white, white, white, white, white, white, white,
black, black, black, black, black, black, black, white, black, black, black,
black, black, black, black, black, black, black, black, black, black, black},
BitPos: 24,
},
},
{
Encoder: &Encoder{
Columns: 31,
},
Encoded: []byte{160, 199, 7, 0},
BitPos: 0,
Want: testResult{
PixelsRow: []byte{white, white, white, white, white, white, white, white, white,
black, black, black, black, black, black, black, white, black, black, black,
black, black, black, black, black, black, black, black, black, black, black},
BitPos: 24,
},
},
{
Encoder: &Encoder{
Columns: 40,
},
Encoded: []byte{},
BitPos: 0,
Want: testResult{
PixelsRow: nil,
BitPos: 0,
},
},
{
Encoder: &Encoder{
Columns: 40,
},
Encoded: []byte{},
BitPos: 2,
Want: testResult{
PixelsRow: nil,
BitPos: 2,
},
},
{
Encoder: &Encoder{
Columns: 40,
},
Encoded: nil,
BitPos: 0,
Want: testResult{
PixelsRow: nil,
BitPos: 0,
},
},
{
Encoder: &Encoder{
Columns: 40,
},
Encoded: nil,
BitPos: 2,
Want: testResult{
PixelsRow: nil,
BitPos: 2,
},
},
}
resultsPixels := drawPixels(nil, true, 0)
resultsPixels = drawPixels(resultsPixels, false, 2486)
resultsPixels = drawPixels(resultsPixels, true, 6338)
resultsPixels = drawPixels(resultsPixels, false, 1)
tests = append(tests, testData{
Encoder: &Encoder{
Columns: 8825,
},
Encoded: []byte{53, 1, 208, 56, 1, 240, 31, 108, 58},
BitPos: 0,
Want: testResult{
PixelsRow: resultsPixels,
BitPos: 72,
},
})
tests = append(tests, testData{
Encoder: &Encoder{
Columns: 8825,
},
Encoded: []byte{53, 1, 208, 56, 1, 240, 31, 108, 58, 0},
BitPos: 0,
Want: testResult{
PixelsRow: resultsPixels,
BitPos: 72,
},
})
tests = append(tests, testData{
Encoder: &Encoder{
Columns: 8825,
},
Encoded: []byte{13, 64, 116, 14, 0, 124, 7, 219, 14, 128},
BitPos: 2,
Want: testResult{
PixelsRow: resultsPixels,
BitPos: 74,
},
})
tests = append(tests, testData{
Encoder: &Encoder{
Columns: 8825,
},
Encoded: []byte{13, 64, 116, 14, 0, 124, 7, 219, 14, 128, 0},
BitPos: 2,
Want: testResult{
PixelsRow: resultsPixels,
BitPos: 74,
},
})
for _, test := range tests {
gotPixelsRow, gotBitPos := test.Encoder.decodeRow1D(test.Encoded, test.BitPos)
if len(gotPixelsRow) != len(test.Want.PixelsRow) {
t.Errorf("Wrong pixels row len. Got %v, want %v\n",
len(gotPixelsRow), len(test.Want.PixelsRow))
} else {
for i := range gotPixelsRow {
if gotPixelsRow[i] != test.Want.PixelsRow[i] {
t.Errorf("Wrong value at %v. Got %v, want %v\n",
i, gotPixelsRow[i], test.Want.PixelsRow[i])
}
}
}
if gotBitPos != test.Want.BitPos {
t.Errorf("Wrong bit pos. Got %v, want %v\n", gotBitPos, test.Want.BitPos)
}
}
}
func TestTryFetchEOFB(t *testing.T) {
type testResult struct {
OK bool
BitPos int
Err error
}
tests := []struct {
Encoded []byte
BitPos int
Want testResult
}{
{
Encoded: []byte{0, 16, 1},
BitPos: 0,
Want: testResult{
OK: true,
BitPos: 24,
Err: nil,
},
},
{
Encoded: []byte{0, 16, 1, 0},
BitPos: 0,
Want: testResult{
OK: true,
BitPos: 24,
Err: nil,
},
},
{
Encoded: []byte{0, 4, 0, 64},
BitPos: 2,
Want: testResult{
OK: true,
BitPos: 26,
Err: nil,
},
},
{
Encoded: []byte{0, 4, 0, 64, 0},
BitPos: 2,
Want: testResult{
OK: true,
BitPos: 26,
Err: nil,
},
},
{
Encoded: []byte{0, 16, 0},
BitPos: 0,
Want: testResult{
OK: false,
BitPos: 0,
Err: errEOFBCorrupt,
},
},
{
Encoded: []byte{0, 1, 0},
BitPos: 0,
Want: testResult{
OK: false,
BitPos: 0,
Err: nil,
},
},
{
Encoded: []byte{0, 1, 0},
BitPos: 2,
Want: testResult{
OK: false,
BitPos: 2,
Err: nil,
},
},
}
for _, test := range tests {
gotOK, gotBitPos, gotErr := tryFetchEOFB(test.Encoded, test.BitPos)
if gotOK != test.Want.OK {
t.Errorf("Wrong ok. Got %v, want %v\n", gotOK, test.Want.OK)
}
if gotBitPos != test.Want.BitPos {
t.Errorf("Wrong bit pos. Got %v, want %v\n", gotBitPos, test.Want.BitPos)
}
if gotErr != test.Want.Err {
t.Errorf("Wrong err. Got %v, want %v\n", gotErr, test.Want.Err)
}
}
}
func TestTryFetchRTC2D(t *testing.T) {
type testResult struct {
OK bool
BitPos int
Err error
}
tests := []struct {
Encoded []byte
BitPos int
Want testResult
}{
{
Encoded: []byte{0, 24, 0, 192, 6, 0, 48, 1, 128, 12},
BitPos: 0,
Want: testResult{
OK: true,
BitPos: 78,
Err: nil,
},
},
{
Encoded: []byte{0, 6, 0, 48, 1, 128, 12, 0, 96, 3},
BitPos: 2,
Want: testResult{
OK: true,
BitPos: 80,
Err: nil,
},
},
{
Encoded: []byte{0, 24, 0, 0, 0},
BitPos: 0,
Want: testResult{
OK: false,
BitPos: 0,
Err: nil,
},
},
{
Encoded: []byte{0, 6, 0, 0, 0},
BitPos: 2,
Want: testResult{
OK: false,
BitPos: 2,
Err: nil,
},
},
{
Encoded: []byte{0, 24, 0, 192, 0, 0, 0},
BitPos: 0,
Want: testResult{
OK: false,
BitPos: 0,
Err: errRTCCorrupt,
},
},
{
Encoded: []byte{0, 6, 0, 48, 0, 0, 0},
BitPos: 2,
Want: testResult{
OK: false,
BitPos: 2,
Err: errRTCCorrupt,
},
},
{
Encoded: []byte{0, 24, 0, 192, 6, 0, 0, 0},
BitPos: 0,
Want: testResult{
OK: false,
BitPos: 0,
Err: errRTCCorrupt,
},
},
{
Encoded: []byte{0, 6, 0, 48, 1, 128, 0, 0, 0},
BitPos: 2,
Want: testResult{
OK: false,
BitPos: 2,
Err: errRTCCorrupt,
},
},
{
Encoded: []byte{0, 24, 0, 192, 6, 0, 48, 0, 0, 0},
BitPos: 0,
Want: testResult{
OK: false,
BitPos: 0,
Err: errRTCCorrupt,
},
},
{
Encoded: []byte{0, 6, 0, 48, 1, 128, 12, 0, 0, 0},
BitPos: 2,
Want: testResult{
OK: false,
BitPos: 2,
Err: errRTCCorrupt,
},
},
{
Encoded: []byte{0, 24, 0, 192, 6, 0, 48, 1, 128, 0, 0, 0},
BitPos: 0,
Want: testResult{
OK: false,
BitPos: 0,
Err: errRTCCorrupt,
},
},
{
Encoded: []byte{0, 6, 0, 48, 1, 128, 12, 0, 96, 0, 0, 0},
BitPos: 2,
Want: testResult{
OK: false,
BitPos: 2,
Err: errRTCCorrupt,
},
},
{
Encoded: []byte{},
BitPos: 0,
Want: testResult{
OK: false,
BitPos: 0,
Err: nil,
},
},
{
Encoded: []byte{},
BitPos: 2,
Want: testResult{
OK: false,
BitPos: 2,
Err: nil,
},
},
{
Encoded: nil,
BitPos: 0,
Want: testResult{
OK: false,
BitPos: 0,
Err: nil,
},
},
{
Encoded: nil,
BitPos: 2,
Want: testResult{
OK: false,
BitPos: 2,
Err: nil,
},
},
}
for _, test := range tests {
gotOK, gotBitPos, gotErr := tryFetchRTC2D(test.Encoded, test.BitPos)
if gotOK != test.Want.OK {
t.Errorf("Wrong ok. Got %v, want %v\n", gotOK, test.Want.OK)
}
if gotBitPos != test.Want.BitPos {
t.Errorf("Wrong bit pos. Got %v, want %v\n", gotBitPos, test.Want.BitPos)
}
if gotErr != test.Want.Err {
t.Errorf("Wrong err. Got %v, want %v\n", gotErr, test.Want.Err)
}
}
}
func TestFetchNext2DCode(t *testing.T) {
type testResult struct {
Code code
BitPos int
OK bool
}
tests := []struct {
Data []byte
BitPos int
Want testResult
}{
{
Data: []byte{16},
BitPos: 0,
Want: testResult{
Code: p,
BitPos: 4,
OK: true,
},
},
{
Data: []byte{4},
BitPos: 2,
Want: testResult{
Code: p,
BitPos: 6,
OK: true,
},
},
{
Data: []byte{16, 0},
BitPos: 0,
Want: testResult{
Code: p,
BitPos: 4,
OK: true,
},
},
{
Data: []byte{4, 0},
BitPos: 2,
Want: testResult{
Code: p,
BitPos: 6,
OK: true,
},
},
{
Data: []byte{32},
BitPos: 0,
Want: testResult{
Code: h,
BitPos: 3,
OK: true,
},
},
{
Data: []byte{8},
BitPos: 2,
Want: testResult{
Code: h,
BitPos: 5,
OK: true,
},
},
{
Data: []byte{32, 0},
BitPos: 0,
Want: testResult{
Code: h,
BitPos: 3,
OK: true,
},
},
{
Data: []byte{8, 0},
BitPos: 2,
Want: testResult{
Code: h,
BitPos: 5,
OK: true,
},
},
{
Data: []byte{128},
BitPos: 0,
Want: testResult{
Code: v0,
BitPos: 1,
OK: true,
},
},
{
Data: []byte{32},
BitPos: 2,
Want: testResult{
Code: v0,
BitPos: 3,
OK: true,
},
},
{
Data: []byte{128, 0},
BitPos: 0,
Want: testResult{
Code: v0,
BitPos: 1,
OK: true,
},
},
{
Data: []byte{32, 0},
BitPos: 2,
Want: testResult{
Code: v0,
BitPos: 3,
OK: true,
},
},
{
Data: []byte{96},
BitPos: 0,
Want: testResult{
Code: v1r,
BitPos: 3,
OK: true,
},
},
{
Data: []byte{24},
BitPos: 2,
Want: testResult{
Code: v1r,
BitPos: 5,
OK: true,
},
},
{
Data: []byte{96, 0},
BitPos: 0,
Want: testResult{
Code: v1r,
BitPos: 3,
OK: true,
},
},
{
Data: []byte{24, 0},
BitPos: 2,
Want: testResult{
Code: v1r,
BitPos: 5,
OK: true,
},
},
{
Data: []byte{12},
BitPos: 0,
Want: testResult{
Code: v2r,
BitPos: 6,
OK: true,
},
},
{
Data: []byte{3},
BitPos: 2,
Want: testResult{
Code: v2r,
BitPos: 8,
OK: true,
},
},
{
Data: []byte{12, 0},
BitPos: 0,
Want: testResult{
Code: v2r,
BitPos: 6,
OK: true,
},
},
{
Data: []byte{3, 0},
BitPos: 2,
Want: testResult{
Code: v2r,
BitPos: 8,
OK: true,
},
},
{
Data: []byte{6},
BitPos: 0,
Want: testResult{
Code: v3r,
BitPos: 7,
OK: true,
},
},
{
Data: []byte{1, 128},
BitPos: 2,
Want: testResult{
Code: v3r,
BitPos: 9,
OK: true,
},
},
{
Data: []byte{6, 0},
BitPos: 0,
Want: testResult{
Code: v3r,
BitPos: 7,
OK: true,
},
},
{
Data: []byte{1, 128, 0},
BitPos: 2,
Want: testResult{
Code: v3r,
BitPos: 9,
OK: true,
},
},
{
Data: []byte{64},
BitPos: 0,
Want: testResult{
Code: v1l,
BitPos: 3,
OK: true,
},
},
{
Data: []byte{16},
BitPos: 2,
Want: testResult{
Code: v1l,
BitPos: 5,
OK: true,
},
},
{
Data: []byte{64, 0},
BitPos: 0,
Want: testResult{
Code: v1l,
BitPos: 3,
OK: true,
},
},
{
Data: []byte{16, 0},
BitPos: 2,
Want: testResult{
Code: v1l,
BitPos: 5,
OK: true,
},
},
{
Data: []byte{8},
BitPos: 0,
Want: testResult{
Code: v2l,
BitPos: 6,
OK: true,
},
},
{
Data: []byte{2},
BitPos: 2,
Want: testResult{
Code: v2l,
BitPos: 8,
OK: true,
},
},
{
Data: []byte{8, 0},
BitPos: 0,
Want: testResult{
Code: v2l,
BitPos: 6,
OK: true,
},
},
{
Data: []byte{2, 0},
BitPos: 2,
Want: testResult{
Code: v2l,
BitPos: 8,
OK: true,
},
},
{
Data: []byte{4},
BitPos: 0,
Want: testResult{
Code: v3l,
BitPos: 7,
OK: true,
},
},
{
Data: []byte{1, 0},
BitPos: 2,
Want: testResult{
Code: v3l,
BitPos: 9,
OK: true,
},
},
{
Data: []byte{0, 0, 0},
BitPos: 0,
Want: testResult{
Code: code{},
BitPos: 0,
OK: false,
},
},
{
Data: []byte{0, 0, 0},
BitPos: 2,
Want: testResult{
Code: code{},
BitPos: 2,
OK: false,
},
},
{
Data: []byte{0},
BitPos: 0,
Want: testResult{
Code: code{},
BitPos: 0,
OK: false,
},
},
{
Data: []byte{0},
BitPos: 2,
Want: testResult{
Code: code{},
BitPos: 2,
OK: false,
},
},
{
Data: []byte{},
BitPos: 0,
Want: testResult{
Code: code{},
BitPos: 0,
OK: false,
},
},
{
Data: []byte{},
BitPos: 2,
Want: testResult{
Code: code{},
BitPos: 2,
OK: false,
},
},
{
Data: nil,
BitPos: 0,
Want: testResult{
Code: code{},
BitPos: 0,
OK: false,
},
},
{
Data: nil,
BitPos: 2,
Want: testResult{
Code: code{},
BitPos: 2,
OK: false,
},
},
}
for _, test := range tests {
gotCode, gotBitPos, gotOK := fetchNext2DCode(test.Data, test.BitPos)
if gotCode != test.Want.Code {
t.Errorf("Wrong code. Got %v, want %v\n", gotCode, test.Want.Code)
}
if gotBitPos != test.Want.BitPos {
t.Errorf("Wrong bit pos. Got %v, want %v\n", gotBitPos, test.Want.BitPos)
}
if gotOK != test.Want.OK {
t.Errorf("Wrong ok. Got %v, want %v\n", gotOK, test.Want.OK)
}
}
}
func TestGet2DCodeFromUint16(t *testing.T) {
type testResult struct {
Code code
OK bool
}
tests := []struct {
Codes []uint16
BitPos int
Want testResult
}{
{
Codes: formTestCodes(4096, 4),
BitPos: 0,
Want: testResult{
Code: p,
OK: true,
},
},
{
Codes: formTestCodes(8192, 3),
BitPos: 0,
Want: testResult{
Code: h,
OK: true,
},
},
{
Codes: formTestCodes(32768, 1),
BitPos: 0,
Want: testResult{
Code: v0,
OK: true,
},
},
{
Codes: formTestCodes(24576, 3),
BitPos: 0,
Want: testResult{
Code: v1r,
OK: true,
},
},
{
Codes: formTestCodes(3072, 6),
BitPos: 0,
Want: testResult{
Code: v2r,
OK: true,
},
},
{
Codes: formTestCodes(1536, 7),
BitPos: 0,
Want: testResult{
Code: v3r,
OK: true,
},
},
{
Codes: formTestCodes(16384, 3),
BitPos: 0,
Want: testResult{
Code: v1l,
OK: true,
},
},
{
Codes: formTestCodes(2048, 6),
BitPos: 0,
Want: testResult{
Code: v2l,
OK: true,
},
},
{
Codes: formTestCodes(1024, 7),
BitPos: 0,
Want: testResult{
Code: v3l,
OK: true,
},
},
{
Codes: []uint16{0, 0, 0},
BitPos: 0,
Want: testResult{
Code: code{},
OK: false,
},
},
}
for _, test := range tests {
for _, code := range test.Codes {
gotCode, gotOK := get2DCodeFromUint16(code, test.BitPos)
if gotCode != test.Want.Code {
t.Errorf("Wrong code. Got %v, want %v\n", gotCode, test.Want.Code)
}
if gotOK != test.Want.OK {
t.Errorf("Wrong ok. Got %v, want %v\n", gotOK, test.Want.OK)
}
}
}
}
func TestFetchNextRunLen(t *testing.T) {
type testResult struct {
RunLen int
BitPos int
}
tests := []struct {
Data []byte
BitPos int
IsWhite bool
Want testResult
}{
{
Data: []byte{0, 0, 0},
BitPos: 0,
IsWhite: true,
Want: testResult{
RunLen: -1,
BitPos: 0,
},
},
{
Data: []byte{0, 0, 0},
BitPos: 2,
IsWhite: true,
Want: testResult{
RunLen: -1,
BitPos: 2,
},
},
{
Data: []byte{0, 0, 0},
BitPos: 0,
IsWhite: false,
Want: testResult{
RunLen: -1,
BitPos: 0,
},
},
{
Data: []byte{0, 0, 0},
BitPos: 2,
IsWhite: false,
Want: testResult{
RunLen: -1,
BitPos: 2,
},
},
{
Data: []byte{},
BitPos: 0,
IsWhite: true,
Want: testResult{
RunLen: -1,
BitPos: 0,
},
},
{
Data: []byte{},
BitPos: 2,
IsWhite: true,
Want: testResult{
RunLen: -1,
BitPos: 2,
},
},
{
Data: []byte{},
BitPos: 0,
IsWhite: false,
Want: testResult{
RunLen: -1,
BitPos: 0,
},
},
{
Data: []byte{},
BitPos: 2,
IsWhite: false,
Want: testResult{
RunLen: -1,
BitPos: 2,
},
},
{
Data: nil,
BitPos: 0,
IsWhite: true,
Want: testResult{
RunLen: -1,
BitPos: 0,
},
},
{
Data: nil,
BitPos: 2,
IsWhite: true,
Want: testResult{
RunLen: -1,
BitPos: 2,
},
},
{
Data: nil,
BitPos: 0,
IsWhite: false,
Want: testResult{
RunLen: -1,
BitPos: 0,
},
},
{
Data: nil,
BitPos: 2,
IsWhite: false,
Want: testResult{
RunLen: -1,
BitPos: 2,
},
},
{
Data: []byte{0, 29, 255},
BitPos: 4,
IsWhite: true,
Want: testResult{
RunLen: 2432,
BitPos: 16,
},
},
{
Data: []byte{0, 29, 255},
BitPos: 4,
IsWhite: false,
Want: testResult{
RunLen: 2432,
BitPos: 16,
},
},
{
Data: []byte{0, 29, 0},
BitPos: 4,
IsWhite: true,
Want: testResult{
RunLen: 2432,
BitPos: 16,
},
},
{
Data: []byte{0, 29, 0},
BitPos: 4,
IsWhite: false,
Want: testResult{
RunLen: 2432,
BitPos: 16,
},
},
{
Data: []byte{1, 223, 255},
BitPos: 0,
IsWhite: true,
Want: testResult{
RunLen: 2432,
BitPos: 12,
},
},
{
Data: []byte{1, 223, 255},
BitPos: 0,
IsWhite: false,
Want: testResult{
RunLen: 2432,
BitPos: 12,
},
},
{
Data: []byte{1, 223, 0},
BitPos: 0,
IsWhite: true,
Want: testResult{
RunLen: 2432,
BitPos: 12,
},
},
{
Data: []byte{1, 223, 0},
BitPos: 0,
IsWhite: false,
Want: testResult{
RunLen: 2432,
BitPos: 12,
},
},
{
Data: []byte{168},
BitPos: 0,
IsWhite: true,
Want: testResult{
RunLen: 16,
BitPos: 6,
},
},
{
Data: []byte{168, 0},
BitPos: 0,
IsWhite: true,
Want: testResult{
RunLen: 16,
BitPos: 6,
},
},
{
Data: []byte{84},
BitPos: 1,
IsWhite: true,
Want: testResult{
RunLen: 16,
BitPos: 7,
},
},
{
Data: []byte{12, 192},
BitPos: 0,
IsWhite: false,
Want: testResult{
RunLen: 28,
BitPos: 12,
},
},
{
Data: []byte{12, 192, 0},
BitPos: 0,
IsWhite: false,
Want: testResult{
RunLen: 28,
BitPos: 12,
},
},
{
Data: []byte{3, 48},
BitPos: 2,
IsWhite: false,
Want: testResult{
RunLen: 28,
BitPos: 14,
},
},
{
Data: []byte{3, 48, 0},
BitPos: 2,
IsWhite: false,
Want: testResult{
RunLen: 28,
BitPos: 14,
},
},
{
Data: []byte{107, 128},
BitPos: 0,
IsWhite: true,
Want: testResult{
RunLen: 1152,
BitPos: 9,
},
},
{
Data: []byte{107, 128, 0},
BitPos: 0,
IsWhite: true,
Want: testResult{
RunLen: 1152,
BitPos: 9,
},
},
{
Data: []byte{26, 224},
BitPos: 2,
IsWhite: true,
Want: testResult{
RunLen: 1152,
BitPos: 11,
},
},
{
Data: []byte{26, 224, 0},
BitPos: 2,
IsWhite: true,
Want: testResult{
RunLen: 1152,
BitPos: 11,
},
},
{
Data: []byte{2, 104},
BitPos: 0,
IsWhite: false,
Want: testResult{
RunLen: 832,
BitPos: 13,
},
},
{
Data: []byte{2, 104, 0},
BitPos: 0,
IsWhite: false,
Want: testResult{
RunLen: 832,
BitPos: 13,
},
},
{
Data: []byte{0, 154},
BitPos: 2,
IsWhite: false,
Want: testResult{
RunLen: 832,
BitPos: 15,
},
},
{
Data: []byte{0, 154, 0},
BitPos: 2,
IsWhite: false,
Want: testResult{
RunLen: 832,
BitPos: 15,
},
},
}
for _, test := range tests {
gotRunLen, gotBitPos := fetchNextRunLen(test.Data, test.BitPos, test.IsWhite)
if gotRunLen != test.Want.RunLen {
t.Errorf("Wrong run len. Got %v, want %v\n", gotRunLen, test.Want.RunLen)
}
if gotBitPos != test.Want.BitPos {
t.Errorf("Wrong bit pos. Got %v, want %v\n", gotBitPos, test.Want.BitPos)
}
}
}
func TestDrawPixels(t *testing.T) {
tests := []struct {
Row []byte
IsWhite bool
Length int
Want []byte
}{
{
Row: nil,
IsWhite: true,
Length: 2,
Want: []byte{white, white},
},
{
Row: nil,
IsWhite: false,
Length: 2,
Want: []byte{black, black},
},
{
Row: nil,
IsWhite: true,
Length: 3,
Want: []byte{white, white, white},
},
{
Row: nil,
IsWhite: false,
Length: 3,
Want: []byte{black, black, black},
},
{
Row: nil,
IsWhite: true,
Length: 0,
Want: nil,
},
{
Row: nil,
IsWhite: false,
Length: 0,
Want: nil,
},
{
Row: nil,
IsWhite: true,
Length: -1,
Want: nil,
},
{
Row: nil,
IsWhite: false,
Length: -1,
Want: nil,
},
{
Row: []byte{},
IsWhite: true,
Length: 2,
Want: []byte{white, white},
},
{
Row: []byte{},
IsWhite: false,
Length: 2,
Want: []byte{black, black},
},
{
Row: []byte{},
IsWhite: true,
Length: 3,
Want: []byte{white, white, white},
},
{
Row: []byte{},
IsWhite: false,
Length: 3,
Want: []byte{black, black, black},
},
{
Row: []byte{},
IsWhite: true,
Length: 0,
Want: []byte{},
},
{
Row: []byte{},
IsWhite: false,
Length: 0,
Want: []byte{},
},
{
Row: []byte{},
IsWhite: true,
Length: -1,
Want: []byte{},
},
{
Row: []byte{},
IsWhite: false,
Length: -1,
Want: []byte{},
},
{
Row: []byte{white, white},
IsWhite: true,
Length: 2,
Want: []byte{white, white, white, white},
},
{
Row: []byte{white, white},
IsWhite: false,
Length: 2,
Want: []byte{white, white, black, black},
},
{
Row: []byte{white, white, black},
IsWhite: true,
Length: 3,
Want: []byte{white, white, black, white, white, white},
},
{
Row: []byte{black, black, white},
IsWhite: false,
Length: 3,
Want: []byte{black, black, white, black, black, black},
},
{
Row: []byte{white, black},
IsWhite: true,
Length: 0,
Want: []byte{white, black},
},
{
Row: []byte{white, black},
IsWhite: false,
Length: 0,
Want: []byte{white, black},
},
{
Row: []byte{black, white},
IsWhite: true,
Length: -1,
Want: []byte{black, white},
},
{
Row: []byte{black, white},
IsWhite: false,
Length: -1,
Want: []byte{black, white},
},
}
for _, test := range tests {
got := drawPixels(test.Row, test.IsWhite, test.Length)
if len(got) != len(test.Want) {
t.Errorf("Wrong len. Got %v, want %v\n", len(got), len(test.Want))
} else {
for i := range got {
if got[i] != test.Want[i] {
t.Errorf("Wron pixel at %v. Got %v, want %v\n", i, got[i], test.Want[i])
}
}
}
}
}
func TestTryFetchEOL(t *testing.T) {
type testResult struct {
OK bool
BitPos int
}
tests := []struct {
Encoded []byte
BitPos int
Want testResult
}{
{
Encoded: []byte{0, 16},
BitPos: 0,
Want: testResult{
OK: true,
BitPos: 12,
},
},
{
Encoded: []byte{0, 16},
BitPos: 1,
Want: testResult{
OK: false,
BitPos: 1,
},
},
{
Encoded: []byte{128, 8},
BitPos: 0,
Want: testResult{
OK: false,
BitPos: 0,
},
},
{
Encoded: []byte{128, 8},
BitPos: 1,
Want: testResult{
OK: true,
BitPos: 13,
},
},
{
Encoded: []byte{0},
BitPos: 0,
Want: testResult{
OK: false,
BitPos: 0,
},
},
{
Encoded: []byte{},
BitPos: 0,
Want: testResult{
OK: false,
BitPos: 0,
},
},
{
Encoded: nil,
BitPos: 0,
Want: testResult{
OK: false,
BitPos: 0,
},
},
}
for _, test := range tests {
gotOK, gotBitPos := tryFetchEOL(test.Encoded, test.BitPos)
if gotOK != test.Want.OK {
t.Errorf("Wrong ok. Got %v, want %v\n", gotOK, test.Want.OK)
}
if gotBitPos != test.Want.BitPos {
t.Errorf("Wrong bit pos. Got %v, want %v\n", gotBitPos, test.Want.BitPos)
}
}
}
func TestTryFetchEOL0(t *testing.T) {
type testResult struct {
OK bool
BitPos int
}
tests := []struct {
Encoded []byte
BitPos int
Want testResult
}{
{
Encoded: []byte{0, 16},
BitPos: 0,
Want: testResult{
OK: true,
BitPos: 13,
},
},
{
Encoded: []byte{0, 16},
BitPos: 1,
Want: testResult{
OK: false,
BitPos: 1,
},
},
{
Encoded: []byte{128, 8},
BitPos: 0,
Want: testResult{
OK: false,
BitPos: 0,
},
},
{
Encoded: []byte{128, 8},
BitPos: 1,
Want: testResult{
OK: true,
BitPos: 14,
},
},
{
Encoded: []byte{0},
BitPos: 0,
Want: testResult{
OK: false,
BitPos: 0,
},
},
{
Encoded: []byte{},
BitPos: 0,
Want: testResult{
OK: false,
BitPos: 0,
},
},
{
Encoded: nil,
BitPos: 0,
Want: testResult{
OK: false,
BitPos: 0,
},
},
}
for _, test := range tests {
gotOK, gotBitPos := tryFetchEOL0(test.Encoded, test.BitPos)
if gotOK != test.Want.OK {
t.Errorf("Wrong ok. Got %v, want %v\n", gotOK, test.Want.OK)
}
if gotBitPos != test.Want.BitPos {
t.Errorf("Wrong bit pos. Got %v, want %v\n", gotBitPos, test.Want.BitPos)
}
}
}
func TestTryFetchEOL1(t *testing.T) {
type testResult struct {
OK bool
BitPos int
}
tests := []struct {
Encoded []byte
BitPos int
Want testResult
}{
{
Encoded: []byte{0, 24},
BitPos: 0,
Want: testResult{
OK: true,
BitPos: 13,
},
},
{
Encoded: []byte{0, 24},
BitPos: 1,
Want: testResult{
OK: false,
BitPos: 1,
},
},
{
Encoded: []byte{128, 12},
BitPos: 0,
Want: testResult{
OK: false,
BitPos: 0,
},
},
{
Encoded: []byte{128, 12},
BitPos: 1,
Want: testResult{
OK: true,
BitPos: 14,
},
},
{
Encoded: []byte{0},
BitPos: 0,
Want: testResult{
OK: false,
BitPos: 0,
},
},
{
Encoded: []byte{},
BitPos: 0,
Want: testResult{
OK: false,
BitPos: 0,
},
},
{
Encoded: nil,
BitPos: 0,
Want: testResult{
OK: false,
BitPos: 0,
},
},
}
for _, test := range tests {
gotOK, gotBitPos := tryFetchEOL1(test.Encoded, test.BitPos)
if gotOK != test.Want.OK {
t.Errorf("Wrong ok. Got %v, want %v\n", gotOK, test.Want.OK)
}
if gotBitPos != test.Want.BitPos {
t.Errorf("Wrong bit pos. Got %v, want %v\n", gotBitPos, test.Want.BitPos)
}
}
}
func TestBitFromUint16(t *testing.T) {
type testData struct {
Num uint16
BitPos int
Want byte
}
var tests []testData
var num uint16 = 43690
for i := 0; i < 16; i++ {
var want byte = 1
if (i % 2) != 0 {
want = 0
}
tests = append(tests, testData{
Num: num,
BitPos: i,
Want: want,
})
}
for _, test := range tests {
bit := bitFromUint16(test.Num, test.BitPos)
if bit != test.Want {
t.Errorf("Wrong bit. Got %v want %v\n", bit, test.Want)
}
}
}
func TestFetchNextCode(t *testing.T) {
testData := []byte{95, 21, 197}
type testResult struct {
Code uint16
CodeBitPos int
DataBitPos int
}
tests := []struct {
Data []byte
BitPos int
Want testResult
}{
{
Data: testData,
BitPos: 0,
Want: testResult{
Code: 24341,
CodeBitPos: 0,
DataBitPos: 16,
},
},
{
Data: testData,
BitPos: 1,
Want: testResult{
Code: 48683,
CodeBitPos: 0,
DataBitPos: 17,
},
},
{
Data: testData,
BitPos: 2,
Want: testResult{
Code: 31831,
CodeBitPos: 0,
DataBitPos: 18,
},
},
{
Data: testData,
BitPos: 3,
Want: testResult{
Code: 63662,
CodeBitPos: 0,
DataBitPos: 19,
},
},
{
Data: testData,
BitPos: 4,
Want: testResult{
Code: 61788,
CodeBitPos: 0,
DataBitPos: 20,
},
},
{
Data: testData,
BitPos: 5,
Want: testResult{
Code: 58040,
CodeBitPos: 0,
DataBitPos: 21,
},
},
{
Data: testData,
BitPos: 6,
Want: testResult{
Code: 50545,
CodeBitPos: 0,
DataBitPos: 22,
},
},
{
Data: testData,
BitPos: 7,
Want: testResult{
Code: 35554,
CodeBitPos: 0,
DataBitPos: 23,
},
},
{
Data: testData,
BitPos: 8,
Want: testResult{
Code: 5573,
CodeBitPos: 0,
DataBitPos: 24,
},
},
{
Data: testData,
BitPos: 9,
Want: testResult{
Code: 5573,
CodeBitPos: 1,
DataBitPos: 24,
},
},
{
Data: testData,
BitPos: 10,
Want: testResult{
Code: 5573,
CodeBitPos: 2,
DataBitPos: 24,
},
},
{
Data: testData,
BitPos: 11,
Want: testResult{
Code: 5573,
CodeBitPos: 3,
DataBitPos: 24,
},
},
{
Data: testData,
BitPos: 12,
Want: testResult{
Code: 1477,
CodeBitPos: 4,
DataBitPos: 24,
},
},
{
Data: testData,
BitPos: 13,
Want: testResult{
Code: 1477,
CodeBitPos: 5,
DataBitPos: 24,
},
},
{
Data: testData,
BitPos: 14,
Want: testResult{
Code: 453,
CodeBitPos: 6,
DataBitPos: 24,
},
},
{
Data: testData,
BitPos: 15,
Want: testResult{
Code: 453,
CodeBitPos: 7,
DataBitPos: 24,
},
},
{
Data: testData,
BitPos: 16,
Want: testResult{
Code: 197,
CodeBitPos: 8,
DataBitPos: 24,
},
},
{
Data: testData,
BitPos: 17,
Want: testResult{
Code: 69,
CodeBitPos: 9,
DataBitPos: 24,
},
},
{
Data: testData,
BitPos: 18,
Want: testResult{
Code: 5,
CodeBitPos: 10,
DataBitPos: 24,
},
},
{
Data: testData,
BitPos: 19,
Want: testResult{
Code: 5,
CodeBitPos: 11,
DataBitPos: 24,
},
},
{
Data: testData,
BitPos: 20,
Want: testResult{
Code: 5,
CodeBitPos: 12,
DataBitPos: 24,
},
},
{
Data: testData,
BitPos: 21,
Want: testResult{
Code: 5,
CodeBitPos: 13,
DataBitPos: 24,
},
},
{
Data: testData,
BitPos: 22,
Want: testResult{
Code: 1,
CodeBitPos: 14,
DataBitPos: 24,
},
},
{
Data: testData,
BitPos: 23,
Want: testResult{
Code: 1,
CodeBitPos: 15,
DataBitPos: 24,
},
},
{
Data: testData,
BitPos: 24,
Want: testResult{
Code: 0,
CodeBitPos: 16,
DataBitPos: 24,
},
},
}
for _, test := range tests {
gotCode, gotCodeBitPos, gotDataBitPos := fetchNextCode(test.Data, test.BitPos)
if gotCode != test.Want.Code {
t.Errorf("Wrong code. Got %v, want %v\n", gotCode, test.Want.Code)
}
if gotCodeBitPos != test.Want.CodeBitPos {
t.Errorf("Wrong code bit pos. Got %v, want %v\n", gotCodeBitPos, test.Want.CodeBitPos)
}
if gotDataBitPos != test.Want.DataBitPos {
t.Errorf("Wrong data bit pos. Got %v, want %v\n", gotDataBitPos, test.Want.DataBitPos)
}
}
}
Reference in New Issue View Git Blame Copy Permalink