func errors.New
1034 uses
errors (current package)
errors.go#L58: func New(text string) error {
bufio
bufio.go#L23: ErrInvalidUnreadByte = errors.New("bufio: invalid use of UnreadByte")
bufio.go#L24: ErrInvalidUnreadRune = errors.New("bufio: invalid use of UnreadRune")
bufio.go#L25: ErrBufferFull = errors.New("bufio: buffer full")
bufio.go#L26: ErrNegativeCount = errors.New("bufio: negative count")
bufio.go#L89: var errNegativeRead = errors.New("bufio: reader returned negative count from Read")
bufio.go#L552: var errNegativeWrite = errors.New("bufio: writer returned negative count from Write")
scan.go#L70: ErrTooLong = errors.New("bufio.Scanner: token too long")
scan.go#L71: ErrNegativeAdvance = errors.New("bufio.Scanner: SplitFunc returns negative advance count")
scan.go#L72: ErrAdvanceTooFar = errors.New("bufio.Scanner: SplitFunc returns advance count beyond input")
scan.go#L73: ErrBadReadCount = errors.New("bufio.Scanner: Read returned impossible count")
scan.go#L125: var ErrFinalToken = errors.New("final token")
bytes
buffer.go#L44: var ErrTooLarge = errors.New("bytes.Buffer: too large")
buffer.go#L45: var errNegativeRead = errors.New("bytes.Buffer: reader returned negative count from Read")
buffer.go#L377: return errors.New("bytes.Buffer: UnreadRune: previous operation was not a successful ReadRune")
buffer.go#L386: var errUnreadByte = errors.New("bytes.Buffer: UnreadByte: previous operation was not a successful read")
reader.go#L54: return 0, errors.New("bytes.Reader.ReadAt: negative offset")
reader.go#L80: return errors.New("bytes.Reader.UnreadByte: at beginning of slice")
reader.go#L106: return errors.New("bytes.Reader.UnreadRune: at beginning of slice")
reader.go#L109: return errors.New("bytes.Reader.UnreadRune: previous operation was not ReadRune")
reader.go#L128: return 0, errors.New("bytes.Reader.Seek: invalid whence")
reader.go#L131: return 0, errors.New("bytes.Reader.Seek: negative position")
compress/gzip
gunzip.go#L32: ErrChecksum = errors.New("gzip: invalid checksum")
gunzip.go#L34: ErrHeader = errors.New("gzip: invalid header")
gzip.go#L95: return errors.New("gzip.Write: Extra data is too large")
gzip.go#L113: return errors.New("gzip.Write: non-Latin-1 header string")
context
context.go#L157: var Canceled = errors.New("context canceled")
crypto/aes
aes_gcm.go#L40: var errOpen = errors.New("cipher: message authentication failed")
crypto/cipher
gcm.go#L113: return nil, errors.New("cipher: incorrect tag size given to GCM")
gcm.go#L117: return nil, errors.New("cipher: the nonce can't have zero length, or the security of the key will be immediately compromised")
gcm.go#L125: return nil, errors.New("cipher: NewGCM requires 128-bit block cipher")
gcm.go#L195: var errOpen = errors.New("cipher: message authentication failed")
crypto/dsa
dsa.go#L46: var ErrInvalidPublicKey = errors.New("crypto/dsa: invalid public key")
dsa.go#L86: return errors.New("crypto/dsa: invalid ParameterSizes")
dsa.go#L161: return errors.New("crypto/dsa: parameters not set up before generating key")
crypto/ecdsa
ecdsa.go#L187: var errZeroParam = errors.New("zero parameter")
crypto/ed25519
ed25519.go#L87: return nil, errors.New("ed25519: cannot sign hashed message")
crypto/ed25519/internal/edwards25519
edwards25519.go#L155: return nil, errors.New("edwards25519: invalid point encoding length")
edwards25519.go#L174: return nil, errors.New("edwards25519: invalid point encoding")
scalar.go#L99: return nil, errors.New("invalid scalar length")
scalar.go#L104: return nil, errors.New("invalid scalar encoding")
crypto/elliptic/internal/fiat
p224.go#L81: return nil, errors.New("invalid P224Element encoding")
p224.go#L88: return nil, errors.New("invalid P224Element encoding")
p384.go#L81: return nil, errors.New("invalid P384Element encoding")
p384.go#L88: return nil, errors.New("invalid P384Element encoding")
p521.go#L81: return nil, errors.New("invalid P521Element encoding")
p521.go#L88: return nil, errors.New("invalid P521Element encoding")
crypto/elliptic/internal/nistec
p224.go#L89: return nil, errors.New("unimplemented") // TODO(filippo)
p224.go#L92: return nil, errors.New("invalid P224 point encoding")
p224.go#L111: return errors.New("P224 point not on curve")
p384.go#L94: return nil, errors.New("unimplemented") // TODO(filippo)
p384.go#L97: return nil, errors.New("invalid P384 point encoding")
p384.go#L116: return errors.New("P384 point not on curve")
p521.go#L106: return nil, errors.New("unimplemented") // TODO(filippo)
p521.go#L109: return nil, errors.New("invalid P521 point encoding")
p521.go#L128: return errors.New("P521 point not on curve")
crypto/md5
md5.go#L74: return errors.New("crypto/md5: invalid hash state identifier")
md5.go#L77: return errors.New("crypto/md5: invalid hash state size")
crypto/rand
util.go#L33: err = errors.New("crypto/rand: prime size must be at least 2-bit")
crypto/rsa
pkcs1v15.go#L316: return 0, nil, errors.New("crypto/rsa: input must be hashed message")
pkcs1v15.go#L320: return 0, nil, errors.New("crypto/rsa: unsupported hash function")
pss.go#L45: return nil, errors.New("crypto/rsa: input must be hashed with given hash")
pss.go#L51: return nil, errors.New("crypto/rsa: key size too small for PSS signature")
pss.go#L115: return errors.New("rsa: internal error: inconsistent length")
rsa.go#L76: errPublicModulus = errors.New("crypto/rsa: missing public modulus")
rsa.go#L77: errPublicExponentSmall = errors.New("crypto/rsa: public exponent too small")
rsa.go#L78: errPublicExponentLarge = errors.New("crypto/rsa: public exponent too large")
rsa.go#L179: return nil, errors.New("crypto/rsa: invalid options for Decrypt")
rsa.go#L213: return errors.New("crypto/rsa: invalid prime value")
rsa.go#L218: return errors.New("crypto/rsa: invalid modulus")
rsa.go#L233: return errors.New("crypto/rsa: invalid exponents")
rsa.go#L263: return nil, errors.New("crypto/rsa: GenerateMultiPrimeKey: nprimes must be >= 2")
rsa.go#L277: return nil, errors.New("crypto/rsa: too few primes of given length to generate an RSA key")
rsa.go#L385: var ErrMessageTooLong = errors.New("crypto/rsa: message too long for RSA public key size")
rsa.go#L450: var ErrDecryption = errors.New("crypto/rsa: decryption error")
rsa.go#L454: var ErrVerification = errors.New("crypto/rsa: verification error")
rsa.go#L579: return nil, errors.New("rsa: internal error")
crypto/sha1
sha1.go#L66: return errors.New("crypto/sha1: invalid hash state identifier")
sha1.go#L69: return errors.New("crypto/sha1: invalid hash state size")
crypto/sha256
sha256.go#L88: return errors.New("crypto/sha256: invalid hash state identifier")
sha256.go#L91: return errors.New("crypto/sha256: invalid hash state size")
crypto/sha512
sha512.go#L153: return nil, errors.New("crypto/sha512: invalid hash function")
sha512.go#L171: return errors.New("crypto/sha512: invalid hash state identifier")
sha512.go#L179: return errors.New("crypto/sha512: invalid hash state identifier")
sha512.go#L182: return errors.New("crypto/sha512: invalid hash state size")
crypto/tls
auth.go#L30: return errors.New("ECDSA verification failure")
auth.go#L38: return errors.New("Ed25519 verification failure")
auth.go#L58: return errors.New("internal error: unknown signature type")
auth.go#L248: return 0, errors.New("tls: peer doesn't support any of the certificate's signature algorithms")
common.go#L1057: var errNoCertificates = errors.New("tls: no certificates configured")
common.go#L1127: return errors.New("no mutually supported protocol versions")
common.go#L1195: return supportsRSAFallback(errors.New("client doesn't support ECDHE, can only use legacy RSA key exchange"))
common.go#L1221: return errors.New("client doesn't support certificate curve")
common.go#L1226: return errors.New("connection doesn't support Ed25519")
common.go#L1259: return supportsRSAFallback(errors.New("client doesn't support any cipher suites compatible with the certificate"))
common.go#L1294: return errors.New("chain is not signed by an acceptable CA")
conn.go#L608: return c.in.setErrorLocked(errors.New("tls: internal error: attempted to read record with pending application data"))
conn.go#L767: return c.in.setErrorLocked(errors.New("tls: too many ignored records"))
conn.go#L1097: errShutdown = errors.New("tls: protocol is shutdown")
conn.go#L1165: return errors.New("tls: internal error: unexpected renegotiation")
conn.go#L1194: return errors.New("tls: unknown Renegotiation value")
conn.go#L1222: return c.in.setErrorLocked(errors.New("tls: too many non-advancing records"))
conn.go#L1349: var errEarlyCloseWrite = errors.New("tls: CloseWrite called before handshake complete")
conn.go#L1462: c.handshakeErr = errors.New("tls: internal error: handshake should have had a result")
conn.go#L1519: return errors.New("tls: VerifyHostname called on TLS server connection")
conn.go#L1522: return errors.New("tls: handshake has not yet been performed")
conn.go#L1525: return errors.New("tls: handshake did not verify certificate chain")
handshake_client.go#L40: return nil, nil, errors.New("tls: either ServerName or InsecureSkipVerify must be specified in the tls.Config")
handshake_client.go#L46: return nil, nil, errors.New("tls: invalid NextProtos value")
handshake_client.go#L52: return nil, nil, errors.New("tls: NextProtos values too large")
handshake_client.go#L57: return nil, nil, errors.New("tls: no supported versions satisfy MinVersion and MaxVersion")
handshake_client.go#L109: return nil, nil, errors.New("tls: short read from Rand: " + err.Error())
handshake_client.go#L116: return nil, nil, errors.New("tls: short read from Rand: " + err.Error())
handshake_client.go#L133: return nil, nil, errors.New("tls: CurvePreferences includes unsupported curve")
handshake_client.go#L203: return errors.New("tls: downgrade attempt detected, possibly due to a MitM attack or a broken middlebox")
handshake_client.go#L461: return errors.New("tls: server chose an unconfigured cipher suite")
handshake_client.go#L498: return errors.New("tls: received unexpected CertificateStatus message")
handshake_client.go#L525: return errors.New("tls: server's identity changed during renegotiation")
handshake_client.go#L647: return errors.New("tls: failed to write to key log: " + err.Error())
handshake_client.go#L693: return false, errors.New("tls: server selected unsupported compression format")
handshake_client.go#L700: return false, errors.New("tls: initial handshake had non-empty renegotiation extension")
handshake_client.go#L710: return false, errors.New("tls: incorrect renegotiation extension contents")
handshake_client.go#L728: return false, errors.New("tls: server resumed a session with a different version")
handshake_client.go#L733: return false, errors.New("tls: server resumed a session with a different cipher suite")
handshake_client.go#L757: return errors.New("tls: server advertised unrequested ALPN extension")
handshake_client.go#L764: return errors.New("tls: server selected unadvertised ALPN protocol")
handshake_client.go#L788: return errors.New("tls: server's Finished message was incorrect")
handshake_client.go#L852: return errors.New("tls: failed to parse certificate from server: " + err.Error())
handshake_client_tls13.go#L48: return errors.New("tls: server selected TLS 1.3 in a renegotiation")
handshake_client_tls13.go#L115: return errors.New("tls: server selected TLS 1.3 using the legacy version field")
handshake_client_tls13.go#L120: return errors.New("tls: server selected an invalid version after a HelloRetryRequest")
handshake_client_tls13.go#L125: return errors.New("tls: server sent an incorrect legacy version")
handshake_client_tls13.go#L135: return errors.New("tls: server sent a ServerHello extension forbidden in TLS 1.3")
handshake_client_tls13.go#L140: return errors.New("tls: server did not echo the legacy session ID")
handshake_client_tls13.go#L145: return errors.New("tls: server selected unsupported compression format")
handshake_client_tls13.go#L151: return errors.New("tls: server changed cipher suite after a HelloRetryRequest")
handshake_client_tls13.go#L155: return errors.New("tls: server chose an unconfigured cipher suite")
handshake_client_tls13.go#L194: return errors.New("tls: server sent an unnecessary HelloRetryRequest message")
handshake_client_tls13.go#L203: return errors.New("tls: received malformed key_share extension")
handshake_client_tls13.go#L219: return errors.New("tls: server selected unsupported group")
handshake_client_tls13.go#L223: return errors.New("tls: server sent an unnecessary HelloRetryRequest key_share")
handshake_client_tls13.go#L227: return errors.New("tls: CurvePreferences includes unsupported curve")
handshake_client_tls13.go#L292: return errors.New("tls: server sent two HelloRetryRequest messages")
handshake_client_tls13.go#L297: return errors.New("tls: server sent a cookie in a normal ServerHello")
handshake_client_tls13.go#L302: return errors.New("tls: malformed key_share extension")
handshake_client_tls13.go#L307: return errors.New("tls: server did not send a key share")
handshake_client_tls13.go#L311: return errors.New("tls: server selected unsupported group")
handshake_client_tls13.go#L320: return errors.New("tls: server selected an invalid PSK")
handshake_client_tls13.go#L332: return errors.New("tls: server selected an invalid PSK and cipher suite pair")
handshake_client_tls13.go#L350: return errors.New("tls: invalid server key share")
handshake_client_tls13.go#L450: return errors.New("tls: received empty certificates message")
handshake_client_tls13.go#L475: return errors.New("tls: certificate used with invalid signature algorithm")
handshake_client_tls13.go#L483: return errors.New("tls: certificate used with invalid signature algorithm")
handshake_client_tls13.go#L489: return errors.New("tls: invalid signature by the server certificate: " + err.Error())
handshake_client_tls13.go#L514: return errors.New("tls: invalid server finished hash")
handshake_client_tls13.go#L600: return errors.New("tls: failed to sign handshake: " + err.Error())
handshake_client_tls13.go#L637: return errors.New("tls: received new session ticket from a client")
handshake_client_tls13.go#L651: return errors.New("tls: received a session ticket with invalid lifetime")
handshake_server.go#L188: return errors.New("tls: client does not support uncompressed connections")
handshake_server.go#L211: return errors.New("tls: initial handshake had non-empty renegotiation extension")
handshake_server.go#L350: return errors.New("tls: no cipher suite supported by both client and server")
handshake_server.go#L359: return errors.New("tls: client using inappropriate protocol fallback")
handshake_server.go#L650: return errors.New("tls: client certificate used with invalid signature algorithm")
handshake_server.go#L667: return errors.New("tls: invalid signature by the client certificate: " + err.Error())
handshake_server.go#L724: return errors.New("tls: client's Finished message is incorrect")
handshake_server.go#L804: return errors.New("tls: failed to parse client certificate: " + err.Error())
handshake_server.go#L810: return errors.New("tls: client didn't provide a certificate")
handshake_server.go#L828: return errors.New("tls: failed to verify client certificate: " + err.Error())
handshake_server_tls13.go#L97: return errors.New("tls: client used the legacy version field to negotiate TLS 1.3")
handshake_server_tls13.go#L115: return errors.New("tls: client using inappropriate protocol fallback")
handshake_server_tls13.go#L124: return errors.New("tls: TLS 1.3 client supports illegal compression methods")
handshake_server_tls13.go#L135: return errors.New("tls: initial handshake had non-empty renegotiation extension")
handshake_server_tls13.go#L146: return errors.New("tls: client sent unexpected early data")
handshake_server_tls13.go#L164: return errors.New("tls: no cipher suite supported by both client and server")
handshake_server_tls13.go#L195: return errors.New("tls: no ECDHE curve supported by both client and server")
handshake_server_tls13.go#L206: return errors.New("tls: CurvePreferences includes unsupported curve")
handshake_server_tls13.go#L217: return errors.New("tls: invalid client key share")
handshake_server_tls13.go#L244: return errors.New("tls: invalid or missing PSK binders")
handshake_server_tls13.go#L298: return errors.New("tls: internal error: failed to clone hash")
handshake_server_tls13.go#L304: return errors.New("tls: invalid PSK binder")
handshake_server_tls13.go#L438: return errors.New("tls: client sent invalid key share in second ClientHello")
handshake_server_tls13.go#L443: return errors.New("tls: client indicated early data in second ClientHello")
handshake_server_tls13.go#L448: return errors.New("tls: client illegally modified second ClientHello")
handshake_server_tls13.go#L631: return errors.New("tls: failed to sign handshake: " + err.Error())
handshake_server_tls13.go#L807: return errors.New("tls: client certificate used with invalid signature algorithm")
handshake_server_tls13.go#L815: return errors.New("tls: client certificate used with invalid signature algorithm")
handshake_server_tls13.go#L821: return errors.New("tls: invalid signature by the client certificate: " + err.Error())
handshake_server_tls13.go#L852: return errors.New("tls: invalid client finished hash")
key_agreement.go#L37: var errClientKeyExchange = errors.New("tls: invalid ClientKeyExchange message")
key_agreement.go#L38: var errServerKeyExchange = errors.New("tls: invalid ServerKeyExchange message")
key_agreement.go#L60: return nil, errors.New("tls: certificate private key does not implement crypto.Decrypter")
key_agreement.go#L77: return errors.New("tls: unexpected ServerKeyExchange")
key_agreement.go#L91: return nil, nil, errors.New("tls: server certificate contains incorrect key type for selected ciphersuite")
key_agreement.go#L178: return nil, errors.New("tls: no supported elliptic curves offered")
key_agreement.go#L181: return nil, errors.New("tls: CurvePreferences includes unsupported curve")
key_agreement.go#L223: return nil, errors.New("tls: certificate cannot be used with the selected cipher suite")
key_agreement.go#L234: return nil, errors.New("tls: failed to sign ECDHE parameters: " + err.Error())
key_agreement.go#L275: return errors.New("tls: server selected unsupported curve")
key_agreement.go#L292: return errors.New("tls: server selected unsupported curve")
key_agreement.go#L322: return errors.New("tls: certificate used with invalid signature algorithm")
key_agreement.go#L346: return errors.New("tls: invalid signature by the server certificate: " + err.Error())
key_agreement.go#L353: return nil, nil, errors.New("tls: missing ServerKeyExchange message")
key_schedule.go#L127: return nil, errors.New("tls: internal error: unsupported curve")
prf.go#L250: return nil, errors.New("crypto/tls: ExportKeyingMaterial is unavailable when renegotiation is enabled")
ticket.go#L121: return nil, errors.New("tls: internal error: session ticket keys unavailable")
ticket.go#L136: return nil, errors.New("tls: failed to create cipher while encrypting ticket: " + err.Error())
tls.go#L91: return nil, errors.New("tls: neither Certificates, GetCertificate, nor GetConfigForClient set in Config")
tls.go#L265: return fail(errors.New("tls: failed to find any PEM data in certificate input"))
tls.go#L268: return fail(errors.New("tls: failed to find certificate PEM data in certificate input, but did find a private key; PEM inputs may have been switched"))
tls.go#L279: return fail(errors.New("tls: failed to find any PEM data in key input"))
tls.go#L282: return fail(errors.New("tls: found a certificate rather than a key in the PEM for the private key"))
tls.go#L308: return fail(errors.New("tls: private key type does not match public key type"))
tls.go#L311: return fail(errors.New("tls: private key does not match public key"))
tls.go#L316: return fail(errors.New("tls: private key type does not match public key type"))
tls.go#L319: return fail(errors.New("tls: private key does not match public key"))
tls.go#L324: return fail(errors.New("tls: private key type does not match public key type"))
tls.go#L327: return fail(errors.New("tls: private key does not match public key"))
tls.go#L330: return fail(errors.New("tls: unknown public key algorithm"))
tls.go#L348: return nil, errors.New("tls: found unknown private key type in PKCS#8 wrapping")
tls.go#L355: return nil, errors.New("tls: failed to parse private key")
crypto/x509
parser.go#L64: return "", errors.New("invalid PrintableString")
parser.go#L70: return "", errors.New("invalid UTF-8 string")
parser.go#L75: return "", errors.New("invalid BMPString")
parser.go#L93: return "", errors.New("invalid IA5String")
parser.go#L99: return "", errors.New("invalid NumericString")
parser.go#L111: return nil, errors.New("x509: invalid RDNSequence")
parser.go#L119: return nil, errors.New("x509: invalid RDNSequence")
parser.go#L124: return nil, errors.New("x509: invalid RDNSequence: invalid attribute")
parser.go#L128: return nil, errors.New("x509: invalid RDNSequence: invalid attribute type")
parser.go#L133: return nil, errors.New("x509: invalid RDNSequence: invalid attribute value")
parser.go#L152: return ai, errors.New("x509: malformed OID")
parser.go#L160: return ai, errors.New("x509: malformed parameters")
parser.go#L176: return t, errors.New("x509: malformed UTCTime")
parser.go#L192: return t, errors.New("x509: malformed UTCTime")
parser.go#L201: return t, errors.New("x509: malformed GeneralizedTime")
parser.go#L204: return t, errors.New("x509: unsupported time format")
parser.go#L224: return ext, errors.New("x509: malformed extension OID field")
parser.go#L228: return ext, errors.New("x509: malformed extension critical field")
parser.go#L233: return ext, errors.New("x509: malformed extension value field")
parser.go#L246: return nil, errors.New("x509: RSA key missing NULL parameters")
parser.go#L251: return nil, errors.New("x509: invalid RSA public key")
parser.go#L254: return nil, errors.New("x509: invalid RSA modulus")
parser.go#L257: return nil, errors.New("x509: invalid RSA public exponent")
parser.go#L261: return nil, errors.New("x509: RSA modulus is not a positive number")
parser.go#L264: return nil, errors.New("x509: RSA public exponent is not a positive number")
parser.go#L276: return nil, errors.New("x509: invalid ECDSA parameters")
parser.go#L280: return nil, errors.New("x509: unsupported elliptic curve")
parser.go#L284: return nil, errors.New("x509: failed to unmarshal elliptic curve point")
parser.go#L296: return nil, errors.New("x509: Ed25519 key encoded with illegal parameters")
parser.go#L299: return nil, errors.New("x509: wrong Ed25519 public key size")
parser.go#L305: return nil, errors.New("x509: invalid DSA public key")
parser.go#L320: return nil, errors.New("x509: invalid DSA parameters")
parser.go#L324: return nil, errors.New("x509: zero or negative DSA parameter")
parser.go#L335: return 0, errors.New("x509: invalid key usage")
parser.go#L350: return false, 0, errors.New("x509: invalid basic constraints a")
parser.go#L354: return false, 0, errors.New("x509: invalid basic constraints b")
parser.go#L360: return false, 0, errors.New("x509: invalid basic constraints c")
parser.go#L370: return errors.New("x509: invalid subject alternative names")
parser.go#L376: return errors.New("x509: invalid subject alternative name")
parser.go#L392: return errors.New("x509: SAN rfc822Name is malformed")
parser.go#L398: return errors.New("x509: SAN dNSName is malformed")
parser.go#L404: return errors.New("x509: SAN uniformResourceIdentifier is malformed")
parser.go#L421: return errors.New("x509: cannot parse IP address of length " + strconv.Itoa(len(data)))
parser.go#L435: return nil, nil, errors.New("x509: invalid extended key usages")
parser.go#L440: return nil, nil, errors.New("x509: invalid extended key usages")
parser.go#L454: return nil, errors.New("x509: invalid certificate policies")
parser.go#L459: return nil, errors.New("x509: invalid certificate policies")
parser.go#L463: return nil, errors.New("x509: invalid certificate policies")
parser.go#L520: return false, errors.New("x509: invalid NameConstraints extension")
parser.go#L528: return false, errors.New("x509: empty name constraints extension")
parser.go#L551: return nil, nil, nil, nil, errors.New("x509: invalid constraint value: " + err.Error())
parser.go#L593: return nil, nil, nil, nil, errors.New("x509: invalid constraint value: " + err.Error())
parser.go#L617: return nil, nil, nil, nil, errors.New("x509: invalid constraint value: " + err.Error())
parser.go#L707: return errors.New("x509: invalid CRL distribution points")
parser.go#L712: return errors.New("x509: invalid CRL distribution point")
parser.go#L717: return errors.New("x509: invalid CRL distribution point")
parser.go#L723: return errors.New("x509: invalid CRL distribution point")
parser.go#L731: return errors.New("x509: invalid CRL distribution point")
parser.go#L742: return errors.New("x509: invalid authority key identifier")
parser.go#L746: return errors.New("x509: invalid authority key identifier")
parser.go#L760: return errors.New("x509: invalid subject key identifier")
parser.go#L776: return errors.New("x509: invalid authority info access")
parser.go#L781: return errors.New("x509: invalid authority info access")
parser.go#L785: return errors.New("x509: invalid authority info access")
parser.go#L791: return errors.New("x509: invalid authority info access")
parser.go#L821: return nil, errors.New("x509: malformed certificate")
parser.go#L825: return nil, errors.New("x509: malformed certificate")
parser.go#L832: return nil, errors.New("x509: malformed tbs certificate")
parser.go#L836: return nil, errors.New("x509: malformed tbs certificate")
parser.go#L840: return nil, errors.New("x509: malformed version")
parser.go#L843: return nil, errors.New("x509: malformed version")
parser.go#L849: return nil, errors.New("x509: invalid version")
parser.go#L854: return nil, errors.New("x509: malformed serial number")
parser.go#L865: return nil, errors.New("x509: malformed signature algorithm identifier")
parser.go#L872: return nil, errors.New("x509: malformed algorithm identifier")
parser.go#L875: return nil, errors.New("x509: inner and outer signature algorithm identifiers don't match")
parser.go#L885: return nil, errors.New("x509: malformed issuer")
parser.go#L896: return nil, errors.New("x509: malformed validity")
parser.go#L905: return nil, errors.New("x509: malformed issuer")
parser.go#L916: return nil, errors.New("x509: malformed spki")
parser.go#L920: return nil, errors.New("x509: malformed spki")
parser.go#L924: return nil, errors.New("x509: malformed public key algorithm identifier")
parser.go#L933: return nil, errors.New("x509: malformed subjectPublicKey")
parser.go#L945: return nil, errors.New("x509: malformed issuerUniqueID")
parser.go#L948: return nil, errors.New("x509: malformed subjectUniqueID")
parser.go#L954: return nil, errors.New("x509: malformed extensions")
parser.go#L958: return nil, errors.New("x509: malformed extensions")
parser.go#L963: return nil, errors.New("x509: malformed extension")
parser.go#L981: return nil, errors.New("x509: malformed signature")
parser.go#L995: return nil, errors.New("x509: trailing data")
pem_decrypt.go#L110: var IncorrectPasswordError = errors.New("x509: decryption password incorrect")
pem_decrypt.go#L127: return nil, errors.New("x509: no DEK-Info header in block")
pem_decrypt.go#L132: return nil, errors.New("x509: malformed DEK-Info header")
pem_decrypt.go#L137: return nil, errors.New("x509: unknown encryption mode")
pem_decrypt.go#L144: return nil, errors.New("x509: incorrect IV size")
pem_decrypt.go#L156: return nil, errors.New("x509: encrypted PEM data is not a multiple of the block size")
pem_decrypt.go#L171: return nil, errors.New("x509: invalid padding")
pem_decrypt.go#L198: return nil, errors.New("x509: unknown encryption mode")
pem_decrypt.go#L202: return nil, errors.New("x509: cannot generate IV: " + err.Error())
pkcs1.go#L55: return nil, errors.New("x509: failed to parse private key (use ParseECPrivateKey instead for this key format)")
pkcs1.go#L58: return nil, errors.New("x509: failed to parse private key (use ParsePKCS8PrivateKey instead for this key format)")
pkcs1.go#L64: return nil, errors.New("x509: unsupported private key version")
pkcs1.go#L68: return nil, errors.New("x509: private key contains zero or negative value")
pkcs1.go#L83: return nil, errors.New("x509: private key contains zero or negative prime")
pkcs1.go#L143: return nil, errors.New("x509: failed to parse public key (use ParsePKIXPublicKey instead for this key format)")
pkcs1.go#L152: return nil, errors.New("x509: public key contains zero or negative value")
pkcs1.go#L155: return nil, errors.New("x509: public key contains large public exponent")
pkcs8.go#L37: return nil, errors.New("x509: failed to parse private key (use ParseECPrivateKey instead for this key format)")
pkcs8.go#L40: return nil, errors.New("x509: failed to parse private key (use ParsePKCS1PrivateKey instead for this key format)")
pkcs8.go#L48: return nil, errors.New("x509: failed to parse RSA private key embedded in PKCS#8: " + err.Error())
pkcs8.go#L60: return nil, errors.New("x509: failed to parse EC private key embedded in PKCS#8: " + err.Error())
pkcs8.go#L66: return nil, errors.New("x509: invalid Ed25519 private key parameters")
pkcs8.go#L102: return nil, errors.New("x509: unknown curve while marshaling to PKCS#8")
pkcs8.go#L107: return nil, errors.New("x509: failed to marshal curve OID: " + err.Error())
pkcs8.go#L118: return nil, errors.New("x509: failed to marshal EC private key while building PKCS#8: " + err.Error())
sec1.go#L46: return nil, errors.New("x509: unknown elliptic curve")
sec1.go#L72: return nil, errors.New("x509: failed to parse private key (use ParsePKCS8PrivateKey instead for this key format)")
sec1.go#L75: return nil, errors.New("x509: failed to parse private key (use ParsePKCS1PrivateKey instead for this key format)")
sec1.go#L77: return nil, errors.New("x509: failed to parse EC private key: " + err.Error())
sec1.go#L90: return nil, errors.New("x509: unknown elliptic curve")
sec1.go#L96: return nil, errors.New("x509: invalid elliptic curve private key value")
sec1.go#L108: return nil, errors.New("x509: invalid private key length")
verify.go#L171: var errNotParsed = errors.New("x509: missing ASN.1 contents; use ParseCertificate")
verify.go#L595: return errors.New("x509: internal error: empty chain when appending CA cert")
verify.go#L847: err = errors.New("x509: signature check attempts limit reached while verifying certificate chain")
x509.go#L59: return nil, errors.New("x509: failed to parse public key (use ParsePKCS1PublicKey instead for this key format)")
x509.go#L63: return nil, errors.New("x509: trailing data after ASN.1 of public-key")
x509.go#L67: return nil, errors.New("x509: unknown public key algorithm")
x509.go#L90: return nil, pkix.AlgorithmIdentifier{}, errors.New("x509: unsupported elliptic curve")
x509.go#L731: var ErrUnsupportedAlgorithm = errors.New("x509: cannot verify signature: algorithm unimplemented")
x509.go#L870: return errors.New("x509: ECDSA verification failure")
x509.go#L878: return errors.New("x509: Ed25519 verification failure")
x509.go#L1286: return ext, errors.New("x509: unknown extended key usage")
x509.go#L1384: err = errors.New("x509: unknown elliptic curve")
x509.go#L1392: err = errors.New("x509: only RSA, ECDSA and Ed25519 keys supported")
x509.go#L1407: err = errors.New("x509: requested SignatureAlgorithm does not match private key type")
x509.go#L1412: err = errors.New("x509: cannot sign with hash function requested")
x509.go#L1424: err = errors.New("x509: unknown SignatureAlgorithm")
x509.go#L1489: return nil, errors.New("x509: certificate private key does not implement crypto.Signer")
x509.go#L1493: return nil, errors.New("x509: no SerialNumber given")
x509.go#L1497: return nil, errors.New("x509: only CAs are allowed to specify MaxPathLen")
x509.go#L1540: return nil, errors.New("x509: internal error: supported public key does not implement Equal")
x509.go#L1542: return nil, errors.New("x509: provided PrivateKey doesn't match parent's PublicKey")
x509.go#L1641: return nil, errors.New("x509: trailing data after CRL")
x509.go#L1654: return nil, errors.New("x509: certificate private key does not implement crypto.Signer")
x509.go#L1793: return nil, errors.New("x509: failed to unmarshal raw CSR Attributes")
x509.go#L1866: return nil, errors.New("x509: certificate private key does not implement crypto.Signer")
x509.go#L1959: return nil, errors.New("x509: failed to serialise extensions attribute: " + err.Error())
x509.go#L2061: return nil, errors.New("x509: trailing data after X.509 Subject")
x509.go#L2131: return nil, errors.New("x509: template can not be nil")
x509.go#L2134: return nil, errors.New("x509: issuer can not be nil")
x509.go#L2137: return nil, errors.New("x509: issuer must have the crlSign key usage bit set")
x509.go#L2140: return nil, errors.New("x509: issuer certificate doesn't contain a subject key identifier")
x509.go#L2143: return nil, errors.New("x509: template.ThisUpdate is after template.NextUpdate")
x509.go#L2146: return nil, errors.New("x509: template contains nil Number field")
database/sql
convert.go#L20: var errNilPtr = errors.New("destination pointer is nil") // embedded in descriptive error
convert.go#L325: return errors.New("invalid context to convert cursor rows, missing parent *Rows")
convert.go#L390: return errors.New("destination not a pointer")
ctxutil.go#L111: return nil, errors.New("sql: driver does not support non-default isolation level")
ctxutil.go#L117: return nil, errors.New("sql: driver does not support read-only transactions")
ctxutil.go#L141: return nil, errors.New("sql: driver does not support the use of Named Parameters")
sql.go#L442: var ErrNoRows = errors.New("sql: no rows in result set")
sql.go#L605: return func() error { return errors.New("sql: duplicate driverConn close") }
sql.go#L615: return errors.New("sql: duplicate driverConn close")
sql.go#L1278: var errDBClosed = errors.New("sql: database is closed")
sql.go#L1914: var ErrConnDone = errors.New("sql: connection is already closed")
sql.go#L2207: var ErrTxDone = errors.New("sql: transaction has already been committed or rolled back")
sql.go#L2401: return &Stmt{stickyErr: errors.New("sql: Tx.Stmt: statement from different database used")}
sql.go#L2706: err = errors.New("sql: statement is closed")
sql.go#L3079: var errRowsClosed = errors.New("sql: Rows are closed")
sql.go#L3080: var errNoRows = errors.New("sql: no Rows available")
sql.go#L3281: return errors.New("sql: Scan called without calling Next")
sql.go#L3370: return errors.New("sql: RawBytes isn't allowed on Row.Scan")
database/sql/driver
driver.go#L148: var ErrSkip = errors.New("driver: skip fast-path; continue as if unimplemented")
driver.go#L162: var ErrBadConn = errors.New("driver: bad connection")
driver.go#L385: var ErrRemoveArgument = errors.New("driver: remove argument from query")
driver.go#L528: return 0, errors.New("LastInsertId is not supported by this driver")
driver.go#L545: return 0, errors.New("no LastInsertId available after DDL statement")
driver.go#L549: return 0, errors.New("no RowsAffected available after DDL statement")
embed
embed.go#L320: return nil, &fs.PathError{Op: "read", Path: name, Err: errors.New("not a directory")}
embed.go#L337: return nil, &fs.PathError{Op: "read", Path: name, Err: errors.New("is a directory")}
embed.go#L394: return 0, &fs.PathError{Op: "read", Path: d.f.name, Err: errors.New("is a directory")}
encoding/asn1
asn1.go#L480: return "", errors.New("asn1: invalid UTF-8 string")
asn1.go#L491: return "", errors.New("pkcs12: odd-length BMP string")
asn1.go#L532: err = errors.New("asn1: internal error in parseTagAndLength")
marshal.go#L646: return nil, errors.New("asn1: string not valid UTF-8")
encoding/binary
binary.go#L253: return errors.New("binary.Read: invalid type " + reflect.TypeOf(data).String())
binary.go#L383: return errors.New("binary.Write: invalid type " + reflect.TypeOf(data).String())
varint.go#L108: var overflow = errors.New("binary: varint overflows a 64-bit integer")
encoding/hex
hex.go#L38: var ErrLength = errors.New("encoding/hex: odd length hex string")
hex.go#L237: return 0, errors.New("encoding/hex: dumper closed")
encoding/json
stream.go#L273: return errors.New("json.RawMessage: UnmarshalJSON on nil pointer")
encoding/pem
pem.go#L242: return errors.New("pem: cannot encode a header key that contains a colon")
encoding/xml
read.go#L149: return errors.New("non-pointer passed to Unmarshal")
read.go#L379: return errors.New("unknown type " + v.Type().String())
read.go#L617: return errors.New("cannot unmarshal into " + dst0.Type().String())
xml.go#L540: var errRawToken = errors.New("xml: cannot use RawToken from UnmarshalXML method")
flag
flag.go#L84: var ErrHelp = errors.New("flag: help requested")
flag.go#L88: var errParse = errors.New("parse error")
flag.go#L92: var errRange = errors.New("value out of range")
flag.go#L909: return errors.New(msg)
fmt
errors.go#L24: err = errors.New(s)
scan.go#L180: return 0, errors.New("ScanState's Read should not be called. Use ReadRune")
scan.go#L244: panic(scanError{errors.New(err)})
scan.go#L371: return errors.New("fmt: scanning called UnreadRune with no rune available")
scan.go#L465: var complexError = errors.New("syntax error scanning complex number")
scan.go#L466: var boolError = errors.New("syntax error scanning boolean")
github.com/aws/aws-sdk-go-v2/aws/arn
arn.go#L63: return ARN{}, errors.New(invalidPrefix)
arn.go#L67: return ARN{}, errors.New(invalidSections)
github.com/aws/aws-sdk-go-v2/internal/sync/singleflight
singleflight.go#L18: var errGoexit = errors.New("runtime.Goexit was called")
github.com/aws/smithy-go/internal/sync/singleflight
singleflight.go#L18: var errGoexit = errors.New("runtime.Goexit was called")
github.com/go-pg/migrations/v8
collection.go#L89: return errors.New("Register expects at least 1 arg")
github.com/go-pg/pg/v10
listener.go#L19: errListenerClosed = errors.New("pg: listener is closed")
listener.go#L20: errPingTimeout = errors.New("pg: ping timeout")
messages.go#L157: return errors.New("pg: SSL is not enabled on the server")
options.go#L182: return nil, errors.New("pg: invalid scheme: " + parsedURL.Scheme)
options.go#L210: return nil, errors.New("pg: database name not provided")
options.go#L253: return nil, errors.New("pg: options other than 'sslmode', 'application_name' and 'connect_timeout' are not supported")
stmt.go#L13: var errStmtClosed = errors.New("pg: statement is closed")
tx.go#L17: var ErrTxDone = errors.New("pg: transaction has already been committed or rolled back")
github.com/go-pg/pg/v10/internal/pool
pool.go#L15: ErrClosed = errors.New("pg: database is closed")
pool.go#L16: ErrPoolTimeout = errors.New("pg: connection pool timeout")
pool_sticky.go#L146: return errors.New("pg: StickyConnPool.Close: infinite loop")
pool_sticky.go#L162: return errors.New("pg: StickyConnPool does not have a Conn")
reader_bytes.go#L57: return errors.New("UnreadByte: at beginning of slice")
github.com/go-pg/pg/v10/orm
composite_parser.go#L13: var errEndOfComposite = errors.New("pg: end of composite")
model.go#L12: var errModelNil = errors.New("pg: Model(nil)")
query.go#L632: q.err(errors.New("pg: no joins to apply JoinOn"))
query.go#L645: q.err(errors.New("pg: no joins to apply JoinOn"))
query.go#L1414: err := errors.New(
github.com/go-pg/pg/v10/types
array_parser.go#L13: var errEndOfArray = errors.New("pg: end of array")
hstore_parser.go#L10: var errEndOfHstore = errors.New("pg: end of hstore")
scan.go#L42: return errors.New("pg: Scan(nil)")
scan.go#L55: return errors.New("pg: Scan(nil)")
scan_value.go#L172: return errors.New("pg: Scan(nil)")
scan_value.go#L181: return errors.New("pg: Scan(nil)")
github.com/golang/mock/gomock
callset.go#L99: return nil, errors.New(callsErrors.String())
github.com/golang/protobuf/jsonpb
decode.go#L74: return errors.New("invalid nil message")
decode.go#L155: return errors.New("Any JSON doesn't have '@type'")
decode.go#L184: return errors.New("Any JSON doesn't have 'value'")
encode.go#L88: return nil, errors.New("Marshal called with nil")
encode.go#L181: return errors.New("signs of seconds and nanos do not match")
encode.go#L214: return errors.New("nil Value")
github.com/golang/protobuf/proto
buffer.go#L313: return nil, 0, errors.New("proto: cannot parse reserved wire type")
deprecated.go#L18: ErrNil = errors.New("proto: Marshal called with nil")
deprecated.go#L21: ErrTooLarge = errors.New("proto: message encodes to over 2 GB")
deprecated.go#L24: ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof")
deprecated.go#L35: return nil, errors.New("proto: not implemented")
deprecated.go#L40: return errors.New("proto: not implemented")
deprecated.go#L45: return nil, errors.New("proto: not implemented")
deprecated.go#L50: return errors.New("proto: not implemented")
extensions.go#L39: var ErrMissingExtension = errors.New("proto: missing extension")
extensions.go#L41: var errNotExtendable = errors.New("proto: not an extendable proto.Message")
text_decode.go#L662: var errBadUTF8 = errors.New("proto: bad UTF-8")
github.com/golang/protobuf/ptypes
duration.go#L63: return errors.New("duration: nil Duration")
timestamp.go#L100: return errors.New("timestamp: nil Timestamp")
github.com/tmthrgd/go-hex
hex.go#L18: var errLength = errors.New("go-hex: odd length hex string")
github.com/valyala/fastjson
scanner.go#L94: var errEOF = errors.New("end of s")
github.com/vmihailenco/bufpool
buffer.go#L41: var errNegativeRead = errors.New("bytes.Buffer: reader returned negative count from Read")
buffer.go#L313: return errors.New("bytes.Buffer: UnreadRune: previous operation was not a successful ReadRune")
buffer.go#L322: var errUnreadByte = errors.New("bytes.Buffer: UnreadByte: previous operation was not a successful read")
github.com/vmihailenco/msgpack/v5
decode.go#L269: return errors.New("msgpack: Decode(nil)")
decode_map.go#L11: var errArrayStruct = errors.New("msgpack: number of fields in array-encoded struct has changed")
decode_value.go#L196: v.Set(reflect.ValueOf(errors.New(vv)))
go.pact.im/x/extraio
count.go#L11: var ErrCounterOverflow = errors.New("extraio: counter overflow")
hardlimit.go#L10: var ErrExceededReadLimit = errors.New("extraio: exceeded read limit")
go.pact.im/x/flaky
debounce.go#L14: var ErrDebounced = errors.New("flaky: debounced")
schedule.go#L14: ErrNoNextSchedule = errors.New("flaky: no next scheduled time")
schedule.go#L18: ErrScheduleDeadline = errors.New("flaky: scheduled time exceeds context deadline")
go.pact.im/x/goupdate
flags.go#L22: var errParse = errors.New("parse error")
workspaces.go#L38: return nil, errors.New("no go.work or go.mod files found")
go.pact.im/x/process
process.go#L16: var ErrProcessInvalidState = errors.New("process: invalid process state")
go.pact.im/x/supervisor
errors.go#L10: ErrNotRunning = errors.New("supervisor: not running")
errors.go#L14: ErrProcessNotFound = errors.New("supervisor: process not found")
errors.go#L18: ErrProcessNotRunning = errors.New("supervisor: process is not running")
errors.go#L22: ErrProcessExists = errors.New("supervisor: process already exists")
go.uber.org/goleak
leaks.go#L60: return errors.New("Cleanup can only be passed to VerifyNone or VerifyTestMain")
go.uber.org/zap
config.go#L185: return nil, errors.New("missing Level")
encoder.go#L32: errNoEncoderNameSpecified = errors.New("no encoder name specified")
encoder.go#L66: return nil, errors.New("missing EncodeTime in EncoderConfig")
http_handler.go#L112: return 0, errors.New("must specify logging level")
http_handler.go#L129: return 0, errors.New("must specify logging level")
sink.go#L79: return errors.New("can't register a sink factory for empty string")
sink.go#L164: return "", errors.New("must start with a letter")
go.uber.org/zap/zapcore
level.go#L29: var errUnmarshalNilLevel = errors.New("can't unmarshal a nil *Level")
go/build
build.go#L1064: var errNoModules = errors.New("not using modules")
build.go#L1203: return errors.New(errStr)
build.go#L1485: errGoBuildWithoutBuild = errors.New("//go:build comment without // +build comment")
build.go#L1486: errMultipleGoBuild = errors.New("multiple //go:build comments")
build.go#L1841: err = errors.New("unclosed quote")
build.go#L1843: err = errors.New("unfinished escaping")
build.go#L1996: return "?", errors.New("architecture letter no longer used")
read.go#L58: errSyntax = errors.New("syntax error")
read.go#L59: errNUL = errors.New("unexpected NUL in input")
go/build/constraint
expr.go#L147: var errNotConstraint = errors.New("not a build constraint")
expr.go#L450: var errComplex = errors.New("expression too complex for // +build lines")
go/parser
interface.go#L40: return nil, errors.New("invalid source")
go/types
check.go#L310: var errBadCgo = errors.New("cannot use FakeImportC and go115UsesCgo together")
instantiate.go#L167: return errors.New(check.sprintf(format, args...))
golang.org/x/crypto/blake2b
blake2b.go#L45: errKeySize = errors.New("blake2b: invalid key size")
blake2b.go#L46: errHashSize = errors.New("blake2b: invalid hash size")
blake2b.go#L164: return nil, errors.New("crypto/blake2b: cannot marshal MACs")
blake2b.go#L182: return errors.New("crypto/blake2b: invalid hash state identifier")
blake2b.go#L185: return errors.New("crypto/blake2b: invalid hash state size")
blake2x.go#L57: return nil, errors.New("blake2b: XOF length too large")
golang.org/x/net/http2
databuffer.go#L73: var errReadEmpty = errors.New("read from empty dataBuffer")
errors.go#L80: var errFromPeer = errors.New("received from peer")
errors.go#L143: errMixPseudoHeaderTypes = errors.New("mix of request and response pseudo headers")
errors.go#L144: errPseudoAfterRegular = errors.New("pseudo header field after regular")
frame.go#L475: var ErrFrameTooLarge = errors.New("http2: frame too large")
frame.go#L533: fr.errDetail = errors.New(reason)
frame.go#L632: errStreamID = errors.New("invalid stream ID")
frame.go#L633: errDepStreamID = errors.New("invalid dependent stream ID")
frame.go#L634: errPadLength = errors.New("pad length too large")
frame.go#L635: errPadBytes = errors.New("padding bytes must all be zeros unless AllowIllegalWrites is enabled")
frame.go#L985: return errors.New("illegal window increment value")
frame.go#L1527: return nil, errors.New("illegal use of AllowIllegalReads with ReadMetaHeaders")
gotrack.go#L111: err = errors.New("invalid base " + strconv.Itoa(base))
pipe.go#L80: var errClosedPipeWrite = errors.New("write on closed buffer")
server.go#L63: errClientDisconnected = errors.New("client disconnected")
server.go#L64: errClosedBody = errors.New("body closed by handler")
server.go#L65: errHandlerComplete = errors.New("http2: request body closed due to handler exiting")
server.go#L66: errStreamClosed = errors.New("http2: stream closed")
server.go#L1045: var errPrefaceTimeout = errors.New("timeout waiting for client preface")
server.go#L1275: var errHandlerPanicked = errors.New("http2: handler panicked")
server.go#L2925: return 0, errors.New("http2: handler wrote more than declared Content-Length")
server.go#L2954: ErrRecursivePush = errors.New("http2: recursive push not allowed")
server.go#L2955: ErrPushLimitReached = errors.New("http2: push would exceed peer's SETTINGS_MAX_CONCURRENT_STREAMS")
server.go#L3003: return errors.New("URL must have a host")
server.go#L3187: return errors.New(`request header "TE" may only be "trailers" in HTTP/2`)
transport.go#L549: return nil, errors.New("http2: unsupported scheme")
transport.go#L601: errClientConnClosed = errors.New("http2: client conn is closed")
transport.go#L602: errClientConnUnusable = errors.New("http2: client conn not usable")
transport.go#L603: errClientConnGotGoAway = errors.New("http2: Transport received Server's graceful shutdown GOAWAY")
transport.go#L698: return nil, errors.New("http2: could not negotiate protocol mutually")
transport.go#L1126: err := errors.New("http2: client connection force closed via ClientConn.Close")
transport.go#L1133: err := errors.New("http2: client connection lost")
transport.go#L1142: var errRequestCanceled = errors.New("net/http: request canceled")
transport.go#L1624: errStopReqBodyWrite = errors.New("http2: aborting request body write")
transport.go#L1627: errStopReqBodyWriteAndCancel = errors.New("http2: canceling request")
transport.go#L1629: errReqBodyTooLong = errors.New("http2: request body larger than specified content length")
transport.go#L1830: var errNilRequestURL = errors.New("http2: Request.URI is nil")
transport.go#L2295: Cause: errors.New("protocol error: headers after END_STREAM"),
transport.go#L2354: return nil, errors.New("malformed response from server: missing status pseudo header")
transport.go#L2358: return nil, errors.New("malformed response from server: malformed non-numeric status pseudo header")
transport.go#L2400: return nil, errors.New("1xx informational response with END_STREAM flag")
transport.go#L2405: return nil, errors.New("http2: too many 1xx informational responses")
transport.go#L2512: err = errors.New("net/http: server replied with more than declared Content-Length; truncated")
transport.go#L2552: var errClosedResponseBody = errors.New("http2: response body closed")
transport.go#L2977: errResponseHeaderListSize = errors.New("http2: response header list larger than advertised limit")
transport.go#L2978: errRequestHeaderListSize = errors.New("http2: request header list larger than peer's advertised limit")
golang.org/x/net/http2/hpack
hpack.go#L116: var ErrStringLength = errors.New("hpack: string too long")
hpack.go#L238: return DecodingError{errors.New("truncated headers")}
hpack.go#L287: var errNeedMore = errors.New("need more data")
hpack.go#L334: return DecodingError{errors.New("invalid encoding")}
hpack.go#L416: return DecodingError{errors.New("dynamic table size update MUST occur at the beginning of a header block")}
hpack.go#L425: return DecodingError{errors.New("dynamic table size update too large")}
hpack.go#L432: var errVarintOverflow = DecodingError{errors.New("varint integer overflow")}
huffman.go#L44: var ErrInvalidHuffman = errors.New("hpack: invalid Huffman-encoded data")
golang.org/x/text/secure/bidirule
bidirule.go#L46: var ErrInvalid = errors.New("bidirule: failed Bidi Rule")
golang.org/x/text/transform
transform.go#L21: ErrShortDst = errors.New("transform: short destination buffer")
transform.go#L25: ErrShortSrc = errors.New("transform: short source buffer")
transform.go#L29: ErrEndOfSpan = errors.New("transform: input and output are not identical")
transform.go#L33: errInconsistentByteCount = errors.New("transform: inconsistent byte count returned")
transform.go#L37: errShortInternal = errors.New("transform: short internal buffer")
golang.org/x/tools/internal/pkgbits
decoder.go#L283: var overflow = errors.New("pkgbits: readUvarint overflows a 64-bit integer")
golang.org/x/tools/internal/typeparams
normalize.go#L19: var ErrEmptyTypeSet = errors.New("empty type set")
google.golang.org/grpc
clientconn.go#L69: errConnDrain = errors.New("grpc: the connection is drained")
clientconn.go#L71: errConnClosing = errors.New("grpc: the connection is closing")
clientconn.go#L82: errNoTransportSecurity = errors.New("grpc: no transport security set (use grpc.WithTransportCredentials(insecure.NewCredentials()) explicitly or set credentials)")
clientconn.go#L85: errTransportCredsAndBundle = errors.New("grpc: credentials.Bundle may not be used with individual TransportCredentials")
clientconn.go#L88: errNoTransportCredsInBundle = errors.New("grpc: credentials.Bundle must return non-nil transport credentials")
clientconn.go#L92: errTransportCredentialsMissing = errors.New("grpc: the credentials require transport level security (use grpc.WithTransportCredentials() to set)")
clientconn.go#L1528: var ErrClientConnTimeout = errors.New("grpc: timed out when dialing")
pickfirst.go#L81: b.ResolverError(errors.New("produced zero addresses"))
server.go#L753: var ErrServerStopped = errors.New("grpc: the server has been stopped")
server.go#L945: defer st.Close(errors.New("finished serving streams for the server transport"))
server.go#L1050: st.Close(errors.New("Server.addConn called when server has already been stopped"))
server.go#L1813: st.Close(errors.New("Server.Stop called"))
service_config.go#L182: errDuplicatedName = errors.New("duplicated name")
service_config.go#L183: errEmptyServiceNonEmptyMethod = errors.New("cannot combine empty 'service' and non-empty 'method'")
stream.go#L1100: return toRPCErr(errors.New("grpc: client streaming protocol violation: get <nil>, want <EOF>"))
stream.go#L1175: return nil, errors.New("transport provided is nil")
stream.go#L1417: return toRPCErr(errors.New("grpc: client streaming protocol violation: get <nil>, want <EOF>"))
google.golang.org/grpc/balancer
balancer.go#L259: ErrNoSubConnAvailable = errors.New("no SubConn is available")
balancer.go#L266: ErrTransientFailure = errors.New("all SubConns are in TransientFailure")
balancer.go#L386: var ErrBadResolverState = errors.New("bad resolver state")
google.golang.org/grpc/balancer/base
balancer.go#L135: b.ResolverError(errors.New("produced zero addresses"))
google.golang.org/grpc/credentials
credentials.go#L125: var ErrConnDispatched = errors.New("credentials: rawConn is dispatched out of gRPC")
credentials.go#L249: return errors.New("AuthInfo is nil")
google.golang.org/grpc/internal/balancer/gracefulswitch
gracefulswitch.go#L33: var errBalancerClosed = errors.New("gracefulSwitchBalancer is closed")
google.golang.org/grpc/internal/binarylog
env_config.go#L65: return errors.New("empty string is not a valid method binary logging config")
google.golang.org/grpc/internal/channelz
funcs.go#L230: return nil, errors.New("a SubChannel's parent id cannot be nil")
funcs.go#L278: return nil, errors.New("a ListenSocket's parent id cannot be 0")
funcs.go#L298: return nil, errors.New("a NormalSocket's parent id cannot be 0")
google.golang.org/grpc/internal/grpcutil
method.go#L30: return "", "", errors.New("invalid method name: should start with /")
method.go#L36: return "", "", errors.New("invalid method name: suffix /method is missing")
google.golang.org/grpc/internal/resolver/dns
dns_resolver.go#L73: errMissingAddr = errors.New("dns resolver: missing address")
dns_resolver.go#L79: errEndsWithColon = errors.New("dns resolver: missing port after port-separator colon")
google.golang.org/grpc/internal/resolver/passthrough
passthrough.go#L35: return nil, errors.New("passthrough: received empty target in Build()")
google.golang.org/grpc/internal/status
status.go#L107: return nil, errors.New("no error details for status with code OK")
google.golang.org/grpc/internal/transport
controlbuf.go#L419: return nil, errors.New("transport closed by client")
controlbuf.go#L766: return errors.New("finished processing active streams while in draining mode")
controlbuf.go#L773: return errors.New("earlyAbortStream not handled on client")
controlbuf.go#L801: return errors.New("received GOAWAY with no active streams")
handler_server.go#L56: return nil, errors.New(msg)
handler_server.go#L61: return nil, errors.New(msg)
handler_server.go#L69: return nil, errors.New(msg)
handler_server.go#L74: return nil, errors.New(msg)
handler_server.go#L254: ht.Close(errors.New("finished writing status"))
handler_server.go#L364: ht.Close(errors.New("request is done processing"))
http2_server.go#L907: t.controlBuf.put(&goAway{code: http2.ErrCodeEnhanceYourCalm, debugData: []byte("too_many_pings"), closeConn: errors.New("got too many pings from the client")})
http2_server.go#L1339: retErr = errors.New("second GOAWAY written and no active streams left to process")
transport.go#L48: var ErrNoHeaders = errors.New("stream has no headers")
transport.go#L770: errStreamDone = errors.New("the stream is done")
google.golang.org/protobuf/internal/errors
errors.go#L16: var Error = errors.New("protobuf error")
gotest.tools/v3/assert/cmp
compare.go#L379: stdlibErrorNewType = reflect.TypeOf(errors.New(""))
gotest.tools/v3/internal/source
source.go#L24: return "", errors.New("failed to find expression")
source.go#L34: return nil, errors.New("failed to get call stack")
source.go#L93: return nil, errors.New("failed to find call expression")
update.go#L36: return errors.New("failed to get call stack")
hash/crc32
crc32.go#L186: return errors.New("hash/crc32: invalid hash state identifier")
crc32.go#L189: return errors.New("hash/crc32: invalid hash state size")
crc32.go#L192: return errors.New("hash/crc32: tables do not match")
hash/fnv
fnv.go#L272: return errors.New("hash/fnv: invalid hash state identifier")
fnv.go#L275: return errors.New("hash/fnv: invalid hash state size")
fnv.go#L283: return errors.New("hash/fnv: invalid hash state identifier")
fnv.go#L286: return errors.New("hash/fnv: invalid hash state size")
fnv.go#L294: return errors.New("hash/fnv: invalid hash state identifier")
fnv.go#L297: return errors.New("hash/fnv: invalid hash state size")
fnv.go#L305: return errors.New("hash/fnv: invalid hash state identifier")
fnv.go#L308: return errors.New("hash/fnv: invalid hash state size")
fnv.go#L316: return errors.New("hash/fnv: invalid hash state identifier")
fnv.go#L319: return errors.New("hash/fnv: invalid hash state size")
fnv.go#L328: return errors.New("hash/fnv: invalid hash state identifier")
fnv.go#L331: return errors.New("hash/fnv: invalid hash state size")
internal/oserror
errors.go#L13: ErrInvalid = errors.New("invalid argument")
errors.go#L14: ErrPermission = errors.New("permission denied")
errors.go#L15: ErrExist = errors.New("file already exists")
errors.go#L16: ErrNotExist = errors.New("file does not exist")
errors.go#L17: ErrClosed = errors.New("file already closed")
internal/poll
fd.go#L35: var ErrFileClosing = errors.New("use of closed file")
fd.go#L39: var ErrNoDeadline = errors.New("file type does not support deadline")
fd.go#L66: var ErrNotPollable = errors.New("not pollable")
fd_poll_runtime.go#L81: return errors.New("waiting for unsupported file type")
internal/profile
encode.go#L179: return errors.New("string_table[0] must be ''")
proto.go#L190: return 0, nil, errors.New("bad varint")
proto.go#L216: return nil, errors.New("not enough data")
proto.go#L227: return nil, errors.New("too much data")
proto.go#L233: return nil, errors.New("not enough data")
proto.go#L246: return errors.New("type mismatch")
io
io.go#L29: var ErrShortWrite = errors.New("short write")
io.go#L32: var errInvalidWrite = errors.New("invalid write result")
io.go#L35: var ErrShortBuffer = errors.New("short buffer")
io.go#L44: var EOF = errors.New("EOF")
io.go#L48: var ErrUnexpectedEOF = errors.New("unexpected EOF")
io.go#L53: var ErrNoProgress = errors.New("multiple Read calls return no data or error")
io.go#L517: var errWhence = errors.New("Seek: invalid whence")
io.go#L518: var errOffset = errors.New("Seek: invalid offset")
pipe.go#L36: var ErrClosedPipe = errors.New("io: read/write on closed pipe")
io/fs
readdir.go#L41: return nil, &PathError{Op: "readdir", Path: name, Err: errors.New("not implemented")}
sub.go#L36: return nil, &PathError{Op: "sub", Path: dir, Err: errors.New("invalid name")}
sub.go#L55: return "", &PathError{Op: op, Path: name, Err: errors.New("invalid name")}
sub.go#L122: return nil, errors.New("invalid result from inner fsys Glob: " + name + " not in " + f.dir) // can't use fmt in this package
walk.go#L15: var SkipDir = errors.New("skip this directory")
math/big
intconv.go#L253: return errors.New("Int.Scan: invalid verb")
natconv.go#L60: errNoDigits = errors.New("number has no digits")
natconv.go#L61: errInvalSep = errors.New("'_' must separate successive digits")
ratconv.go#L32: return errors.New("Rat.Scan: invalid verb")
ratconv.go#L35: return errors.New("Rat.Scan: invalid syntax")
ratmarsh.go#L29: return nil, errors.New("Rat.GobEncode: numerator too large")
mellium.im/sasl
mechanism.go#L16: ErrInvalidState = errors.New("invalid state")
mechanism.go#L17: ErrInvalidChallenge = errors.New("invalid or missing challenge")
mechanism.go#L18: ErrAuthn = errors.New("authentication error")
mechanism.go#L19: ErrTooManySteps = errors.New("step called too many times")
scram.go#L150: err = errors.New("server sent reserved attribute `m'")
scram.go#L160: err = errors.New("iteration count is invalid")
scram.go#L163: err = errors.New("server nonce does not match client nonce")
scram.go#L166: err = errors.New("server sent empty salt")
scram.go#L175: err = errors.New("sasl: SCRAM with channel binding requires a TLS connection")
scram.go#L183: err = errors.New("sasl: SCRAM with channel binding requires valid TLS keying material")
scram.go#L193: err = errors.New("sasl: SCRAM with channel binding requires valid tls-unique data")
mime
encodedword.go#L29: errInvalidWord = errors.New("mime: invalid RFC 2047 encoded-word")
mediatype.go#L106: return errors.New("mime: no media type")
mediatype.go#L112: return errors.New("mime: expected slash after first token")
mediatype.go#L116: return errors.New("mime: expected token after slash")
mediatype.go#L119: return errors.New("mime: unexpected content after media subtype")
mediatype.go#L127: var ErrInvalidMediaParameter = errors.New("mime: invalid media parameter")
mediatype.go#L185: return "", nil, errors.New("mime: duplicate parameter name")
mime/multipart
formdata.go#L18: var ErrMessageTooLarge = errors.New("multipart: message too large")
writer.go#L47: return errors.New("mime: SetBoundary called after write")
writer.go#L51: return errors.New("mime: invalid boundary length")
writer.go#L66: return errors.New("mime: invalid boundary character")
writer.go#L194: return 0, errors.New("multipart: can't write to finished part")
net
dnsclient_unix.go#L40: errLameReferral = errors.New("lame referral")
dnsclient_unix.go#L41: errCannotUnmarshalDNSMessage = errors.New("cannot unmarshal DNS message")
dnsclient_unix.go#L42: errCannotMarshalDNSMessage = errors.New("cannot marshal DNS message")
dnsclient_unix.go#L43: errServerMisbehaving = errors.New("server misbehaving")
dnsclient_unix.go#L44: errInvalidDNSResponse = errors.New("invalid DNS response")
dnsclient_unix.go#L45: errNoAnswerFromDNSServer = errors.New("no answer from DNS server")
dnsclient_unix.go#L50: errServerTemporarilyMisbehaving = errors.New("server misbehaving")
interface.go#L21: errInvalidInterface = errors.New("invalid network interface")
interface.go#L22: errInvalidInterfaceIndex = errors.New("invalid network interface index")
interface.go#L23: errInvalidInterfaceName = errors.New("invalid network interface name")
interface.go#L24: errNoSuchInterface = errors.New("no such network interface")
interface.go#L25: errNoSuchMulticastInterface = errors.New("no such multicast network interface")
net.go#L410: errNoSuitableAddress = errors.New("no suitable address found")
net.go#L413: errMissingAddress = errors.New("missing address")
net.go#L416: errCanceled = errors.New("operation was canceled")
net.go#L417: ErrWriteToConnected = errors.New("use of WriteTo with pre-connected connection")
net.go#L608: errNoSuchHost = errors.New("no such host")
nss.go#L91: return errors.New("no colon on line")
nss.go#L114: return errors.New("unclosed criterion bracket")
nss.go#L119: return errors.New("invalid criteria: " + string(srcs[1:bclose]))
nss.go#L145: return errors.New("criterion too short")
nss.go#L149: return errors.New("criterion lacks equal sign")
unixsock_posix.go#L42: return nil, errors.New("unknown mode: " + mode)
net/http
client.go#L209: return nil, alwaysFalse, errors.New("http: no Client.Transport or DefaultTransport")
client.go#L214: return nil, alwaysFalse, errors.New("http: nil Request.URL")
client.go#L219: return nil, alwaysFalse, errors.New("http: Request.RequestURI can't be set in client requests")
client.go#L263: err = errors.New("http: server gave HTTP response to HTTPS client")
client.go#L489: var ErrUseLastResponse = errors.New("net/http: use last response")
client.go#L606: Err: errors.New("http: nil Request.URL"),
client.go#L813: return errors.New("stopped after 10 redirects")
cookie.go#L244: return errors.New("http: nil Cookie")
cookie.go#L247: return errors.New("http: invalid Cookie.Name")
cookie.go#L250: return errors.New("http: invalid Cookie.Expires")
cookie.go#L266: return errors.New("http: invalid Cookie.Domain")
fs.go#L73: return nil, errors.New("http: invalid character in file path")
fs.go#L211: var errSeeker = errors.New("seeker can't seek")
fs.go#L215: var errNoOverlap = errors.New("invalid range: failed to overlap")
fs.go#L773: var errMissingSeek = errors.New("io.File missing Seek method")
fs.go#L774: var errMissingReadDir = errors.New("io.File directory missing ReadDir method")
fs.go#L877: return nil, errors.New("invalid range")
fs.go#L888: return nil, errors.New("invalid range")
fs.go#L899: return nil, errors.New("invalid range")
fs.go#L903: return nil, errors.New("invalid range")
fs.go#L913: return nil, errors.New("invalid range")
fs.go#L928: return nil, errors.New("invalid range")
h2_bundle.go#L1093: var http2errReadEmpty = errors.New("read from empty dataBuffer")
h2_bundle.go#L1238: var http2errFromPeer = errors.New("received from peer")
h2_bundle.go#L1301: http2errMixPseudoHeaderTypes = errors.New("mix of request and response pseudo headers")
h2_bundle.go#L1302: http2errPseudoAfterRegular = errors.New("pseudo header field after regular")
h2_bundle.go#L1807: var http2ErrFrameTooLarge = errors.New("http2: frame too large")
h2_bundle.go#L1865: fr.errDetail = errors.New(reason)
h2_bundle.go#L1964: http2errStreamID = errors.New("invalid stream ID")
h2_bundle.go#L1965: http2errDepStreamID = errors.New("invalid dependent stream ID")
h2_bundle.go#L1966: http2errPadLength = errors.New("pad length too large")
h2_bundle.go#L1967: http2errPadBytes = errors.New("padding bytes must all be zeros unless AllowIllegalWrites is enabled")
h2_bundle.go#L2308: return errors.New("illegal window increment value")
h2_bundle.go#L2850: return nil, errors.New("illegal use of AllowIllegalReads with ReadMetaHeaders")
h2_bundle.go#L3104: err = errors.New("invalid base " + strconv.Itoa(base))
h2_bundle.go#L3667: var http2errClosedPipeWrite = errors.New("write on closed buffer")
h2_bundle.go#L3777: http2errClientDisconnected = errors.New("client disconnected")
h2_bundle.go#L3778: http2errClosedBody = errors.New("body closed by handler")
h2_bundle.go#L3779: http2errHandlerComplete = errors.New("http2: request body closed due to handler exiting")
h2_bundle.go#L3780: http2errStreamClosed = errors.New("http2: stream closed")
h2_bundle.go#L4690: var http2errPrefaceTimeout = errors.New("timeout waiting for client preface")
h2_bundle.go#L4910: var http2errHandlerPanicked = errors.New("http2: handler panicked")
h2_bundle.go#L6438: return 0, errors.New("http2: handler wrote more than declared Content-Length")
h2_bundle.go#L6467: http2ErrRecursivePush = errors.New("http2: recursive push not allowed")
h2_bundle.go#L6468: http2ErrPushLimitReached = errors.New("http2: push would exceed peer's SETTINGS_MAX_CONCURRENT_STREAMS")
h2_bundle.go#L6516: return errors.New("URL must have a host")
h2_bundle.go#L6700: return errors.New(`request header "TE" may only be "trailers" in HTTP/2`)
h2_bundle.go#L7201: return nil, errors.New("http2: unsupported scheme")
h2_bundle.go#L7248: http2errClientConnClosed = errors.New("http2: client conn is closed")
h2_bundle.go#L7249: http2errClientConnUnusable = errors.New("http2: client conn not usable")
h2_bundle.go#L7250: http2errClientConnGotGoAway = errors.New("http2: Transport received Server's graceful shutdown GOAWAY")
h2_bundle.go#L7343: return nil, errors.New("http2: could not negotiate protocol mutually")
h2_bundle.go#L7727: err := errors.New("http2: client connection force closed via ClientConn.Close")
h2_bundle.go#L7733: err := errors.New("http2: client connection lost")
h2_bundle.go#L7742: var http2errRequestCanceled = errors.New("net/http: request canceled")
h2_bundle.go#L8216: http2errStopReqBodyWrite = errors.New("http2: aborting request body write")
h2_bundle.go#L8219: http2errStopReqBodyWriteAndCancel = errors.New("http2: canceling request")
h2_bundle.go#L8221: http2errReqBodyTooLong = errors.New("http2: request body larger than specified content length")
h2_bundle.go#L8422: var http2errNilRequestURL = errors.New("http2: Request.URI is nil")
h2_bundle.go#L8886: Cause: errors.New("protocol error: headers after END_STREAM"),
h2_bundle.go#L8945: return nil, errors.New("malformed response from server: missing status pseudo header")
h2_bundle.go#L8949: return nil, errors.New("malformed response from server: malformed non-numeric status pseudo header")
h2_bundle.go#L8991: return nil, errors.New("1xx informational response with END_STREAM flag")
h2_bundle.go#L8996: return nil, errors.New("http2: too many 1xx informational responses")
h2_bundle.go#L9103: err = errors.New("net/http: server replied with more than declared Content-Length; truncated")
h2_bundle.go#L9154: var http2errClosedResponseBody = errors.New("http2: response body closed")
h2_bundle.go#L9576: http2errResponseHeaderListSize = errors.New("http2: response header list larger than advertised limit")
h2_bundle.go#L9577: http2errRequestHeaderListSize = errors.New("http2: request header list larger than peer's advertised limit")
request.go#L39: var ErrMissingFile = errors.New("http: no such file")
request.go#L415: var ErrNoCookie = errors.New("http: named cookie not present")
request.go#L469: return nil, errors.New("http: MultipartReader called twice")
request.go#L472: return nil, errors.New("http: multipart handled by ParseMultipartForm")
request.go#L543: var errMissingHost = errors.New("http: Request.Write on Request with no Host or URL set")
request.go#L595: return errors.New("net/http: can't write control character in Request.URL")
request.go#L867: return nil, errors.New("net/http: nil Context")
request.go#L1178: l.err = errors.New("http: request body too large")
request.go#L1194: err = errors.New("missing form body")
request.go#L1220: err = errors.New("http: POST too large")
request.go#L1301: return errors.New("http: multipart handled by MultipartReader")
request.go#L1373: return nil, nil, errors.New("http: multipart handled by MultipartReader")
response.go#L131: var ErrNoLocation = errors.New("http: no Location header in response")
server.go#L41: ErrBodyNotAllowed = errors.New("http: request method or response status code does not allow body")
server.go#L48: ErrHijacked = errors.New("http: connection has been hijacked")
server.go#L54: ErrContentLength = errors.New("http: wrote more than the declared Content-Length")
server.go#L59: ErrWriteAfterFlush = errors.New("unused")
server.go#L956: var errTooLarge = errors.New("http: request too large")
server.go#L1797: var ErrAbortHandler = errors.New("net/http: abort Handler")
server.go#L2997: var ErrServerClosed = errors.New("http: Server closed")
server.go#L3334: var ErrHandlerTimeout = errors.New("http: Handler timeout")
socks_bundle.go#L63: return nil, errors.New("too many authentication methods")
socks_bundle.go#L78: return nil, errors.New("unexpected protocol version " + strconv.Itoa(int(b[0])))
socks_bundle.go#L82: return nil, errors.New("no acceptable authentication methods")
socks_bundle.go#L100: return nil, errors.New("unknown address type")
socks_bundle.go#L104: return nil, errors.New("FQDN too long")
socks_bundle.go#L119: return nil, errors.New("unexpected protocol version " + strconv.Itoa(int(b[0])))
socks_bundle.go#L122: return nil, errors.New("unknown error " + cmdErr.String())
socks_bundle.go#L125: return nil, errors.New("non-zero reserved field")
socks_bundle.go#L142: return nil, errors.New("unknown address type " + strconv.Itoa(int(b[3])))
socks_bundle.go#L171: return "", 0, errors.New("port number out of range " + port)
socks_bundle.go#L314: return nil, &net.OpError{Op: d.cmd.String(), Net: network, Source: proxy, Addr: dst, Err: errors.New("nil context")}
socks_bundle.go#L350: return nil, &net.OpError{Op: d.cmd.String(), Net: network, Source: proxy, Addr: dst, Err: errors.New("nil context")}
socks_bundle.go#L393: return errors.New("network not implemented")
socks_bundle.go#L398: return errors.New("command not implemented")
socks_bundle.go#L449: return errors.New("invalid username/password")
socks_bundle.go#L465: return errors.New("invalid username/password version")
socks_bundle.go#L468: return errors.New("username/password authentication failed")
socks_bundle.go#L472: return errors.New("unsupported authentication method " + strconv.Itoa(int(auth)))
transfer.go#L828: var ErrBodyReadAfterClose = errors.New("http: invalid Read on closed Body")
transfer.go#L908: var errTrailerEOF = errors.New("http: unexpected EOF reading trailer")
transfer.go#L933: return errors.New("http: suspiciously long trailer after chunked body")
transport.go#L511: return nil, errors.New("http: nil Request.URL")
transport.go#L515: return nil, errors.New("http: nil Request.Header")
transport.go#L558: return nil, errors.New("http: no Host in request URL")
transport.go#L627: var errCannotRewind = errors.New("net/http: cannot rewind body after connection loss")
transport.go#L732: var ErrSkipAltProtocol = errors.New("net/http: skip alternate protocol")
transport.go#L859: errKeepAlivesDisabled = errors.New("http: putIdleConn: keep alives disabled")
transport.go#L860: errConnBroken = errors.New("http: putIdleConn: connection is in bad state")
transport.go#L861: errCloseIdle = errors.New("http: putIdleConn: CloseIdleConnections was called")
transport.go#L862: errTooManyIdle = errors.New("http: putIdleConn: too many idle connections")
transport.go#L863: errTooManyIdleHost = errors.New("http: putIdleConn: too many idle connections for host")
transport.go#L864: errCloseIdleConns = errors.New("http: CloseIdleConnections called")
transport.go#L865: errReadLoopExiting = errors.New("http: persistConn.readLoop exiting")
transport.go#L866: errIdleConnTimeout = errors.New("http: idle connection timeout")
transport.go#L872: errServerClosedIdle = errors.New("http: server closed idle connection")
transport.go#L1174: err = errors.New("net/http: Transport.Dial hook returned (nil, nil)")
transport.go#L1322: err = errors.New("net/http: Transport.DialTLS or DialTLSContext returned (nil, nil)")
transport.go#L1724: return nil, errors.New("unknown status code")
transport.go#L1726: return nil, errors.New(text)
transport.go#L2056: var errCallerOwnsConn = errors.New("read loop ending; caller owns writable underlying conn")
transport.go#L2309: return nil, errors.New("net/http: too many 1xx informational responses")
transport.go#L2518: var errRequestCanceledConn = errors.New("net/http: request canceled while waiting for connection") // TODO: unify?
transport.go#L2761: var errReadOnClosedResBody = errors.New("http: read on closed response body")
net/http/httputil
dump.go#L293: var errNoBody = errors.New("sentinel error value")
persist.go#L30: var errClosed = errors.New("i/o operation on closed connection")
persist.go#L203: return errors.New("persist server pipe count")
net/http/internal
chunked.go#L21: var ErrLineTooLong = errors.New("header line too long")
chunked.go#L81: cr.err = errors.New("malformed chunked encoding")
chunked.go#L252: return 0, errors.New("invalid byte in chunk length")
chunked.go#L255: return 0, errors.New("http chunk length too large")
net/netip
netip.go#L652: return Prefix{}, errors.New("negative Prefix bits")
netip.go#L660: return Prefix{}, errors.New("prefix length " + itoa.Itoa(b) + " too large for IPv4")
netip.go#L665: return Prefix{}, errors.New("prefix length " + itoa.Itoa(b) + " too large for IPv6")
netip.go#L1030: return errors.New("unexpected slice size")
netip.go#L1057: return "", "", false, errors.New("not an ip:port")
netip.go#L1062: return "", "", false, errors.New("no IP")
netip.go#L1065: return "", "", false, errors.New("no port")
netip.go#L1069: return "", "", false, errors.New("missing ]")
netip.go#L1090: return ipp, errors.New("invalid port " + strconv.Quote(port) + " parsing " + strconv.Quote(s))
netip.go#L1098: return AddrPort{}, errors.New("invalid ip:port " + strconv.Quote(s) + ", square brackets can only be used with IPv6 addresses")
netip.go#L1100: return AddrPort{}, errors.New("invalid ip:port " + strconv.Quote(s) + ", IPv6 addresses must be surrounded by square brackets")
netip.go#L1221: return errors.New("unexpected slice size")
netip.go#L1298: return Prefix{}, errors.New("netip.ParsePrefix(" + strconv.Quote(s) + "): no '/'")
netip.go#L1302: return Prefix{}, errors.New("netip.ParsePrefix(" + strconv.Quote(s) + "): " + err.Error())
netip.go#L1307: return Prefix{}, errors.New("netip.ParsePrefix(" + strconv.Quote(s) + ": bad bits after slash: " + strconv.Quote(bitsStr))
netip.go#L1314: return Prefix{}, errors.New("netip.ParsePrefix(" + strconv.Quote(s) + ": prefix length out of range")
netip.go#L1481: return errors.New("unexpected slice size")
net/url
url.go#L443: return "", "", errors.New("missing protocol scheme")
url.go#L499: return nil, errors.New("net/url: invalid control character in URL")
url.go#L503: return nil, errors.New("empty url")
url.go#L533: return nil, errors.New("invalid URI for request")
url.go#L544: return nil, errors.New("first path segment in URL cannot contain colon")
url.go#L584: return nil, "", errors.New("net/url: invalid userinfo")
url.go#L612: return "", errors.New("missing ']' in host")
os
exec.go#L18: var ErrProcessDone = errors.New("os: process already finished")
exec_unix.go#L64: return errors.New("os: process already released")
exec_unix.go#L67: return errors.New("os: process not initialized")
exec_unix.go#L76: return errors.New("os: unsupported signal type")
executable_procfs.go#L18: return "", errors.New("Executable not implemented for " + runtime.GOOS)
file.go#L133: return 0, &PathError{Op: "readat", Path: f.name, Err: errors.New("negative offset")}
file.go#L193: var errWriteAtInAppendMode = errors.New("os: invalid use of WriteAt on file opened with O_APPEND")
file.go#L209: return 0, &PathError{Op: "writeat", Path: f.name, Err: errors.New("negative offset")}
file.go#L413: return "", errors.New("%LocalAppData% is not defined")
file.go#L419: return "", errors.New("$HOME is not defined")
file.go#L426: return "", errors.New("$home is not defined")
file.go#L435: return "", errors.New("neither $XDG_CACHE_HOME nor $HOME are defined")
file.go#L464: return "", errors.New("%AppData% is not defined")
file.go#L470: return "", errors.New("$HOME is not defined")
file.go#L477: return "", errors.New("$home is not defined")
file.go#L486: return "", errors.New("neither $XDG_CONFIG_HOME nor $HOME are defined")
file.go#L518: return "", errors.New(enverr + " is not defined")
tempfile.go#L55: var errPatternHasSeparator = errors.New("pattern contains path separator")
os/exec
exec.go#L392: return errors.New("exec: already started")
exec.go#L500: return errors.New("exec: not started")
exec.go#L503: return errors.New("exec: Wait was already called")
exec.go#L536: return nil, errors.New("exec: Stdout already set")
exec.go#L559: return nil, errors.New("exec: Stdout already set")
exec.go#L562: return nil, errors.New("exec: Stderr already set")
exec.go#L579: return nil, errors.New("exec: Stdin already set")
exec.go#L582: return nil, errors.New("exec: StdinPipe after process started")
exec.go#L621: return nil, errors.New("exec: Stdout already set")
exec.go#L624: return nil, errors.New("exec: StdoutPipe after process started")
exec.go#L646: return nil, errors.New("exec: Stderr already set")
exec.go#L649: return nil, errors.New("exec: StderrPipe after process started")
lp_unix.go#L18: var ErrNotFound = errors.New("executable file not found in $PATH")
path
match.go#L14: var ErrBadPattern = errors.New("syntax error in pattern")
path/filepath
match.go#L17: var ErrBadPattern = errors.New("syntax error in pattern")
path.go#L287: return "", errors.New("Rel: can't make " + targpath + " relative to " + basepath)
path.go#L313: return "", errors.New("Rel: can't make " + targpath + " relative to " + basepath)
symlink.go#L100: return "", errors.New("EvalSymlinks: too many links")
reflect
value.go#L1283: return Value{}, errors.New("reflect: indirection through nil pointer to embedded struct field " + v.typ.Elem().Name())
runtime/pprof
elf.go#L15: errBadELF = errors.New("malformed ELF binary")
elf.go#L16: errNoBuildID = errors.New("no NT_GNU_BUILD_ID found in ELF binary")
strconv
atoi.go#L18: var ErrRange = errors.New("value out of range")
atoi.go#L21: var ErrSyntax = errors.New("invalid syntax")
atoi.go#L45: return &NumError{fn, str, errors.New("invalid base " + Itoa(base))}
atoi.go#L49: return &NumError{fn, str, errors.New("invalid bit size " + Itoa(bitSize))}
strings
reader.go#L53: return 0, errors.New("strings.Reader.ReadAt: negative offset")
reader.go#L79: return errors.New("strings.Reader.UnreadByte: at beginning of string")
reader.go#L105: return errors.New("strings.Reader.UnreadRune: at beginning of string")
reader.go#L108: return errors.New("strings.Reader.UnreadRune: previous operation was not ReadRune")
reader.go#L127: return 0, errors.New("strings.Reader.Seek: invalid whence")
reader.go#L130: return 0, errors.New("strings.Reader.Seek: negative position")
syscall
exec_unix.go#L191: return 0, errorspkg.New("both Setctty and Foreground set in SysProcAttr")
exec_unix.go#L194: return 0, errorspkg.New("Setctty set but Ctty not valid in child")
testing
fuzz.go#L385: return errors.New(buf.String())
testing.go#L1297: var errNilPanicOrGoexit = errors.New("test executed panic(nil) or runtime.Goexit")
testing.go#L1567: var errMain = errors.New("testing: unexpected use of func Main")
testing/iotest
reader.go#L74: var ErrTimeout = errors.New("timeout")
text/template
exec.go#L249: walkBreak = errors.New("break")
exec.go#L250: walkContinue = errors.New("continue")
funcs.go#L404: errBadComparisonType = errors.New("invalid type for comparison")
funcs.go#L405: errBadComparison = errors.New("incompatible types for comparison")
funcs.go#L406: errNoComparison = errors.New("missing argument for comparison")
time
format.go#L414: var atoiError = errors.New("time: invalid number")
format.go#L770: var errBad = errors.New("bad value for field") // placeholder not passed to user
format.go#L1441: var errLeadingInt = errors.New("time: bad [0-9]*") // never printed
format.go#L1530: return 0, errors.New("time: invalid duration " + quote(orig))
format.go#L1542: return 0, errors.New("time: invalid duration " + quote(orig))
format.go#L1548: return 0, errors.New("time: invalid duration " + quote(orig))
format.go#L1562: return 0, errors.New("time: invalid duration " + quote(orig))
format.go#L1574: return 0, errors.New("time: missing unit in duration " + quote(orig))
format.go#L1580: return 0, errors.New("time: unknown unit " + quote(u) + " in duration " + quote(orig))
format.go#L1584: return 0, errors.New("time: invalid duration " + quote(orig))
format.go#L1593: return 0, errors.New("time: invalid duration " + quote(orig))
format.go#L1598: return 0, errors.New("time: invalid duration " + quote(orig))
format.go#L1605: return 0, errors.New("time: invalid duration " + quote(orig))
sys_unix.go#L47: return errors.New("short read")
tick.go#L24: panic(errors.New("non-positive interval for NewTicker"))
time.go#L1187: return nil, errors.New("Time.MarshalBinary: unexpected zone offset")
time.go#L1222: return errors.New("Time.UnmarshalBinary: no data")
time.go#L1227: return errors.New("Time.UnmarshalBinary: unsupported version")
time.go#L1235: return errors.New("Time.UnmarshalBinary: invalid length")
time.go#L1286: return nil, errors.New("Time.MarshalJSON: year outside of range [0,9999]")
time.go#L1313: return nil, errors.New("Time.MarshalText: year outside of range [0,9999]")
zoneinfo.go#L621: var errLocation = errors.New("time: invalid location name")
zoneinfo_read.go#L110: var badData = errors.New("malformed time zone information")
zoneinfo_read.go#L419: return nil, errors.New("corrupt zip file " + zipfile)
zoneinfo_read.go#L427: return nil, errors.New("corrupt zip file " + zipfile)
zoneinfo_read.go#L469: return nil, errors.New("unsupported compression for " + name + " in " + zipfile)
zoneinfo_read.go#L494: return nil, errors.New("corrupt zip file " + zipfile)
zoneinfo_read.go#L500: return nil, errors.New("corrupt zip file " + zipfile)
zoneinfo_read.go#L555: return nil, errors.New("unknown time zone " + name)
vendor/golang.org/x/crypto/chacha20
chacha_generic.go#L82: return nil, errors.New("chacha20: wrong key size")
chacha_generic.go#L93: return nil, errors.New("chacha20: wrong nonce size")
chacha_generic.go#L354: return nil, errors.New("chacha20: wrong HChaCha20 key size")
chacha_generic.go#L357: return nil, errors.New("chacha20: wrong HChaCha20 nonce size")
vendor/golang.org/x/crypto/chacha20poly1305
chacha20poly1305.go#L42: return nil, errors.New("chacha20poly1305: bad key length")
chacha20poly1305.go#L69: var errOpen = errors.New("chacha20poly1305: message authentication failed")
xchacha20poly1305.go#L26: return nil, errors.New("chacha20poly1305: bad key length")
vendor/golang.org/x/crypto/cryptobyte
builder.go#L234: b.err = errors.New("pending ASN.1 child too long")
builder.go#L292: b.err = errors.New("cryptobyte: length overflow")
builder.go#L295: b.err = errors.New("cryptobyte: Builder is exceeding its fixed-size buffer")
vendor/golang.org/x/crypto/hkdf
hkdf.go#L51: return 0, errors.New("hkdf: entropy limit reached")
vendor/golang.org/x/net/dns/dnsmessage
message.go#L252: ErrNotStarted = errors.New("parsing/packing of this type isn't available yet")
message.go#L256: ErrSectionDone = errors.New("parsing/packing of this section has completed")
message.go#L258: errBaseLen = errors.New("insufficient data for base length type")
message.go#L259: errCalcLen = errors.New("insufficient data for calculated length type")
message.go#L260: errReserved = errors.New("segment prefix is reserved")
message.go#L261: errTooManyPtr = errors.New("too many pointers (>10)")
message.go#L262: errInvalidPtr = errors.New("invalid pointer")
message.go#L263: errNilResouceBody = errors.New("nil resource body")
message.go#L264: errResourceLen = errors.New("insufficient data for resource body length")
message.go#L265: errSegTooLong = errors.New("segment length too long")
message.go#L266: errZeroSegLen = errors.New("zero length segment")
message.go#L267: errResTooLong = errors.New("resource length too long")
message.go#L268: errTooManyQuestions = errors.New("too many Questions to pack (>65535)")
message.go#L269: errTooManyAnswers = errors.New("too many Answers to pack (>65535)")
message.go#L270: errTooManyAuthorities = errors.New("too many Authorities to pack (>65535)")
message.go#L271: errTooManyAdditionals = errors.New("too many Additionals to pack (>65535)")
message.go#L272: errNonCanonicalName = errors.New("name is not in canonical format (it must end with a .)")
message.go#L273: errStringTooLong = errors.New("character string exceeds maximum length (255)")
message.go#L274: errCompressedSRV = errors.New("compressed name in SRV resource data")
vendor/golang.org/x/net/http/httpproxy
proxy.go#L134: return nil, errors.New("refusing to use HTTP_PROXY value in CGI environment; see golang.org/s/cgihttpproxy")
vendor/golang.org/x/net/http2/hpack
hpack.go#L116: var ErrStringLength = errors.New("hpack: string too long")
hpack.go#L238: return DecodingError{errors.New("truncated headers")}
hpack.go#L287: var errNeedMore = errors.New("need more data")
hpack.go#L334: return DecodingError{errors.New("invalid encoding")}
hpack.go#L403: return DecodingError{errors.New("dynamic table size update MUST occur at the beginning of a header block")}
hpack.go#L412: return DecodingError{errors.New("dynamic table size update too large")}
hpack.go#L419: var errVarintOverflow = DecodingError{errors.New("varint integer overflow")}
huffman.go#L44: var ErrInvalidHuffman = errors.New("hpack: invalid Huffman-encoded data")
vendor/golang.org/x/text/secure/bidirule
bidirule.go#L46: var ErrInvalid = errors.New("bidirule: failed Bidi Rule")
vendor/golang.org/x/text/transform
transform.go#L21: ErrShortDst = errors.New("transform: short destination buffer")
transform.go#L25: ErrShortSrc = errors.New("transform: short source buffer")
transform.go#L29: ErrEndOfSpan = errors.New("transform: input and output are not identical")
transform.go#L33: errInconsistentByteCount = errors.New("transform: inconsistent byte count returned")
transform.go#L37: errShortInternal = errors.New("transform: short internal buffer")