Skip to content

Commit 3453256

Browse files
SuperManifoldsSuperManifolds
authored
BREAKING: fix linter issues (#38)
Rename errors to follow Go code-style conventions
1 parent 70db268 commit 3453256

File tree

6 files changed

+66
-66
lines changed

6 files changed

+66
-66
lines changed

‎buffer_test.go

+2-2
Original file line numberDiff line numberDiff line change
@@ -406,7 +406,7 @@ func TestNilSlice(t *testing.T) {
406406
assert.Equal(t, uint32(len(s)), j)
407407

408408
j, err = d.Slice(StringKind)
409-
assert.ErrorIs(t, err, InvalidSlice)
409+
assert.ErrorIs(t, err, ErrInvalidSlice)
410410
assert.Zero(t, j)
411411
}
412412

@@ -420,7 +420,7 @@ func TestError(t *testing.T) {
420420

421421
d := Decoder(p.Bytes())
422422
_, err := d.String()
423-
assert.ErrorIs(t, err, InvalidString)
423+
assert.ErrorIs(t, err, ErrInvalidString)
424424

425425
val, err := d.Error()
426426
assert.NoError(t, err)

‎decode.go

+32-32
Original file line numberDiff line numberDiff line change
@@ -30,20 +30,20 @@ const (
3030
)
3131

3232
var (
33-
InvalidSlice = errors.New("invalid slice encoding")
34-
InvalidMap = errors.New("invalid map encoding")
35-
InvalidBytes = errors.New("invalid bytes encoding")
36-
InvalidString = errors.New("invalid string encoding")
37-
InvalidError = errors.New("invalid error encoding")
38-
InvalidBool = errors.New("invalid bool encoding")
39-
InvalidUint8 = errors.New("invalid uint8 encoding")
40-
InvalidUint16 = errors.New("invalid uint16 encoding")
41-
InvalidUint32 = errors.New("invalid uint32 encoding")
42-
InvalidUint64 = errors.New("invalid uint64 encoding")
43-
InvalidInt32 = errors.New("invalid int32 encoding")
44-
InvalidInt64 = errors.New("invalid int64 encoding")
45-
InvalidFloat32 = errors.New("invalid float32 encoding")
46-
InvalidFloat64 = errors.New("invalid float64 encoding")
33+
ErrInvalidSlice = errors.New("invalid slice encoding")
34+
ErrInvalidMap = errors.New("invalid map encoding")
35+
ErrInvalidBytes = errors.New("invalid bytes encoding")
36+
ErrInvalidString = errors.New("invalid string encoding")
37+
ErrInvalidError = errors.New("invalid error encoding")
38+
ErrInvalidBool = errors.New("invalid bool encoding")
39+
ErrInvalidUint8 = errors.New("invalid uint8 encoding")
40+
ErrInvalidUint16 = errors.New("invalid uint16 encoding")
41+
ErrInvalidUint32 = errors.New("invalid uint32 encoding")
42+
ErrInvalidUint64 = errors.New("invalid uint64 encoding")
43+
ErrInvalidInt32 = errors.New("invalid int32 encoding")
44+
ErrInvalidInt64 = errors.New("invalid int64 encoding")
45+
ErrInvalidFloat32 = errors.New("invalid float32 encoding")
46+
ErrInvalidFloat64 = errors.New("invalid float64 encoding")
4747
)
4848

4949
func decodeNil(b []byte) ([]byte, bool) {
@@ -59,11 +59,11 @@ func decodeMap(b []byte, keyKind, valueKind Kind) ([]byte, uint32, error) {
5959
var err error
6060
b, size, err = decodeUint32(b[3:])
6161
if err != nil {
62-
return b, 0, InvalidMap
62+
return b, 0, ErrInvalidMap
6363
}
6464
return b, size, nil
6565
}
66-
return b, 0, InvalidMap
66+
return b, 0, ErrInvalidMap
6767
}
6868

6969
func decodeSlice(b []byte, kind Kind) ([]byte, uint32, error) {
@@ -72,11 +72,11 @@ func decodeSlice(b []byte, kind Kind) ([]byte, uint32, error) {
7272
var err error
7373
b, size, err = decodeUint32(b[2:])
7474
if err != nil {
75-
return b, 0, InvalidSlice
75+
return b, 0, ErrInvalidSlice
7676
}
7777
return b, size, nil
7878
}
79-
return b, 0, InvalidSlice
79+
return b, 0, ErrInvalidSlice
8080
}
8181

8282
func decodeBytes(b []byte, ret []byte) ([]byte, []byte, error) {
@@ -120,7 +120,7 @@ func decodeBytes(b []byte, ret []byte) ([]byte, []byte, error) {
120120
return b[size+offset:], append(ret[:0], b[offset:size+offset]...), nil
121121
}
122122
}
123-
return b, nil, InvalidBytes
123+
return b, nil, ErrInvalidBytes
124124
}
125125

126126
func decodeString(b []byte) ([]byte, string, error) {
@@ -129,13 +129,13 @@ func decodeString(b []byte) ([]byte, string, error) {
129129
var err error
130130
b, size, err = decodeUint32(b[1:])
131131
if err != nil {
132-
return b, emptyString, InvalidString
132+
return b, emptyString, ErrInvalidString
133133
}
134134
if len(b) > int(size)-1 {
135135
return b[size:], string(b[:size]), nil
136136
}
137137
}
138-
return b, emptyString, InvalidString
138+
return b, emptyString, ErrInvalidString
139139
}
140140

141141
func decodeError(b []byte) ([]byte, error, error) {
@@ -144,11 +144,11 @@ func decodeError(b []byte) ([]byte, error, error) {
144144
var err error
145145
b, val, err = decodeString(b[1:])
146146
if err != nil {
147-
return b, nil, InvalidError
147+
return b, nil, ErrInvalidError
148148
}
149149
return b, Error(val), nil
150150
}
151-
return b, nil, InvalidError
151+
return b, nil, ErrInvalidError
152152
}
153153

154154
func decodeBool(b []byte) ([]byte, bool, error) {
@@ -160,14 +160,14 @@ func decodeBool(b []byte) ([]byte, bool, error) {
160160
return b[2:], false, nil
161161
}
162162
}
163-
return b, false, InvalidBool
163+
return b, false, ErrInvalidBool
164164
}
165165

166166
func decodeUint8(b []byte) ([]byte, uint8, error) {
167167
if len(b) > 1 && b[0] == Uint8RawKind {
168168
return b[2:], b[1], nil
169169
}
170-
return b, 0, InvalidUint8
170+
return b, 0, ErrInvalidUint8
171171
}
172172

173173
func decodeUint16(b []byte) ([]byte, uint16, error) {
@@ -189,7 +189,7 @@ func decodeUint16(b []byte) ([]byte, uint16, error) {
189189
return b[4:], x | (cb << 14), nil
190190
}
191191
}
192-
return b, 0, InvalidUint16
192+
return b, 0, ErrInvalidUint16
193193
}
194194

195195
func decodeUint32(b []byte) ([]byte, uint32, error) {
@@ -223,7 +223,7 @@ func decodeUint32(b []byte) ([]byte, uint32, error) {
223223
return b[6:], x | (cb << 28), nil
224224
}
225225
}
226-
return b, 0, InvalidUint32
226+
return b, 0, ErrInvalidUint32
227227
}
228228

229229
func decodeUint64(b []byte) ([]byte, uint64, error) {
@@ -287,7 +287,7 @@ func decodeUint64(b []byte) ([]byte, uint64, error) {
287287
return b[11:], x | (cb << 63), nil
288288
}
289289
}
290-
return b, 0, InvalidUint64
290+
return b, 0, ErrInvalidUint64
291291
}
292292

293293
func decodeInt32(b []byte) ([]byte, int32, error) {
@@ -341,7 +341,7 @@ func decodeInt32(b []byte) ([]byte, int32, error) {
341341
return b[6:], int32(x >> 1), nil
342342
}
343343
}
344-
return b, 0, InvalidInt32
344+
return b, 0, ErrInvalidInt32
345345
}
346346

347347
func decodeInt64(b []byte) ([]byte, int64, error) {
@@ -445,20 +445,20 @@ func decodeInt64(b []byte) ([]byte, int64, error) {
445445
return b[11:], int64(x >> 1), nil
446446
}
447447
}
448-
return b, 0, InvalidInt64
448+
return b, 0, ErrInvalidInt64
449449
}
450450

451451
func decodeFloat32(b []byte) ([]byte, float32, error) {
452452
if len(b) > 4 && b[0] == Float32RawKind {
453453
return b[5:], math.Float32frombits(uint32(b[4]) | uint32(b[3])<<8 | uint32(b[2])<<16 | uint32(b[1])<<24), nil
454454
}
455-
return b, 0, InvalidFloat32
455+
return b, 0, ErrInvalidFloat32
456456
}
457457

458458
func decodeFloat64(b []byte) ([]byte, float64, error) {
459459
if len(b) > 8 && b[0] == Float64RawKind {
460460
return b[9:], math.Float64frombits(uint64(b[8]) | uint64(b[7])<<8 | uint64(b[6])<<16 | uint64(b[5])<<24 |
461461
uint64(b[4])<<32 | uint64(b[3])<<40 | uint64(b[2])<<48 | uint64(b[1])<<56), nil
462462
}
463-
return b, 0, InvalidFloat64
463+
return b, 0, ErrInvalidFloat64
464464
}

‎decode_test.go

+14-14
Original file line numberDiff line numberDiff line change
@@ -66,10 +66,10 @@ func TestDecodeMap(t *testing.T) {
6666
assert.Equal(t, 0, len(remaining))
6767

6868
_, _, err = decodeMap((p.Bytes())[1:], StringKind, Uint32Kind)
69-
assert.ErrorIs(t, err, InvalidMap)
69+
assert.ErrorIs(t, err, ErrInvalidMap)
7070

7171
_, _, err = decodeMap(p.Bytes(), StringKind, Float64Kind)
72-
assert.ErrorIs(t, err, InvalidMap)
72+
assert.ErrorIs(t, err, ErrInvalidMap)
7373

7474
remaining, size, err = decodeMap(p.Bytes(), StringKind, Uint32Kind)
7575
assert.NoError(t, err)
@@ -100,7 +100,7 @@ func TestDecodeBytes(t *testing.T) {
100100
assert.Equal(t, 0, len(remaining))
101101

102102
_, value, err = decodeBytes((p.Bytes())[1:], value)
103-
assert.ErrorIs(t, err, InvalidBytes)
103+
assert.ErrorIs(t, err, ErrInvalidBytes)
104104

105105
remaining, value, err = decodeBytes(p.Bytes(), value)
106106
assert.NoError(t, err)
@@ -163,7 +163,7 @@ func TestDecodeString(t *testing.T) {
163163
assert.Equal(t, 0, len(remaining))
164164

165165
_, _, err = decodeString((p.Bytes())[1:])
166-
assert.ErrorIs(t, err, InvalidString)
166+
assert.ErrorIs(t, err, ErrInvalidString)
167167

168168
remaining, value, err = decodeString(p.Bytes())
169169
assert.NoError(t, err)
@@ -219,7 +219,7 @@ func TestDecodeError(t *testing.T) {
219219
assert.Equal(t, 0, len(remaining))
220220

221221
_, _, err = decodeError((p.Bytes())[1:])
222-
assert.ErrorIs(t, err, InvalidError)
222+
assert.ErrorIs(t, err, ErrInvalidError)
223223

224224
remaining, value, err = decodeError(p.Bytes())
225225
assert.NoError(t, err)
@@ -273,7 +273,7 @@ func TestDecodeBool(t *testing.T) {
273273
assert.Equal(t, 0, len(remaining))
274274

275275
_, _, err = decodeBool((p.Bytes())[1:])
276-
assert.ErrorIs(t, err, InvalidBool)
276+
assert.ErrorIs(t, err, ErrInvalidBool)
277277

278278
remaining, value, err = decodeBool(p.Bytes())
279279
assert.NoError(t, err)
@@ -329,7 +329,7 @@ func TestDecodeUint8(t *testing.T) {
329329
assert.Equal(t, 0, len(remaining))
330330

331331
_, _, err = decodeUint8((p.Bytes())[1:])
332-
assert.ErrorIs(t, err, InvalidUint8)
332+
assert.ErrorIs(t, err, ErrInvalidUint8)
333333

334334
remaining, value, err = decodeUint8(p.Bytes())
335335
assert.NoError(t, err)
@@ -363,7 +363,7 @@ func TestDecodeUint16(t *testing.T) {
363363
assert.Equal(t, 0, len(remaining))
364364

365365
_, _, err = decodeUint16((p.Bytes())[1:])
366-
assert.ErrorIs(t, err, InvalidUint16)
366+
assert.ErrorIs(t, err, ErrInvalidUint16)
367367

368368
remaining, value, err = decodeUint16(p.Bytes())
369369
assert.NoError(t, err)
@@ -397,7 +397,7 @@ func TestDecodeUint32(t *testing.T) {
397397
assert.Equal(t, 0, len(remaining))
398398

399399
_, _, err = decodeUint32((p.Bytes())[1:])
400-
assert.ErrorIs(t, err, InvalidUint32)
400+
assert.ErrorIs(t, err, ErrInvalidUint32)
401401

402402
remaining, value, err = decodeUint32(p.Bytes())
403403
assert.NoError(t, err)
@@ -432,7 +432,7 @@ func TestDecodeUint64(t *testing.T) {
432432
assert.Equal(t, 0, len(remaining))
433433

434434
_, _, err = decodeUint64((p.Bytes())[1:])
435-
assert.ErrorIs(t, err, InvalidUint64)
435+
assert.ErrorIs(t, err, ErrInvalidUint64)
436436

437437
remaining, value, err = decodeUint64(p.Bytes())
438438
assert.NoError(t, err)
@@ -475,7 +475,7 @@ func TestDecodeInt32(t *testing.T) {
475475
assert.Equal(t, 0, len(remaining))
476476

477477
_, _, err = decodeInt32((p.Bytes())[1:])
478-
assert.ErrorIs(t, err, InvalidInt32)
478+
assert.ErrorIs(t, err, ErrInvalidInt32)
479479

480480
remaining, value, err = decodeInt32(p.Bytes())
481481
assert.NoError(t, err)
@@ -519,7 +519,7 @@ func TestDecodeInt64(t *testing.T) {
519519
assert.Equal(t, 0, len(remaining))
520520

521521
_, _, err = decodeInt64((p.Bytes())[1:])
522-
assert.ErrorIs(t, err, InvalidInt64)
522+
assert.ErrorIs(t, err, ErrInvalidInt64)
523523

524524
remaining, value, err = decodeInt64(p.Bytes())
525525
assert.NoError(t, err)
@@ -554,7 +554,7 @@ func TestDecodeFloat32(t *testing.T) {
554554
assert.Equal(t, 0, len(remaining))
555555

556556
_, _, err = decodeFloat32((p.Bytes())[1:])
557-
assert.ErrorIs(t, err, InvalidFloat32)
557+
assert.ErrorIs(t, err, ErrInvalidFloat32)
558558

559559
remaining, value, err = decodeFloat32(p.Bytes())
560560
assert.NoError(t, err)
@@ -588,7 +588,7 @@ func TestDecodeFloat64(t *testing.T) {
588588
assert.Equal(t, 0, len(remaining))
589589

590590
_, _, err = decodeFloat64((p.Bytes())[1:])
591-
assert.ErrorIs(t, err, InvalidFloat64)
591+
assert.ErrorIs(t, err, ErrInvalidFloat64)
592592

593593
remaining, value, err = decodeFloat64(p.Bytes())
594594
assert.NoError(t, err)

0 commit comments

Comments
 (0)