func fmt.Sprintf
749 uses
fmt (current package)
print.go#L217: func Sprintf(format string, a ...any) string {
crypto/tls
cipher_suites.go#L110: return fmt.Sprintf("0x%04X", id)
common.go#L842: panic(fmt.Sprintf("tls: unable to generate random session ticket key: %v", err))
common.go#L904: panic(fmt.Sprintf("unable to generate random session ticket key: %v", err))
common.go#L1336: logLine := []byte(fmt.Sprintf("%s %x %x\n", label, clientRandom, secret))
conn.go#L641: msg := fmt.Sprintf("received record with version %x when expecting version %x", vers, c.vers)
conn.go#L655: msg := fmt.Sprintf("oversized record received with length %d", n)
crypto/x509
verify.go#L149: s += fmt.Sprintf(" (possibly because of %q while trying to verify candidate authority certificate %q)", e.hintErr, certName)
verify.go#L522: return CertificateInvalidError{c, CANotAuthorizedForThisName, fmt.Sprintf("%s %q is excluded by constraint %q", nameType, name, constraint)}
verify.go#L548: return CertificateInvalidError{c, CANotAuthorizedForThisName, fmt.Sprintf("%s %q is not permitted by any constraint", nameType, name)}
verify.go#L576: Detail: fmt.Sprintf("current time %s is before %s", now.Format(time.RFC3339), c.NotBefore.Format(time.RFC3339)),
verify.go#L582: Detail: fmt.Sprintf("current time %s is after %s", now.Format(time.RFC3339), c.NotAfter.Format(time.RFC3339)),
x509.go#L749: return fmt.Sprintf("x509: cannot verify signature: insecure algorithm %v", SignatureAlgorithm(e)) + override
database/sql
convert.go#L24: return fmt.Sprintf("$%d", nv.Ordinal)
convert.go#L26: return fmt.Sprintf("with name %q", nv.Name)
convert.go#L518: return fmt.Sprintf("%v", src)
sql.go#L728: panic(fmt.Sprintf("unpaired removeDep: no deps for %T", x))
sql.go#L737: panic(fmt.Sprintf("unpaired removeDep: no %T dep on %T", dep, x))
database/sql/driver
types.go#L146: return fmt.Sprintf("%v", v), nil
encoding/asn1
asn1.go#L783: err = StructuralError{fmt.Sprintf("unknown Go type: %v", fieldType)}
asn1.go#L842: err = StructuralError{fmt.Sprintf("tags don't match (%d vs %+v) %+v %s @%d", expectedTag, t, params, fieldType.Name(), offset)}
asn1.go#L980: err = SyntaxError{fmt.Sprintf("internal error: unknown string type %d", universalTag)}
marshal.go#L626: return nil, StructuralError{fmt.Sprintf("unknown Go type: %v", v.Type())}
encoding/hex
hex.go#L44: return fmt.Sprintf("encoding/hex: invalid byte: %#U", rune(e))
encoding/json
encode.go#L789: e.error(&UnsupportedValueError{v, fmt.Sprintf("encountered a cycle via %s", v.Type())})
encode.go#L884: e.error(&UnsupportedValueError{v, fmt.Sprintf("encountered a cycle via %s", v.Type())})
encode.go#L940: e.error(&UnsupportedValueError{v, fmt.Sprintf("encountered a cycle via %s", v.Type())})
encoding/xml
typeinfo.go#L344: return fmt.Sprintf("%s field %q with tag %q conflicts with field %q with tag %q", e.Struct, e.Field1, e.Tag1, e.Field2, e.Tag2)
xml.go#L1138: d.err = d.syntaxError(fmt.Sprintf("illegal character code %U", r))
flag
flag.go#L899: msg := fmt.Sprintf(format, a...)
github.com/aws/aws-sdk-go-v2/aws
endpoints.go#L149: return fmt.Sprintf("endpoint not found, %v", e.Err)
request.go#L24: return fmt.Sprintf("request canceled, %v", e.Err)
types.go#L20: return fmt.Sprintf("unknown value, %d", int(t))
github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream
debug.go#L142: panic(fmt.Sprintf("unknown type, %s, %T", typ.String(), val))
error.go#L14: return fmt.Sprintf("%s length invalid, %d/%d, %v",
header.go#L154: panic(fmt.Sprintf("unknown value type %d", raw.Type))
header_value.go#L55: return fmt.Sprintf("unknown value type %d", uint8(t))
header_value.go#L209: return fmt.Sprintf("0x%02x", int8(v))
header_value.go#L247: return fmt.Sprintf("0x%04x", int16(v))
header_value.go#L284: return fmt.Sprintf("0x%08x", int32(v))
header_value.go#L321: return fmt.Sprintf("0x%016x", int64(v))
github.com/aws/aws-sdk-go-v2/aws/ratelimit
token_rate_limit.go#L44: return fmt.Sprintf("canceled, %v", c.Err)
token_rate_limit.go#L85: return fmt.Sprintf("retry quota exceeded, %d available, %d requested",
github.com/aws/aws-sdk-go-v2/aws/retry
errors.go#L13: return fmt.Sprintf("exceeded maximum number of attempts, %d, %v", e.Attempt, e.Err)
github.com/aws/aws-sdk-go-v2/aws/signer/v4
middleware.go#L29: return fmt.Sprintf("failed to compute payload hash: %v", e.Err)
middleware.go#L43: return fmt.Sprintf("failed to sign request: %v", e.Err)
v4.go#L526: signedURLMsg = fmt.Sprintf(logSignedURLMsg, request.Request.URL.String())
github.com/aws/aws-sdk-go-v2/aws/transport/http
response_error.go#L24: return fmt.Sprintf(
timeout_read_closer.go#L30: return fmt.Sprintf("read on body reach timeout limit, %v", e.TimeoutDur)
github.com/aws/aws-sdk-go-v2/internal/sync/singleflight
singleflight.go#L29: return fmt.Sprintf("%v\n\n%s", p.value, p.stack)
github.com/aws/aws-sdk-go-v2/internal/v4a
error.go#L11: return fmt.Sprintf("failed to sign request: %v", e.Err)
v4a.go#L508: signedURLMsg = fmt.Sprintf(logSignedURLMsg, r.Request.URL.String())
github.com/aws/aws-sdk-go-v2/service/internal/checksum
algorithms.go#L321: return fmt.Sprintf("checksum did not match: algorithm %v, expect %v, actual %v",
middleware_compute_input_checksum.go#L91: return fmt.Sprintf("%s, %s, %v", intro, e.Msg, e.Err)
middleware_compute_input_checksum.go#L94: return fmt.Sprintf("%s, %s", intro, e.Msg)
middleware_compute_input_checksum.go#L115: Msg: fmt.Sprintf("unknown request type %T", req),
middleware_compute_input_checksum.go#L240: return fmt.Sprintf("%s, %s, %v", intro, e.Msg, e.Err)
middleware_compute_input_checksum.go#L243: return fmt.Sprintf("%s, %s", intro, e.Msg)
middleware_compute_input_checksum.go#L270: Msg: fmt.Sprintf("unknown request type %T", req),
github.com/aws/aws-sdk-go-v2/service/internal/s3shared
endpoint_error.go#L82: extra := fmt.Sprintf("ARN: %s, client partition: %s, client region: %s",
response_error.go#L24: return fmt.Sprintf(
github.com/aws/aws-sdk-go-v2/service/internal/s3shared/arn
arn.go#L84: return fmt.Sprintf("invalid Amazon %s ARN, %s, %s", e.ARN.Service, e.Reason, e.ARN.String())
github.com/aws/aws-sdk-go-v2/service/s3
validators.go#L2438: invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
validators.go#L2596: invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
validators.go#L2841: invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
validators.go#L2919: invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
validators.go#L3077: invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
validators.go#L3145: invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
validators.go#L3180: invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
validators.go#L3327: invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
validators.go#L3419: invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
validators.go#L3544: invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
validators.go#L3689: invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
validators.go#L3723: invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
validators.go#L3755: invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
validators.go#L3790: invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
github.com/aws/aws-sdk-go-v2/service/s3/internal/arn
arn_parser.go#L33: return arn.AccessPointARN{}, arn.InvalidARNError{ARN: a, Reason: fmt.Sprintf("service is not %s or %s", s3Namespace, s3ObjectsLambdaNamespace)}
arn_parser.go#L91: return arn.S3ObjectLambdaAccessPointARN{}, arn.InvalidARNError{ARN: a, Reason: fmt.Sprintf("service is not %s", s3ObjectsLambdaNamespace)}
arn_parser.go#L95: return arn.S3ObjectLambdaAccessPointARN{}, arn.InvalidARNError{ARN: a, Reason: fmt.Sprintf("%s region not set", s3ObjectsLambdaNamespace)}
github.com/aws/aws-sdk-go-v2/service/s3/types
errors.go#L21: return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
errors.go#L51: return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
errors.go#L80: return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
errors.go#L106: return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
errors.go#L132: return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
errors.go#L158: return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
errors.go#L184: return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
errors.go#L210: return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
errors.go#L237: return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage())
github.com/aws/smithy-go
errors.go#L37: return fmt.Sprintf("api error %s: %s", e.Code, e.Message)
errors.go#L60: return fmt.Sprintf("operation error %s: %s, %v", e.ServiceID, e.OperationName, e.Err)
errors.go#L76: return fmt.Sprintf("%s, %v", msg, e.Err)
errors.go#L114: return fmt.Sprintf("%s: %v", msg, e.Err)
errors.go#L136: return fmt.Sprintf("canceled, %v", e.Err)
validation.go#L88: return fmt.Sprintf("%s, %s.", e.reason, e.Field())
validation.go#L121: e.nestedContext = fmt.Sprintf("%s.%s", ctx, e.nestedContext)
validation.go#L137: reason: fmt.Sprintf("missing required field"),
github.com/aws/smithy-go/document
errors.go#L19: return fmt.Sprintf("unmarshal failed, cannot unmarshal %s into Go value type %s",
errors.go#L36: msg = fmt.Sprintf("cannot unmarshal to non-pointer value, got %s", e.Type.String())
errors.go#L38: msg = fmt.Sprintf("cannot unmarshal to nil value, %s", e.Type.String())
errors.go#L41: return fmt.Sprintf("unmarshal failed, %s", msg)
errors.go#L61: return fmt.Sprintf("unmarshal failed, cannot unmarshal %q into %s, %v",
errors.go#L74: return fmt.Sprintf("marshal failed, %s", e.Message)
github.com/aws/smithy-go/encoding
encoding.go#L16: panic(fmt.Sprintf("invalid float value: %s", strconv.FormatFloat(v, 'g', -1, bits)))
github.com/aws/smithy-go/internal/sync/singleflight
singleflight.go#L29: return fmt.Sprintf("%v\n\n%s", p.value, p.stack)
github.com/aws/smithy-go/transport/http
client.go#L106: return fmt.Sprintf("request send failed, %v", e.Err)
host.go#L21: errors.WriteString(fmt.Sprintf("\n endpoint %v, failed to parse, got ", host))
host.go#L26: errors.WriteString(fmt.Sprintf("port number should be in range [0-65535], got %v", port))
host.go#L50: errors.WriteString(fmt.Sprintf("\nendpoint host must be less than 255 characters, but was %d", len(hostname)))
middleware_min_proto.go#L20: return fmt.Sprintf("operation requires minimum HTTP protocol of HTTP/%d.%d, but was %s",
response.go#L31: return fmt.Sprintf(
github.com/aws/smithy-go/waiter
logger.go#L28: logger.Logf(logging.Debug, fmt.Sprintf("attempting waiter request, attempt count: %d", m.Attempt))
github.com/go-pg/migrations/v8
collection.go#L742: return fmt.Sprintf("%d_%s.go", version, descr)
github.com/go-pg/pg/v10
db.go#L48: return fmt.Sprintf("DB<Addr=%q%s>", db.opt.Addr, db.fmter)
listener.go#L51: return fmt.Sprintf("Listener(%s)", strings.Join(ln.channels, ", "))
messages.go#L226: message = append(message, fmt.Sprintf("%s: %s", string(fieldType), fieldValue))
options.go#L105: opt.Addr = fmt.Sprintf("%s:%s", host, port)
github.com/go-pg/pg/v10/internal
error.go#L17: return Error{s: fmt.Sprintf(s, args...)}
error.go#L48: return fmt.Sprintf("%s #%s %s",
log.go#L23: _ = l.log.Output(2, fmt.Sprintf(format, v...))
github.com/go-pg/pg/v10/orm
count_estimate.go#L14: var pgCountEstimateFunc = fmt.Sprintf(`
format.go#L168: ss[i] = fmt.Sprintf("%s=%v", k, f.namedParams[k])
relation.go#L32: return fmt.Sprintf("relation=%s", r.Field.GoName)
select.go#L228: b = types.AppendString(b, fmt.Sprintf("%d columns", len(table.Fields)), 2)
github.com/go-x-pkg/namesgenerator
namesgenerator.go#L838: name := fmt.Sprintf("%s-%s", left[rand.Intn(len(left))], right[rand.Intn(len(right))])
namesgenerator.go#L844: name = fmt.Sprintf("%s%d", name, rand.Intn(10))
github.com/golang/mock/gomock
call.go#L305: return fmt.Sprintf("%T.%v(%s) %s", c.receiver, c.method, arguments, c.origin)
call.go#L440: got := fmt.Sprintf("%v (%T)", arg, arg)
controller.go#L309: return fmt.Sprintf("%s:%d", file, line)
matchers.go#L123: return fmt.Sprintf("is equal to %v (%T)", e.x, e.x)
matchers.go#L207: return fmt.Sprintf("has length %d", m.i)
matchers.go#L271: return fmt.Sprintf("has the same elements as %v", m.x)
github.com/golang/protobuf/jsonpb
decode.go#L496: panic(fmt.Sprintf("invalid kind %v", fd.Kind()))
encode.go#L187: x := fmt.Sprintf("%s%d.%09d", sign, s, ns)
encode.go#L191: w.write(fmt.Sprintf(`"%vs"`, x))
encode.go#L207: w.write(fmt.Sprintf(`"%vZ"`, x))
encode.go#L548: w.write(fmt.Sprintf(`"%d"`, v.Interface()))
github.com/golang/protobuf/proto
extensions.go#L264: panic(fmt.Sprintf("mismatching field number: got %d, want %d", num, fnum))
properties.go#L229: panic(fmt.Sprintf("%v is not a generated message in the open-struct API", t))
properties.go#L295: panic(fmt.Sprintf("%v is not a generated message in the open-struct API", t))
registry.go#L38: panic(fmt.Sprintf("proto: invalid compressed file descriptor: %v", err))
registry.go#L42: panic(fmt.Sprintf("proto: invalid compressed file descriptor: %v", err))
registry.go#L194: panic(fmt.Sprintf("invalid map kind: %v", t))
text_decode.go#L37: return fmt.Sprintf("line 1.%d: %v", e.Offset, e.Message)
text_decode.go#L39: return fmt.Sprintf("line %d: %v", e.Line, e.Message)
text_decode.go#L468: panic(fmt.Sprintf("invalid kind %v", fd.Kind()))
text_decode.go#L535: pe := &ParseError{fmt.Sprintf(format, a...), p.cur.line, p.cur.offset}
text_encode.go#L425: w.buf = append(w.buf, fmt.Sprintf(`\%03o`, c)...)
github.com/golang/protobuf/ptypes
timestamp.go#L84: return fmt.Sprintf("(%v)", err)
github.com/google/go-cmp/cmp
compare.go#L206: panic(fmt.Sprintf("cannot use an unfiltered option: %v", opt))
compare.go#L214: panic(fmt.Sprintf("unknown option %T", opt))
compare.go#L297: panic(fmt.Sprintf("%v kind not handled", t.Kind()))
compare.go#L340: panic(fmt.Sprintf("non-deterministic function detected: %s", function.NameOf(f)))
compare.go#L359: panic(fmt.Sprintf("non-deterministic or non-symmetric function detected: %s", function.NameOf(f)))
compare.go#L544: panic(fmt.Sprintf("%#v has map key with NaNs\n%s", s.curPath, help))
compare.go#L621: ss = append(ss, fmt.Sprintf("%v: %v => %v", t, tf.In(0), tf.Out(0)))
compare.go#L630: panic(fmt.Sprintf("%s:\n\t%s\n%s", warning, set, help))
options.go#L97: panic(fmt.Sprintf("%s at %#v:\n\t%s\n%s", warning, s.curPath, set, help))
options.go#L105: return fmt.Sprintf("Options{%s}", strings.Join(ss, ", "))
options.go#L142: return fmt.Sprintf("FilterPath(%s, %v)", function.NameOf(reflect.ValueOf(f.fnc)), f.opt)
options.go#L162: panic(fmt.Sprintf("invalid values filter function: %T", f))
options.go#L192: return fmt.Sprintf("FilterValues(%s, %v)", function.NameOf(f.fnc), f.opt)
options.go#L234: name = fmt.Sprintf("%q.%v", t.PkgPath(), t.Name()) // e.g., "path/to/package".MyType
options.go#L244: name = fmt.Sprintf("%q.(%v)", pkgPath, t.String()) // e.g., "path/to/package".(struct { a int })
options.go#L246: panic(fmt.Sprintf("cannot handle unexported field at %#v:\n\t%v\n%s", s.curPath, name, help))
options.go#L280: panic(fmt.Sprintf("invalid transformer function: %T", f))
options.go#L288: panic(fmt.Sprintf("invalid name: %q", name))
options.go#L329: return fmt.Sprintf("Transformer(%s, %s)", tr.name, function.NameOf(tr.fnc))
options.go#L347: panic(fmt.Sprintf("invalid comparer function: %T", f))
options.go#L377: return fmt.Sprintf("Comparer(%s)", function.NameOf(cm.fnc))
options.go#L427: panic(fmt.Sprintf("invalid struct type: %T", typ))
options.go#L550: panic(fmt.Sprintf("invalid option type: %T", opt))
path.go#L168: return fmt.Sprintf("{%s}", s)
path.go#L201: func (sf StructField) String() string { return fmt.Sprintf(".%s", sf.name) }
path.go#L223: return fmt.Sprintf("[%d]", si.xkey)
path.go#L226: return fmt.Sprintf("[%d->?]", si.xkey)
path.go#L229: return fmt.Sprintf("[?->%d]", si.ykey)
path.go#L232: return fmt.Sprintf("[%d->%d]", si.xkey, si.ykey)
path.go#L264: func (mi MapIndex) String() string { return fmt.Sprintf("[%#v]", mi.key) }
path.go#L287: func (ta TypeAssertion) String() string { return fmt.Sprintf(".(%v)", value.TypeString(ta.typ, false)) }
path.go#L298: func (tf Transform) String() string { return fmt.Sprintf("%s()", tf.trans.name) }
report_compare.go#L198: panic(fmt.Sprintf("%v cannot have children", k))
report_references.go#L255: return fmt.Sprintf("ref#%d", id)
report_reflect.go#L244: header := fmt.Sprintf("ptr:%v, len:%d, cap:%d", formatPointer(value.PointerOf(v), false), v.Len(), v.Cap())
report_reflect.go#L310: panic(fmt.Sprintf("%v kind not handled", v.Kind()))
report_reflect.go#L340: comment := commentString(fmt.Sprintf("%d elided lines", numElided))
report_reflect.go#L413: return fmt.Sprintf(f, u)
report_slices.go#L274: comment := commentString(fmt.Sprintf("%c|%v|", d, formatASCII(v.String())))
report_slices.go#L332: out = &textWrap{Prefix: "strings.Join(", Value: out, Suffix: fmt.Sprintf(", %q)", delim)}
report_slices.go#L337: out = &textWrap{Prefix: "bytes.Join(", Value: out, Suffix: fmt.Sprintf(", %q)", delim)}
report_text.go#L405: ss = append(ss, fmt.Sprintf("%d %v", n, labels[i]))
github.com/google/go-cmp/cmp/internal/value
sort.go#L104: panic(fmt.Sprintf("%T is not comparable", x.Type()))
github.com/tmthrgd/go-hex
hex.go#L29: return fmt.Sprintf("go-hex: invalid byte: %#U", rune(e))
github.com/vmihailenco/msgpack/v5
msgpack.go#L51: return fmt.Sprintf("msgpack: unexpected code=%x decoding %s", err.code, err.hint)
go.pact.im/x/crypt/crypterrors
crypterrors.go#L22: return fmt.Sprintf(m+" %q", e.Hash)
crypterrors.go#L38: return fmt.Sprintf(m+" %q", e.HashID)
crypterrors.go#L56: return fmt.Sprintf(m+" %d (suggested version is %d)", e.Parsed, e.Suggested)
crypterrors.go#L79: return fmt.Sprintf(m+" %q%s", e.Name, suffix)
crypterrors.go#L99: return fmt.Sprintf(m+" %q (given %q, expected %s)", e.Name, e.Value, e.Expected)
crypterrors.go#L115: return fmt.Sprintf(m+" (unparsed %q)", e.Unparsed)
crypterrors.go#L132: return fmt.Sprintf(m+" (need %s)", e.Required)
crypterrors.go#L151: return fmt.Sprintf(m+" %d (expected %s)", e.Length, e.Expected)
go.pact.im/x/phcformat
parse.go#L14: panic(fmt.Sprintf("phcformat.MustParse(%q)", s))
go.uber.org/goleak/internal/stack
stacks.go#L64: return fmt.Sprintf(
stacks.go#L135: panic(fmt.Sprintf("function calls missing parents: %q", line))
stacks.go#L145: panic(fmt.Sprintf("unexpected stack header format: %q", line))
stacks.go#L150: panic(fmt.Sprintf("failed to parse goroutine ID: %v in line %q", parts[1], line))
go.uber.org/multierr
error.go#L308: writePrefixLine(w, _multilineIndent, fmt.Sprintf("%+v", item))
go.uber.org/zap
global.go#L107: panic(fmt.Sprintf(_programmerErrorTemplate, err))
sink.go#L51: return fmt.Sprintf("no sink found for scheme %q", e.scheme)
sugar.go#L318: return fmt.Sprintf(template, fmtArgs...)
go.uber.org/zap/internal/color
color.go#L43: return fmt.Sprintf("\x1b[%dm%s\x1b[0m", uint8(c), s)
go.uber.org/zap/zapcore
error.go#L70: verbose := fmt.Sprintf("%+v", e)
field.go#L180: panic(fmt.Sprintf("unknown field type: %v", f))
field.go#L184: enc.AddString(fmt.Sprintf("%sError", f.Key), err.Error())
level.go#L130: return fmt.Sprintf("Level(%d)", l)
level.go#L154: return fmt.Sprintf("LEVEL(%d)", l)
go/ast
commentmap.go#L334: s = fmt.Sprintf("%T", node)
resolve.go#L26: p.error(pos, fmt.Sprintf(format, args...))
resolve.go#L38: prevDecl = fmt.Sprintf("\n\tprevious declaration at %s", p.fset.Position(pos))
resolve.go#L40: p.error(obj.Pos(), fmt.Sprintf("%s redeclared in this block%s", obj.Name, prevDecl))
walk.go#L378: panic(fmt.Sprintf("ast.Walk: unexpected node type %T", n))
go/build
build.go#L509: return fmt.Sprintf("found packages %s (%s) and %s (%s) in %s", e.Packages[0], e.Files[0], e.Packages[1], e.Files[1], e.Dir)
build.go#L750: paths = append(paths, fmt.Sprintf(format, dir))
build.go#L754: paths = append(paths, fmt.Sprintf("\t%s (from $GOROOT)", tried.goroot))
build.go#L760: paths = append(paths, fmt.Sprintf(format, dir))
go/constant
value.go#L204: return fmt.Sprintf("%.6g", x)
value.go#L236: return fmt.Sprintf("%.6ge%+d", m, e)
value.go#L239: func (x complexVal) String() string { return fmt.Sprintf("(%s + %si)", x.re, x.im) }
value.go#L258: return fmt.Sprintf("(%s + %si)", x.re.ExactString(), x.im.ExactString())
value.go#L454: panic(fmt.Sprintf("%v is not a valid token", tok))
value.go#L475: panic(fmt.Sprintf("%v not a Bool", x))
value.go#L488: panic(fmt.Sprintf("%v not a String", x))
value.go#L504: panic(fmt.Sprintf("%v not an Int", x))
value.go#L520: panic(fmt.Sprintf("%v not an Int", x))
value.go#L541: panic(fmt.Sprintf("%v not a Float", x))
value.go#L566: panic(fmt.Sprintf("%v not a Float", x))
value.go#L648: panic(fmt.Sprintf("%v not an Int", x))
value.go#L676: panic(fmt.Sprintf("%v not numeric", x))
value.go#L700: panic(fmt.Sprintf("%v not an Int", x))
value.go#L770: panic(fmt.Sprintf("%v not Int or Float", x))
value.go#L792: panic(fmt.Sprintf("%v not Int or Float", x))
value.go#L807: panic(fmt.Sprintf("%v not Int or Float", x))
value.go#L820: panic(fmt.Sprintf("%v not numeric", x))
value.go#L835: panic(fmt.Sprintf("%v not numeric", x))
value.go#L1008: panic(fmt.Sprintf("invalid unary operation %s%v", op, y))
value.go#L1264: panic(fmt.Sprintf("invalid binary operation %v %s %v", x_, op, y_))
value.go#L1306: panic(fmt.Sprintf("invalid shift %v %s %d", x, op, s))
value.go#L1324: panic(fmt.Sprintf("invalid comparison %v %s 0", x, op))
value.go#L1404: panic(fmt.Sprintf("invalid comparison %v %s %v", x_, op, y_))
go/doc
reader.go#L38: return fmt.Sprintf("%s[%s]", recvString(t.X), recvParam(t.Index))
go/parser
parser.go#L1981: p.error(p.safePos(x.End()), fmt.Sprintf("function must be invoked in %s statement", callType))
parser.go#L2058: p.error(s.Pos(), fmt.Sprintf("expected %s, found %s (missing parentheses around composite literal?)", want, found))
resolver.go#L84: return fmt.Sprintf(format, args...)
resolver.go#L115: r.declErr(ident.Pos(), fmt.Sprintf("label %s undefined", ident.Name))
resolver.go#L126: panic(fmt.Sprintf("%v: identifier %s already declared or resolved", ident.Pos(), ident.Name))
resolver.go#L147: r.declErr(ident.Pos(), fmt.Sprintf("%s redeclared in this block%s", ident.Name, prevDecl))
go/printer
printer.go#L213: p.output = append(p.output, fmt.Sprintf("//line %s:%d\n", pos.Filename, pos.Line)...)
printer.go#L311: p.output = append(p.output, fmt.Sprintf("/*%s*/", pos)...) // do not update p.pos!
go/scanner
errors.go#L100: return fmt.Sprintf("%s (and %d more errors)", p[0], len(p)-1)
scanner.go#L130: panic(fmt.Sprintf("file size (%d) does not match src len (%d)", file.Size(), len(src)))
scanner.go#L159: s.error(offs, fmt.Sprintf(format, args...))
scanner.go#L627: msg := fmt.Sprintf("illegal character %#U in escape sequence", s.ch)
go/token
position.go#L45: s += fmt.Sprintf("%d", pos.Line)
position.go#L47: s += fmt.Sprintf(":%d", pos.Column)
position.go#L153: panic(fmt.Sprintf("invalid line number %d (should be >= 1)", line))
position.go#L158: panic(fmt.Sprintf("invalid line number %d (should be < %d)", line, len(f.lines)))
position.go#L220: panic(fmt.Sprintf("invalid line number %d (should be >= 1)", line))
position.go#L225: panic(fmt.Sprintf("invalid line number %d (should be < %d)", line, len(f.lines)))
position.go#L270: panic(fmt.Sprintf("invalid file offset %d (should be <= %d)", offset, f.size))
position.go#L281: panic(fmt.Sprintf("invalid Pos value %d (should be in [%d, %d])", p, f.base, f.base+f.size))
position.go#L349: panic(fmt.Sprintf("invalid Pos value %d (should be in [%d, %d])", p, f.base, f.base+f.size))
position.go#L434: panic(fmt.Sprintf("invalid base %d (should be >= %d)", base, s.base))
position.go#L437: panic(fmt.Sprintf("invalid size %d (should be >= 0)", size))
go/types
api.go#L62: return fmt.Sprintf("%s: %s", err.Fset.Position(err.Pos), err.Msg)
assignments.go#L297: return fmt.Sprintf("%d %s", x, unit)
check.go#L240: panic(fmt.Sprintf("invalid Go version %q (%v)", conf.GoVersion, err))
context.go#L77: panic(fmt.Sprintf("non-identical instances: (orig: %s, targs: %v) and %s", orig, targs, e.instance))
context.go#L100: panic(fmt.Sprintf("%s and %s are not identical", inst, e.instance))
errors.go#L127: return fmt.Sprintf(format, args...)
expr.go#L1646: panic(fmt.Sprintf("%s: unknown expression type %T", check.fset.Position(e.Pos()), e))
exprstring.go#L36: buf.WriteString(fmt.Sprintf("(ast: %T)", x)) // nil, ast.BadExpr, ast.KeyValueExpr
infer.go#L779: panic(fmt.Sprintf("unexpected %T", typ))
instantiate.go#L109: panic(fmt.Sprintf("%v: cannot instantiate %v", pos, orig))
instantiate.go#L131: panic(fmt.Sprintf("%v: got %d arguments but %d type parameters", pos, ntargs, ntparams))
object.go#L243: panic(fmt.Sprintf("invalid underlying type %T", t.underlying))
object.go#L448: panic(fmt.Sprintf("writeObject(%T)", obj))
package.go#L26: scope := NewScope(Universe, token.NoPos, token.NoPos, fmt.Sprintf("package %q", path))
package.go#L64: return fmt.Sprintf("package %s (%q)", pkg.name, pkg.path)
resolver.go#L131: return fmt.Sprintf("file[%d]", fileNo)
typeset.go#L229: panic(fmt.Sprintf("%v: duplicate method %s", m.pos, m.name))
typeset.go#L322: panic(fmt.Sprintf("%v: duplicate method %s", m.pos, m.name))
typestring.go#L306: w.string(fmt.Sprintf("$%d", i))
typexpr.go#L212: return strings.ReplaceAll(fmt.Sprintf("%T", typ), "types.", "")
typexpr.go#L416: panic(fmt.Sprintf("%v: cannot instantiate %v", ix.Pos(), gtyp))
golang.org/x/exp/apidiff
apidiff.go#L69: ms.add(obj, part, fmt.Sprintf(format, args...))
compatibility.go#L304: part = fmt.Sprintf(", method set of %s", msname)
correspondence.go#L137: panic(fmt.Sprintf("unknown type kind %T", old))
messageset.go#L65: return fmt.Sprintf("%s.%s", tn, obj.Name())
report.go#L33: return fmt.Sprintf("!!%v", err)
golang.org/x/net/http2
databuffer.go#L57: panic(fmt.Sprintf("unexpected buffer len=%v", len(p)))
errors.go#L53: return fmt.Sprintf("unknown error code 0x%x", uint32(e))
errors.go#L60: return fmt.Sprintf("ERR_UNKNOWN_%d", uint32(e))
errors.go#L67: func (e ConnectionError) Error() string { return fmt.Sprintf("connection error: %s", ErrCode(e)) }
errors.go#L88: return fmt.Sprintf("stream error: stream ID %d; %v; %v", e.StreamID, e.Code, e.Cause)
errors.go#L90: return fmt.Sprintf("stream error: stream ID %d; %v", e.StreamID, e.Code)
errors.go#L115: return fmt.Sprintf("http2: connection error: %v: %v", e.Code, e.Reason)
errors.go#L121: return fmt.Sprintf("invalid pseudo-header %q", string(e))
errors.go#L127: return fmt.Sprintf("duplicate pseudo-header %q", string(e))
errors.go#L133: return fmt.Sprintf("invalid header field name %q", string(e))
errors.go#L139: return fmt.Sprintf("invalid header field value for %q", string(e))
frame.go#L59: return fmt.Sprintf("UNKNOWN_FRAME_TYPE_%d", uint8(t))
frame.go#L551: fmt.Sprintf("got %s for stream %d; expected CONTINUATION following %s for stream %d",
frame.go#L557: fmt.Sprintf("got CONTINUATION for stream %d; expected stream %d",
frame.go#L561: return fr.connError(ErrCodeProtocol, fmt.Sprintf("unexpected CONTINUATION for stream %d", fh.StreamID))
frame.go#L1169: return nil, connError{ErrCodeFrameSize, fmt.Sprintf("PRIORITY frame payload size was %d; want 5", len(payload))}
gotrack.go#L60: panic(fmt.Sprintf("No space found in %q", b))
gotrack.go#L65: panic(fmt.Sprintf("Failed to parse goroutine ID out of %q: %v", b, err))
http2.go#L122: return fmt.Sprintf("[%v = %d]", s.ID, s.Val)
http2.go#L171: return fmt.Sprintf("UNKNOWN_SETTING_%d", uint16(s))
server.go#L505: sc.rejectConn(ErrCodeInadequateSecurity, fmt.Sprintf("Prohibited TLS 1.2 Cipher Suite: %x", sc.tlsState.CipherSuite))
server.go#L992: panic(fmt.Sprintf("unexpected type %T", v))
server.go#L1237: panic(fmt.Sprintf("internal error: attempt to send frame on a half-closed-local stream: %v", wr))
server.go#L1240: panic(fmt.Sprintf("internal error: attempt to send frame on a closed stream: %v", wr))
server.go#L1626: panic(fmt.Sprintf("invariant; can't close stream in state %v", st.state))
server.go#L2833: panic(fmt.Sprintf("invalid WriteHeader code %v", code))
server.go#L3129: panic(fmt.Sprintf("newWriterAndRequestNoBody(%+v): %v", msg.url, err))
server.go#L3236: f(fmt.Sprintf("%s_%s_%s", typ, codeStr, name))
transport.go#L2136: return fmt.Sprintf("http2: server sent GOAWAY and closed the connection; LastStreamID=%v, ErrCode=%v, debug=%q",
transport.go#L2196: f(fmt.Sprintf("read_frame_conn_error_%s", errCode.stringToken()))
write.go#L105: return fmt.Sprintf("writeData(stream=%d, p=%d, endStream=%v)", w.streamID, len(w.p), w.endStream)
writesched.go#L166: des = fmt.Sprintf("%T", wr.write)
writesched.go#L168: return fmt.Sprintf("[FrameWriteRequest stream=%d, ch=%v, writer=%v]", wr.StreamID(), wr.done != nil, des)
writesched.go#L180: panic(fmt.Sprintf("unbuffered done channel passed in for type %T", wr.write))
writesched_priority.go#L261: panic(fmt.Sprintf("stream %d already opened", streamID))
writesched_priority.go#L293: panic(fmt.Sprintf("violation of WriteScheduler interface: unknown stream %d", streamID))
writesched_priority.go#L296: panic(fmt.Sprintf("violation of WriteScheduler interface: stream %d already closed", streamID))
golang.org/x/net/http2/hpack
hpack.go#L23: return fmt.Sprintf("decoding error: %v", de.Err)
hpack.go#L31: return fmt.Sprintf("invalid indexed representation index %d", int(e))
hpack.go#L57: return fmt.Sprintf("header field %q = %q%s", hf.Name, hf.Value, suffix)
tables.go#L66: panic(fmt.Sprintf("evictOldest(%v) on table with %v entries", n, t.len()))
tables.go#L118: panic(fmt.Sprintf("id (%v) <= evictCount (%v)", id, t.evictCount))
golang.org/x/net/idna
idna10.0.0.go#L325: return fmt.Sprintf("idna: invalid label %q", e.label)
idna10.0.0.go#L332: return fmt.Sprintf("idna: disallowed rune %U", e)
golang.org/x/net/internal/timeseries
timeseries.go#L55: func (f *Float) String() string { return fmt.Sprintf("%g", f.Value()) }
golang.org/x/net/trace
events.go#L314: e := logEntry{When: time.Now(), IsErr: isErr, What: fmt.Sprintf(format, a...)}
events.go#L331: el.events[0].What = fmt.Sprintf("(%d events discarded)", el.discarded)
events.go#L360: return fmt.Sprintf("%.6f", elapsed.Seconds())
histogram.go#L235: return fmt.Sprintf("%d, %f, %d, %d, %v",
trace.go#L357: return fmt.Sprintf(l.format, l.a...)
trace.go#L664: func (m minCond) String() string { return fmt.Sprintf("≥%gs", time.Duration(m).Seconds()) }
trace.go#L709: return fmt.Sprintf("(%d events discarded)", int(*d))
trace.go#L900: return fmt.Sprintf("%.6f", t.Seconds())
trace.go#L935: b := []byte(fmt.Sprintf("%.6f", d.Seconds()))
golang.org/x/text/unicode/bidi
bracket.go#L57: return fmt.Sprintf("(%v, %v)", b.opener, b.closer)
golang.org/x/tools/go/packages
golist.go#L125: panic(fmt.Sprintf("mustGetEnv: %v", err))
golist.go#L238: Msg: fmt.Sprintf("package %s expected but not seen", id),
golist.go#L710: msg += fmt.Sprintf(": import stack: %v", p.Error.ImportStack)
golist.go#L886: fmt.Sprintf("-compiled=%t", cfg.Mode&(NeedCompiledGoFiles|NeedSyntax|NeedTypes|NeedTypesInfo|NeedTypesSizes) != 0),
golist.go#L887: fmt.Sprintf("-test=%t", cfg.Tests),
golist.go#L888: fmt.Sprintf("-export=%t", usesExportData(cfg)),
golist.go#L889: fmt.Sprintf("-deps=%t", cfg.Mode&NeedImports != 0),
golist.go#L892: fmt.Sprintf("-find=%t", !cfg.Tests && cfg.Mode&findFlags == 0 && !usesExportData(cfg)),
golist.go#L1002: output := fmt.Sprintf(`{"ImportPath": "command-line-arguments","Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
golist.go#L1009: output := fmt.Sprintf(`{"ImportPath": "command-line-arguments","Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
golist.go#L1021: output := fmt.Sprintf(`{"ImportPath": %q,"Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
golist.go#L1029: output := fmt.Sprintf(`{"ImportPath": "command-line-arguments","Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
golist.go#L1037: output := fmt.Sprintf(`{"ImportPath": %q,"Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
golist.go#L1045: output := fmt.Sprintf(`{"ImportPath": %q,"Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
golist.go#L1066: output := fmt.Sprintf(`{"ImportPath": %q,"Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
golist.go#L1122: f, err := ioutil.TempFile(dir, fmt.Sprintf("*-%s", noSeparator))
golist.go#L1172: return fmt.Sprintf("GOROOT=%v GOPATH=%v GO111MODULE=%v GOPROXY=%v PWD=%v %v", env["GOROOT"], env["GOPATH"], env["GO111MODULE"], env["GOPROXY"], env["PWD"], strings.Join(args, " "))
golist_overlay.go#L147: id = fmt.Sprintf("%s [%s.test]", pkgPath, forTest)
golist_overlay.go#L149: id = fmt.Sprintf("%s [%s.test]", pkgPath, pkgPath)
loadmode_string.go#L56: return fmt.Sprintf("LoadMode(%s)", strings.Join(out, "|"))
packages.go#L969: Msg: fmt.Sprintf("This application uses version go1.%d of the source-processing packages but runs version go1.%d of 'go list'. It may fail to process source files that rely on newer language features. If so, rebuild the application using a newer version of Go.", runtimeVersion, lpkg.goVersion),
packages.go#L979: appendError(Error{"-", fmt.Sprintf("sources missing for package %s", lpkg.ID), ParseError})
golang.org/x/tools/internal/gcimporter
bexport.go#L87: return internalError(fmt.Sprintf(format, args...))
bexport.go#L118: p.rawStringln(fmt.Sprintf("version %d", exportVersion))
bimport.go#L171: panic(fmt.Sprintf(format, args...))
golang.org/x/tools/internal/gocommand
invoke.go#L316: panic(fmt.Sprintf("running ps: %v", err))
invoke.go#L330: panic(fmt.Sprintf("running %s: %v", listFiles, err))
invoke.go#L333: panic(fmt.Sprintf("detected hanging go command (pid %d): see golang/go#54461 for more details", proc.Pid))
invoke.go#L355: return fmt.Sprintf("GOROOT=%v GOPATH=%v GO111MODULE=%v GOPROXY=%v PWD=%v %v", env["GOROOT"], env["GOPATH"], env["GO111MODULE"], env["GOPROXY"], env["PWD"], strings.Join(args, " "))
golang.org/x/tools/internal/pkgbits
sync.go#L19: res = append(res, fmt.Sprintf("%s:%v: %s +0x%v", file, line, name, offset))
google.golang.org/grpc
clientconn.go#L174: Desc: fmt.Sprintf("Nested Channel(id:%d) created", cc.channelzID.Int()),
clientconn.go#L588: panic(fmt.Sprintf("impossible error parsing empty service config: %v", cfg.Err))
clientconn.go#L729: Desc: fmt.Sprintf("Subchannel(id:%d) created", ac.channelzID.Int()),
clientconn.go#L1057: Desc: fmt.Sprintf("Nested channel(id:%d) deleted", cc.channelzID.Int()),
clientconn.go#L1434: Desc: fmt.Sprintf("Subchannel(id:%d) deleted", ac.channelzID.Int()),
server.go#L623: s.events = trace.NewEventLog("grpc.Server", fmt.Sprintf("%s:%d", file, line))
server.go#L1392: panic(fmt.Sprintf("grpc: Unexpected error (%T) from sendResponse: %v", st, st))
server.go#L1685: errDesc := fmt.Sprintf("malformed method name: %q", stream.Method())
server.go#L1719: errDesc = fmt.Sprintf("unknown service %v", service)
server.go#L1721: errDesc = fmt.Sprintf("unknown method %v for service %v", method, service)
trace.go#L107: return truncate(fmt.Sprintf("sent: %v", p.msg), truncateSize)
trace.go#L109: return truncate(fmt.Sprintf("recv: %v", p.msg), truncateSize)
trace.go#L118: return fmt.Sprintf(f.format, f.a...)
google.golang.org/grpc/credentials
credentials.go#L82: return fmt.Sprintf("invalid SecurityLevel: %v", int(s))
google.golang.org/grpc/grpclog
component.go#L71: c.InfoDepth(1, fmt.Sprintf(format, args...))
component.go#L75: c.WarningDepth(1, fmt.Sprintf(format, args...))
component.go#L79: c.ErrorDepth(1, fmt.Sprintf(format, args...))
component.go#L83: c.FatalDepth(1, fmt.Sprintf(format, args...))
loggerv2.go#L173: g.m[severity].Output(2, fmt.Sprintf("%v: %v", sevStr, s))
loggerv2.go#L194: g.output(infoLog, fmt.Sprintf(format, args...))
loggerv2.go#L206: g.output(warningLog, fmt.Sprintf(format, args...))
loggerv2.go#L218: g.output(errorLog, fmt.Sprintf(format, args...))
loggerv2.go#L232: g.output(fatalLog, fmt.Sprintf(format, args...))
google.golang.org/grpc/internal/channelz
id.go#L70: str := fmt.Sprintf("%s #%d", typ, id)
id.go#L72: str = fmt.Sprintf("%s %s", pid, str)
logging.go#L44: Desc: fmt.Sprintf(format, args...),
logging.go#L60: Desc: fmt.Sprintf(format, args...),
logging.go#L76: Desc: fmt.Sprintf(format, args...),
google.golang.org/grpc/internal/grpclog
prefixLogger.go#L38: pl.logger.InfoDepth(1, fmt.Sprintf(format, args...))
prefixLogger.go#L41: InfoDepth(1, fmt.Sprintf(format, args...))
prefixLogger.go#L48: pl.logger.WarningDepth(1, fmt.Sprintf(format, args...))
prefixLogger.go#L51: WarningDepth(1, fmt.Sprintf(format, args...))
prefixLogger.go#L58: pl.logger.ErrorDepth(1, fmt.Sprintf(format, args...))
prefixLogger.go#L61: ErrorDepth(1, fmt.Sprintf(format, args...))
prefixLogger.go#L72: pl.logger.InfoDepth(1, fmt.Sprintf(format, args...))
prefixLogger.go#L75: InfoDepth(1, fmt.Sprintf(format, args...))
google.golang.org/grpc/internal/pretty
pretty.go#L47: return fmt.Sprintf("%+v", ee)
pretty.go#L60: return fmt.Sprintf("%+v", ee)
pretty.go#L66: return fmt.Sprintf("%+v", ee)
google.golang.org/grpc/internal/serviceconfig
serviceconfig.go#L56: return []byte(fmt.Sprintf(`[{%q: %v}]`, bc.Name, "{}")), nil
serviceconfig.go#L62: return []byte(fmt.Sprintf(`[{%q: %s}]`, bc.Name, c)), nil
google.golang.org/grpc/internal/status
status.go#L53: return New(c, fmt.Sprintf(format, a...))
status.go#L68: return Err(c, fmt.Sprintf(format, a...))
status.go#L140: return fmt.Sprintf("rpc error: code = %s desc = %s", s.Code(), s.Message())
google.golang.org/grpc/internal/transport
handler_server.go#L59: msg := fmt.Sprintf("invalid gRPC request method %q", r.Method)
handler_server.go#L67: msg := fmt.Sprintf("invalid gRPC request content-type %q", contentType)
handler_server.go#L90: msg := fmt.Sprintf("malformed grpc-timeout: %v", err)
handler_server.go#L110: msg := fmt.Sprintf("malformed binary metadata %q in header %q: %v", v, k, err)
handler_server.go#L215: h.Set("Grpc-Status", fmt.Sprintf("%d", st.Code()))
http2_client.go#L378: t.channelzID, err = channelz.RegisterNormalSocket(t, opts.ChannelzParentID, fmt.Sprintf("%s -> %s", t.localAddr, t.remoteAddr))
http2_client.go#L1353: t.goAwayDebugMessage = fmt.Sprintf("code: %s", f.ErrCode)
http2_client.go#L1355: t.goAwayDebugMessage = fmt.Sprintf("code: %s, debug data: %q", f.ErrCode, string(f.DebugData()))
http2_client.go#L1421: contentTypeErr = fmt.Sprintf("transport: received unexpected content-type %q", hf.Value)
http2_client.go#L1432: se := status.New(codes.Internal, fmt.Sprintf("transport: malformed grpc-status: %v", err))
http2_client.go#L1443: headerError = fmt.Sprintf("transport: malformed grpc-status-details-bin: %v", err)
http2_client.go#L1455: se := status.New(codes.Internal, fmt.Sprintf("transport: malformed http-status: %v", err))
http2_client.go#L1462: httpStatusErr = fmt.Sprintf(
http2_client.go#L1473: headerError = fmt.Sprintf("transport: malformed %s: %v", hf.Name, err)
http2_server.go#L288: t.channelzID, err = channelz.RegisterNormalSocket(t, config.ChannelzParentID, fmt.Sprintf("%s -> %s", t.remoteAddr, t.localAddr))
http2_server.go#L446: errMsg := fmt.Sprintf("num values of :authority: %v, num values of host: %v, both must only have 1 value as per HTTP/2 spec", len(mdata[":authority"]), len(mdata["host"]))
http2_server.go#L542: errMsg := fmt.Sprintf("http2Server.operateHeaders parsed a :method field: %v which should be POST", httpMethod)
transport.go#L518: return fmt.Sprintf("<stream: %p, %v>", s, s.method)
transport.go#L722: Desc: fmt.Sprintf(format, a...),
transport.go#L737: return fmt.Sprintf("connection error: desc = %q", e.Desc)
google.golang.org/grpc/metadata
metadata.go#L77: panic(fmt.Sprintf("metadata: Pairs got the odd number of input pairs for metadata: %d", len(kv)))
metadata.go#L169: panic(fmt.Sprintf("metadata: AppendToOutgoingContext got an odd number of input pairs for metadata: %d", len(kv)))
metadata.go#L274: panic(fmt.Sprintf("metadata: FromOutgoingContext got an odd number of input pairs for metadata: %d", len(added)))
google.golang.org/grpc/status
status.go#L54: return New(c, fmt.Sprintf(format, a...))
status.go#L64: return Error(c, fmt.Sprintf(format, a...))
google.golang.org/protobuf/encoding/protojson
decode.go#L99: head := fmt.Sprintf("(line %d:%d): ", line, column)
decode.go#L111: head := fmt.Sprintf("syntax error (line %d:%d): ", line, column)
decode.go#L337: panic(fmt.Sprintf("unmarshalScalar: invalid scalar kind %v", kind))
decode.go#L661: panic(fmt.Sprintf("invalid kind for map key: %v", kind))
encode.go#L308: panic(fmt.Sprintf("%v has unknown kind: %v", fd.FullName(), kind))
well_known_types.go#L618: x := fmt.Sprintf("%s%d.%09d", sign, secs, nanos)
google.golang.org/protobuf/encoding/prototext
decode.go#L89: head := fmt.Sprintf("(line %d:%d): ", line, column)
decode.go#L101: head := fmt.Sprintf("syntax error (line %d:%d): ", line, column)
decode.go#L355: panic(fmt.Sprintf("invalid scalar kind %v", kind))
encode.go#L252: panic(fmt.Sprintf("%v has unknown kind: %v", fd.FullName(), kind))
encode.go#L327: panic(fmt.Sprintf("prototext: error parsing unknown field wire type: %v", wtype))
google.golang.org/protobuf/internal/descfmt
stringer.go#L67: ss = append(ss, fmt.Sprintf("%d", r[0]))
stringer.go#L69: ss = append(ss, fmt.Sprintf("%d:%d", r[0], r[1])) // enum ranges are end exclusive
stringer.go#L77: ss = append(ss, fmt.Sprintf("%d", r[0]))
stringer.go#L79: ss = append(ss, fmt.Sprintf("%d:%d", r[0], int64(r[1])+1)) // enum ranges are end inclusive
stringer.go#L217: panic(fmt.Sprintf("unknown accessor: %v.%s", v.Type(), a))
stringer.go#L260: s = fmt.Sprintf("%q", v)
google.golang.org/protobuf/internal/encoding/defval
default.go#L208: s = append(s, fmt.Sprintf(`\%03o`, c)...)
google.golang.org/protobuf/internal/encoding/json
decode.go#L291: panic(fmt.Sprintf(
decode_token.go#L102: panic(fmt.Sprintf("Token is not a Name: %v", t.RawString()))
decode_token.go#L110: panic(fmt.Sprintf("Token is not a Bool: %v", t.RawString()))
decode_token.go#L119: panic(fmt.Sprintf("Token is not a String: %v", t.RawString()))
google.golang.org/protobuf/internal/encoding/text
decode.go#L358: panic(fmt.Sprintf("Decoder.parseNext: bug at handling line %d:%d with lastKind=%v", line, column, lastKind))
decode.go#L383: panic(fmt.Sprintf("Decoder: openStack contains invalid byte %c", openCh))
decode_token.go#L63: return fmt.Sprintf("<invalid:%v>", uint8(t))
decode_token.go#L86: return fmt.Sprintf("<invalid:%v>", uint8(t))
decode_token.go#L153: panic(fmt.Sprintf("Token is not a Name type: %s", t.kind))
decode_token.go#L162: panic(fmt.Sprintf("Token is not a Name type: %s", t.kind))
decode_token.go#L170: panic(fmt.Sprintf("Token is not an IdentName: %s:%s", t.kind, NameKind(t.attrs&^hasSeparator)))
decode_token.go#L178: panic(fmt.Sprintf("Token is not a TypeName: %s:%s", t.kind, NameKind(t.attrs&^hasSeparator)))
decode_token.go#L186: panic(fmt.Sprintf("Token is not a FieldNumber: %s:%s", t.kind, NameKind(t.attrs&^hasSeparator)))
google.golang.org/protobuf/internal/errors
errors.go#L80: return fmt.Sprintf(f, x...)
google.golang.org/protobuf/internal/filedesc
desc.go#L630: panic(fmt.Sprintf("detected mutation on the default bytes for %v", fd.FullName()))
desc_list.go#L125: return fmt.Sprintf("%d", r.Start())
desc_list.go#L127: return fmt.Sprintf("%d to %d", r.Start(), r.End())
desc_list.go#L217: return fmt.Sprintf("%d", r.Start())
desc_list.go#L219: return fmt.Sprintf("%d to %d", r.Start(), r.End())
google.golang.org/protobuf/internal/impl
api_export.go#L106: panic(fmt.Sprintf("message %T is neither a v1 or v2 Message", m))
api_export.go#L121: panic(fmt.Sprintf("message %T is neither a v1 or v2 Message", m))
codec_field.go#L139: panic(fmt.Sprintf("weak message %v is not linked in", fd.Message().FullName()))
codec_field.go#L150: panic(fmt.Sprintf("weak message %v is not linked in", fd.Message().FullName()))
codec_field.go#L183: panic(fmt.Sprintf("weak message %v is not linked in", fd.Message().FullName()))
codec_message.go#L141: panic(fmt.Sprintf("%v: MessageSet with no extensions field", mi.Desc.FullName()))
codec_message.go#L144: panic(fmt.Sprintf("%v: MessageSet with no unknown field", mi.Desc.FullName()))
codec_tables.go#L432: panic(fmt.Sprintf("invalid type: no encoder for %v %v %v/%v", fd.FullName(), fd.Cardinality(), fd.Kind(), ft))
codec_tables.go#L556: panic(fmt.Sprintf("invalid field: no encoder for %v %v %v", fd.FullName(), fd.Cardinality(), fd.Kind()))
convert.go#L62: panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
convert.go#L143: panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
convert.go#L153: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L177: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L201: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L225: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L249: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L273: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L297: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L321: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L351: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L388: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L424: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L449: panic(fmt.Sprintf("invalid type: got %v, want %v", rv.Type(), reflect.PtrTo(c.goType)))
convert.go#L458: panic(fmt.Sprintf("invalid type: got %v, want %v", rv.Type(), c.goType))
convert_list.go#L21: panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
convert_list.go#L31: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert_list.go#L73: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert_map.go#L21: panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
convert_map.go#L32: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
legacy_enum.go#L126: panic(fmt.Sprintf("%v already implements proto.Enum", t))
legacy_enum.go#L208: suffix = fmt.Sprintf("UnknownX%X", reflect.ValueOf(t).Pointer())
legacy_message.go#L102: panic(fmt.Sprintf("%v already implements proto.Message", t))
legacy_message.go#L147: panic(fmt.Sprintf("mismatching message name: got %v, want %v", md.FullName(), name))
legacy_message.go#L366: return filedesc.PlaceholderEnumValue(protoreflect.FullName(fmt.Sprintf("UNKNOWN_%d", n)))
merge.go#L39: panic(fmt.Sprintf("invalid value: merging into nil message"))
message.go#L85: panic(fmt.Sprintf("got %v, want *struct kind", t))
message_reflect.go#L295: panic(fmt.Sprintf("%v: assigning invalid value", xt.TypeDescriptor().FullName()))
message_reflect.go#L399: panic(fmt.Sprintf("type mismatch: got %T, want %v", m, mi.GoReflectType))
message_reflect.go#L441: panic(fmt.Sprintf("mismatching field: got %v, want %v", got, want))
message_reflect.go#L443: panic(fmt.Sprintf("mismatching field: %v", fd.FullName()))
message_reflect.go#L451: panic(fmt.Sprintf("extension %v has mismatching containing message: got %v, want %v", fd.FullName(), got, want))
message_reflect.go#L454: panic(fmt.Sprintf("extension %v extends %v outside the extension range", fd.FullName(), mi.Desc.FullName()))
message_reflect.go#L458: panic(fmt.Sprintf("extension %v does not implement protoreflect.ExtensionTypeDescriptor", fd.FullName()))
message_reflect.go#L462: panic(fmt.Sprintf("field %v is invalid", fd.FullName()))
message_reflect_field.go#L67: panic(fmt.Sprintf("field %v has invalid type: got %v, want interface kind", fd.FullName(), ft))
message_reflect_field.go#L70: panic(fmt.Sprintf("field %v has invalid type: got %v, want struct kind", fd.FullName(), ot))
message_reflect_field.go#L73: panic(fmt.Sprintf("field %v has invalid type: %v does not implement %v", fd.FullName(), ot, ft))
message_reflect_field.go#L126: panic(fmt.Sprintf("field %v with invalid Mutable call on field with non-composite type", fd.FullName()))
message_reflect_field.go#L150: panic(fmt.Sprintf("field %v has invalid type: got %v, want map kind", fd.FullName(), ft))
message_reflect_field.go#L183: panic(fmt.Sprintf("map field %v cannot be set with read-only value", fd.FullName()))
message_reflect_field.go#L203: panic(fmt.Sprintf("field %v has invalid type: got %v, want slice kind", fd.FullName(), ft))
message_reflect_field.go#L236: panic(fmt.Sprintf("list field %v cannot be set with read-only value", fd.FullName()))
message_reflect_field.go#L296: panic(fmt.Sprintf("field %v has invalid type: %v", fd.FullName(), rv.Type())) // should never happen
message_reflect_field.go#L353: panic(fmt.Sprintf("weak message %v for field %v is not linked in", messageName, fd.FullName()))
message_reflect_field.go#L387: panic(fmt.Sprintf("field %v has mismatching message descriptor: got %v, want %v", fd.FullName(), got, want))
message_reflect_field.go#L389: panic(fmt.Sprintf("field %v has mismatching message descriptor: %v", fd.FullName(), m.Descriptor().FullName()))
message_reflect_field.go#L447: panic(fmt.Sprintf("field %v has invalid nil pointer", fd.FullName()))
validate.go#L51: return fmt.Sprintf("ValidationStatus(%d)", int(v))
weak.go#L51: panic(fmt.Sprintf("message %v for weak field is not linked in", name))
weak.go#L60: panic(fmt.Sprintf("message %v for weak field is not linked in", name))
weak.go#L63: panic(fmt.Sprintf("invalid message type for weak field: got %T, want %T", m, mt.Zero().Interface()))
google.golang.org/protobuf/internal/version
version.go#L66: v := fmt.Sprintf("v%d.%d.%d", Major, Minor, Patch)
google.golang.org/protobuf/proto
merge.go#L32: panic(fmt.Sprintf("descriptor mismatch: %v != %v", got, want))
merge.go#L80: panic(fmt.Sprintf("cannot merge into invalid %v message", dst.Descriptor().FullName()))
reset.go#L26: panic(fmt.Sprintf("cannot reset invalid %v message", m.Descriptor().FullName()))
google.golang.org/protobuf/reflect/protodesc
proto.go#L161: panic(fmt.Sprintf("%v: %v", field.FullName(), err))
google.golang.org/protobuf/reflect/protoreflect
proto.go#L176: return fmt.Sprintf("<unknown:%d>", s)
proto.go#L188: return fmt.Sprintf("Syntax(%d)", s)
proto.go#L224: return fmt.Sprintf("<unknown:%d>", c)
proto.go#L238: return fmt.Sprintf("Cardinality(%d)", c)
proto.go#L324: return fmt.Sprintf("<unknown:%d>", k)
proto.go#L368: return fmt.Sprintf("Kind(%d)", k)
value_union.go#L115: panic(fmt.Sprintf("invalid proto.Message(%T) type, expected a protoreflect.Message type", v))
value_union.go#L117: panic(fmt.Sprintf("invalid type: %T", v))
value_union.go#L260: return fmt.Sprintf("<unknown: %T>", v)
value_union.go#L266: return fmt.Sprintf("type mismatch: cannot convert %v to %s", v.typeName(), what)
google.golang.org/protobuf/reflect/protoregistry
registry.go#L56: panic(fmt.Sprintf("%v\nSee %v\n", err, faq))
registry.go#L205: panic(fmt.Sprintf(""+
registry.go#L853: return fmt.Sprintf("%T", t)
gotest.tools/v3/assert/cmp
compare.go#L79: fmt.Sprintf("value %q does not match regexp %q", v, re.String()))
compare.go#L93: return ResultFailure(fmt.Sprintf("invalid type %T for regex pattern", regex))
compare.go#L145: result = ResultFailure(fmt.Sprintf("type %T does not have a length", seq))
compare.go#L153: msg := fmt.Sprintf("expected %s (length %d) to have length %d", seq, length, expected)
compare.go#L172: msg := fmt.Sprintf("%v does not contain %v", collection, item)
compare.go#L182: fmt.Sprintf("string %q does not contain %q", collection, item))
compare.go#L186: return ResultFailure(fmt.Sprintf(
compare.go#L199: return ResultFailure(fmt.Sprintf("type %T does not contain items", collection))
compare.go#L225: return ResultFailure(fmt.Sprintf(
compare.go#L240: return ResultFailure(fmt.Sprintf(
compare.go#L254: return fmt.Sprintf("%q\n%+v", err, err)
compare.go#L257: return fmt.Sprintf("%q", err)
compare.go#L266: return fmt.Sprintf("%v (type %s) is not nil", reflect.Indirect(value), value.Type())
compare.go#L285: return ResultFailure(fmt.Sprintf("%v (type %s) can not be nil", value, value.Type()))
compare.go#L331: return ResultFailure(fmt.Sprintf("invalid type for expected: %T", expected))
compare.go#L341: actual = fmt.Sprintf("%s (%T)", err, err)
compare.go#L350: return ResultFailure(fmt.Sprintf("error is nil, not %s", expectedType))
compare.go#L356: return ResultFailure(fmt.Sprintf("error is %s (%T), not %s", err, err, expectedType))
compare.go#L361: return ResultFailure(fmt.Sprintf("error is nil, not %s", expectedType))
compare.go#L367: return ResultFailure(fmt.Sprintf("error is %s (%T), not %s", err, err, expectedType))
result.go#L67: return fmt.Sprintf("failed to render failure message: %s", err)
gotest.tools/v3/internal/assert
assert.go#L62: t.Log(fmt.Sprintf("invalid Comparison: %v (%T)", check, check))
assert.go#L112: return fmt.Sprintf("error is not nil: error has type %T", err)
result.go#L57: message = fmt.Sprintf("comparison returned invalid Result type: %T", result)
gotest.tools/v3/internal/format
diff.go#L37: buf.WriteString(fmt.Sprintf(format, args...))
diff.go#L145: return fmt.Sprintf("%d", beginning)
diff.go#L150: return fmt.Sprintf("%d,%d", beginning, length)
format.go#L11: return fmt.Sprintf("%v", msgAndArgs[0])
format.go#L13: return fmt.Sprintf(msgAndArgs[0].(string), msgAndArgs[1:]...)
format.go#L26: return fmt.Sprintf("%s: %s", source, custom)
gotest.tools/v3/internal/source
source.go#L145: return fmt.Sprintf("failed to format %s: %s", n.Node, err)
source.go#L147: return fmt.Sprintf("(%T) %s", n.Node, out)
html/template
context.go#L35: return fmt.Sprintf("{%v %v %v %v %v %v %v}", c.state, c.delim, c.urlPart, c.jsCtx, c.attr, c.element, err)
css.go#L121: panic(fmt.Sprintf("Bad hex digit in %q", s))
error.go#L220: return fmt.Sprintf("html/template:%s: %s", loc, e.Description)
error.go#L222: return fmt.Sprintf("html/template:%s:%d: %s", e.Name, e.Line, e.Description)
error.go#L224: return fmt.Sprintf("html/template:%s: %s", e.Name, e.Description)
error.go#L232: return &Error{k, node, "", line, fmt.Sprintf(f, args...)}
escape.go#L27: err = &Error{ErrEndContext, nil, name, 0, fmt.Sprintf("ends in a non-text context: %v", c)}
escape.go#L770: panic(fmt.Sprintf("infinite loop from %v to %v on %q..%q", c, c1, s[:i], s[i:]))
escape.go#L850: panic(fmt.Sprintf("node %s shared between templates", n))
escape.go#L858: panic(fmt.Sprintf("node %s shared between templates", n))
escape.go#L866: panic(fmt.Sprintf("node %s shared between templates", n))
js.go#L174: return fmt.Sprintf(" /* %s */null ", strings.ReplaceAll(err.Error(), "*/", "* /"))
internal/profile
merge.go#L184: labels = append(labels, fmt.Sprintf("%q%q", k, v))
merge.go#L190: numlabels = append(numlabels, fmt.Sprintf("%q%x%x", k, v, sample.NumUnit[k]))
profile.go#L341: ss = append(ss, fmt.Sprintf("PeriodType: %s %s", pt.Type, pt.Unit))
profile.go#L343: ss = append(ss, fmt.Sprintf("Period: %d", p.Period))
profile.go#L345: ss = append(ss, fmt.Sprintf("Time: %v", time.Unix(0, p.TimeNanos)))
profile.go#L348: ss = append(ss, fmt.Sprintf("Duration: %v", time.Duration(p.DurationNanos)))
profile.go#L354: sh1 = sh1 + fmt.Sprintf("%s/%s ", s.Type, s.Unit)
profile.go#L360: sv = fmt.Sprintf("%s %10d", sv, v)
profile.go#L364: sv = sv + fmt.Sprintf("%d ", l.ID)
profile.go#L371: ls = ls + fmt.Sprintf("%s:%v ", k, v)
profile.go#L378: ls = ls + fmt.Sprintf("%s:%v ", k, v)
profile.go#L386: locStr := fmt.Sprintf("%6d: %#x ", l.ID, l.Address)
profile.go#L388: locStr = locStr + fmt.Sprintf("M=%d ", m.ID)
profile.go#L396: lnStr = fmt.Sprintf("%s %s:%d s=%d",
profile.go#L426: ss = append(ss, fmt.Sprintf("%d: %#x/%#x/%#x %s %s %s",
log
log.go#L205: l.Output(2, fmt.Sprintf(format, v...))
log.go#L234: l.Output(2, fmt.Sprintf(format, v...))
log.go#L253: s := fmt.Sprintf(format, v...)
log.go#L351: std.Output(2, fmt.Sprintf(format, v...))
log.go#L371: std.Output(2, fmt.Sprintf(format, v...))
log.go#L390: s := fmt.Sprintf(format, v...)
math/big
float.go#L378: panic(fmt.Sprintf("msb not set in last word %#x of %s", x.mant[m-1], x.Text('p', 0)))
int.go#L840: panic(fmt.Sprintf("big: invalid 2nd argument to Int.Jacobi: need odd integer but got %s", y))
natconv.go#L115: panic(fmt.Sprintf("invalid number base %d", base))
rat.go#L138: panic(fmt.Sprintf("expected exactly %d bits of result", Msize2))
rat.go#L236: panic(fmt.Sprintf("expected exactly %d bits of result", Msize2))
mime
mediatype.go#L206: simplePart := fmt.Sprintf("%s*%d", key, n)
mime/multipart
writer.go#L90: return fmt.Sprintf("%x", buf[:])
writer.go#L143: fmt.Sprintf(`form-data; name="%s"; filename="%s"`,
writer.go#L154: fmt.Sprintf(`form-data; name="%s"`, escapeQuotes(fieldname)))
net/http
filetransport.go#L111: pr.res.Status = fmt.Sprintf("%d %s", code, StatusText(code))
fs.go#L265: w.Header().Set("Content-Range", fmt.Sprintf("bytes */%d", size))
fs.go#L859: return fmt.Sprintf("bytes %d-%d/%d", r.start, r.start+r.length-1, size)
h2_bundle.go#L1077: panic(fmt.Sprintf("unexpected buffer len=%v", len(p)))
h2_bundle.go#L1209: return fmt.Sprintf("unknown error code 0x%x", uint32(e))
h2_bundle.go#L1216: return fmt.Sprintf("ERR_UNKNOWN_%d", uint32(e))
h2_bundle.go#L1224: return fmt.Sprintf("connection error: %s", http2ErrCode(e))
h2_bundle.go#L1246: return fmt.Sprintf("stream error: stream ID %d; %v; %v", e.StreamID, e.Code, e.Cause)
h2_bundle.go#L1248: return fmt.Sprintf("stream error: stream ID %d; %v", e.StreamID, e.Code)
h2_bundle.go#L1273: return fmt.Sprintf("http2: connection error: %v: %v", e.Code, e.Reason)
h2_bundle.go#L1279: return fmt.Sprintf("invalid pseudo-header %q", string(e))
h2_bundle.go#L1285: return fmt.Sprintf("duplicate pseudo-header %q", string(e))
h2_bundle.go#L1291: return fmt.Sprintf("invalid header field name %q", string(e))
h2_bundle.go#L1297: return fmt.Sprintf("invalid header field value %q", string(e))
h2_bundle.go#L1388: return fmt.Sprintf("UNKNOWN_FRAME_TYPE_%d", uint8(t))
h2_bundle.go#L1883: fmt.Sprintf("got %s for stream %d; expected CONTINUATION following %s for stream %d",
h2_bundle.go#L1889: fmt.Sprintf("got CONTINUATION for stream %d; expected stream %d",
h2_bundle.go#L1893: return fr.connError(http2ErrCodeProtocol, fmt.Sprintf("unexpected CONTINUATION for stream %d", fh.StreamID))
h2_bundle.go#L2492: return nil, http2connError{http2ErrCodeFrameSize, fmt.Sprintf("PRIORITY frame payload size was %d; want 5", len(payload))}
h2_bundle.go#L3053: panic(fmt.Sprintf("No space found in %q", b))
h2_bundle.go#L3058: panic(fmt.Sprintf("Failed to parse goroutine ID out of %q: %v", b, err))
h2_bundle.go#L3331: return fmt.Sprintf("[%v = %d]", s.ID, s.Val)
h2_bundle.go#L3380: return fmt.Sprintf("UNKNOWN_SETTING_%d", uint16(s))
h2_bundle.go#L4177: sc.rejectConn(http2ErrCodeInadequateSecurity, fmt.Sprintf("Prohibited TLS 1.2 Cipher Suite: %x", sc.tlsState.CipherSuite))
h2_bundle.go#L4635: panic(fmt.Sprintf("unexpected type %T", v))
h2_bundle.go#L4879: panic(fmt.Sprintf("internal error: attempt to send frame on a half-closed-local stream: %v", wr))
h2_bundle.go#L4882: panic(fmt.Sprintf("internal error: attempt to send frame on a closed stream: %v", wr))
h2_bundle.go#L5246: panic(fmt.Sprintf("invariant; can't close stream in state %v", st.state))
h2_bundle.go#L6374: panic(fmt.Sprintf("invalid WriteHeader code %v", code))
h2_bundle.go#L6642: panic(fmt.Sprintf("newWriterAndRequestNoBody(%+v): %v", msg.url, err))
h2_bundle.go#L6749: f(fmt.Sprintf("%s_%s_%s", typ, codeStr, name))
h2_bundle.go#L8728: return fmt.Sprintf("http2: server sent GOAWAY and closed the connection; LastStreamID=%v, ErrCode=%v, debug=%q",
h2_bundle.go#L8787: f(fmt.Sprintf("read_frame_conn_error_%s", errCode.stringToken()))
h2_bundle.go#L9833: return fmt.Sprintf("writeData(stream=%d, p=%d, endStream=%v)", w.streamID, len(w.p), w.endStream)
h2_bundle.go#L10259: des = fmt.Sprintf("%T", wr.write)
h2_bundle.go#L10261: return fmt.Sprintf("[FrameWriteRequest stream=%d, ch=%v, writer=%v]", wr.StreamID(), wr.done != nil, des)
h2_bundle.go#L10273: panic(fmt.Sprintf("unbuffered done channel passed in for type %T", wr.write))
h2_bundle.go#L10597: panic(fmt.Sprintf("stream %d already opened", streamID))
h2_bundle.go#L10629: panic(fmt.Sprintf("violation of WriteScheduler interface: unknown stream %d", streamID))
h2_bundle.go#L10632: panic(fmt.Sprintf("violation of WriteScheduler interface: stream %d already closed", streamID))
request.go#L435: s := fmt.Sprintf("%s=%s", sanitizeCookieName(c.Name), sanitizeCookieValue(c.Value))
server.go#L1111: panic(fmt.Sprintf("invalid WriteHeader code %v", code))
server.go#L2056: panic("unexpected type " + fmt.Sprintf("%T", rc))
server.go#L2072: panic("unexpected type " + fmt.Sprintf("%T", rc))
server.go#L3542: name: fmt.Sprintf("%s-%d", baseName, uniqNameNext[baseName]),
transfer.go#L641: return &unsupportedTEError{fmt.Sprintf("too many transfer encodings: %q", raw)}
transfer.go#L644: return &unsupportedTEError{fmt.Sprintf("unsupported transfer encoding: %q", raw[0])}
transport.go#L890: return fmt.Sprintf("net/http: Transport failed to read from server: %v", e.err)
transport.go#L1867: return fmt.Sprintf("%s|%s%s|%s", k.proxy, k.scheme, h1, k.addr)
transport.go#L2653: panic(fmt.Sprintf("internal error: exactly one of res or err should be set; nil=%v", re.res == nil))
net/http/httptest
recorder.go#L138: panic(fmt.Sprintf("invalid WriteHeader code %v", code))
recorder.go#L199: res.Status = fmt.Sprintf("%03d %s", res.StatusCode, http.StatusText(res.StatusCode))
server.go#L64: panic(fmt.Sprintf("httptest: failed to listen on %v: %v", serveFlag, err))
server.go#L71: panic(fmt.Sprintf("httptest: failed to listen on a port: %v", err))
server.go#L149: panic(fmt.Sprintf("httptest: NewTLSServer: %v", err))
server.go#L170: panic(fmt.Sprintf("httptest: NewTLSServer: %v", err))
net/http/pprof
pprof.go#L139: fmt.Sprintf("Could not enable CPU profiling: %s", err))
pprof.go#L168: fmt.Sprintf("Could not enable tracing: %s", err))
pprof.go#L251: w.Header().Set("Content-Disposition", fmt.Sprintf(`attachment; filename="%s"`, name))
pprof.go#L317: w.Header().Set("Content-Disposition", fmt.Sprintf(`attachment; filename="%s-delta"`, name))
net/textproto
reader.go#L557: return ProtocolError(fmt.Sprintf("malformed MIME header: missing colon: %q", line))
textproto.go#L42: return fmt.Sprintf("%03d %s", e.Code, e.Msg)
net/url
url.go#L29: func (e *Error) Error() string { return fmt.Sprintf("%s %q: %s", e.Op, e.URL, e.Err) }
runtime/pprof
elf.go#L105: return fmt.Sprintf("%x", buf[:descSize]), nil
label.go#L49: keyVals = append(keyVals, fmt.Sprintf("%q:%q", k, v))
runtime/trace
annotation.go#L106: userLog(id, category, fmt.Sprintf(format, args...))
testing
benchmark.go#L46: return fmt.Sprintf("%dx", f.n)
benchmark.go#L490: return fmt.Sprintf("%8d B/op\t%8d allocs/op",
benchmark.go#L497: return fmt.Sprintf("%s-%d", name, n)
example.go#L75: fail = fmt.Sprintf("got:\n%s\nwant (unordered):\n%s\n", stdout, eg.Output)
example.go#L79: fail = fmt.Sprintf("got:\n%s\nwant:\n%s\n", got, want)
fuzz.go#L157: panic(fmt.Sprintf("testing: unsupported type to Add %v", t))
fuzz.go#L161: f.corpus = append(f.corpus, corpusEntry{Values: values, IsSeed: true, Path: fmt.Sprintf("seed#%d", len(f.corpus))})
fuzz.go#L239: panic(fmt.Sprintf("testing: unsupported type for fuzzing %v", t))
fuzz.go#L280: panic(fmt.Sprintf("corpus file %q was not unmarshaled", e.Path))
fuzz.go#L287: testName = fmt.Sprintf("%s/%s", testName, filepath.Base(e.Path))
fuzz.go#L399: name := fmt.Sprintf("%s/%s", f.name, filepath.Base(e.Path))
match.go#L217: name := fmt.Sprintf("%s#%02d", base, n)
testing.go#L561: panic(fmt.Sprintf("testing: f.%s was called inside the fuzz target, use t.%s instead", name, name))
testing.go#L739: return fmt.Sprintf("%.2fs", d.Seconds())
testing.go#L920: c.log(fmt.Sprintf(format, args...))
testing.go#L933: c.log(fmt.Sprintf(format, args...))
testing.go#L947: c.log(fmt.Sprintf(format, args...))
testing.go#L961: c.log(fmt.Sprintf(format, args...))
testing.go#L1101: dir := fmt.Sprintf("%s%c%03d", c.tempDir, os.PathSeparator, seq)
testing.go#L2016: return fmt.Sprintf("%s%c%s", *outputDir, os.PathSeparator, path)
testing.go#L2029: panic(fmt.Sprintf("test timed out after %v", *timeout))
text/template
exec.go#L132: format = fmt.Sprintf("template: %s: %s", name, format)
exec.go#L135: format = fmt.Sprintf("template: %s: executing %q at <%s>: %s", location, name, doublePercent(context), format)
funcs.go#L52: "printf": fmt.Sprintf,
text/template/parse
lex.go#L29: return fmt.Sprintf("<%s>", i.val)
lex.go#L31: return fmt.Sprintf("%.10q...", i.val)
lex.go#L33: return fmt.Sprintf("%q", i.val)
lex.go#L194: l.items <- item{itemError, l.start, fmt.Sprintf(format, args...), l.startLine}
node.go#L140: return fmt.Sprintf(textFormat, t.Text)
parse.go#L157: return fmt.Sprintf("%s:%d:%d", tree.ParseName, lineNum, byteNum), context
parse.go#L163: format = fmt.Sprintf("template: %s:%d: %s", t.ParseName, t.token[0].line, format)
parse.go#L195: extra = fmt.Sprintf(" in action started at %s:%d", t.ParseName, t.actionLine)
vendor/golang.org/x/net/http2/hpack
hpack.go#L23: return fmt.Sprintf("decoding error: %v", de.Err)
hpack.go#L31: return fmt.Sprintf("invalid indexed representation index %d", int(e))
hpack.go#L57: return fmt.Sprintf("header field %q = %q%s", hf.Name, hf.Value, suffix)
tables.go#L66: panic(fmt.Sprintf("evictOldest(%v) on table with %v entries", n, t.len()))
tables.go#L119: panic(fmt.Sprintf("id (%v) <= evictCount (%v)", id, t.evictCount))
vendor/golang.org/x/net/idna
idna10.0.0.go#L325: return fmt.Sprintf("idna: invalid label %q", e.label)
idna10.0.0.go#L332: return fmt.Sprintf("idna: disallowed rune %U", e)
vendor/golang.org/x/text/unicode/bidi
bracket.go#L57: return fmt.Sprintf("(%v, %v)", b.opener, b.closer)