moderize error handling with errors.As/Is

armor.go

@@ -5,6 +5,7 @@ package saltpack
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
 	"io"
 	"strings"
@@ -206,11 +207,11 @@ func (s *framedDecoderStream) Read(p []byte) (n int, err error) {
 
 	if s.state == fdsBody {
 		n, err = s.r.Read(p)
-		if err == ErrPunctuated {
+		if errors.Is(err, ErrPunctuated) {
 			err = nil
 			s.state = fdsFooter
 		}
-		if err == io.EOF {
+		if errors.Is(err, io.EOF) {
 			err = io.ErrUnexpectedEOF
 		}
 		if err != nil {
@@ -241,7 +242,7 @@ func (s *framedDecoderStream) Read(p []byte) (n int, err error) {
 
 	if s.state == fdsEndOfStream {
 		err = s.consumeUntilEOF()
-		if err == io.EOF && n > 0 {
+		if errors.Is(err, io.EOF) && n > 0 {
 			err = nil
 		}
 	}

chunk_reader_test.go

@@ -57,7 +57,7 @@ func (c exampleChunker) getNextChunk() ([]byte, error) {
 	seqno, err := c.mps.Read(&block)
 	if err != nil {
 		// An EOF here is unexpected.
-		if err == io.EOF {
+		if errors.Is(err, io.EOF) {
 			err = io.ErrUnexpectedEOF
 		}
 		return nil, err

classify_and_decrypt.go

@@ -5,6 +5,7 @@ package saltpack
 
 import (
 	"bufio"
+	"errors"
 	"fmt"
 	"io"
 	"regexp"
@@ -34,7 +35,7 @@ const (
 // rest of the message is well formed.
 func IsSaltpackBinary(stream *bufio.Reader) (msgType MessageType, version Version, err error) {
 	b, err := stream.Peek(minLengthToIdentifyBinarySaltpack)
-	if err == bufio.ErrBufferFull {
+	if errors.Is(err, bufio.ErrBufferFull) {
 		return MessageTypeUnknown, Version{}, ErrShortSliceOrBuffer
 	}
 	if err != nil {
@@ -115,7 +116,7 @@ func IsSaltpackBinarySlice(b []byte) (msgType MessageType, version Version, err
 // rest of the message is well formed.
 func IsSaltpackArmored(stream *bufio.Reader) (brand string, msgType MessageType, ver Version, err error) {
 	buf, err := stream.Peek(stream.Size())
-	if (err != nil && err != io.EOF) || len(buf) == 0 {
+	if (err != nil && !errors.Is(err, io.EOF)) || len(buf) == 0 {
 		return "", MessageTypeUnknown, ver, err
 	}
 
@@ -186,7 +187,7 @@ func IsSaltpackArmoredPrefix(pref string) (brand string, messageType MessageType
 	// a truncated block as if it was a short block. Moreover, we only need one codeword, so if an error is returned but a codeword
 	// was decoded, the error can be ignored.
 	if len(dec) < 32 {
-		if err == basex.ErrInvalidEncodingLength || err == nil {
+		if errors.Is(err, basex.ErrInvalidEncodingLength) || err == nil {
 			return "", MessageTypeUnknown, ver, ErrShortSliceOrBuffer
 		}
 		return "", MessageTypeUnknown, ver, ErrNotASaltpackMessage
@@ -222,7 +223,7 @@ func ClassifyStream(stream *bufio.Reader) (isArmored bool, brand string, message
 	brand, messageType, ver, err = IsSaltpackArmored(stream)
 	if err == nil {
 		return true, brand, messageType, ver, err
-	} else if err == ErrShortSliceOrBuffer {
+	} else if errors.Is(err, ErrShortSliceOrBuffer) {
 		return false, "", MessageTypeUnknown, Version{}, ErrShortSliceOrBuffer
 	}
 	messageType, ver, err = IsSaltpackBinary(stream)
@@ -244,7 +245,7 @@ func ClassifyEncryptedStreamAndMakeDecoder(source io.Reader, decryptionKeyring S
 	stream := bufio.NewReader(source)
 
 	isArmored, _, msgType, ver, err = ClassifyStream(stream)
-	if err == ErrShortSliceOrBuffer {
+	if errors.Is(err, ErrShortSliceOrBuffer) {
 		return nil, MessageTypeUnknown, nil, nil, false, "", Version{}, ErrShortSliceOrBuffer
 	}
 	if err != nil {

decrypt.go

@@ -7,6 +7,7 @@ import (
 	"bytes"
 	"crypto/hmac"
 	"crypto/sha512"
+	"errors"
 	"io"
 
 	"golang.org/x/crypto/nacl/secretbox"
@@ -42,7 +43,7 @@ type MessageKeyInfo struct {
 func (ds *decryptStream) getNextChunk() ([]byte, error) {
 	ciphertext, authenticators, isFinal, seqno, err := readEncryptionBlock(ds.version, ds.mps)
 	if err != nil {
-		if err == io.EOF {
+		if errors.Is(err, io.EOF) {
 			err = io.ErrUnexpectedEOF
 		}
 		return nil, err

decrypt_test.go

@@ -51,7 +51,7 @@ type errAtEOFReader struct {
 
 func (r errAtEOFReader) Read(p []byte) (n int, err error) {
 	n, err = r.Reader.Read(p)
-	if err == io.EOF {
+	if errors.Is(err, io.EOF) {
 		err = r.errAtEOF
 	}
 	return n, err

encoding/basex/go_base64_test.go

@@ -139,12 +139,12 @@ func TestDecoder(t *testing.T) {
 		decoder := NewDecoder(Base58StdEncoding, strings.NewReader(p.encoded))
 		dbuf := make([]byte, Base58StdEncoding.DecodedLen(len(p.encoded)))
 		count, err := decoder.Read(dbuf)
-		if err != nil && err != io.EOF {
+		if err != nil && !errors.Is(err, io.EOF) {
 			t.Fatal("Read failed", err)
 		}
 		testEqual(t, "Read from %q = length %v, want %v", p.encoded, count, len(p.decoded))
 		testEqual(t, "Decoding of %q = %q, want %q", p.encoded, string(dbuf[0:count]), p.decoded)
-		if err != io.EOF {
+		if !errors.Is(err, io.EOF) {
 			_, err = decoder.Read(dbuf)
 		}
 		testEqual(t, "Read from %q = %v, want %v", p.encoded, err, io.EOF)
@@ -263,7 +263,7 @@ func TestDecoderIssue3577(t *testing.T) {
 	}()
 	select {
 	case err := <-errc:
-		if err != wantErr {
+		if !errors.Is(err, wantErr) {
 			t.Errorf("got error %v; want %v", err, wantErr)
 		}
 	case <-time.After(5 * time.Second):
@@ -336,10 +336,10 @@ func TestDecodeCorrupt(t *testing.T) {
 			}
 			continue
 		}
-		switch err := err.(type) {
-		case CorruptInputError:
-			testEqual(t, "Corruption in %q at offset %v, want %v", tc.input, int(err), tc.offset)
-		default:
+		var cie CorruptInputError
+		if errors.As(err, &cie) {
+			testEqual(t, "Corruption in %q at offset %v, want %v", tc.input, int(cie), tc.offset)
+		} else {
 			t.Error("Decoder failed to detect corruption in", tc)
 		}
 	}

encoding/basex/stream.go

@@ -3,7 +3,10 @@
 
 package basex
 
-import "io"
+import (
+	"errors"
+	"io"
+)
 
 // Much of this code is adopted from Go's encoding/base64
 
@@ -145,7 +148,7 @@ func (d *decoder) Read(p []byte) (int, error) {
 
 	eof := false
 
-	if d.err == io.EOF {
+	if errors.Is(d.err, io.EOF) {
 		if d.nbuf == 0 {
 			return 0, d.err
 		}

encrypt_test.go

@@ -233,7 +233,7 @@ func slowRead(r io.Reader, sz int) ([]byte, error) {
 	for eof := false; !eof; {
 		n, err := r.Read(buf)
 		res = append(res, buf[:n]...)
-		if err == io.EOF {
+		if errors.Is(err, io.EOF) {
 			break
 		}
 		if err != nil {
@@ -1250,19 +1250,19 @@ func TestEncryptSubsequenceV1(t *testing.T) {
 	validator := SingleVersionValidator(Version1())
 	_, _, err = Open(validator, truncatedCiphertext1.Bytes(), kr)
 	expectedErr := ErrBadTag(2)
-	if err != expectedErr {
+	if !errors.Is(err, expectedErr) {
 		t.Errorf("err=%v != %v for truncatedCiphertext1", err, expectedErr)
 	}
 
 	_, _, err = Open(validator, truncatedCiphertext2.Bytes(), kr)
 	expectedErr = ErrBadTag(1)
-	if err != expectedErr {
+	if !errors.Is(err, expectedErr) {
 		t.Errorf("err=%v != %v for truncatedCiphertext2", err, expectedErr)
 	}
 
 	_, _, err = Open(validator, truncatedCiphertext3.Bytes(), kr)
 	expectedErr = ErrBadTag(1)
-	if err != expectedErr {
+	if !errors.Is(err, expectedErr) {
 		t.Errorf("err=%v != %v for truncatedCiphertext3", err, expectedErr)
 	}
 }
@@ -1316,7 +1316,7 @@ func TestEncryptSubsequenceV2(t *testing.T) {
 		validator := SingleVersionValidator(Version2())
 		_, _, err = Open(validator, truncatedCiphertext.Bytes(), kr)
 		expectedErr := ErrBadTag(1)
-		if err != expectedErr {
+		if !errors.Is(err, expectedErr) {
 			t.Errorf("err=%v != %v for truncatedCiphertext%d", err, expectedErr, i+1)
 		}
 	}
@@ -1547,7 +1547,8 @@ func (i encryptArmor62SealInput) call() (string, error) {
 		receivers,
 		constantEphemeralKeyCreator{ephemeralKey},
 		constantEncryptRNG{payloadKey, i.permutation},
-		i.brand)
+		i.brand,
+	)
 }
 
 // encryptArmor62SealResult encapsulates all the inputs and outputs of

punctuated_reader.go

@@ -103,17 +103,17 @@ func (p *punctuatedReader) ReadUntilPunctuation(lim int) (res []byte, err error)
 	for {
 		var n int
 		n, err = p.Read(p.buf[:])
-		switch err {
-		case nil, ErrPunctuated:
+		switch {
+		case err == nil, errors.Is(err, ErrPunctuated):
 			res = append(res, p.buf[0:n]...)
-			if err == ErrPunctuated {
+			if errors.Is(err, ErrPunctuated) {
 				err = nil
 				return res, err
 			}
 			if len(res) >= lim {
 				return nil, ErrOverflow
 			}
-		case io.EOF:
+		case errors.Is(err, io.EOF):
 			err = io.ErrUnexpectedEOF
 			fallthrough
 		default:

punctuated_reader_test.go

@@ -5,6 +5,7 @@ package saltpack
 
 import (
 	"bytes"
+	"errors"
 	"io"
 	"testing"
 )
@@ -50,7 +51,7 @@ func TestPunctuatedReaderRegularReads(t *testing.T) {
 		}
 	}
 	_, err := r.ReadUntilPunctuation(1024)
-	if err != io.ErrUnexpectedEOF {
+	if !errors.Is(err, io.ErrUnexpectedEOF) {
 		t.Fatalf("Wrong error; wanted %v but got %v", io.ErrUnexpectedEOF, err)
 	}
 }
@@ -64,15 +65,15 @@ func TestPunctuatedReaderSlowReads(t *testing.T) {
 		}
 	}
 	_, err := r.ReadUntilPunctuation(1024)
-	if err != io.ErrUnexpectedEOF {
+	if !errors.Is(err, io.ErrUnexpectedEOF) {
 		t.Fatalf("Wrong error; wanted %v but got %v", io.ErrUnexpectedEOF, err)
 	}
 }
 
 func TestPunctuatedReaderSlowReadsOverflow(t *testing.T) {
 	r := newPunctuatedReader(&slowReader{[]byte(testText)}, '.')
 	_, err := r.ReadUntilPunctuation(20)
-	if err != ErrOverflow {
+	if !errors.Is(err, ErrOverflow) {
 		t.Fatalf("Wrong error; wanted %v but got %v", ErrOverflow, err)
 	}
 }