func fmt.Errorf
314 uses
fmt (current package)
errors.go#L22: func Errorf(format string, a ...any) error {
compress/flate
deflate.go#L597: return fmt.Errorf("flate: invalid compression level %d: want value in range [-2, 9]", level)
compress/gzip
gzip.go#L62: return nil, fmt.Errorf("gzip: invalid compression level: %d", level)
crypto/tls
auth.go#L27: return fmt.Errorf("expected an ECDSA public key, got %T", pubkey)
auth.go#L35: return fmt.Errorf("expected an Ed25519 public key, got %T", pubkey)
auth.go#L43: return fmt.Errorf("expected an RSA public key, got %T", pubkey)
auth.go#L51: return fmt.Errorf("expected an RSA public key, got %T", pubkey)
auth.go#L109: return 0, 0, fmt.Errorf("unsupported signature algorithm: %v", signatureAlgorithm)
auth.go#L123: return 0, 0, fmt.Errorf("unsupported signature algorithm: %v", signatureAlgorithm)
auth.go#L142: return 0, 0, fmt.Errorf("tls: Ed25519 public keys are not supported before TLS 1.2")
auth.go#L144: return 0, 0, fmt.Errorf("tls: unsupported public key: %T", pub)
auth.go#L260: return fmt.Errorf("tls: unsupported certificate: private key is %T, expected *%T",
auth.go#L263: return fmt.Errorf("tls: unsupported certificate: private key is *ed25519.PrivateKey, expected ed25519.PrivateKey")
auth.go#L268: return fmt.Errorf("tls: certificate private key (%T) does not implement crypto.Signer",
auth.go#L279: return fmt.Errorf("tls: unsupported certificate curve (%s)", pub.Curve.Params().Name)
auth.go#L282: return fmt.Errorf("tls: certificate RSA key size too small for supported signature algorithms")
auth.go#L285: return fmt.Errorf("tls: unsupported certificate key (%T)", pub)
auth.go#L289: return fmt.Errorf("tls: peer doesn't support the certificate custom signature algorithms")
auth.go#L292: return fmt.Errorf("tls: internal error: unsupported key (%T)", cert.PrivateKey)
common.go#L1267: return fmt.Errorf("failed to parse certificate: %w", err)
common.go#L1270: return fmt.Errorf("certificate is not valid for requested server name: %w", err)
common.go#L1416: return fmt.Errorf("failed to parse certificate #%d in the chain: %w", j, err)
common.go#L1611: return fmt.Errorf("tls: received unexpected handshake message of type %T when waiting for %T", got, wanted)
conn.go#L1108: return nil, c.in.setErrorLocked(fmt.Errorf("tls: handshake message of length %d bytes exceeds maximum of %d bytes", n, maxHandshakeSize))
conn.go#L1325: return fmt.Errorf("tls: received unexpected handshake message of type %T", msg)
conn.go#L1440: alertErr = fmt.Errorf("tls: failed to send closeNotify alert (but connection was closed anyway): %w", err)
conn.go#L1602: c.handshakeErr = fmt.Errorf("%w%.0w", c.handshakeErr, AlertError(a))
handshake_client.go#L526: return fmt.Errorf("tls: server selected unsupported protocol version %x", peerVersion)
handshake_client.go#L785: return fmt.Errorf("tls: client certificate private key of type %T does not implement crypto.Signer", chainToSend.PrivateKey)
handshake_client.go#L1084: return fmt.Errorf("tls: server sent certificate containing RSA key larger than %d bits", max)
handshake_client.go#L1140: return fmt.Errorf("tls: server's certificate contains an unsupported type of public key: %T", certs[0].PublicKey)
handshake_messages.go#L29: return fmt.Errorf("invalid value length: expected %d, got %d", n, len(v))
handshake_server.go#L166: return nil, fmt.Errorf("tls: client offered only unsupported versions: %x", clientVersions)
handshake_server.go#L272: return fmt.Errorf("tls: unsupported signing key type (%T)", priv.Public())
handshake_server.go#L281: return fmt.Errorf("tls: unsupported decryption key type (%T)", priv.Public())
handshake_server.go#L295: return "", fmt.Errorf("tls: client did not request an application protocol")
handshake_server.go#L317: return "", fmt.Errorf("tls: client requested unsupported application protocols (%s)", clientProtos)
handshake_server.go#L887: return fmt.Errorf("tls: client sent certificate containing RSA key larger than %d bits", max)
handshake_server.go#L938: return fmt.Errorf("tls: client certificate contains an unsupported public key of type %T", certs[0].PublicKey)
key_agreement.go#L202: return nil, fmt.Errorf("tls: certificate private key of type %T does not implement crypto.Signer", cert.PrivateKey)
key_schedule.go#L61: panic(fmt.Errorf("failed to construct HKDF label: %s", err))
prf.go#L275: return nil, fmt.Errorf("crypto/tls: reserved ExportKeyingMaterial label: %s", label)
prf.go#L289: return nil, fmt.Errorf("crypto/tls: ExportKeyingMaterial context too long")
quic.go#L278: q.conn.handshakeErr = fmt.Errorf("tls: handshake message of length %d bytes exceeds maximum of %d bytes", n, maxHandshake)
quic.go#L372: return fmt.Errorf("%w%.0w", err, AlertError(a))
tls.go#L280: return fail(fmt.Errorf("tls: failed to find \"CERTIFICATE\" PEM block in certificate input after skipping PEM blocks of the following types: %v", skippedBlockTypes))
tls.go#L294: return fail(fmt.Errorf("tls: failed to find PEM block with type ending in \"PRIVATE KEY\" in key input after skipping PEM blocks of the following types: %v", skippedBlockTypes))
crypto/x509
parser.go#L107: return "", fmt.Errorf("unsupported string type: %v", tag)
parser.go#L141: return nil, fmt.Errorf("x509: invalid RDNSequence: invalid attribute value: %s", err)
parser.go#L396: return fmt.Errorf("x509: cannot parse URI %q: %s", uriStr, err)
parser.go#L400: return fmt.Errorf("x509: cannot parse URI %q: invalid domain", uriStr)
parser.go#L545: return nil, nil, nil, nil, fmt.Errorf("x509: invalid NameConstraints extension")
parser.go#L571: return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse dnsName constraint %q", domain)
parser.go#L589: return nil, nil, nil, nil, fmt.Errorf("x509: IP constraint contained value of length %d", l)
parser.go#L593: return nil, nil, nil, nil, fmt.Errorf("x509: IP constraint contained invalid mask %x", mask)
parser.go#L608: return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse rfc822Name constraint %q", constraint)
parser.go#L617: return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse rfc822Name constraint %q", constraint)
parser.go#L629: return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse URI constraint %q: cannot be IP address", domain)
parser.go#L641: return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse URI constraint %q", domain)
parser.go#L992: return nil, fmt.Errorf("x509: certificate contains duplicate extension with OID %q", oidStr)
parser.go#L1085: return nil, fmt.Errorf("x509: unsupported crl version: %d", version)
parser.go#L1179: return nil, fmt.Errorf("x509: malformed reasonCode extension")
pkcs8.go#L72: return nil, fmt.Errorf("x509: invalid Ed25519 private key: %v", err)
pkcs8.go#L75: return nil, fmt.Errorf("x509: invalid Ed25519 private key length: %d", l)
pkcs8.go#L85: return nil, fmt.Errorf("x509: invalid X25519 private key: %v", err)
pkcs8.go#L90: return nil, fmt.Errorf("x509: PKCS#8 wrapping contained private key with unknown algorithm: %v", privKey.Algo.Algorithm)
pkcs8.go#L137: return nil, fmt.Errorf("x509: failed to marshal private key: %v", err)
pkcs8.go#L148: return nil, fmt.Errorf("x509: failed to marshal private key: %v", err)
pkcs8.go#L171: return nil, fmt.Errorf("x509: unknown key type while marshaling PKCS#8: %T", key)
sec1.go#L96: return nil, fmt.Errorf("x509: unknown EC private key version %d", privKey.Version)
verify.go#L406: return false, fmt.Errorf("x509: internal error: cannot parse constraint %q", constraint)
verify.go#L427: return false, fmt.Errorf("URI with empty host (%q) cannot be matched against constraints", uri.String())
verify.go#L442: return false, fmt.Errorf("URI with IP (%q) cannot be matched against constraints", uri.String())
verify.go#L471: return false, fmt.Errorf("x509: internal error: cannot parse domain %q", domain)
verify.go#L487: return false, fmt.Errorf("x509: internal error: cannot parse domain %q", constraint)
verify.go#L623: return fmt.Errorf("x509: cannot parse rfc822Name %q", mailbox)
verify.go#L636: return fmt.Errorf("x509: cannot parse dnsName %q", name)
verify.go#L650: return fmt.Errorf("x509: internal error: URI SAN %q failed to parse", name)
verify.go#L663: return fmt.Errorf("x509: internal error: IP SAN %x failed to parse", data)
verify.go#L765: return nil, fmt.Errorf("crypto/x509: error fetching intermediate: %w", err)
x509.go#L135: return nil, pkix.AlgorithmIdentifier{}, fmt.Errorf("x509: unsupported public key type: %T", pub)
x509.go#L887: return fmt.Errorf("x509: signature algorithm specifies an %s public key, but have public key of type %T", expectedPubKeyAlgo.String(), pubKey)
x509.go#L1107: return fmt.Errorf("x509: %q cannot be encoded as an IA5String", s)
x509.go#L1529: return nil, fmt.Errorf("x509: signature returned by signer is invalid: %w", err)
x509.go#L1632: return nil, fmt.Errorf("x509: unsupported public key type: %T", pub)
database/sql/driver
types.go#L74: return nil, fmt.Errorf("sql/driver: couldn't convert %q into type bool", s)
types.go#L80: return nil, fmt.Errorf("sql/driver: couldn't convert %q into type bool", s)
types.go#L92: return nil, fmt.Errorf("sql/driver: couldn't convert %d into type bool", iv)
types.go#L98: return nil, fmt.Errorf("sql/driver: couldn't convert %d into type bool", uv)
types.go#L101: return nil, fmt.Errorf("sql/driver: couldn't convert %v (%T) into type bool", src, src)
types.go#L118: return nil, fmt.Errorf("sql/driver: value %d overflows int32", v)
types.go#L124: return nil, fmt.Errorf("sql/driver: value %d overflows int32", v)
types.go#L130: return nil, fmt.Errorf("sql/driver: value %q can't be converted to int32", v)
types.go#L134: return nil, fmt.Errorf("sql/driver: unsupported value %v (type %T) converting to int32", v, v)
types.go#L174: return nil, fmt.Errorf("nil value not allowed")
types.go#L253: return nil, fmt.Errorf("non-Value type %T returned from Value", sv)
types.go#L278: return nil, fmt.Errorf("uint64 values with high bit set are not supported")
types.go#L290: return nil, fmt.Errorf("unsupported type %T, a slice of %s", v, ek)
types.go#L294: return nil, fmt.Errorf("unsupported type %T, a %s", v, rv.Kind())
encoding/asn1
asn1.go#L356: err = fmt.Errorf("asn1: time did not serialize back to the original value and may be invalid: given %q, but serialized as %q", s, serialized)
asn1.go#L379: err = fmt.Errorf("asn1: time did not serialize back to the original value and may be invalid: given %q, but serialized as %q", s, serialized)
marshal.go#L578: return nil, fmt.Errorf("asn1: cannot marshal nil value")
encoding/json
decode.go#L709: d.saveError(fmt.Errorf("json: cannot set embedded pointer to unexported struct: %v", subv.Type().Elem()))
decode.go#L728: d.saveError(fmt.Errorf("json: unknown field %q", key))
decode.go#L752: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal unquoted value into %v", subv.Type()))
decode.go#L848: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L859: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L875: return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
decode.go#L889: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L902: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L908: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L926: return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
decode.go#L948: return fmt.Errorf("json: invalid number literal, trying to unmarshal %q into Number", item)
decode.go#L962: return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
decode.go#L975: return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
encode.go#L577: e.error(fmt.Errorf("json: invalid number literal %q", numStr))
encode.go#L758: e.error(fmt.Errorf("json: encoding error for type %q: %q", v.Type().String(), err.Error()))
github.com/apapsch/go-jsonmerge/v2
merge.go#L42: err := fmt.Errorf("patch value must be object for key \"%v\"", pathStr)
merge.go#L113: err = fmt.Errorf("error in data JSON: %v", err)
merge.go#L119: err = fmt.Errorf("error in patch JSON: %v", err)
merge.go#L127: err = fmt.Errorf("error writing merged JSON: %v", err)
merge.go#L142: err = fmt.Errorf("error in data JSON: %v", err)
merge.go#L148: err = fmt.Errorf("error in patch JSON: %v", err)
merge.go#L156: err = fmt.Errorf("error writing merged JSON: %v", err)
github.com/coinbase/cdp-sdk/go
cdp.go#L45: return nil, fmt.Errorf("failed to create CDP client: %w", err)
cdp.go#L70: return fmt.Errorf("failed to generate JWT: %w", err)
cdp.go#L94: return fmt.Errorf("failed to read request body: %w", err)
cdp.go#L102: return fmt.Errorf("failed to parse request body: %w", err)
cdp.go#L118: return fmt.Errorf("failed to generate wallet JWT: %w", err)
github.com/coinbase/cdp-sdk/go/auth
jwt.go#L43: return "", fmt.Errorf("failed to generate nonce: %w", err)
jwt.go#L69: return "", fmt.Errorf("failed to decode wallet secret: %w", err)
jwt.go#L75: return "", fmt.Errorf("could not create the EC key: %w", err)
jwt.go#L80: return "", fmt.Errorf("private key is not an ECDSA key")
jwt.go#L86: return "", fmt.Errorf("failed to generate nonce: %w", err)
jwt.go#L109: return "", fmt.Errorf("could not sign token: %w", err)
jwt.go#L150: return "", fmt.Errorf("failed to parse EC private key: %w", err)
jwt.go#L172: return "", fmt.Errorf("failed to sign token: %w", err)
jwt.go#L183: return "", fmt.Errorf("failed to decode Ed25519 key: %w", err)
jwt.go#L212: return "", fmt.Errorf("failed to sign token: %w", err)
github.com/golang-jwt/jwt/v5
errors_go1_20.go#L45: err = fmt.Errorf(format, args...)
types.go#L87: return fmt.Errorf("could not parse NumericData: %w", err)
types.go#L91: return fmt.Errorf("could not convert json number value to float: %w", err)
github.com/google/uuid
marshal.go#L34: return fmt.Errorf("invalid UUID (got %d bytes)", len(data))
null.go#L72: return fmt.Errorf("invalid UUID (got %d bytes)", len(data))
sql.go#L29: return fmt.Errorf("Scan: %v", err)
sql.go#L48: return fmt.Errorf("Scan: unable to scan type %T into UUID", src)
uuid.go#L77: return uuid, fmt.Errorf("invalid urn prefix: %q", s[:9])
uuid.go#L126: return uuid, fmt.Errorf("invalid urn prefix: %q", b[:9])
uuid.go#L203: return fmt.Errorf("invalid urn prefix: %q", s[:9])
uuid.go#L210: return fmt.Errorf("invalid bracketed UUID format")
github.com/oapi-codegen/runtime
bindparam.go#L74: return fmt.Errorf("parameter '%s' is empty, can't bind its value", paramName)
bindparam.go#L86: return fmt.Errorf("error unescaping query parameter '%s': %v", paramName, err)
bindparam.go#L91: return fmt.Errorf("error unescaping path parameter '%s': %v", paramName, err)
bindparam.go#L100: return fmt.Errorf("error unmarshaling '%s' text as %T: %s", value, dest, err)
bindparam.go#L127: return fmt.Errorf("error splitting input '%s' into parts: %s", value, err)
bindparam.go#L162: return nil, fmt.Errorf("invalid format for label parameter '%s', should start with '.'", paramName)
bindparam.go#L169: return nil, fmt.Errorf("invalid format for label parameter '%s', should start with '.'", paramName)
bindparam.go#L182: return nil, fmt.Errorf("invalid format for matrix parameter '%s', should start with ';'", paramName)
bindparam.go#L199: return nil, fmt.Errorf("expected parameter '%s' to start with %s", paramName, prefix)
bindparam.go#L225: return nil, fmt.Errorf("unhandled parameter style: %s", style)
bindparam.go#L244: return fmt.Errorf("error setting array element: %w", err)
bindparam.go#L272: return fmt.Errorf("parameter '%s' has invalid exploded format", paramName)
bindparam.go#L278: return fmt.Errorf("parameter '%s' has invalid format, property/values need to be pairs", paramName)
bindparam.go#L290: return fmt.Errorf("error binding parameter %s fields: %s", paramName, err)
bindparam.go#L371: return fmt.Errorf("query parameter '%s' is required", paramName)
bindparam.go#L395: return fmt.Errorf("query parameter '%s' is required", paramName)
bindparam.go#L401: return fmt.Errorf("multiple values for single value parameter '%s'", paramName)
bindparam.go#L406: return fmt.Errorf("query parameter '%s' is required", paramName)
bindparam.go#L427: return fmt.Errorf("query parameter '%s' is required", paramName)
bindparam.go#L433: return fmt.Errorf("parameter '%s' is not exploded, but is specified multiple times", paramName)
bindparam.go#L446: return fmt.Errorf("query parameter '%s' is required", paramName)
bindparam.go#L452: return fmt.Errorf("multiple values for single value parameter '%s'", paramName)
bindparam.go#L469: return fmt.Errorf("query arguments of style '%s' aren't yet supported", style)
bindparam.go#L471: return fmt.Errorf("style '%s' on parameter '%s' is invalid", style, paramName)
bindparam.go#L494: return false, fmt.Errorf("unmarshaling query arg '%s' into wrong type", paramName)
bindparam.go#L522: return false, fmt.Errorf("field '%s' specified multiple times for param '%s'", fieldName, paramName)
bindparam.go#L526: return false, fmt.Errorf("could not bind query arg '%s' to request object: %s'", paramName, err)
bindstring.go#L67: err = fmt.Errorf("value '%s' overflows destination of type: %s", src, t.Kind())
bindstring.go#L78: err = fmt.Errorf("value '%s' overflows destination of type: %s", src, t.Kind())
bindstring.go#L90: err = fmt.Errorf("value '%s' overflows destination of type: %s", src, t.Kind())
bindstring.go#L103: return fmt.Errorf("error unmarshaling '%s' text as %T: %s", src, dst, err)
bindstring.go#L125: return fmt.Errorf("error parsing '%s' as RFC3339 or 2006-01-02 time: %s", src, err)
bindstring.go#L148: return fmt.Errorf("error parsing '%s' as date: %s", src, err)
bindstring.go#L168: err = fmt.Errorf("can not bind to destination of type: %s", t.Kind())
bindstring.go#L171: return fmt.Errorf("error binding string parameter: %w", err)
deepobject.go#L28: return nil, fmt.Errorf("error traversing array: %w", err)
deepobject.go#L48: return nil, fmt.Errorf("error traversing map: %w", err)
deepobject.go#L72: return "", fmt.Errorf("failed to marshal input to JSON: %w", err)
deepobject.go#L77: return "", fmt.Errorf("failed to unmarshal JSON: %w", err)
deepobject.go#L81: return "", fmt.Errorf("error traversing JSON structure: %w", err)
deepobject.go#L138: return fmt.Errorf("%s has multiple values", pName)
deepobject.go#L155: return fmt.Errorf("error assigning value to destination: %w", err)
deepobject.go#L210: return fmt.Errorf("error binding map: %w", err)
deepobject.go#L221: return fmt.Errorf("error assigning slice: %w", err)
deepobject.go#L241: return fmt.Errorf("invalid date format: %w", err)
deepobject.go#L261: return fmt.Errorf("error parsing '%s' as RFC3339 or 2006-01-02 time: %s", pathValues.value, err)
deepobject.go#L263: return fmt.Errorf("invalid date format: %w", err)
deepobject.go#L276: return fmt.Errorf("failed enumerating fields: %w", err)
deepobject.go#L282: return fmt.Errorf("field [%s] is not present in destination object", fieldName)
deepobject.go#L287: return fmt.Errorf("error assigning field [%s]: %w", fieldName, err)
deepobject.go#L304: return fmt.Errorf("expected a valid bool, got %s", pathValues.value)
deepobject.go#L311: return fmt.Errorf("expected a valid float, got %s", pathValues.value)
deepobject.go#L318: return fmt.Errorf("expected a valid float, got %s", pathValues.value)
deepobject.go#L325: return fmt.Errorf("expected a valid int, got %s", pathValues.value)
deepobject.go#L357: return fmt.Errorf("error binding array: %w", err)
styleparam.go#L64: return "", fmt.Errorf("value is a nil pointer")
styleparam.go#L82: return "", fmt.Errorf("error marshaling '%s' as text: %s", value, err)
styleparam.go#L156: return "", fmt.Errorf("unsupported style '%s'", style)
styleparam.go#L168: return "", fmt.Errorf("error formatting '%s': %s", paramName, err)
styleparam.go#L216: return "", fmt.Errorf("failed to style time: %w", err)
styleparam.go#L233: return "", fmt.Errorf("failed to marshal input to JSON: %w", err)
styleparam.go#L240: return "", fmt.Errorf("failed to unmarshal JSON: %w", err)
styleparam.go#L244: return "", fmt.Errorf("error style JSON structure: %w", err)
styleparam.go#L276: return "", fmt.Errorf("error formatting '%s': %s", paramName, err)
styleparam.go#L301: return "", fmt.Errorf("error formatting '%s': %s", paramName, err)
styleparam.go#L359: return "", fmt.Errorf("deepObject parameters must be exploded")
styleparam.go#L369: return "", fmt.Errorf("unsupported style '%s'", style)
styleparam.go#L391: return "", fmt.Errorf("unsupported style '%s'", style)
styleparam.go#L439: return "", fmt.Errorf("failed to marshal input to JSON: %w", err)
styleparam.go#L446: return "", fmt.Errorf("failed to unmarshal JSON: %w", err)
styleparam.go#L450: return "", fmt.Errorf("error convert JSON structure: %w", err)
styleparam.go#L458: return "", fmt.Errorf("unsupported type %s", reflect.TypeOf(value).String())
math/big
floatconv.go#L129: err = fmt.Errorf("exponent overflow")
floatconv.go#L277: err = fmt.Errorf("expected end of string, found %q", ch)
floatmarsh.go#L76: return fmt.Errorf("Float.GobDecode: encoding version %d not supported", buf[0])
floatmarsh.go#L128: err = fmt.Errorf("math/big: cannot unmarshal %q into a *big.Float (%v)", text, err)
intconv.go#L222: err = fmt.Errorf("invalid rune %#U", ch)
intmarsh.go#L41: return fmt.Errorf("Int.GobDecode: encoding version %d not supported", b>>1)
intmarsh.go#L59: return fmt.Errorf("math/big: cannot unmarshal %q into a *big.Int", text)
ratmarsh.go#L54: return fmt.Errorf("Rat.GobDecode: encoding version %d not supported", b>>1)
ratmarsh.go#L83: return fmt.Errorf("math/big: cannot unmarshal %q into a *big.Rat", text)
mime
encodedword.go#L333: return fmt.Errorf("mime: unhandled charset %q", charset)
encodedword.go#L413: return 0, fmt.Errorf("mime: invalid hex byte %#02x", b)
mediatype.go#L363: return "", fmt.Errorf("mime: bogus characters after %%: %q", s)
type.go#L162: return fmt.Errorf("mime: extension %q missing leading dot", ext)
mime/multipart
multipart.go#L389: return nil, fmt.Errorf("multipart: boundary is empty")
multipart.go#L404: return nil, fmt.Errorf("multipart: NextPart: %w", err)
multipart.go#L423: return nil, fmt.Errorf("multipart: expecting a new Part; got line %q", string(line))
multipart.go#L440: return nil, fmt.Errorf("multipart: unexpected line in Next(): %q", line)
mime/quotedprintable
reader.go#L40: return 0, fmt.Errorf("quotedprintable: invalid hex byte 0x%02x", b)
reader.go#L99: r.rerr = fmt.Errorf("quotedprintable: invalid bytes after =: %q", rightStripped)
reader.go#L131: return n, fmt.Errorf("quotedprintable: invalid unescaped byte 0x%02x in body", b)
net/http
client.go#L276: return nil, didTimeout, fmt.Errorf("http: RoundTripper implementation (%T) returned a nil *Response with a nil error", rt)
client.go#L290: return nil, didTimeout, fmt.Errorf("http: RoundTripper implementation (%T) returned a *Response with content length %d but a nil Body", rt, resp.ContentLength)
client.go#L651: return nil, uerr(fmt.Errorf("failed to parse Location header %q: %v", loc, err))
cookie.go#L306: return fmt.Errorf("http: invalid byte %q in Cookie.Value", c.Value[i])
cookie.go#L312: return fmt.Errorf("http: invalid byte %q in Cookie.Path", c.Path[i])
h2_bundle.go#L4146: return fmt.Errorf("http2: TLSConfig.CipherSuites is missing an HTTP/2-required AES_128_GCM_SHA256 cipher (need at least one of TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 or TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256)")
h2_bundle.go#L4932: errc <- fmt.Errorf("bogus greeting %q", buf)
h2_bundle.go#L5689: st.body.CloseWithError(fmt.Errorf("sender tried to send more than declared Content-Length of %d bytes", st.declBodyBytes))
h2_bundle.go#L5757: st.body.CloseWithError(fmt.Errorf("request declared a Content-Length of %d but only wrote %d bytes",
h2_bundle.go#L5783: st.body.CloseWithError(fmt.Errorf("%w", os.ErrDeadlineExceeded))
h2_bundle.go#L6916: return fmt.Errorf("target must be an absolute URL or an absolute path: %q", target)
h2_bundle.go#L6922: return fmt.Errorf("cannot push URL with scheme %q from request with scheme %q", u.Scheme, wantScheme)
h2_bundle.go#L6930: return fmt.Errorf("promised request headers cannot include pseudo header %q", k)
h2_bundle.go#L6942: return fmt.Errorf("promised request headers cannot include %q", k)
h2_bundle.go#L6953: return fmt.Errorf("method %q must be GET or HEAD", opts.Method)
h2_bundle.go#L7105: return fmt.Errorf("request header %q is not valid in HTTP/2", k)
h2_bundle.go#L7818: return nil, fmt.Errorf("http2: Transport: cannot retry err [%v] after Request.Body was written; define Request.GetBody to avoid this error", err)
h2_bundle.go#L7877: return nil, fmt.Errorf("http2: unexpected ALPN protocol %q; want %q", p, http2NextProtoTLS)
h2_bundle.go#L8059: cs.abortStreamLocked(fmt.Errorf("http2: Transport received GOAWAY from server ErrCode:%v", cc.goAway.ErrCode))
h2_bundle.go#L8353: return "", fmt.Errorf("invalid Trailer key %q", k)
h2_bundle.go#L8380: return fmt.Errorf("http2: invalid Upgrade request header: %q", req.Header["Upgrade"])
h2_bundle.go#L8383: return fmt.Errorf("http2: invalid Transfer-Encoding request header: %q", vv)
h2_bundle.go#L8386: return fmt.Errorf("http2: invalid Connection request header: %q", vv)
h2_bundle.go#L9133: return nil, fmt.Errorf("invalid request :path %q from URL.Opaque = %q", orig, req.URL.Opaque)
h2_bundle.go#L9135: return nil, fmt.Errorf("invalid request :path %q", orig)
h2_bundle.go#L9145: return nil, fmt.Errorf("invalid HTTP header %s", err)
h2_bundle.go#L9148: return nil, fmt.Errorf("invalid HTTP trailer %s", err)
h2_bundle.go#L10357: err = fmt.Errorf("%v", e)
h2_bundle.go#L11622: panic(fmt.Errorf("stream %d already opened", streamID))
pattern.go#L91: err = fmt.Errorf("at offset %d: %w", off, err)
pattern.go#L104: return nil, fmt.Errorf("invalid method %q", method)
pattern.go#L174: return nil, fmt.Errorf("bad wildcard name %q", name)
pattern.go#L177: return nil, fmt.Errorf("duplicate wildcard name %q", name)
request.go#L95: func badStringError(what, val string) error { return fmt.Errorf("%s %q", what, val) }
request.go#L906: return nil, fmt.Errorf("net/http: invalid method %q", method)
request.go#L1148: return nil, fmt.Errorf("too many Host headers")
responsecontroller.go#L146: return fmt.Errorf("%w", ErrNotSupported)
server.go#L330: return nil, nil, fmt.Errorf("unexpected Peek failure reading buffered byte: %v", err)
server.go#L2814: return fmt.Errorf("parsing %q: %w", patstr, err)
server.go#L2832: return fmt.Errorf("pattern %q (registered at %s) conflicts with pattern %q (registered at %s):\n%s",
transfer.go#L85: return nil, fmt.Errorf("http: Request.ContentLength=%d with nil Body", rr.ContentLength)
transfer.go#L391: return fmt.Errorf("http: ContentLength=%d with Body length %d",
transfer.go#L673: return 0, fmt.Errorf("http: message cannot contain multiple Content-Length headers; got %q", contentLens)
transport.go#L549: return nil, fmt.Errorf("net/http: invalid header %s", err)
transport.go#L555: return nil, fmt.Errorf("net/http: invalid trailer %s", err)
transport.go#L578: return nil, fmt.Errorf("net/http: invalid method %q", req.Method)
transport.go#L2047: return 0, fmt.Errorf("read limit of %d bytes exhausted", pc.maxHeaderResponseSize())
transport.go#L2159: return fmt.Errorf("net/http: HTTP/1.x transport connection broken: %w", err)
transport.go#L2228: err = fmt.Errorf("net/http: server response headers exceeded %d bytes; aborted", pc.maxHeaderResponseSize())
transport.go#L2364: pc.closeLocked(fmt.Errorf("readLoopPeekFailLocked: %w", peekErr))
transport.go#L2761: pc.close(fmt.Errorf("write error: %w", err))
net/textproto
reader.go#L137: return nil, fmt.Errorf("missing validateFirstLine func")
net/url
url.go#L634: return "", fmt.Errorf("invalid port %q after host", colonPort)
url.go#L662: return "", fmt.Errorf("invalid port %q after host", colonPort)
url.go#L974: err = fmt.Errorf("invalid semicolon separator in query")
vendor/golang.org/x/crypto/cryptobyte
asn1.go#L112: b.err = fmt.Errorf("cryptobyte: cannot represent %v as a GeneralizedTime", t)
asn1.go#L126: b.err = fmt.Errorf("cryptobyte: cannot represent %v as a UTCTime", t)
asn1.go#L184: b.err = fmt.Errorf("cryptobyte: invalid OID: %v", oid)
asn1.go#L237: b.err = fmt.Errorf("cryptobyte: high-tag number identifier octects not supported: 0x%x", tag)
builder.go#L283: b.err = fmt.Errorf("cryptobyte: pending child length %d exceeds %d-byte length prefix", length, child.pendingLenLen)
vendor/golang.org/x/net/http/httpproxy
proxy.go#L162: return nil, fmt.Errorf("invalid proxy address %q: %v", proxy, err)
vendor/golang.org/x/text/unicode/bidi
core.go#L1016: return fmt.Errorf("types is null")
core.go#L1020: return fmt.Errorf("B type before end of paragraph at index: %d", i)
core.go#L1030: return fmt.Errorf("illegal paragraph embedding level: %d", embeddingLevel)
core.go#L1039: return fmt.Errorf("bad linebreak: %d at index: %d", next, i)
core.go#L1044: return fmt.Errorf("last linebreak was %d, want %d", prev, textLength)
core.go#L1051: return fmt.Errorf("pairTypes is null")
core.go#L1057: return fmt.Errorf("illegal pairType value at %d: %v", i, pairTypes[i])
core.go#L1065: return fmt.Errorf("pairValues is null")
core.go#L1068: return fmt.Errorf("pairTypes is different length from pairValues")
vendor/golang.org/x/text/unicode/norm
iter.go#L76: return 0, fmt.Errorf("norm: invalid whence")
iter.go#L79: return 0, fmt.Errorf("norm: negative position")
 |
The pages are generated with Golds v0.7.6. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds. |