From: Anton Rudenko Date: Thu, 30 Jan 2025 12:39:08 +0000 (+0300) Subject: test changes X-Git-Url: http://www.git.cypherpunks.su/?a=commitdiff_plain;h=e56ae45fa2e26dc2f25df2b143f19057f17d374d8026507d3d19b15f129b1a24;p=keks.git test changes --- diff --git a/go/bin_test.go b/go/bin_test.go index 05a934b..31a455f 100644 --- a/go/bin_test.go +++ b/go/bin_test.go @@ -17,11 +17,9 @@ package keks import ( "bytes" - "crypto/rand" "encoding/hex" "io" "reflect" - "slices" "strings" "testing" "testing/quick" @@ -29,171 +27,198 @@ import ( func TestBinaryEmpty(t *testing.T) { object := []byte{} - hexstring := mustHexDec("80") - decoder := NewDecoderFromBytes(hexstring, nil) + binstring := mustHexDec("80") + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != nil { + t.Fatalf("error during decode: %s", err) + } encoded, err := EncodeBuf(object, nil) if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during encode: %s", err) } - if !bytes.Equal(encoded, hexstring) { - t.Errorf("expected hexstring %s, got %s", hex.EncodeToString(hexstring), hex.EncodeToString(encoded)) + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected binstring %s, got %s", hex.EncodeToString(binstring), hex.EncodeToString(encoded)) } - decoded, err := decoder.Decode() if err != nil { - t.Errorf("error during decode: %s", err) + t.Fatalf("error during decode: %s", err) + } + udecoded, ok := decoded.([]byte) + if !ok { + t.Fatalf("failed to cast") } - if !bytes.Equal(decoded.([]byte), object) { + if !bytes.Equal(udecoded, object) { t.Logf("expected type %s, value %s", reflect.TypeOf(object), object) t.Logf("got type %s, value %s", reflect.TypeOf(decoded), decoded) - t.Error() + t.FailNow() } } func TestBinary1234(t *testing.T) { object := []byte{0x01, 0x02, 0x03, 0x04} - hexstring := mustHexDec("8401020304") - decoder := NewDecoderFromBytes(hexstring, nil) + binstring := mustHexDec("8401020304") + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != nil { + t.Fatalf("error during decode: %s", err) + } encoded, err := EncodeBuf(object, nil) if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during encode: %s", err) } - if !bytes.Equal(encoded, hexstring) { - t.Errorf("expected hexstring %s, got %s", hex.EncodeToString(hexstring), hex.EncodeToString(encoded)) + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected binstring %s, got %s", hex.EncodeToString(binstring), hex.EncodeToString(encoded)) } - decoded, err := decoder.Decode() if err != nil { - t.Errorf("error during decode: %s", err) + t.Fatalf("error during decode: %s", err) } - if !bytes.Equal(decoded.([]byte), object) { + udecoded, ok := decoded.([]byte) + if !ok { + t.Fatalf("failed to cast") + } + if !bytes.Equal(udecoded, object) { t.Logf("expected type %s, value %s", reflect.TypeOf(object), object) - t.Logf("got type %s, value %s", reflect.TypeOf(decoded), decoded) - t.Error() + t.Logf("got type %s, value %s", reflect.TypeOf(udecoded), udecoded) + t.FailNow() } } func TestBinaryLen62(t *testing.T) { object := bytes.Repeat([]byte{'a'}, 62) - hexstring := mustHexDec("BD01" + strings.Repeat("61", 62)) - decoder := NewDecoderFromBytes(hexstring, nil) + binstring := mustHexDec("BD01" + strings.Repeat("61", 62)) + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != nil { + t.Fatalf("error during decode: %s", err) + } encoded, err := EncodeBuf(object, nil) if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during encode: %s", err) } - if !bytes.Equal(encoded, hexstring) { - t.Errorf("expected hexstring %s, got %s", hex.EncodeToString(hexstring), hex.EncodeToString(encoded)) + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected binstring %s, got %s", hex.EncodeToString(binstring), hex.EncodeToString(encoded)) } - decoded, err := decoder.Decode() if err != nil { - t.Errorf("error during decode: %s", err) + t.Fatalf("error during decode: %s", err) + } + udecoded, ok := decoded.([]byte) + if !ok { + t.Fatalf("failed to cast") } - if !bytes.Equal(decoded.([]byte), object) { + if !bytes.Equal(udecoded, object) { t.Logf("expected type %s, value %s", reflect.TypeOf(object), object) - t.Logf("got type %s, value %s", reflect.TypeOf(decoded), decoded) - t.Error() + t.Logf("got type %s, value %s", reflect.TypeOf(udecoded), udecoded) + t.FailNow() } } func TestBinaryLen318(t *testing.T) { object := bytes.Repeat([]byte{'a'}, 318) - hexstring := mustHexDec("BE0001" + strings.Repeat("61", 318)) - decoder := NewDecoderFromBytes(hexstring, nil) + binstring := mustHexDec("BE0001" + strings.Repeat("61", 318)) + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != nil { + t.Fatalf("error during decode: %s", err) + } encoded, err := EncodeBuf(object, nil) if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during encode: %s", err) } - if !bytes.Equal(encoded, hexstring) { - t.Errorf("expected hexstring %s, got %s", hex.EncodeToString(hexstring), hex.EncodeToString(encoded)) + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected binstring %s, got %s", hex.EncodeToString(binstring), hex.EncodeToString(encoded)) } - decoded, err := decoder.Decode() if err != nil { - t.Errorf("error during decode: %s", err) + t.Fatalf("error during decode: %s", err) } - if !bytes.Equal(decoded.([]byte), object) { + udecoded, ok := decoded.([]byte) + if !ok { + t.Fatalf("failed to cast") + } + if !bytes.Equal(udecoded, object) { t.Logf("expected type %s, value %s", reflect.TypeOf(object), object) - t.Logf("got type %s, value %s", reflect.TypeOf(decoded), decoded) - t.Error() + t.Logf("got type %s, value %s", reflect.TypeOf(udecoded), udecoded) + t.FailNow() } } func TestBinaryLen65853(t *testing.T) { object := bytes.Repeat([]byte{'a'}, 65853) - hexstring := mustHexDec("BF0000000000000000" + strings.Repeat("61", 65853)) - decoder := NewDecoderFromBytes(hexstring, nil) + binstring := mustHexDec("BF0000000000000000" + strings.Repeat("61", 65853)) + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != nil { + t.Fatalf("error during decode: %s", err) + } encoded, err := EncodeBuf(object, nil) if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during encode: %s", err) } - if !bytes.Equal(encoded, hexstring) { - t.Errorf("expected hexstring %s, got %s", hex.EncodeToString(hexstring), hex.EncodeToString(encoded)) + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected binstring %s, got %s", hex.EncodeToString(binstring), hex.EncodeToString(encoded)) } - decoded, err := decoder.Decode() if err != nil { - t.Errorf("error during decode: %s", err) + t.Fatalf("error during decode: %s", err) + } + udecoded, ok := decoded.([]byte) + if !ok { + t.Fatalf("failed to cast") } - if !bytes.Equal(decoded.([]byte), object) { + if !bytes.Equal(udecoded, object) { t.Logf("expected type %s, value %s", reflect.TypeOf(object), object) - t.Logf("got type %s, value %s", reflect.TypeOf(decoded), decoded) - t.Error() + t.Logf("got type %s, value %s", reflect.TypeOf(udecoded), udecoded) + t.FailNow() } } func TestBinaryThrowsWhenNotEnoughData(t *testing.T) { - hexstring := mustHexDec("84010203") - decoder := NewDecoderFromBytes(hexstring, nil) - _, err := decoder.Decode() + binstring := mustHexDec("84010203") + _, err := NewDecoderFromBytes(binstring, nil).Decode() if err != io.ErrUnexpectedEOF { - t.Errorf("expected io.ErrUnexpectedEOF, got %v", err) + t.Fatalf("expected io.ErrUnexpectedEOF, got %v", err) } } func TestBinaryThrowsWhenNotEnoughDataForLength8(t *testing.T) { - hexstring := mustHexDec("BD01" + strings.Repeat("61", 61)) - decoder := NewDecoderFromBytes(hexstring, nil) - _, err := decoder.Decode() + binstring := mustHexDec("BD01" + strings.Repeat("61", 61)) + _, err := NewDecoderFromBytes(binstring, nil).Decode() if err != io.ErrUnexpectedEOF { - t.Errorf("expected io.ErrUnexpectedEOF, got %v", err) + t.Fatalf("expected io.ErrUnexpectedEOF, got %v", err) } } func TestBinaryThrowsWhenNotEnoughDataForLength16(t *testing.T) { - hexstring := mustHexDec("BE0001" + strings.Repeat("61", 317)) - decoder := NewDecoderFromBytes(hexstring, nil) - _, err := decoder.Decode() + binstring := mustHexDec("BE0001" + strings.Repeat("61", 317)) + _, err := NewDecoderFromBytes(binstring, nil).Decode() if err != io.ErrUnexpectedEOF { - t.Errorf("expected io.ErrUnexpectedEOF, got %v", err) + t.Fatalf("expected io.ErrUnexpectedEOF, got %v", err) } } func TestBinaryThrowsWhenNotEnoughDataForLength64(t *testing.T) { - hexstring := mustHexDec("BF0000000000000000" + strings.Repeat("61", 65852)) - decoder := NewDecoderFromBytes(hexstring, nil) - _, err := decoder.Decode() + binstring := mustHexDec("BF0000000000000000" + strings.Repeat("61", 65852)) + _, err := NewDecoderFromBytes(binstring, nil).Decode() if err != io.ErrUnexpectedEOF { - t.Errorf("expected io.ErrUnexpectedEOF, got %v", err) + t.Fatalf("expected io.ErrUnexpectedEOF, got %v", err) } } -func TestBinSymmetric(t *testing.T) { - f := func(x uint8) bool { - str := make([]byte, x) - rand.Read(str) - encoded, err := EncodeBuf(str, nil) +func TestBinarySymmetric(t *testing.T) { + f := func(object []byte) bool { + encoded, err := EncodeBuf(object, nil) if err != nil { return false } - decoder := NewDecoderFromBytes(encoded, nil) - decoded, err := decoder.Decode() + decoded, err := NewDecoderFromBytes(encoded, nil).Decode() if err != nil { return false } - if !slices.Equal(str, decoded.([]byte)) { - t.Logf("Expected <%s, %d>", reflect.TypeOf(str), str) - t.Logf("Instead <%s, %d>", reflect.TypeOf(decoded), decoded) + udecoded, ok := decoded.([]byte) + if !ok { + t.Fatalf("failed to cast") + } + if !bytes.Equal(object, udecoded) { + t.Logf("Expected <%s, %d>", reflect.TypeOf(object), object) + t.Logf("Instead <%s, %d>", reflect.TypeOf(udecoded), udecoded) return false } return true } if err := quick.Check(f, nil); err != nil { - t.Error(err) + t.Fatal(err) } } diff --git a/go/blob_test.go b/go/blob_test.go index 0d817ec..a3422b0 100644 --- a/go/blob_test.go +++ b/go/blob_test.go @@ -24,183 +24,177 @@ import ( "testing/quick" ) -func TestMultipleOfChunkLen(t *testing.T) { +func TestBlobMultipleOfChunkLen(t *testing.T) { object := BlobChunked{ Chunks: []string{"test", "data"}, ChunkLen: 4, } - hexstring := mustHexDec("0B00000000000000038474657374846461746180") + binstring := mustHexDec("0B00000000000000038474657374846461746180") encoded, err := EncodeBuf(object, nil) if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during encode: %s", err) } - if !bytes.Equal(encoded, hexstring) { - t.Errorf("expected %s, got %s", hex.EncodeToString(hexstring), hex.EncodeToString(encoded)) + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected %s, got %s", hex.EncodeToString(binstring), hex.EncodeToString(encoded)) } - decoder := NewDecoderFromBytes(encoded, nil) - decoded, err := decoder.Decode() + decoded, err := NewDecoderFromBytes(encoded, nil).Decode() if err != nil { - t.Errorf("error during decode: %s", err) + t.Fatalf("error during decode: %s", err) } - udecoded, success := decoded.(BlobChunked) - if !success { - t.Errorf("failed to cast") + udecoded, ok := decoded.(BlobChunked) + if !ok { + t.Fatalf("failed to cast") } if object.ChunkLen != udecoded.ChunkLen { - t.Errorf("expected <%s, %v>", reflect.TypeOf(object), object) - t.Errorf("instead <%s, %v>", reflect.TypeOf(decoded), decoded) + t.Fatalf("expected <%s, %v>", reflect.TypeOf(object), object) + t.Fatalf("instead <%s, %v>", reflect.TypeOf(decoded), decoded) } for i := range len(object.Chunks) { if object.Chunks[i] != udecoded.Chunks[i] { - t.Errorf("expected <%s, %v>", reflect.TypeOf(object), object) - t.Errorf("instead <%s, %v>", reflect.TypeOf(decoded), decoded) + t.Fatalf("expected <%s, %v>", reflect.TypeOf(object), object) + t.Fatalf("instead <%s, %v>", reflect.TypeOf(decoded), decoded) } } } -func TestLargerOfChunkLen(t *testing.T) { +func TestBlobLargerOfChunkLen(t *testing.T) { object := BlobChunked{ Chunks: []string{"test", "data", "2"}, ChunkLen: 4, } - hexstring := mustHexDec("0B0000000000000003847465737484646174618132") + binstring := mustHexDec("0B0000000000000003847465737484646174618132") encoded, err := EncodeBuf(object, nil) if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during encode: %s", err) } - if !bytes.Equal(encoded, hexstring) { - t.Errorf("expected %s, got %s", hex.EncodeToString(hexstring), hex.EncodeToString(encoded)) + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected %s, got %s", hex.EncodeToString(binstring), hex.EncodeToString(encoded)) } - decoder := NewDecoderFromBytes(encoded, nil) - decoded, err := decoder.Decode() + decoded, err := NewDecoderFromBytes(encoded, nil).Decode() if err != nil { - t.Errorf("error during decode: %s", err) + t.Fatalf("error during decode: %s", err) } - udecoded, success := decoded.(BlobChunked) - if !success { - t.Errorf("failed to cast") + udecoded, ok := decoded.(BlobChunked) + if !ok { + t.Fatalf("failed to cast") } if object.ChunkLen != udecoded.ChunkLen { - t.Errorf("expected <%s, %v>", reflect.TypeOf(object), object) - t.Errorf("instead <%s, %v>", reflect.TypeOf(decoded), decoded) + t.Fatalf("expected <%s, %v>", reflect.TypeOf(object), object) + t.Fatalf("instead <%s, %v>", reflect.TypeOf(decoded), decoded) } for i := range len(object.Chunks) { if object.Chunks[i] != udecoded.Chunks[i] { - t.Errorf("expected <%s, %v>", reflect.TypeOf(object), object) - t.Errorf("instead <%s, %v>", reflect.TypeOf(decoded), decoded) + t.Fatalf("expected <%s, %v>", reflect.TypeOf(object), object) + t.Fatalf("instead <%s, %v>", reflect.TypeOf(decoded), decoded) } } } -func TestEmpty(t *testing.T) { +func TestBlobEmpty(t *testing.T) { object := BlobChunked{ Chunks: []string{}, ChunkLen: 4, } - hexstring := mustHexDec("0B000000000000000380") + binstring := mustHexDec("0B000000000000000380") encoded, err := EncodeBuf(object, nil) if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during encode: %s", err) } - if !bytes.Equal(encoded, hexstring) { - t.Errorf("expected %s, got %s", hex.EncodeToString(hexstring), hex.EncodeToString(encoded)) + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected %s, got %s", hex.EncodeToString(binstring), hex.EncodeToString(encoded)) } - decoder := NewDecoderFromBytes(encoded, nil) - decoded, err := decoder.Decode() + decoded, err := NewDecoderFromBytes(encoded, nil).Decode() if err != nil { - t.Errorf("error during decode: %s", err) + t.Fatalf("error during decode: %s", err) } - udecoded, success := decoded.(BlobChunked) - if !success { - t.Errorf("failed to cast") + udecoded, ok := decoded.(BlobChunked) + if !ok { + t.Fatalf("failed to cast") } if object.ChunkLen != udecoded.ChunkLen { - t.Errorf("expected <%s, %v>", reflect.TypeOf(object), object) - t.Errorf("instead <%s, %v>", reflect.TypeOf(decoded), decoded) + t.Fatalf("expected <%s, %v>", reflect.TypeOf(object), object) + t.Fatalf("instead <%s, %v>", reflect.TypeOf(decoded), decoded) } for i := range len(object.Chunks) { if object.Chunks[i] != udecoded.Chunks[i] { - t.Errorf("expected <%s, %v>", reflect.TypeOf(object), object) - t.Errorf("instead <%s, %v>", reflect.TypeOf(decoded), decoded) + t.Fatalf("expected <%s, %v>", reflect.TypeOf(object), object) + t.Fatalf("instead <%s, %v>", reflect.TypeOf(decoded), decoded) } } } func TestBlobSymmetric(t *testing.T) { - f := func(ChunkLen, ChunkNum uint8) bool { - if uint16(ChunkLen)*uint16(ChunkNum) > 2000 { - return true - } - chunks := make([]string, ChunkNum) - for i := range ChunkNum { - chunks[i] = RandStringBytes(int(ChunkLen)) - } - object := BlobChunked{ - Chunks: chunks, - ChunkLen: int64(ChunkLen), - } + f := func(data []byte, ChunkLen uint8) bool { + object := BlobReader{ChunkLen: int64(ChunkLen), R: bytes.NewReader(data)} encoded, err := EncodeBuf(object, nil) if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during encode: %s", err) return false } decoded, err := NewDecoderFromBytes(encoded, nil).Decode() if err != nil { - t.Errorf("error during decode: %s", err) + t.Fatalf("error during decode: %s", err) return false } - udecoded, success := decoded.(BlobChunked) - if !success { - t.Errorf("failed to cast") + udecoded, ok := decoded.(BlobChunked) + if !ok { + t.Fatalf("failed to cast") return false } if object.ChunkLen != udecoded.ChunkLen { - t.Errorf("expected <%s, %v>", reflect.TypeOf(object), object) - t.Errorf("instead <%s, %v>", reflect.TypeOf(decoded), decoded) + t.Fatalf("expected <%s, %v>", reflect.TypeOf(object), object) + t.Fatalf("instead <%s, %v>", reflect.TypeOf(decoded), decoded) return false } - for i := range len(object.Chunks) { - if object.Chunks[i] != udecoded.Chunks[i] { - t.Errorf("expected <%s, %v>", reflect.TypeOf(object), object) - t.Errorf("instead <%s, %v>", reflect.TypeOf(decoded), decoded) + for i := range len(data) { + if data[i] != udecoded.Chunks[i/int(ChunkLen)][i%int(ChunkLen)] { + t.Fatalf("expected <%s, %v>", reflect.TypeOf(object), object) + t.Fatalf("instead <%s, %v>", reflect.TypeOf(decoded), decoded) + return false + } + } + for i := range int(ChunkLen)*(len(data)/int(ChunkLen)) - len(data) { + if udecoded.Chunks[len(data)/int(ChunkLen)][i] != 0 { + t.Fatalf("expected <%s, %v>", reflect.TypeOf(object), object) + t.Fatalf("instead <%s, %v>", reflect.TypeOf(decoded), decoded) return false } } return true } if err := quick.Check(f, nil); err != nil { - t.Error(err) + t.Fatal(err) } } func TestBlobThrowsWhenNotEnoughData(t *testing.T) { - hexstring := mustHexDec("0B00000000000000038474657374846461") - _, err := NewDecoderFromBytes(hexstring, nil).Decode() + binstring := mustHexDec("0B00000000000000038474657374846461") + _, err := NewDecoderFromBytes(binstring, nil).Decode() if err != io.ErrUnexpectedEOF { - t.Errorf("expected io.ErrUnexpectedEOF, got %s", err) + t.Fatalf("expected io.ErrUnexpectedEOF, got %s", err) } } func TestBlobThrowsWhenNotEnoughDataForLength(t *testing.T) { - hexstring := mustHexDec("0B00000000") - _, err := NewDecoderFromBytes(hexstring, nil).Decode() + binstring := mustHexDec("0B00000000") + _, err := NewDecoderFromBytes(binstring, nil).Decode() if err != io.ErrUnexpectedEOF { - t.Errorf("expected io.ErrUnexpectedEOF, got %s", err) + t.Fatalf("expected io.ErrUnexpectedEOF, got %s", err) } } func TestBlobThrowsWhenWrongTerminatorLength(t *testing.T) { - hexstring := mustHexDec("0B0000000000000003847465737484646174618A7465726D696E61746F72") - _, err := NewDecoderFromBytes(hexstring, nil).Decode() + binstring := mustHexDec("0B0000000000000003847465737484646174618A7465726D696E61746F72") + _, err := NewDecoderFromBytes(binstring, nil).Decode() if err != ErrBlobBadChunkLen { - t.Errorf("expected ErrBlobBadChunkLen, got %s", err) + t.Fatalf("expected ErrBlobBadChunkLen, got %s", err) } } func TestBlobThrowsWhenWrongTerminatorTag(t *testing.T) { - hexstring := mustHexDec("0B00000000000000038474657374846461746104746861742077617320612077726F6E6720746167") - _, err := NewDecoderFromBytes(hexstring, nil).Decode() + binstring := mustHexDec("0B00000000000000038474657374846461746104746861742077617320612077726F6E6720746167") + _, err := NewDecoderFromBytes(binstring, nil).Decode() if err != ErrBlobBadAtom { - t.Errorf("expected ErrBlobBadChunkLen, got %s", err) + t.Fatalf("expected ErrBlobBadChunkLen, got %s", err) } } diff --git a/go/bool_test.go b/go/bool_test.go index 6e83b83..eaed601 100644 --- a/go/bool_test.go +++ b/go/bool_test.go @@ -24,44 +24,42 @@ import ( func TestTrue(t *testing.T) { object := true - hexstring := mustHexDec("03") - decoder := NewDecoderFromBytes(hexstring, nil) - encoded, err := EncodeBuf(object, nil) + binstring := mustHexDec("03") + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() if err != nil { - t.Errorf("error during encode: %s", err) - } - if !bytes.Equal(encoded, hexstring) { - t.Errorf("expected hexstring %s, got %s", hex.EncodeToString(hexstring), hex.EncodeToString(encoded)) + t.Fatalf("error during decode: %s", err) } - decoded, err := decoder.Decode() + encoded, err := EncodeBuf(object, nil) if err != nil { - t.Errorf("error during decode: %s", err) + t.Fatalf("error during encode: %s", err) + } + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected binstring %s, got %s", hex.EncodeToString(binstring), hex.EncodeToString(encoded)) } if decoded != object { t.Logf("expected type %s, value true", reflect.TypeOf(object)) t.Logf("got type %s, value %t", reflect.TypeOf(decoded), decoded) - t.Error() + t.FailNow() } } func TestFalse(t *testing.T) { object := false - hexstring := mustHexDec("02") - decoder := NewDecoderFromBytes(hexstring, nil) - encoded, err := EncodeBuf(object, nil) + binstring := mustHexDec("02") + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during decode: %s", err) } - if !bytes.Equal(encoded, hexstring) { - t.Errorf("expected hexstring %s, got %s", hex.EncodeToString(hexstring), hex.EncodeToString(encoded)) - } - decoded, err := decoder.Decode() + encoded, err := EncodeBuf(object, nil) if err != nil { - t.Errorf("error during decode: %s", err) + t.Fatalf("error during encode: %s", err) + } + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected binstring %s, got %s", hex.EncodeToString(binstring), hex.EncodeToString(encoded)) } if decoded != object { - t.Logf("expected type %s, value true", reflect.TypeOf(object)) - t.Logf("got type %s, value %t", reflect.TypeOf(decoded), decoded) - t.Error() + t.Logf("expected type %s, value false", reflect.TypeOf(object)) + t.Logf("got type %s, value %+v", reflect.TypeOf(decoded), decoded) + t.FailNow() } } diff --git a/go/float_test.go b/go/float_test.go index 2ebcfb1..5c06602 100644 --- a/go/float_test.go +++ b/go/float_test.go @@ -25,116 +25,116 @@ import ( func TestThrowsWhenEncodingFloat(t *testing.T) { _, err := EncodeBuf(1.5, nil) if err == nil { - t.Errorf("expected Error, got nil") + t.Fatalf("expected Error, got nil") } } -func TestLoadsFloat16(t *testing.T) { +func TestFloat16Loads(t *testing.T) { decoded, err := NewDecoderFromBytes(append([]byte{0x10}, bytes.Repeat([]byte{0x11}, 2)...), nil).Decode() object := Raw(append([]byte{0x10}, bytes.Repeat([]byte{0x11}, 2)...)) if err != nil { - t.Errorf("error during decode: %v", err) + t.Fatalf("error during decode: %v", err) } - udecoded, success := decoded.(Raw) - if !success { - t.Errorf("expected Raw, got %v", reflect.TypeOf(decoded)) + udecoded, ok := decoded.(Raw) + if !ok { + t.Fatalf("expected Raw, got %v", reflect.TypeOf(decoded)) } if !bytes.Equal(object, udecoded) { - t.Errorf("expected %v, got %v", object, decoded) + t.Fatalf("expected %v, got %v", object, decoded) } } -func TestLoadsFloat32(t *testing.T) { +func TestFloat32Loads(t *testing.T) { decoded, err := NewDecoderFromBytes(append([]byte{0x11}, bytes.Repeat([]byte{0x11}, 4)...), nil).Decode() object := Raw(append([]byte{0x11}, bytes.Repeat([]byte{0x11}, 4)...)) if err != nil { - t.Errorf("error during decode: %v", err) + t.Fatalf("error during decode: %v", err) } - udecoded, success := decoded.(Raw) - if !success { - t.Errorf("expected Raw, got %v", reflect.TypeOf(decoded)) + udecoded, ok := decoded.(Raw) + if !ok { + t.Fatalf("expected Raw, got %v", reflect.TypeOf(decoded)) } if !bytes.Equal(object, udecoded) { - t.Errorf("expected %v, got %v", object, decoded) + t.Fatalf("expected %v, got %v", object, decoded) } } -func TestLoadsFloat64(t *testing.T) { +func TestFloat64Loads(t *testing.T) { decoded, err := NewDecoderFromBytes(append([]byte{0x12}, bytes.Repeat([]byte{0x11}, 8)...), nil).Decode() object := Raw(append([]byte{0x12}, bytes.Repeat([]byte{0x11}, 8)...)) if err != nil { - t.Errorf("error during decode: %v", err) + t.Fatalf("error during decode: %v", err) } - udecoded, success := decoded.(Raw) - if !success { - t.Errorf("expected Raw, got %v", reflect.TypeOf(decoded)) + udecoded, ok := decoded.(Raw) + if !ok { + t.Fatalf("expected Raw, got %v", reflect.TypeOf(decoded)) } if !bytes.Equal(object, udecoded) { - t.Errorf("expected %v, got %v", object, decoded) + t.Fatalf("expected %v, got %v", object, decoded) } } -func TestLoadsFloat128(t *testing.T) { +func TestFloat128Loads(t *testing.T) { decoded, err := NewDecoderFromBytes(append([]byte{0x13}, bytes.Repeat([]byte{0x11}, 16)...), nil).Decode() object := Raw(append([]byte{0x13}, bytes.Repeat([]byte{0x11}, 16)...)) if err != nil { - t.Errorf("error during decode: %v", err) + t.Fatalf("error during decode: %v", err) } - udecoded, success := decoded.(Raw) - if !success { - t.Errorf("expected Raw, got %v", reflect.TypeOf(decoded)) + udecoded, ok := decoded.(Raw) + if !ok { + t.Fatalf("expected Raw, got %v", reflect.TypeOf(decoded)) } if !bytes.Equal(object, udecoded) { - t.Errorf("expected %v, got %v", object, decoded) + t.Fatalf("expected %v, got %v", object, decoded) } } -func TestLoadsFloat256(t *testing.T) { +func TestFloat256Loads(t *testing.T) { decoded, err := NewDecoderFromBytes(append([]byte{0x14}, bytes.Repeat([]byte{0x11}, 32)...), nil).Decode() object := Raw(append([]byte{0x14}, bytes.Repeat([]byte{0x11}, 32)...)) if err != nil { - t.Errorf("error during decode: %v", err) + t.Fatalf("error during decode: %v", err) } - udecoded, success := decoded.(Raw) - if !success { - t.Errorf("expected Raw, got %v", reflect.TypeOf(decoded)) + udecoded, ok := decoded.(Raw) + if !ok { + t.Fatalf("expected Raw, got %v", reflect.TypeOf(decoded)) } if !bytes.Equal(object, udecoded) { - t.Errorf("expected %v, got %v", object, decoded) + t.Fatalf("expected %v, got %v", object, decoded) } } -func TestThrowhsWhenNotEnoughDataForFloat256(t *testing.T) { +func TestFloatThrowhsWhenNotEnoughDataForFloat256(t *testing.T) { _, err := NewDecoderFromBytes(append([]byte{0x14}, bytes.Repeat([]byte{0x11}, 32-1)...), nil).Decode() if err != io.ErrUnexpectedEOF { - t.Errorf("expected io.ErrUnexpectedEOF, got %s", err) + t.Fatalf("expected io.ErrUnexpectedEOF, got %s", err) } } -func TestThrowhsWhenNotEnoughDataForFloat128(t *testing.T) { +func TestFloatThrowhsWhenNotEnoughDataForFloat128(t *testing.T) { _, err := NewDecoderFromBytes(append([]byte{0x13}, bytes.Repeat([]byte{0x11}, 16-1)...), nil).Decode() if err != io.ErrUnexpectedEOF { - t.Errorf("expected io.ErrUnexpectedEOF, got %s", err) + t.Fatalf("expected io.ErrUnexpectedEOF, got %s", err) } } -func TestThrowhsWhenNotEnoughDataForFloat64(t *testing.T) { +func TestFloatThrowhsWhenNotEnoughDataForFloat64(t *testing.T) { _, err := NewDecoderFromBytes(append([]byte{0x12}, bytes.Repeat([]byte{0x11}, 8-1)...), nil).Decode() if err != io.ErrUnexpectedEOF { - t.Errorf("expected io.ErrUnexpectedEOF, got %s", err) + t.Fatalf("expected io.ErrUnexpectedEOF, got %s", err) } } -func TestThrowhsWhenNotEnoughDataForFloat32(t *testing.T) { +func TestFloatThrowhsWhenNotEnoughDataForFloat32(t *testing.T) { _, err := NewDecoderFromBytes(append([]byte{0x11}, bytes.Repeat([]byte{0x11}, 4-1)...), nil).Decode() if err != io.ErrUnexpectedEOF { - t.Errorf("expected io.ErrUnexpectedEOF, got %s", err) + t.Fatalf("expected io.ErrUnexpectedEOF, got %s", err) } } -func TestThrowhsWhenNotEnoughDataForFloat16(t *testing.T) { +func TestFloatThrowhsWhenNotEnoughDataForFloat16(t *testing.T) { _, err := NewDecoderFromBytes(append([]byte{0x10}, bytes.Repeat([]byte{0x11}, 2-1)...), nil).Decode() if err != io.ErrUnexpectedEOF { - t.Errorf("expected io.ErrUnexpectedEOF, got %s", err) + t.Fatalf("expected io.ErrUnexpectedEOF, got %s", err) } } diff --git a/go/generic_test.go b/go/generic_test.go index 7ab65ab..e7ad006 100644 --- a/go/generic_test.go +++ b/go/generic_test.go @@ -21,28 +21,25 @@ import ( ) func TestThrowsWhenUnknownTag(t *testing.T) { - hexstring := []byte{0x05} - decoder := NewDecoderFromBytes(hexstring, nil) - _, err := decoder.Decode() + binstring := []byte{0x05} + _, err := NewDecoderFromBytes(binstring, nil).Decode() if err != ErrUnknownType { - t.Errorf("expected ErrUnknownType, got %v", err) + t.Fatalf("expected ErrUnknownType, got %v", err) } } func TestThrowsWhenEmptyData(t *testing.T) { - hexstring := []byte{} - decoder := NewDecoderFromBytes(hexstring, nil) - _, err := decoder.Decode() + binstring := []byte{} + _, err := NewDecoderFromBytes(binstring, nil).Decode() if err != io.ErrUnexpectedEOF { - t.Errorf("expected io.ErrUnexpectedEOF, got %v", err) + t.Fatalf("expected io.ErrUnexpectedEOF, got %v", err) } } func TestLonelyEOC(t *testing.T) { - hexstring := []byte{0x00} - decoder := NewDecoderFromBytes(hexstring, nil) - _, err := decoder.Decode() + binstring := []byte{0x00} + _, err := NewDecoderFromBytes(binstring, nil).Decode() if err != ErrUnexpectedEOC { - t.Errorf("expected ErrUnexpectedEOC, got %v", err) + t.Fatalf("expected ErrUnexpectedEOC, got %v", err) } } diff --git a/go/int_test.go b/go/int_test.go index bb87b62..fbfc886 100644 --- a/go/int_test.go +++ b/go/int_test.go @@ -25,362 +25,412 @@ import ( "testing/quick" ) -func mustHexDec(s string) []byte { - b, err := hex.DecodeString(s) +func TestIntZero(t *testing.T) { + object := 0 + binstring := mustHexDec("0C80") + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() if err != nil { - panic(err) + t.Fatalf("error during decode: %s", err) + } + encoded, err := EncodeBuf(object, nil) + if err != nil { + t.Fatalf("error during encode: %s", err) + } + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected binstring %s, got %s", hex.EncodeToString(binstring), hex.EncodeToString(encoded)) + } + if decoded != uint64(object) { + t.Logf("expected type %s, value %d", reflect.TypeOf(object), object) + t.Logf("got type %s, value %d", reflect.TypeOf(decoded), decoded) + t.FailNow() } - return b } -func TestZero(t *testing.T) { - object := uint64(0) - hexstring := mustHexDec("0C80") - decoder := NewDecoderFromBytes(hexstring, nil) +func TestIntOne(t *testing.T) { + object := 1 + binstring := mustHexDec("0C8101") + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != nil { + t.Fatalf("error during decode: %s", err) + } encoded, err := EncodeBuf(object, nil) if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during encode: %s", err) + } + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected binstring %s, got %s", hex.EncodeToString(binstring), hex.EncodeToString(encoded)) } - if !bytes.Equal(encoded, hexstring) { - t.Errorf("expected hexstring %s, got %s", hex.EncodeToString(hexstring), hex.EncodeToString(encoded)) + if decoded != uint64(object) { + t.Logf("expected type %s, value %d", reflect.TypeOf(object), object) + t.Logf("got type %s, value %d", reflect.TypeOf(decoded), decoded) + t.FailNow() } - decoded, err := decoder.Decode() +} + +func TestIntNegativeOne(t *testing.T) { + object := -1 + binstring := mustHexDec("0D80") + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() if err != nil { - t.Errorf("error during decode: %s", err) + t.Fatalf("error during decode: %s", err) } - if decoded != object { + encoded, err := EncodeBuf(object, nil) + if err != nil { + t.Fatalf("error during encode: %s", err) + } + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected binstring %s, got %s", hex.EncodeToString(binstring), hex.EncodeToString(encoded)) + } + if decoded != int64(object) { t.Logf("expected type %s, value %d", reflect.TypeOf(object), object) t.Logf("got type %s, value %d", reflect.TypeOf(decoded), decoded) - t.Error() + t.FailNow() } } -func TestOne(t *testing.T) { - object := uint64(1) - hexstring := mustHexDec("0C8101") - decoder := NewDecoderFromBytes(hexstring, nil) +func TestInt1s63Minus1(t *testing.T) { + object := uint64(1<<63 - 1) + binstring := mustHexDec("0c887fffffffffffffff") + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != nil { + t.Fatalf("error during decode: %s", err) + } encoded, err := EncodeBuf(object, nil) if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during encode: %s", err) } - if !bytes.Equal(encoded, hexstring) { - t.Errorf("expected hexstring %s, got %s", hex.EncodeToString(hexstring), hex.EncodeToString(encoded)) + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected binstring %s, got %s", hex.EncodeToString(binstring), hex.EncodeToString(encoded)) } - decoded, err := decoder.Decode() if err != nil { - t.Errorf("error during decode: %s", err) + t.Fatalf("error during decode: %s", err) } if decoded != object { t.Logf("expected type %s, value %d", reflect.TypeOf(object), object) t.Logf("got type %s, value %d", reflect.TypeOf(decoded), decoded) - t.Error() + t.FailNow() } } -func TestNegativeOne(t *testing.T) { - object := int64(-1) - hexstring := mustHexDec("0D80") - decoder := NewDecoderFromBytes(hexstring, nil) +func TestInt1s63(t *testing.T) { + object, _ := big.NewInt(0).SetString("18446744073709551616", 10) + binstring := mustHexDec("0c89010000000000000000") + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != nil { + t.Fatalf("error during decode: %s", err) + } encoded, err := EncodeBuf(object, nil) + t.Log(hex.EncodeToString(encoded)) if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during encode: %s", err) } - if !bytes.Equal(encoded, hexstring) { - t.Errorf("expected hexstring %s, got %s", hex.EncodeToString(hexstring), hex.EncodeToString(encoded)) + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected binstring %s, got %s", hex.EncodeToString(binstring), hex.EncodeToString(encoded)) } - decoded, err := decoder.Decode() if err != nil { - t.Errorf("error during decode: %s", err) + t.Fatalf("error during decode: %s", err) } - if decoded != object { + udecoded, ok := decoded.(*big.Int) + if !ok { + t.Fatalf("failed to cast") + } + if udecoded.Cmp(object) != 0 { t.Logf("expected type %s, value %d", reflect.TypeOf(object), object) t.Logf("got type %s, value %d", reflect.TypeOf(decoded), decoded) - t.Error() + t.FailNow() } } -func Test1s63(t *testing.T) { - object := big.NewInt(0).SetBytes(mustHexDec("800000000000000000")) - hexstring := mustHexDec("0C89800000000000000000") - decoder := NewDecoderFromBytes(hexstring, nil) +func TestInt1s64(t *testing.T) { + object := big.NewInt(1).SetBytes(mustHexDec("010000000000000000")) + binstring := mustHexDec("0C89010000000000000000") + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != nil { + t.Fatalf("error during decode: %s", err) + } encoded, err := EncodeBuf(object, nil) if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during encode: %s", err) } - if !bytes.Equal(encoded, hexstring) { - t.Errorf("expected hexstring %s, got %s", hex.EncodeToString(hexstring), hex.EncodeToString(encoded)) + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected binstring %s, got %s", hex.EncodeToString(binstring), hex.EncodeToString(encoded)) } - decoded, err := decoder.Decode() if err != nil { - t.Errorf("error during decode: %s", err) + t.Fatalf("error during decode: %s", err) } if decoded.(*big.Int).Cmp(object) != 0 { t.Logf("expected type %s, value %d", reflect.TypeOf(object), object) t.Logf("got type %s, value %d", reflect.TypeOf(decoded), decoded) - t.Error() + t.FailNow() } } -func Test1s64(t *testing.T) { - object := big.NewInt(1).SetBytes(mustHexDec("010000000000000000")) - hexstring := mustHexDec("0C89010000000000000000") - decoder := NewDecoderFromBytes(hexstring, nil) +func TestInt1s130(t *testing.T) { + object := big.NewInt(1).SetBytes(mustHexDec("0400000000000000000000000000000000")) + binstring := mustHexDec("0C910400000000000000000000000000000000") + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != nil { + t.Fatalf("error during decode: %s", err) + } encoded, err := EncodeBuf(object, nil) if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during encode: %s", err) } - if !bytes.Equal(encoded, hexstring) { - t.Errorf("expected hexstring %s, got %s", hex.EncodeToString(hexstring), hex.EncodeToString(encoded)) + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected binstring %s, got %s", hex.EncodeToString(binstring), hex.EncodeToString(encoded)) } - decoded, err := decoder.Decode() if err != nil { - t.Errorf("error during decode: %s", err) + t.Fatalf("error during decode: %s", err) } if decoded.(*big.Int).Cmp(object) != 0 { t.Logf("expected type %s, value %d", reflect.TypeOf(object), object) t.Logf("got type %s, value %d", reflect.TypeOf(decoded), decoded) - t.Error() + t.FailNow() } } -func Test1s130(t *testing.T) { - object := big.NewInt(1).SetBytes(mustHexDec("0400000000000000000000000000000000")) - hexstring := mustHexDec("0C910400000000000000000000000000000000") - decoder := NewDecoderFromBytes(hexstring, nil) +func TestIntM1s62Plus1(t *testing.T) { + object := int64(-9223372036854775808) + binstring := mustHexDec("0D887FFFFFFFFFFFFFFF") + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != nil { + t.Fatalf("error during decode: %s", err) + } encoded, err := EncodeBuf(object, nil) if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during encode: %s", err) } - if !bytes.Equal(encoded, hexstring) { - t.Errorf("expected hexstring %s, got %s", hex.EncodeToString(hexstring), hex.EncodeToString(encoded)) + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected binstring %s, got %s", hex.EncodeToString(binstring), hex.EncodeToString(encoded)) } - decoded, err := decoder.Decode() if err != nil { - t.Errorf("error during decode: %s", err) + t.Fatalf("error during decode: %s", err) } - if decoded.(*big.Int).Cmp(object) != 0 { + udecoded, ok := decoded.(int64) + if !ok { + t.Fatalf("failed to cast") + } + if udecoded != object { t.Logf("expected type %s, value %d", reflect.TypeOf(object), object) t.Logf("got type %s, value %d", reflect.TypeOf(decoded), decoded) - t.Error() + t.FailNow() } } -func TestM1s63(t *testing.T) { - object := big.NewInt(0).SetBytes(mustHexDec("00800000000000000000")) - object = object.Neg(object) - hexstring := mustHexDec("0D897FFFFFFFFFFFFFFFFF") - decoder := NewDecoderFromBytes(hexstring, nil) +func TestIntM1s62(t *testing.T) { + object, _ := big.NewInt(0).SetString("-9223372036854775809", 10) + binstring := mustHexDec("0D888000000000000000") + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != nil { + t.Fatalf("error during decode: %s", err) + } encoded, err := EncodeBuf(object, nil) if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during encode: %s", err) } - if !bytes.Equal(encoded, hexstring) { - t.Errorf("expected hexstring %s, got %s", hex.EncodeToString(hexstring), hex.EncodeToString(encoded)) + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected binstring %s, got %s", hex.EncodeToString(binstring), hex.EncodeToString(encoded)) } - decoded, err := decoder.Decode() if err != nil { - t.Errorf("error during decode: %s", err) + t.Fatalf("error during decode: %s", err) } if decoded.(*big.Int).Cmp(object) != 0 { t.Logf("expected type %s, value %d", reflect.TypeOf(object), object) t.Logf("got type %s, value %d", reflect.TypeOf(decoded), decoded) - t.Error() + t.FailNow() } } -func TestM1s64(t *testing.T) { +func TestIntM1s64(t *testing.T) { object := big.NewInt(0).SetBytes(mustHexDec("010000000000000000")) object = object.Neg(object) - hexstring := mustHexDec("0D88FFFFFFFFFFFFFFFF") - decoder := NewDecoderFromBytes(hexstring, nil) + binstring := mustHexDec("0D88FFFFFFFFFFFFFFFF") + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != nil { + t.Fatalf("error during decode: %s", err) + } encoded, err := EncodeBuf(object, nil) if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during encode: %s", err) } - if !bytes.Equal(encoded, hexstring) { - t.Errorf("expected hexstring %s, got %s", hex.EncodeToString(hexstring), hex.EncodeToString(encoded)) + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected binstring %s, got %s", hex.EncodeToString(binstring), hex.EncodeToString(encoded)) } - decoded, err := decoder.Decode() if err != nil { - t.Errorf("error during decode: %s", err) + t.Fatalf("error during decode: %s", err) } if decoded.(*big.Int).Cmp(object) != 0 { t.Logf("expected type %s, value %d", reflect.TypeOf(object), object) t.Logf("got type %s, value %d", reflect.TypeOf(decoded), decoded) - t.Error() + t.FailNow() } } -func TestM1s130(t *testing.T) { +func TestIntM1s130(t *testing.T) { object := big.NewInt(1).SetBytes(mustHexDec("0100000000000000000000000000000000")) object = object.Neg(object) - hexstring := mustHexDec("0D90FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF") - decoder := NewDecoderFromBytes(hexstring, nil) + binstring := mustHexDec("0D90FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF") + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != nil { + t.Fatalf("error during decode: %s", err) + } encoded, err := EncodeBuf(object, nil) if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during encode: %s", err) } - if !bytes.Equal(encoded, hexstring) { - t.Errorf("expected hexstring %s, got %s", hex.EncodeToString(hexstring), hex.EncodeToString(encoded)) + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected binstring %s, got %s", hex.EncodeToString(binstring), hex.EncodeToString(encoded)) } - decoded, err := decoder.Decode() if err != nil { - t.Errorf("error during decode: %s", err) + t.Fatalf("error during decode: %s", err) } if decoded.(*big.Int).Cmp(object) != 0 { t.Logf("expected type %s, value %d", reflect.TypeOf(object), object) t.Logf("got type %s, value %d", reflect.TypeOf(decoded), decoded) - t.Error() + t.FailNow() } } -func TestDecodeNotEnoughData(t *testing.T) { +func TestIntThrowsWhenNotEnoughData(t *testing.T) { _, err := NewDecoderFromBytes(mustHexDec("0C830102"), nil).Decode() if err != io.ErrUnexpectedEOF { - t.Errorf("expected error, got %v", err) + t.Fatalf("expected error, got %v", err) } _, err = NewDecoderFromBytes(mustHexDec("0C8301"), nil).Decode() if err != io.ErrUnexpectedEOF { - t.Errorf("expected error, got %v", err) + t.Fatalf("expected error, got %v", err) } } -func TestThrowsWhenUnminimalInt(t *testing.T) { +func TestIntThrowsWhenNonMinimalInt(t *testing.T) { encoded := mustHexDec("0C81007B") _, err := NewDecoderFromBytes(encoded, nil).Decode() if err != ErrIntNonMinimal { - t.Errorf("expected ErrIntNonMinimal, got %v", err) + t.Fatalf("expected ErrIntNonMinimal, got %v", err) } } -func TestThrowsWhenNonBinInInt(t *testing.T) { +func TestIntThrowsWhenNonBinInInt(t *testing.T) { encoded := mustHexDec("0C017B") _, err := NewDecoderFromBytes(encoded, nil).Decode() if err != ErrBadInt { - t.Errorf("expected ErrBadInt, got %v", err) + t.Fatalf("expected ErrBadInt, got %v", err) } } -func TestTemp(t *testing.T) { - object, suc := big.NewInt(1).SetString("-400000000000000000090009090909090909000000000000", 10) - t.Log(object) - if !suc { - t.Errorf("expected ErrBadInt, got %v", suc) - } -} - -func TestUInt64Symmetric(t *testing.T) { +func TestInt64UnsignedSymmetric(t *testing.T) { f := func(x uint64) bool { encoded, err := EncodeBuf(x, nil) if err != nil { t.Logf("error during encode: %s", err) return false } - decoder := NewDecoderFromBytes(encoded, nil) - decoded, err := decoder.Decode() + decoded, err := NewDecoderFromBytes(encoded, nil).Decode() if err != nil { t.Logf("error during decode: %s", err) return false } - if x != decoded { + udecoded, ok := decoded.(uint64) + if !ok { + t.Logf("failed to cast") + return false + } + if uint64(x) != udecoded { t.Logf("Expected <%s, %d>, got <%s, %d>", reflect.TypeOf(x), x, reflect.TypeOf(decoded), decoded) return false } return true } if err := quick.Check(f, nil); err != nil { - t.Error(err) + t.Fatal(err) } } -func TestUInt32Symmetric(t *testing.T) { +func TestInt32UnsignedSymmetric(t *testing.T) { f := func(x uint32) bool { encoded, err := EncodeBuf(x, nil) if err != nil { t.Logf("error during encode: %s", err) return false } - decoder := NewDecoderFromBytes(encoded, nil) - decoded, err := decoder.Decode() + decoded, err := NewDecoderFromBytes(encoded, nil).Decode() if err != nil { t.Logf("error during decode: %s", err) return false } - udecoded, success := decoded.(uint64) - if !success { + udecoded, ok := decoded.(uint64) + if !ok { t.Logf("failed to cast") return false } - if x != uint32(udecoded) { + if uint64(x) != udecoded { t.Logf("Expected <%s, %d>, got <%s, %d>", reflect.TypeOf(x), x, reflect.TypeOf(decoded), decoded) return false } return true } if err := quick.Check(f, nil); err != nil { - t.Error(err) + t.Fatal(err) } } -func TestUInt16Symmetric(t *testing.T) { +func TestInt16UnsignedSymmetric(t *testing.T) { f := func(x uint16) bool { encoded, err := EncodeBuf(x, nil) if err != nil { t.Logf("error during encode: %s", err) return false } - decoder := NewDecoderFromBytes(encoded, nil) - decoded, err := decoder.Decode() + decoded, err := NewDecoderFromBytes(encoded, nil).Decode() if err != nil { t.Logf("error during decode: %s", err) return false } - udecoded, success := decoded.(uint64) - if !success { + udecoded, ok := decoded.(uint64) + if !ok { t.Logf("failed to cast") return false } - if x != uint16(udecoded) { + if uint64(x) != udecoded { t.Logf("Expected <%s, %d>, got <%s, %d>", reflect.TypeOf(x), x, reflect.TypeOf(decoded), decoded) return false } return true } if err := quick.Check(f, nil); err != nil { - t.Error(err) + t.Fatal(err) } } -func TestUInt8Symmetric(t *testing.T) { +func TestInt8UnsignedSymmetric(t *testing.T) { f := func(x uint8) bool { encoded, err := EncodeBuf(x, nil) if err != nil { t.Logf("error during encode: %s", err) return false } - decoder := NewDecoderFromBytes(encoded, nil) - decoded, err := decoder.Decode() + decoded, err := NewDecoderFromBytes(encoded, nil).Decode() if err != nil { t.Logf("error during decode: %s", err) return false } - udecoded, success := decoded.(uint64) - if !success { + udecoded, ok := decoded.(uint64) + if !ok { t.Logf("failed to cast") return false } - if x != uint8(udecoded) { + if uint64(x) != udecoded { t.Logf("Expected <%s, %d>, got <%s, %d>", reflect.TypeOf(x), x, reflect.TypeOf(decoded), decoded) return false } return true } if err := quick.Check(f, nil); err != nil { - t.Error(err) + t.Fatal(err) } } -func TestPlusInt32Symmetric(t *testing.T) { +func TestInt32PositiveSymmetric(t *testing.T) { f := func(x int32) bool { if x == -1<<31 { return true @@ -393,29 +443,28 @@ func TestPlusInt32Symmetric(t *testing.T) { t.Logf("error during encode: %s", err) return false } - decoder := NewDecoderFromBytes(encoded, nil) - decoded, err := decoder.Decode() + decoded, err := NewDecoderFromBytes(encoded, nil).Decode() if err != nil { t.Logf("error during decode: %s", err) return false } - udecoded, success := decoded.(uint64) - if !success { + udecoded, ok := decoded.(uint64) + if !ok { t.Logf("failed to cast") return false } - if x != int32(udecoded) { + if uint64(x) != udecoded { t.Logf("Expected <%s, %d>, got <%s, %d>", reflect.TypeOf(x), x, reflect.TypeOf(decoded), decoded) return false } return true } if err := quick.Check(f, nil); err != nil { - t.Error(err) + t.Fatal(err) } } -func TestMinusInt32Symmetric(t *testing.T) { +func TestInt32NegativeSymmetric(t *testing.T) { f := func(x int32) bool { if x > 0 { x = -x @@ -428,29 +477,28 @@ func TestMinusInt32Symmetric(t *testing.T) { t.Logf("error during encode: %s", err) return false } - decoder := NewDecoderFromBytes(encoded, nil) - decoded, err := decoder.Decode() + decoded, err := NewDecoderFromBytes(encoded, nil).Decode() if err != nil { t.Logf("error during decode: %s", err) return false } - udecoded, success := decoded.(int64) - if !success { + udecoded, ok := decoded.(int64) + if !ok { t.Logf("failed to cast") return false } - if x != int32(udecoded) { + if int64(x) != udecoded { t.Logf("Expected <%s, %d>, got <%s, %d>", reflect.TypeOf(x), x, reflect.TypeOf(decoded), decoded) return false } return true } if err := quick.Check(f, nil); err != nil { - t.Error(err) + t.Fatal(err) } } -func TestPlusInt16Symmetric(t *testing.T) { +func TestInt16PositiveSymmetric(t *testing.T) { f := func(x int16) bool { if x == -1<<15 { return true @@ -463,29 +511,28 @@ func TestPlusInt16Symmetric(t *testing.T) { t.Logf("error during encode: %s", err) return false } - decoder := NewDecoderFromBytes(encoded, nil) - decoded, err := decoder.Decode() + decoded, err := NewDecoderFromBytes(encoded, nil).Decode() if err != nil { t.Logf("error during decode: %s", err) return false } - udecoded, success := decoded.(uint64) - if !success { + udecoded, ok := decoded.(uint64) + if !ok { t.Logf("failed to cast") return false } - if x != int16(udecoded) { + if uint64(x) != udecoded { t.Logf("Expected <%s, %d>, got <%s, %d>", reflect.TypeOf(x), x, reflect.TypeOf(decoded), decoded) return false } return true } if err := quick.Check(f, nil); err != nil { - t.Error(err) + t.Fatal(err) } } -func TestMinusInt16Symmetric(t *testing.T) { +func TestInt16NegativeSymmetric(t *testing.T) { f := func(x int16) bool { if x > 0 { x = -x @@ -498,29 +545,28 @@ func TestMinusInt16Symmetric(t *testing.T) { t.Logf("error during encode: %s", err) return false } - decoder := NewDecoderFromBytes(encoded, nil) - decoded, err := decoder.Decode() + decoded, err := NewDecoderFromBytes(encoded, nil).Decode() if err != nil { t.Logf("error during decode: %s", err) return false } - udecoded, success := decoded.(int64) - if !success { + udecoded, ok := decoded.(int64) + if !ok { t.Logf("failed to cast") return false } - if x != int16(udecoded) { + if int64(x) != udecoded { t.Logf("Expected <%s, %d>, got <%s, %d>", reflect.TypeOf(x), x, reflect.TypeOf(decoded), decoded) return false } return true } if err := quick.Check(f, nil); err != nil { - t.Error(err) + t.Fatal(err) } } -func TestPlusInt8Symmetric(t *testing.T) { +func TestInt8PositiveSymmetric(t *testing.T) { f := func(x int8) bool { if x == -1<<7 { return true @@ -533,29 +579,28 @@ func TestPlusInt8Symmetric(t *testing.T) { t.Logf("error during encode: %s", err) return false } - decoder := NewDecoderFromBytes(encoded, nil) - decoded, err := decoder.Decode() + decoded, err := NewDecoderFromBytes(encoded, nil).Decode() if err != nil { t.Logf("error during decode: %s", err) return false } - udecoded, success := decoded.(uint64) - if !success { + udecoded, ok := decoded.(uint64) + if !ok { t.Logf("failed to cast") return false } - if x != int8(udecoded) { + if uint64(x) != udecoded { t.Logf("Expected <%s, %d>, got <%s, %d>", reflect.TypeOf(x), x, reflect.TypeOf(decoded), decoded) return false } return true } if err := quick.Check(f, nil); err != nil { - t.Error(err) + t.Fatal(err) } } -func TestMinusInt8Symmetric(t *testing.T) { +func TestInt8NegativeSymmetric(t *testing.T) { f := func(x int8) bool { if x > 0 { x = -x @@ -568,29 +613,28 @@ func TestMinusInt8Symmetric(t *testing.T) { t.Logf("error during encode: %s", err) return false } - decoder := NewDecoderFromBytes(encoded, nil) - decoded, err := decoder.Decode() + decoded, err := NewDecoderFromBytes(encoded, nil).Decode() if err != nil { t.Logf("error during decode: %s", err) return false } - udecoded, success := decoded.(int64) - if !success { + udecoded, ok := decoded.(int64) + if !ok { t.Logf("failed to cast") return false } - if x != int8(udecoded) { + if int64(x) != udecoded { t.Logf("Expected <%s, %d>, got <%s, %d>", reflect.TypeOf(x), x, reflect.TypeOf(decoded), decoded) return false } return true } if err := quick.Check(f, nil); err != nil { - t.Error(err) + t.Fatal(err) } } -func TestPlusInt64Symmetric(t *testing.T) { +func TestInt64PositiveSymmetric(t *testing.T) { f := func(x int64) bool { if x < 0 { x = -x @@ -600,29 +644,28 @@ func TestPlusInt64Symmetric(t *testing.T) { t.Logf("error during encode: %s", err) return false } - decoder := NewDecoderFromBytes(encoded, nil) - decoded, err := decoder.Decode() + decoded, err := NewDecoderFromBytes(encoded, nil).Decode() if err != nil { t.Logf("error during decode: %s", err) return false } - udecoded, success := decoded.(uint64) - if !success { + udecoded, ok := decoded.(uint64) + if !ok { t.Logf("failed to cast") return false } - if x != int64(udecoded) { + if uint64(x) != udecoded { t.Logf("Expected <%s, %d>, got <%s, %d>", reflect.TypeOf(x), x, reflect.TypeOf(decoded), decoded) return false } return true } if err := quick.Check(f, nil); err != nil { - t.Error(err) + t.Fatal(err) } } -func TestMinusInt64Symmetric(t *testing.T) { +func TestInt64NegativeSymmetric(t *testing.T) { f := func(x int64) bool { if x > 0 { x = -x @@ -635,25 +678,24 @@ func TestMinusInt64Symmetric(t *testing.T) { t.Logf("error during encode: %s", err) return false } - decoder := NewDecoderFromBytes(encoded, nil) - decoded, err := decoder.Decode() + decoded, err := NewDecoderFromBytes(encoded, nil).Decode() if err != nil { t.Logf("error during decode: %s", err) return false } - udecoded, success := decoded.(int64) - if !success { + udecoded, ok := decoded.(int64) + if !ok { t.Logf("failed to cast") return false } - if x != int64(udecoded) { + if int64(x) != udecoded { t.Logf("Expected <%s, %d>, got <%s, %d>", reflect.TypeOf(x), x, reflect.TypeOf(decoded), decoded) return false } return true } if err := quick.Check(f, nil); err != nil { - t.Error(err) + t.Fatal(err) } } diff --git a/go/list_test.go b/go/list_test.go index 00f57ff..e28a806 100644 --- a/go/list_test.go +++ b/go/list_test.go @@ -27,36 +27,37 @@ import ( func TestListEmpty(t *testing.T) { object := []any{} - hexstring := []byte("\x08\x00") - decoder := NewDecoderFromBytes(hexstring, nil) + binstring := []byte("\x08\x00") + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != nil { + t.Fatalf("error during decode: %s", err) + } encoded, err := EncodeBuf(object, nil) if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during encode: %s", err) } - if !bytes.Equal(encoded, hexstring) { - t.Errorf("expected hexstring %s, got %s", hex.EncodeToString(hexstring), hex.EncodeToString(encoded)) + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected binstring %s, got %s", hex.EncodeToString(binstring), hex.EncodeToString(encoded)) } - decoded, err := decoder.Decode() if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during encode: %s", err) } - udecoded, success := decoded.([]any) - if !success { - t.Errorf("failed to cast") + udecoded, ok := decoded.([]any) + if !ok { + t.Fatalf("failed to cast") } if !slices.Equal(object, udecoded) { t.Logf("expected type %s, value true", reflect.TypeOf(object)) t.Logf("got type %s, value %t", reflect.TypeOf(decoded), decoded) - t.Error() + t.FailNow() } } -func TestThrowsWhenNoEOC(t *testing.T) { - hexstring := []byte("\x08") - decoder := NewDecoderFromBytes(hexstring, nil) - _, err := decoder.Decode() +func TestListThrowsWhenNoEOC(t *testing.T) { + binstring := []byte("\x08") + _, err := NewDecoderFromBytes(binstring, nil).Decode() if err != io.ErrUnexpectedEOF { - t.Errorf("expected io.ErrUnexpectedEOF, got %v", err) + t.Fatalf("expected io.ErrUnexpectedEOF, got %v", err) } } @@ -66,14 +67,16 @@ func TestListIntSymmetric(t *testing.T) { if err != nil { return false } - decoder := NewDecoderFromBytes(encoded, nil) - decoded, err := decoder.Decode() + decoded, err := NewDecoderFromBytes(encoded, nil).Decode() if err != nil { return false } - udecoded, success := decoded.([]any) - if !success { - t.Errorf("failed to cast") + udecoded, ok := decoded.([]any) + if !ok { + t.Fatalf("failed to cast") + } + if len(x) != len(udecoded) { + return false } for i := range x { if x[i] != udecoded[i] { @@ -85,6 +88,6 @@ func TestListIntSymmetric(t *testing.T) { return true } if err := quick.Check(f, nil); err != nil { - t.Error(err) + t.Fatal(err) } } diff --git a/go/map_test.go b/go/map_test.go index 1a785aa..d3de806 100644 --- a/go/map_test.go +++ b/go/map_test.go @@ -24,24 +24,26 @@ import ( "testing/quick" ) -func TestEmptyMap(t *testing.T) { - hexstring := []byte("\x09\x00") +func TestMapEmpty(t *testing.T) { + binstring := []byte("\x09\x00") object := make(map[string]any) - decoder := NewDecoderFromBytes(hexstring, nil) + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != nil { + t.Fatalf("error during decode: %s", err) + } encoded, err := EncodeBuf(object, nil) if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during encode: %s", err) } - if !bytes.Equal(encoded, hexstring) { - t.Errorf("expected hexstring %s, got %s", hex.EncodeToString(hexstring), hex.EncodeToString(encoded)) + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected binstring %s, got %s", hex.EncodeToString(binstring), hex.EncodeToString(encoded)) } - decoded, err := decoder.Decode() if err != nil { - t.Errorf("error during decode: %s", err) + t.Fatalf("error during decode: %s", err) } - udecoded, success := decoded.(map[string]any) - if !success { - t.Errorf("failed to cast") + udecoded, ok := decoded.(map[string]any) + if !ok { + t.Fatalf("failed to cast") } if !maps.Equal(object, udecoded) { t.Logf("expected type %s, value %s", reflect.TypeOf(object), object) @@ -50,51 +52,50 @@ func TestEmptyMap(t *testing.T) { } } -func TestThrowsWhenNonStringKey(t *testing.T) { +func TestMapThrowsWhenNonStringKey(t *testing.T) { object := make(map[any]any) object[1] = "a" - hexstring := []byte("\x09\x0C\x80\xC6value2\x00") + binstring := []byte("\x09\x0C\x80\xC6value2\x00") _, err := EncodeBuf(object, nil) if err != ErrMapBadKey { - t.Errorf("expected ErrMapBadKey during encode, got %v", err) + t.Fatalf("expected ErrMapBadKey during encode, got %v", err) } - decoder := NewDecoderFromBytes(hexstring, nil) - _, err = decoder.Decode() + _, err = NewDecoderFromBytes(binstring, nil).Decode() if err != ErrMapBadKey { - t.Errorf("expected ErrMapBadKey during decode, got %v", err) + t.Fatalf("expected ErrMapBadKey during decode, got %v", err) } } -func TestThrowsWhenUnexpectedEOC(t *testing.T) { - hexstring := []byte("\x09\xC4key1\x00\x00") - decoder := NewDecoderFromBytes(hexstring, nil) - _, err := decoder.Decode() +func TestMapThrowsWhenUnexpectedEOC(t *testing.T) { + binstring := []byte("\x09\xC4key1\x00\x00") + _, err := NewDecoderFromBytes(binstring, nil).Decode() if err != ErrUnexpectedEOC { - t.Errorf("expected ErrUnexpectedEOC during decode, got %v", err) + t.Fatalf("expected ErrUnexpectedEOC during decode, got %v", err) } } -func TestThrowsWhenEmptyStringKey(t *testing.T) { +func TestMapThrowsWhenEmptyStringKeyEncode(t *testing.T) { object := make(map[any]any) object[""] = "a" - hexstring := []byte("\x09\xC0\x0C\x81\x01\xC4key1\xC6value1\x00") _, err := EncodeBuf(object, nil) if err != ErrMapBadKey { - t.Errorf("expected ErrMapBadKey during encode, got %v", err) + t.Fatalf("expected ErrMapBadKey during encode, got %v", err) } - decoder := NewDecoderFromBytes(hexstring, nil) - _, err = decoder.Decode() +} + +func TestMapThrowsWhenEmptyStringKeyDecode(t *testing.T) { + binstring := []byte("\x09\xC0\x0C\x81\x01\xC4key1\xC6value1\x00") + _, err := NewDecoderFromBytes(binstring, nil).Decode() if err != ErrMapBadKey { - t.Errorf("expected ErrMapBadKey during decode, got %v", err) + t.Fatalf("expected ErrMapBadKey during decode, got %v", err) } } -func TestThrowsWhenUnsortedKeys(t *testing.T) { - hexstring := []byte("\x09\xC4key2\xC6value2\xC4key1\xC6value1\x00") - decoder := NewDecoderFromBytes(hexstring, nil) - _, err := decoder.Decode() +func TestMapThrowsWhenUnsortedKeys(t *testing.T) { + binstring := []byte("\x09\xC4key2\xC6value2\xC4key1\xC6value1\x00") + _, err := NewDecoderFromBytes(binstring, nil).Decode() if err != ErrMapUnordered { - t.Errorf("expected ErrMapUnordered during decode, got %v", err) + t.Fatalf("expected ErrMapUnordered during decode, got %v", err) } } @@ -105,14 +106,13 @@ func TestMapIntSymmetric(t *testing.T) { if err != nil { return false } - decoder := NewDecoderFromBytes(encoded, nil) - decoded, err := decoder.Decode() + decoded, err := NewDecoderFromBytes(encoded, nil).Decode() if err != nil { t.Logf("error during decode: %s", err) return false } - udecoded, success := decoded.(map[string]any) - if !success { + udecoded, ok := decoded.(map[string]any) + if !ok { t.Logf("failed to cast") return false } @@ -126,6 +126,6 @@ func TestMapIntSymmetric(t *testing.T) { return true } if err := quick.Check(f, nil); err != nil { - t.Error(err) + t.Fatal(err) } } diff --git a/go/string_test.go b/go/string_test.go index 36b6d0b..8826260 100644 --- a/go/string_test.go +++ b/go/string_test.go @@ -19,221 +19,286 @@ import ( "bytes" "encoding/hex" "io" - "math/rand" + mrand "math/rand" "reflect" "strings" "testing" "testing/quick" ) -func TestEmptyString(t *testing.T) { +func TestStrEmpty(t *testing.T) { object := "" - hexstring := mustHexDec("C0") - decoder := NewDecoderFromBytes(hexstring, nil) + binstring := mustHexDec("C0") + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != nil { + t.Fatalf("error during decode: %s", err) + } encoded, err := EncodeBuf(object, nil) if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during encode: %s", err) + } + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected binstring %s, got %s", hex.EncodeToString(binstring), hex.EncodeToString(encoded)) } - if !bytes.Equal(encoded, hexstring) { - t.Errorf("expected hexstring %s, got %s", hex.EncodeToString(hexstring), hex.EncodeToString(encoded)) + if decoded != object { + t.Logf("expected type %s, value %s", reflect.TypeOf(object), object) + t.Logf("got type %s, value %s", reflect.TypeOf(decoded), decoded) + t.FailNow() } - decoded, err := decoder.Decode() +} + +func TestStrHelloWorld(t *testing.T) { + object := "hello world" + binstring := bytes.Join([][]byte{mustHexDec("CB"), []byte("hello world")}, nil) + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != nil { + t.Fatalf("error during decode: %s", err) + } + encoded, err := EncodeBuf(object, nil) if err != nil { - t.Errorf("error during decode: %s", err) + t.Fatalf("error during encode: %s", err) + } + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected binstring %s, got %s", hex.EncodeToString(binstring), hex.EncodeToString(encoded)) } if decoded != object { t.Logf("expected type %s, value %s", reflect.TypeOf(object), object) t.Logf("got type %s, value %s", reflect.TypeOf(decoded), decoded) - t.Error() + t.FailNow() } } -func TestStringLen62(t *testing.T) { +func TestStrRuHelloWorld(t *testing.T) { + object := "привет мир" + binstring := bytes.Join([][]byte{mustHexDec("D3"), []byte("привет мир")}, nil) + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != nil { + t.Fatalf("error during decode: %s", err) + } + encoded, err := EncodeBuf(object, nil) + if err != nil { + t.Fatalf("error during encode: %s", err) + } + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected binstring %s, got %s", hex.EncodeToString(binstring), hex.EncodeToString(encoded)) + } + if decoded != object { + t.Logf("expected type %s, value %s", reflect.TypeOf(object), object) + t.Logf("got type %s, value %s", reflect.TypeOf(decoded), decoded) + t.FailNow() + } +} + +func TestStrLen62(t *testing.T) { object := strings.Repeat("a", 62) - hexstring := mustHexDec( + binstring := mustHexDec( strings.Join([]string{"FD01", strings.Repeat("61", 62)}, ""), ) - decoder := NewDecoderFromBytes(hexstring, nil) - encoded, err := EncodeBuf(object, nil) + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() if err != nil { - t.Errorf("error during encode: %s", err) - } - if !bytes.Equal(encoded, hexstring) { - t.Errorf("expected hexstring %s, got %s", hex.EncodeToString(hexstring), hex.EncodeToString(encoded)) + t.Fatalf("error during decode: %s", err) } - decoded, err := decoder.Decode() + encoded, err := EncodeBuf(object, nil) if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during encode: %s", err) + } + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected binstring %s, got %s", hex.EncodeToString(binstring), hex.EncodeToString(encoded)) } if decoded != object { t.Logf("expected type %s, value %s", reflect.TypeOf(object), object) t.Logf("got type %s, value %s", reflect.TypeOf(decoded), decoded) - t.Error() + t.FailNow() } } -func TestStringLen318(t *testing.T) { +func TestStrLen318(t *testing.T) { object := strings.Repeat("a", 318) - hexstring := mustHexDec( + binstring := mustHexDec( strings.Join([]string{"FE0001", strings.Repeat("61", 318)}, ""), ) - decoder := NewDecoderFromBytes(hexstring, nil) - encoded, err := EncodeBuf(object, nil) + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during decode: %s", err) } - if !bytes.Equal(encoded, hexstring) { - t.Errorf("expected hexstring %s, got %s", hex.EncodeToString(hexstring), hex.EncodeToString(encoded)) - } - decoded, err := decoder.Decode() + encoded, err := EncodeBuf(object, nil) if err != nil { - t.Errorf("error during decode: %s", err) + t.Fatalf("error during encode: %s", err) + } + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected binstring %s, got %s", hex.EncodeToString(binstring), hex.EncodeToString(encoded)) } if decoded != object { t.Logf("expected type %s, value %s", reflect.TypeOf(object), object) t.Logf("got type %s, value %s", reflect.TypeOf(decoded), decoded) - t.Error() + t.FailNow() } } -func TestStringLen65853(t *testing.T) { +func TestStrLen65853(t *testing.T) { object := strings.Repeat("a", 65853) - hexstring := mustHexDec( + binstring := mustHexDec( strings.Join([]string{"FF0000000000000000", strings.Repeat("61", 65853)}, ""), ) - decoder := NewDecoderFromBytes(hexstring, nil) + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != nil { + t.Fatalf("error during decode: %s", err) + } encoded, err := EncodeBuf(object, nil) if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during encode: %s", err) } - if !bytes.Equal(encoded, hexstring) { - t.Logf("expected hexstring to begin with %s, got %s", hex.EncodeToString(hexstring)[:40], hex.EncodeToString(encoded)[:40]) + if !bytes.Equal(encoded, binstring) { + t.Logf("expected binstring to begin with %s, got %s", hex.EncodeToString(binstring)[:40], hex.EncodeToString(encoded)[:40]) t.Fail() } - decoded, err := decoder.Decode() - if err != nil { - t.Errorf("error during decode: %s", err) - } if decoded != object { t.Logf("expected type %s, value %s", reflect.TypeOf(object), object) t.Logf("got type %s, value %s", reflect.TypeOf(decoded), decoded) - t.Error() + t.FailNow() } } -func TestThrowsWhenNullByteInUTF8(t *testing.T) { - hexstring := []byte("\xC5he\x00\x01\x02") - decoder := NewDecoderFromBytes(hexstring, nil) - _, err := decoder.Decode() +func TestStrThrowsWhenNullByteInUTF8(t *testing.T) { + binstring := []byte("\xC5he\x00\x01\x02") + _, err := NewDecoderFromBytes(binstring, nil).Decode() if err != ErrBadUTF8 { - t.Errorf("expected ErrBadUTF8, got %v", err) + t.Fatalf("expected ErrBadUTF8, got %v", err) } } -func TestOkWhenNullByteInUTF8AndUTF8CheckDisabled(t *testing.T) { - hexstring := []byte("\xC5he\xe2\x82\x28") - decoder := NewDecoderFromBytes(hexstring, &DecodeOpts{DisableUTF8Check: true}) - _, err := decoder.Decode() +func TestStrOkWhenNullByteInUTF8AndUTF8CheckDisabled(t *testing.T) { + binstring := []byte("\xC5he\xe2\x82\x28") + _, err := NewDecoderFromBytes(binstring, &DecodeOpts{DisableUTF8Check: true}).Decode() if err != nil { - t.Errorf("error during decode: %v", err) + t.Fatalf("error during decode: %v", err) } } -func TestThrowsWhenInvalid2BytesInUTF8(t *testing.T) { - hexstring := []byte("\xC5he\xc3\x28o") - decoder := NewDecoderFromBytes(hexstring, nil) - _, err := decoder.Decode() - if err != ErrBadUTF8 { - t.Errorf("expected ErrBadUTF8, got %v", err) +func TestStrThrowsWhenInvalid2BytesInUTF8(t *testing.T) { + f := func(x, y int) bool { + binstring := bytes.Join([][]byte{[]byte("\xC2"), invalidUTF8_2Byte(x, y)}, nil) + _, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != ErrBadUTF8 { + t.Logf("expected ErrBadUTF8, got %v", err) + return false + } + return true + } + if err := quick.Check(f, &quick.Config{ + Values: func(v []reflect.Value, r *mrand.Rand) { + v[0] = reflect.ValueOf(r.Intn(1 << 5)) + v[1] = reflect.ValueOf(r.Intn(1 << 5)) + }, + }); err != nil { + t.Fatal(err) } } -func TestOkWhenInvalid2BytesUTF8AndUTF8CheckDisabled(t *testing.T) { - hexstring := []byte("\xC5he\xc3\x28o") - decoder := NewDecoderFromBytes(hexstring, &DecodeOpts{DisableUTF8Check: true}) - _, err := decoder.Decode() - if err != nil { - t.Errorf("error during decode: %v", err) +func TestStrOkWhenInvalid2BytesInUTF8AndUTF8CheckDisabled(t *testing.T) { + f := func(x, y int) bool { + _, err := NewDecoderFromBytes(bytes.Join([][]byte{[]byte("\xC2"), invalidUTF8_2Byte(x, y)}, nil), &DecodeOpts{DisableUTF8Check: true}).Decode() + if err != nil { + t.Logf("error during decode: %v", err) + return false + } + return true + } + if err := quick.Check(f, &quick.Config{ + Values: func(v []reflect.Value, r *mrand.Rand) { + v[0] = reflect.ValueOf(r.Intn(1 << 5)) + v[1] = reflect.ValueOf(r.Intn(1 << 5)) + }, + }); err != nil { + t.Fatal(err) } } -func TestThrowsWhenInvalidUTF3Bytes(t *testing.T) { - hexstring := []byte("\xC5he\xe2\x82\x28") - decoder := NewDecoderFromBytes(hexstring, nil) - _, err := decoder.Decode() - if err != ErrBadUTF8 { - t.Errorf("expected ErrBadUTF8, got %v", err) +func TestStrThrowsWhenInvalid3BytesInUTF8(t *testing.T) { + f := func(x, y, z int) bool { + binstring := bytes.Join([][]byte{[]byte("\xC3"), invalidUTF8_3Byte(x, y, z)}, nil) + _, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != ErrBadUTF8 { + t.Logf("expected ErrBadUTF8, got %v", err) + return false + } + return true + } + if err := quick.Check(f, &quick.Config{ + Values: func(v []reflect.Value, r *mrand.Rand) { + v[0] = reflect.ValueOf(r.Intn(1 << 4)) + v[1] = reflect.ValueOf(r.Intn(1 << 6)) + v[2] = reflect.ValueOf(r.Intn(1 << 6)) + }, + }); err != nil { + t.Fatal(err) } } -func TestOkWhenInvalid3BytesUTF8AndUTF8CheckDisabled(t *testing.T) { - hexstring := []byte("\xC5he\xe2\x82\x28") - decoder := NewDecoderFromBytes(hexstring, &DecodeOpts{DisableUTF8Check: true}) - _, err := decoder.Decode() - if err != nil { - t.Errorf("error during decode: %v", err) +func TestStrOkWhenInvalid3BytesInUTF8AndUTF8CheckDisabled(t *testing.T) { + f := func(x, y, z int) bool { + binstring := bytes.Join([][]byte{[]byte("\xC3"), invalidUTF8_3Byte(x, y, z)}, nil) + _, err := NewDecoderFromBytes(binstring, &DecodeOpts{DisableUTF8Check: true}).Decode() + if err != nil { + t.Logf("error during decode: %v", err) + return false + } + return true + } + if err := quick.Check(f, &quick.Config{ + Values: func(v []reflect.Value, r *mrand.Rand) { + v[0] = reflect.ValueOf(r.Intn(1 << 4)) + v[1] = reflect.ValueOf(r.Intn(1 << 6)) + v[2] = reflect.ValueOf(r.Intn(1 << 6)) + }, + }); err != nil { + t.Fatal(err) } } -func TestThrowsWhenNotEnoughData(t *testing.T) { - hexstring := []byte("\xC5he") - decoder := NewDecoderFromBytes(hexstring, nil) - _, err := decoder.Decode() +func TestStrThrowsWhenNotEnoughData(t *testing.T) { + binstring := []byte("\xC5he") + _, err := NewDecoderFromBytes(binstring, nil).Decode() if err != io.ErrUnexpectedEOF { - t.Errorf("expected io.ErrUnexpectedEOF, got %v", err) + t.Fatalf("expected io.ErrUnexpectedEOF, got %v", err) } } -func TestThrowsWhenNotEnoughDataForLength8(t *testing.T) { - hexstring := []byte("\xC5he") - decoder := NewDecoderFromBytes(hexstring, nil) - _, err := decoder.Decode() +func TestStrThrowsWhenNotEnoughDataForLength8(t *testing.T) { + binstring := []byte("\xC5he") + _, err := NewDecoderFromBytes(binstring, nil).Decode() if err != io.ErrUnexpectedEOF { - t.Errorf("expected io.ErrUnexpectedEOF, got %v", err) + t.Fatalf("expected io.ErrUnexpectedEOF, got %v", err) } } -func TestThrowsWhenNotEnoughDataForLength16(t *testing.T) { - hexstring := []byte("\xC5he") - decoder := NewDecoderFromBytes(hexstring, nil) - _, err := decoder.Decode() +func TestStrThrowsWhenNotEnoughDataForLength16(t *testing.T) { + binstring := []byte("\xC5he") + _, err := NewDecoderFromBytes(binstring, nil).Decode() if err != io.ErrUnexpectedEOF { - t.Errorf("expected io.ErrUnexpectedEOF, got %v", err) + t.Fatalf("expected io.ErrUnexpectedEOF, got %v", err) } } func TestThrowsWhenNotEnoughDataForLength64(t *testing.T) { - hexstring := []byte("\xC5he") - decoder := NewDecoderFromBytes(hexstring, nil) - _, err := decoder.Decode() + binstring := []byte("\xC5he") + _, err := NewDecoderFromBytes(binstring, nil).Decode() if err != io.ErrUnexpectedEOF { - t.Errorf("expected io.ErrUnexpectedEOF, got %v", err) - } -} - -const letterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" - -func RandStringBytes(n int) string { - b := make([]byte, n) - for i := range b { - b[i] = letterBytes[rand.Intn(len(letterBytes))] + t.Fatalf("expected io.ErrUnexpectedEOF, got %v", err) } - return string(b) } -func TestThrowsWhenStringTooLong(t *testing.T) { - f := func(x, y uint8) bool { - if (y == x) || (y == 0) || (x == 0) { +func TestStrThrowsWhenStringTooLong(t *testing.T) { + f := func(str string, y uint8) bool { + if str == "" { return true } - if y > x { - z := x - x = y - y = z + y = y % uint8(len(str)) + if y == 0 { + return true } - str := RandStringBytes(int(x)) encoded, _ := EncodeBuf(str, nil) - decoder := NewDecoderFromBytes(encoded, &DecodeOpts{MaxStrLen: int64(x - y)}) + decoder := NewDecoderFromBytes(encoded, &DecodeOpts{MaxStrLen: int64(len(str) - int(y))}) _, err := decoder.Decode() if err != ErrLenTooBig { t.Logf("expected ErrLenTooBig, got %v", err) @@ -242,18 +307,17 @@ func TestThrowsWhenStringTooLong(t *testing.T) { return true } if err := quick.Check(f, nil); err != nil { - t.Error(err) + t.Fatal(err) } } -func TestStringSymmetric(t *testing.T) { - f := func(x uint8) bool { - str := RandStringBytes(int(x)) +func TestStrOkWhenMaxStrLenSet(t *testing.T) { + f := func(str string, y uint8) bool { encoded, err := EncodeBuf(str, nil) if err != nil { return false } - decoder := NewDecoderFromBytes(encoded, nil) + decoder := NewDecoderFromBytes(encoded, &DecodeOpts{MaxStrLen: int64(len(str) + int(y))}) decoded, err := decoder.Decode() if err != nil { return false @@ -266,6 +330,28 @@ func TestStringSymmetric(t *testing.T) { return true } if err := quick.Check(f, nil); err != nil { - t.Error(err) + t.Fatal(err) + } +} + +func TestStrSymmetric(t *testing.T) { + f := func(str string) bool { + encoded, err := EncodeBuf(str, nil) + if err != nil { + return false + } + decoded, err := NewDecoderFromBytes(encoded, nil).Decode() + if err != nil { + return false + } + if str != decoded.(string) { + t.Logf("Expected <%s, %s>", reflect.TypeOf(str), str) + t.Logf("Instead <%s, %s>", reflect.TypeOf(decoded), decoded) + return false + } + return true + } + if err := quick.Check(f, nil); err != nil { + t.Fatal(err) } } diff --git a/go/support_test.go b/go/support_test.go new file mode 100644 index 0000000..a57611d --- /dev/null +++ b/go/support_test.go @@ -0,0 +1,49 @@ +// GoKEKS -- Go KEKS codec implementation +// Copyright (C) 2024-2025 Anton Rudenko +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, version 3 of the License. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this program. If not, see . + +package keks + +import ( + "crypto/rand" + "encoding/hex" + "io" + mrand "math/rand" +) + +func mustHexDec(s string) []byte { + b, err := hex.DecodeString(s) + if err != nil { + panic(err) + } + return b +} + +func invalidUTF8_2Byte(x, y int) []byte { + return []byte{1<<7 | 1<<6 | byte(x), 1<<7 | 1<<6 | byte(y)} +} + +func invalidUTF8_3Byte(x, y, z int) []byte { + return []byte{(1<<7 | 1<<6 | 1<<5 | byte(x)), (1<<7 | byte(y)), (1<<7 | 1<<6 | byte(z))} +} + +var Junk []byte + +func init() { + Junk = make([]byte, 1+mrand.Intn(8)) + _, err := io.ReadFull(rand.Reader, Junk) + if err != nil { + panic(err) + } +} diff --git a/go/tai_test.go b/go/tai_test.go index 513e135..ca533b1 100644 --- a/go/tai_test.go +++ b/go/tai_test.go @@ -22,160 +22,233 @@ import ( "time" ) -func TestLargeNumberOfSeconds(t *testing.T) { - hexstring := mustHexDec("187000000065195F65") - decoder := NewDecoderFromBytes(hexstring, nil) - decoded, err := decoder.Decode() +func TestTai64LargeNumberOfSeconds(t *testing.T) { + binstring := bytes.Join([][]byte{ + mustHexDec("18"), + mustHexDec("7000000065195F65"), + }, nil) + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during decode: %s", err) + } + if err != nil { + t.Fatalf("error during encode: %s", err) + } + t.Log(decoded) +} + +func TestTai64NLargeNumberOfSeconds(t *testing.T) { + binstring := bytes.Join([][]byte{ + mustHexDec("19"), + mustHexDec("7000000065195F65"), + mustHexDec("3B9AC9FF"), + }, nil) + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != nil { + t.Fatalf("error during decode: %s", err) + } + if err != nil { + t.Fatalf("error during encode: %s", err) + } + t.Log(decoded) +} + +func TestTai64NALargeNumberOfSeconds(t *testing.T) { + binstring := bytes.Join([][]byte{ + mustHexDec("1A"), + mustHexDec("7000000065195F66"), + mustHexDec("3B9AC9FF"), + mustHexDec("3B9AC9FF"), + }, nil) + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != nil { + t.Fatalf("error during decode: %s", err) + } + if err != nil { + t.Fatalf("error during encode: %s", err) } t.Log(decoded) } -func TestThrowsWhenMsbIsSet(t *testing.T) { - hexstring := mustHexDec("188000000065195F65") - decoder := NewDecoderFromBytes(hexstring, nil) - _, err := decoder.Decode() - if err == nil { - t.Errorf("expected 'reserved TAI64 value is in use', got %v", err) +func TestTaiThrowsWhenMsbIsSet(t *testing.T) { + binstring := bytes.Join([][]byte{ + mustHexDec("18"), + mustHexDec("8000000065195F65"), + }, nil) + _, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != ErrTaiReserved { + t.Fatalf("expected 'reserved TAI64 value is in use', got %v", err) } } -func TestThrowsWhenTooManyNanosecs(t *testing.T) { - hexstring := bytes.Join([][]byte{mustHexDec("194000000065195F65"), []byte(";\x9a\xca\x00")}, nil) - decoder := NewDecoderFromBytes(hexstring, nil) - _, err := decoder.Decode() - if err == nil { - t.Errorf("expected 'too many nanoseconds', got %v", err) +func TestTai64NThrowsWhenTooManyNanosecs(t *testing.T) { + binstring := bytes.Join([][]byte{ + mustHexDec("19"), + mustHexDec("4000000000000000"), + mustHexDec("3B9ACA00"), + }, nil) + _, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != ErrTooManyNsecs { + t.Fatalf("expected 'too many nanoseconds', got %v", err) } } -func TestThrowsWhenZeroNanoseconds(t *testing.T) { - hexstring := mustHexDec("19400000000000000000000000") - decoder := NewDecoderFromBytes(hexstring, nil) - _, err := decoder.Decode() - if err == nil { - t.Errorf("expected 'non-minimal TAI64N', got %v", err) +func TestTai64NThrowsWhenZeroNanoseconds(t *testing.T) { + binstring := bytes.Join([][]byte{ + mustHexDec("19"), + mustHexDec("4000000000000000"), + mustHexDec("00000000"), + }, nil) + _, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != ErrTaiNonMinimal { + t.Fatalf("expected 'non-minimal TAI64N', got %v", err) } } -func TestThrowsWhenTooManyAttoseconds(t *testing.T) { - hexstring := mustHexDec("1A4000000065195F65075BCA00A75BCA00") - decoder := NewDecoderFromBytes(hexstring, nil) - _, err := decoder.Decode() - if err == nil { - t.Errorf("expected 'too many attoseconds', got %v", err) +func TestTai64NAThrowsWhenTooManyAttoseconds(t *testing.T) { + binstring := bytes.Join([][]byte{ + mustHexDec("1A"), + mustHexDec("4000000000000000"), + mustHexDec("00000000"), + mustHexDec("3B9ACA00"), + }, nil) + _, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != ErrTooManyAsecs { + t.Fatalf("expected 'too many attoseconds', got %v", err) } } -func TestThrowsWhenZeroAttoseconds(t *testing.T) { - hexstring := mustHexDec("1A40000000000000000000000000000000") - decoder := NewDecoderFromBytes(hexstring, nil) - _, err := decoder.Decode() - if err == nil { - t.Errorf("expected 'non-minimal TAI64NA', got %v", err) +func TestTai64NAThrowsWhenZeroAttoseconds(t *testing.T) { + binstring := bytes.Join([][]byte{ + mustHexDec("1A"), + mustHexDec("4000000000000000"), + mustHexDec("00000000"), + mustHexDec("00000000"), + }, nil) + _, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != ErrTaiNonMinimal { + t.Fatalf("expected 'non-minimal TAI64NA', got %v", err) } } -func TestZeroNanosecondsOkForTAI64NA(t *testing.T) { - hexstring := mustHexDec("1A40000000000000000000000000000001") - decoder := NewDecoderFromBytes(hexstring, nil) - _, err := decoder.Decode() +func TestTai64NAZeroNanosecondsOk(t *testing.T) { + binstring := bytes.Join([][]byte{ + mustHexDec("1A"), + mustHexDec("4000000000000000"), + mustHexDec("00000000"), + mustHexDec("00000001"), + }, nil) + _, err := NewDecoderFromBytes(binstring, nil).Decode() if err != nil { - t.Errorf("expected no error, got %v", err) + t.Fatalf("expected no error, got %v", err) } } -func TestThrowsWhenMsbIsSetForTAI64NA(t *testing.T) { - hexstring := bytes.Join([][]byte{mustHexDec("1A8000000065195F65"), mustHexDec("00010000"), mustHexDec("00010000")}, nil) - decoder := NewDecoderFromBytes(hexstring, nil) - _, err := decoder.Decode() - if err == nil { - t.Errorf("expected 'reserved TAI64 value is in use', got %v", err) +func TestTai64NAThrowsWhenMsbIsSet(t *testing.T) { + binstring := bytes.Join([][]byte{ + mustHexDec("1A"), + mustHexDec("8000000065195F65"), + mustHexDec("00000001"), + mustHexDec("00000001")}, nil) + _, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != ErrTaiReserved { + t.Fatalf("expected 'reserved TAI64 value is in use', got %v", err) } } -func Test19700101(t *testing.T) { - hexstring := mustHexDec("18400000000000000A") - decoder := NewDecoderFromBytes(hexstring, nil) - decoded, err := decoder.Decode() +func TestTai19700101(t *testing.T) { + binstring := mustHexDec("18400000000000000A") + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != nil { + t.Fatalf("error during decode: %s", err) + } if err != nil { - t.Errorf("error during decode: %v", err) + t.Fatalf("error during decode: %v", err) } expected := time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC) decodedTime := decoded.(time.Time) if !decodedTime.Equal(expected) { - t.Errorf("expected %v, got %v", expected, decoded) + t.Fatalf("expected %v, got %v", expected, decoded) } } -func Test19920602(t *testing.T) { - hexstring := mustHexDec("18400000002A2B2C2D") - decoder := NewDecoderFromBytes(hexstring, nil) - decoded, err := decoder.Decode() +func TestTai19920602(t *testing.T) { + binstring := mustHexDec("18400000002A2B2C2D") + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != nil { + t.Fatalf("error during decode: %s", err) + } decodedTime := decoded.(time.Time) if err != nil { - t.Errorf("error during decode: %v", err) + t.Fatalf("error during decode: %v", err) } expected := time.Date(1992, 6, 2, 8, 6, 43, 0, time.UTC) if !decodedTime.Equal(expected) { - t.Errorf("expected %v, got %v", expected, decoded) + t.Fatalf("expected %v, got %v", expected, decoded) } } -func Test19971003(t *testing.T) { - hexstring := mustHexDec("184000000034353637") - decoder := NewDecoderFromBytes(hexstring, nil) - decoded, err := decoder.Decode() +func TestTai19971003(t *testing.T) { + binstring := mustHexDec("184000000034353637") + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != nil { + t.Fatalf("error during decode: %s", err) + } decodedTime := decoded.(time.Time) if err != nil { - t.Errorf("error during decode: %v", err) + t.Fatalf("error during decode: %v", err) } expected := time.Date(1997, 10, 3, 18, 14, 48, 0, time.UTC) if !decodedTime.Equal(expected) { - t.Errorf("expected %v, got %v", expected, decoded) + t.Fatalf("expected %v, got %v", expected, decoded) } } -func Test20161231(t *testing.T) { - hexstring := mustHexDec("1840000000586846A3") - decoder := NewDecoderFromBytes(hexstring, nil) - decoded, err := decoder.Decode() +func TestTai20161231(t *testing.T) { + binstring := mustHexDec("1840000000586846A3") + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != nil { + t.Fatalf("error during decode: %s", err) + } decodedTime := decoded.(time.Time) if err != nil { - t.Errorf("error during decode: %v", err) + t.Fatalf("error during decode: %v", err) } expected := time.Date(2016, 12, 31, 23, 59, 59, 0, time.UTC) if !decodedTime.Equal(expected) { - t.Errorf("expected %v, got %v", expected, decoded) + t.Fatalf("expected %v, got %v", expected, decoded) } } -func Test20170101(t *testing.T) { - hexstring := mustHexDec("1840000000586846A5") - decoder := NewDecoderFromBytes(hexstring, nil) - decoded, err := decoder.Decode() +func TestTai20170101(t *testing.T) { + binstring := mustHexDec("1840000000586846A5") + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != nil { + t.Fatalf("error during decode: %s", err) + } decodedTime := decoded.(time.Time) if err != nil { - t.Errorf("error during decode: %v", err) + t.Fatalf("error during decode: %v", err) } expected := time.Date(2017, 1, 1, 0, 0, 0, 0, time.UTC) if !decodedTime.Equal(expected) { - t.Errorf("expected %v, got %v", expected, decoded) + t.Fatalf("expected %v, got %v", expected, decoded) } } -func Test20241120(t *testing.T) { - hexstring := mustHexDec("1940000000673DD3E136F11FE0") - decoder := NewDecoderFromBytes(hexstring, nil) - decoded, err := decoder.Decode() +func TestTai20241120(t *testing.T) { + binstring := mustHexDec("1940000000673DD3E136F11FE0") + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() + if err != nil { + t.Fatalf("error during decode: %s", err) + } decodedTime := decoded.(time.Time) if err != nil { - t.Errorf("error during decode: %v", err) + t.Fatalf("error during decode: %v", err) } expected := time.Date(2024, 11, 20, 12, 19, 8, 921772000, time.UTC) if !decodedTime.Equal(expected) { - t.Errorf("expected %v, got %v", expected, decoded) + t.Fatalf("expected %v, got %v", expected, decoded) } } @@ -193,19 +266,18 @@ func TestTaiSymmetric(t *testing.T) { t.Logf("error during encode: %s", err) return false } - decoder := NewDecoderFromBytes(encoded, nil) - decoded, err := decoder.Decode() + decoded, err := NewDecoderFromBytes(encoded, nil).Decode() if err != nil { t.Logf("error during decode: %s", err) return false } - udecoded, success := decoded.(time.Time) - if !success { + udecoded, ok := decoded.(time.Time) + if !ok { return false } return x.Equal(udecoded) } if err := quick.Check(f, nil); err != nil { - t.Error(err) + t.Fatal(err) } } diff --git a/go/uuid_test.go b/go/uuid_test.go index 2daadd6..9dd3fc3 100644 --- a/go/uuid_test.go +++ b/go/uuid_test.go @@ -26,55 +26,51 @@ import ( func TestUUIDEncodeDecode(t *testing.T) { object, _ := uuid.Parse("12345678-1234-5678-1234-567812345678") - hexstring := mustHexDec("0412345678123456781234567812345678") - decoder := NewDecoderFromBytes(hexstring, nil) - decoded, err := decoder.Decode() + binstring := mustHexDec("0412345678123456781234567812345678") + decoded, err := NewDecoderFromBytes(binstring, nil).Decode() if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during decode: %s", err) + } + if err != nil { + t.Fatalf("error during encode: %s", err) } if decoded != object { - t.Errorf("expected %v, got %v", object, decoded) + t.Fatalf("expected %v, got %v", object, decoded) } - encoded, err := EncodeBuf(hexstring, nil) + encoded, err := EncodeBuf(object, nil) if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during encode: %s", err) } - if bytes.Equal(encoded, hexstring) { - t.Errorf("expected %v, got %v", hexstring, encoded) + if !bytes.Equal(encoded, binstring) { + t.Fatalf("expected %v, got %v", binstring, encoded) } } func TestUUIDSymmetric(t *testing.T) { - f := func(x uuid.UUID) bool { - encoded, err := EncodeBuf(x[:], nil) + f := func(object uuid.UUID) bool { + encoded, err := EncodeBuf(object, nil) if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during encode: %s", err) return false } - decoder := NewDecoderFromBytes(encoded, nil) - decoded, err := decoder.Decode() + decoded, err := NewDecoderFromBytes(encoded, nil).Decode() if err != nil { - t.Errorf("error during encode: %s", err) + t.Fatalf("error during encode: %s", err) return false } - decodedBytes, success := decoded.([]byte) - if !success { - t.Errorf("failed to cast to []byte") - return false - } - udecoded, err := uuid.FromBytes(decodedBytes) - if err != nil { - t.Errorf("failed to cast to uuid") + udecoded, ok := decoded.(uuid.UUID) + if !ok { + t.Fatalf("failed to cast to uuid.UUID") return false } - if x != udecoded { - t.Logf("expected <%s, %d>", reflect.TypeOf(x), x) + if object != udecoded { + t.Logf("expected <%s, %d>", reflect.TypeOf(object), object) t.Logf("instead <%s, %d>", reflect.TypeOf(udecoded), udecoded) return false } return true } if err := quick.Check(f, nil); err != nil { - t.Error(err) + t.Fatal(err) } }