Unify prefixes in Err* names

diff --git a/go/atom-decode.go b/go/atom-decode.go
index 6129fec2e30a86218fc9e5671268a14f1ab1e97b76d5d7005a082fce946baf1c..87b9580dce8b30627b71e95ecee30c36ad920c89d52d1ef2b5267139517d4c64 100644 (file)
--- a/go/atom-decode.go
+++ b/go/atom-decode.go
@@ -29,16 +29,16 @@ import (
 )
 
 var (
-       ErrLenTooBig     = errors.New("too big string")
-       ErrIntNonMinimal = errors.New("int non minimal")
-       ErrUnknownType   = errors.New("unknown type")
-       ErrBadUTF8       = errors.New("invalid UTF-8")
-       ErrBadInt        = errors.New("bad int value")
-       ErrBadMagic      = errors.New("bad magic value")
-       ErrTAIReserved   = errors.New("reserved TAI64 values in use")
-       ErrTAINonMinimal = errors.New("non-minimal TAI64")
-       ErrTooManyNsecs  = errors.New("too many nanoseconds")
-       ErrTooManyAsecs  = errors.New("too many attoseconds")
+       ErrLenTooBig       = errors.New("too big string")
+       ErrIntNonMinimal   = errors.New("int non minimal")
+       ErrUnknownType     = errors.New("unknown type")
+       ErrUTF8Bad         = errors.New("invalid UTF-8")
+       ErrIntBad          = errors.New("bad int value")
+       ErrMagicBad        = errors.New("bad magic value")
+       ErrTAIReserved     = errors.New("reserved TAI64 values in use")
+       ErrTAINonMinimal   = errors.New("non-minimal TAI64")
+       ErrTAITooManyNsecs = errors.New("too many nanoseconds")
+       ErrTAITooManyAsecs = errors.New("too many attoseconds")
 )
 
 func (ctx *Decoder) DecodeAtom() (t types.Type, err error) {
@@ -66,10 +66,10 @@ func (ctx *Decoder) DecodeAtom() (t types.Type, err error) {
                ctx.strs = append(ctx.strs, s)
                if t == types.Str && !(ctx.opts != nil && ctx.opts.DisableUTF8Check) {
                        if !utf8.ValidString(s) {
-                               err = ErrBadUTF8
+                               err = ErrUTF8Bad
                        }
                        if strings.Contains(s, "\x00") {
-                               err = ErrBadUTF8
+                               err = ErrUTF8Bad
                        }
                }
                return
@@ -127,7 +127,7 @@ func (ctx *Decoder) DecodeAtom() (t types.Type, err error) {
                        return
                }
                if tag&AtomStrings == 0 || tag&AtomIsUTF8 != 0 {
-                       err = ErrBadInt
+                       err = ErrIntBad
                        return
                }
                var s string
@@ -222,7 +222,7 @@ func (ctx *Decoder) DecodeAtom() (t types.Type, err error) {
                                return
                        }
                        if nsecs > 999999999 {
-                               err = ErrTooManyNsecs
+                               err = ErrTAITooManyNsecs
                                return
                        }
                }
@@ -233,7 +233,7 @@ func (ctx *Decoder) DecodeAtom() (t types.Type, err error) {
                                return
                        }
                        if asecs > 999999999 {
-                               err = ErrTooManyAsecs
+                               err = ErrTAITooManyAsecs
                                return
                        }
                }
@@ -255,7 +255,7 @@ func (ctx *Decoder) DecodeAtom() (t types.Type, err error) {
                        return
                }
                if s[:3] != "EKS" {
-                       err = ErrBadMagic
+                       err = ErrMagicBad
                        return
                }
                t = types.Magic

diff --git a/go/fuzz_test.go b/go/fuzz_test.go
index 36b56a6f3c3a31910e466b1f80c919d7519befca97530b3b55e42e943b2b6477..81048ea8c195eb77d772050ef22fa6b14c7933de72a34fbfb7c71a8043996e43 100644 (file)
--- a/go/fuzz_test.go
+++ b/go/fuzz_test.go
@@ -32,7 +32,7 @@ func FuzzDecode(f *testing.F) {
                if err == nil {
                        v, err = d.Unmarshal()
                        if err != nil {
-                               if err == ErrLeapSecond {
+                               if err == ErrTAILeapSecond {
                                        return
                                }
                                t.Fatal(err)

diff --git a/go/generic_test.go b/go/generic_test.go
index 738b00958b958ee806e2dc3c762999da9e9bcc2e159d2066dedf0f27219c0309..deecf1918d84ae95b5e86b47c8698eddf8592cdc6174a43a1360aa5735cf446b 100644 (file)
--- a/go/generic_test.go
+++ b/go/generic_test.go
@@ -38,7 +38,7 @@ func TestEmptyData(t *testing.T) {
 
 func TestLonelyEOC(t *testing.T) {
        _, err := NewDecoderFromBytes(append([]byte{0x00}, Junk...), nil).Decode()
-       if err != ErrUnexpectedEOC {
+       if err != ErrEOCUnexpected {
                t.Fatal(err)
        }
 }

diff --git a/go/int_test.go b/go/int_test.go
index 34e13372e8bd3d8b1577dd7b80a8824cb98bb8ec0348181a5060c64cf7ade579..8e4bed2e36d59354c404e41cb9d84646258d53ac668e78754220639a9730cc24 100644 (file)
--- a/go/int_test.go
+++ b/go/int_test.go
@@ -379,7 +379,7 @@ func TestIntNonMinimalInt(t *testing.T) {
 func TestIntNonBinInInt(t *testing.T) {
        encoded := mustHexDec("0C017B")
        _, err := NewDecoderFromBytes(encoded, nil).Decode()
-       if err != ErrBadInt {
+       if err != ErrIntBad {
                t.Fatal(err)
        }
 }
@@ -663,7 +663,7 @@ func TestIntTooDeep(t *testing.T) {
        if _, err := NewDecoderFromBytes(append(
                []byte{byte(AtomPInt)},
                bytes.Repeat([]byte{byte(AtomList)}, 1000)...,
-       ), nil).Decode(); err != ErrBadInt {
+       ), nil).Decode(); err != ErrIntBad {
                t.Fatal(err)
        }
 }

diff --git a/go/magic_test.go b/go/magic_test.go
index 4efe285e2b869cc6a2d46b998cc6376d925500a177161cdd04438424dbf0f33e..f501c85808265d4426108c452a3757978a7d9a0c9eb4396e930e0c362614d982 100644 (file)
--- a/go/magic_test.go
+++ b/go/magic_test.go
@@ -68,7 +68,7 @@ func TestMagicBadMagic(t *testing.T) {
        encoded[2] = 'e'
        decoder := NewDecoderFromBytes(encoded, nil)
        _, err = decoder.Decode()
-       if err != ErrBadMagic {
+       if err != ErrMagicBad {
                t.Fatal(err)
        }
 }

diff --git a/go/map_test.go b/go/map_test.go
index 1414ab78bc8e46ef8033fd9ffdcc1966d4c281b1648482a56fa26d00f6ad87ce..22b935d128c64c622e252293ae6545b4f32975e0f8cfbcd69a95c15e28c94fa3 100644 (file)
--- a/go/map_test.go
+++ b/go/map_test.go
@@ -66,7 +66,7 @@ func TestMapDecodeNonStrKey(t *testing.T) {
 
 func TestMapUnexpectedEOC(t *testing.T) {
        _, err := NewDecoderFromBytes([]byte("\x09\xC4key1\x00\x00"), nil).Decode()
-       if err != ErrUnexpectedEOC {
+       if err != ErrEOCUnexpected {
                t.Fatal(err)
        }
 }

diff --git a/go/parse.go b/go/parse.go
index 3426f8c6db2aa6f5c189e056657c46ac999d8dba64daf83c3cf69d2bdcde4a9f..e745bf1d46c321e11d73050aefa0a96d9ce36cfde158b76f2cb3fc512a0fb982 100644 (file)
--- a/go/parse.go
+++ b/go/parse.go
@@ -26,7 +26,7 @@ var (
        ErrMapUnordered    = errors.New("map unordered")
        ErrBlobBadAtom     = errors.New("blob unexpected atom")
        ErrBlobBadChunkLen = errors.New("blob bad chunk len")
-       ErrUnexpectedEOC   = errors.New("unexpected EOC")
+       ErrEOCUnexpected   = errors.New("unexpected EOC")
        ErrTooDeep         = errors.New("too deep structure")
 )
 
@@ -117,7 +117,7 @@ func (ctx *Decoder) parse() (t types.Type, err error) {
                                return
                        }
                        if sub == types.EOC {
-                               err = ErrUnexpectedEOC
+                               err = ErrEOCUnexpected
                                return
                        }
                        count++
@@ -175,7 +175,7 @@ func (ctx *Decoder) parse() (t types.Type, err error) {
 func (ctx *Decoder) Parse() (t types.Type, err error) {
        t, err = ctx.parse()
        if t == types.EOC {
-               err = ErrUnexpectedEOC
+               err = ErrEOCUnexpected
        }
        return
 }

diff --git a/go/str_test.go b/go/str_test.go
index 273a10466004718adc52135455627d12f3f0763d280316a9ab5e88c2e5a5b817..55af3f494966d61314e2c40c96e7116267668c67aed99efbb5f139f754ccc195 100644 (file)
--- a/go/str_test.go
+++ b/go/str_test.go
@@ -193,7 +193,7 @@ func TestStrLen65853(t *testing.T) {
 func TestStrNullByteInUTF8(t *testing.T) {
        bin := []byte("\xC5he\x00\x01\x02")
        _, err := NewDecoderFromBytes(bin, nil).Decode()
-       if err != ErrBadUTF8 {
+       if err != ErrUTF8Bad {
                t.Fatal(err)
        }
 }
@@ -201,7 +201,7 @@ func TestStrNullByteInUTF8(t *testing.T) {
 func TestStrNullByteInUTF8AndCheckDisabled(t *testing.T) {
        bin := []byte("\xC5he\x00\x01\x02")
        _, err := NewDecoderFromBytes(bin, &DecodeOpts{DisableUTF8Check: true}).Decode()
-       if err == ErrBadUTF8 {
+       if err == ErrUTF8Bad {
                t.Fatal(err)
        }
 }
@@ -219,7 +219,7 @@ func TestStrStripped2ByteInUTF8(t *testing.T) {
        f := func(x int) bool {
                bin := []byte{0xC1, (1 << 7) | (1 << 6) | byte(x)}
                _, err := NewDecoderFromBytes(bin, nil).Decode()
-               if err != ErrBadUTF8 {
+               if err != ErrUTF8Bad {
                        return false
                }
                _, err = NewDecoderFromBytes(bin,
@@ -244,7 +244,7 @@ func TestStrStripped3ByteInUTF8(t *testing.T) {
                        byte((1 << 7) | (((1 << 6) - 1) & x)),
                }
                _, err := NewDecoderFromBytes(bin, nil).Decode()
-               if err != ErrBadUTF8 {
+               if err != ErrUTF8Bad {
                        return false
                }
                _, err = NewDecoderFromBytes(bin,

diff --git a/go/tai_test.go b/go/tai_test.go
index 92b9182113ab43d8977c83c79cf6f36537ccf5f8d27915fe7caa4342c6549fc1..fda053bfbd214d73730a813ba3b323caf4fcb9a8233c7502f9b2660aab4299ee 100644 (file)
--- a/go/tai_test.go
+++ b/go/tai_test.go
@@ -105,7 +105,7 @@ func TestTAINAMsbIsSet(t *testing.T) {
 func TestTAINTooManyNanosecs(t *testing.T) {
        bin := mustHexDec("19" + "4000000000000000" + hex1G)
        _, err := NewDecoderFromBytes(bin, nil).Decode()
-       if err != ErrTooManyNsecs {
+       if err != ErrTAITooManyNsecs {
                t.Fatal(err)
        }
 }
@@ -113,7 +113,7 @@ func TestTAINTooManyNanosecs(t *testing.T) {
 func TestTAINATooManyNanosecs(t *testing.T) {
        bin := mustHexDec("1A" + "4000000000000000" + hex1G + "00010000")
        _, err := NewDecoderFromBytes(bin, nil).Decode()
-       if err != ErrTooManyNsecs {
+       if err != ErrTAITooManyNsecs {
                t.Fatal(err)
        }
 }
@@ -121,7 +121,7 @@ func TestTAINATooManyNanosecs(t *testing.T) {
 func TestTAINATooManyAttosecs(t *testing.T) {
        bin := mustHexDec("1A" + "4000000000000000" + "00010000" + hex1G)
        _, err := NewDecoderFromBytes(bin, nil).Decode()
-       if err != ErrTooManyAsecs {
+       if err != ErrTAITooManyAsecs {
                t.Fatal(err)
        }
 }

diff --git a/go/unmarshal.go b/go/unmarshal.go
index 9716988055df021c5cccbec9a32b308841f0eada34abb911c386f3aafdda47a7..9b00943a9580478f262620662c4453be6175e8b7ff0d8f77c52f29703230d905 100644 (file)
--- a/go/unmarshal.go
+++ b/go/unmarshal.go
@@ -25,13 +25,16 @@ import (
        "go.cypherpunks.su/tai64n/v4"
 )
 
-var ErrLeapSecond = errors.New("leap second")
+var (
+       ErrTAILeapSecond = errors.New("leap second")
+       ErrNonMap        = errors.New("non-map decoded")
+)
 
 func toUTC(t time.Time) (ret time.Time, err error) {
        var isLeap bool
        ret, isLeap = tai64n.Leapsecs.Sub(t)
        if isLeap {
-               err = ErrLeapSecond
+               err = ErrTAILeapSecond
        }
        return
 }
@@ -165,7 +168,7 @@ func (ctx *Decoder) UnmarshalStruct(dst any) error {
        }
        src, ok := srcAny.(map[string]any)
        if !ok {
-               return errors.New("non-map decoded")
+               return ErrNonMap
        }
        return Map2Struct(dst, src)
 }