func fmt.Sprintf
702 uses
fmt (current package)
print.go#L237: func Sprintf(format string, a ...any) string {
crypto/tls
cipher_suites.go#L113: return fmt.Sprintf("0x%04X", id)
common.go#L59: return fmt.Sprintf("0x%04X", version)
common.go#L987: panic(fmt.Sprintf("tls: unable to generate random session ticket key: %v", err))
common.go#L1049: panic(fmt.Sprintf("unable to generate random session ticket key: %v", err))
common.go#L1685: return fmt.Sprintf("tls: failed to verify certificate: %s", e.Err)
conn.go#L663: msg := fmt.Sprintf("received record with version %x when expecting version %x", vers, expectedVers)
conn.go#L677: msg := fmt.Sprintf("oversized record received with length %d", n)
quic.go#L35: return fmt.Sprintf("QUICEncryptionLevel(%v)", int(l))
crypto/x509
verify.go#L97: s = fmt.Sprintf("%s: %s", s, e.Detail)
verify.go#L162: s += fmt.Sprintf(" (possibly because of %q while trying to verify candidate authority certificate %q)", e.hintErr, certName)
verify.go#L563: return CertificateInvalidError{c, CANotAuthorizedForThisName, fmt.Sprintf("%s %q is excluded by constraint %q", nameType, name, constraint)}
verify.go#L589: return CertificateInvalidError{c, CANotAuthorizedForThisName, fmt.Sprintf("%s %q is not permitted by any constraint", nameType, name)}
verify.go#L617: Detail: fmt.Sprintf("current time %s is before %s", now.Format(time.RFC3339), c.NotBefore.Format(time.RFC3339)),
verify.go#L623: Detail: fmt.Sprintf("current time %s is after %s", now.Format(time.RFC3339), c.NotAfter.Format(time.RFC3339)),
verify.go#L889: details = append(details, fmt.Sprintf("%d chains with incompatible key usage", incompatibleKeyUsageChains))
verify.go#L892: details = append(details, fmt.Sprintf("%d chains with invalid policies", invalidPoliciesChains))
verify.go#L1259: panic(fmt.Sprintf("OIDFromInts(%v) unexpected error: %v", ints, err))
x509.go#L884: return fmt.Sprintf("x509: cannot verify signature: insecure algorithm %v", SignatureAlgorithm(e))
encoding/asn1
asn1.go#L780: err = StructuralError{fmt.Sprintf("unknown Go type: %v", fieldType)}
asn1.go#L839: err = StructuralError{fmt.Sprintf("tags don't match (%d vs %+v) %+v %s @%d", expectedTag, t, params, fieldType.Name(), offset)}
asn1.go#L977: err = SyntaxError{fmt.Sprintf("internal error: unknown string type %d", universalTag)}
marshal.go#L623: return nil, StructuralError{fmt.Sprintf("unknown Go type: %v", v.Type())}
encoding/hex
hex.go#L73: return fmt.Sprintf("encoding/hex: invalid byte: %#U", rune(e))
encoding/json
encode.go#L755: e.error(&UnsupportedValueError{v, fmt.Sprintf("encountered a cycle via %s", v.Type())})
encode.go#L838: e.error(&UnsupportedValueError{v, fmt.Sprintf("encountered a cycle via %s", v.Type())})
encode.go#L894: e.error(&UnsupportedValueError{v, fmt.Sprintf("encountered a cycle via %s", v.Type())})
flag
flag.go#L311: panic(fmt.Sprintf("default type does not match variable type: %v != %v", defVal.Type(), ptrVal.Type().Elem()))
flag.go#L516: f.undef[name] = fmt.Sprintf("%s:%d", file, line)
flag.go#L1031: panic(fmt.Sprintf("flag %s set at %s before being defined", name, pos))
flag.go#L1051: msg := fmt.Sprintf(format, a...)
github.com/google/go-cmp/cmp
compare.go#L208: panic(fmt.Sprintf("cannot use an unfiltered option: %v", opt))
compare.go#L216: panic(fmt.Sprintf("unknown option %T", opt))
compare.go#L299: panic(fmt.Sprintf("%v kind not handled", t.Kind()))
compare.go#L342: panic(fmt.Sprintf("non-deterministic function detected: %s", function.NameOf(f)))
compare.go#L361: panic(fmt.Sprintf("non-deterministic or non-symmetric function detected: %s", function.NameOf(f)))
compare.go#L546: panic(fmt.Sprintf("%#v has map key with NaNs\n%s", s.curPath, help))
compare.go#L623: ss = append(ss, fmt.Sprintf("%v: %v => %v", t, tf.In(0), tf.Out(0)))
compare.go#L632: 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#L254: name = fmt.Sprintf("%q.(%v)", pkgPath, t.String()) // e.g., "path/to/package".(struct { a int })
options.go#L256: panic(fmt.Sprintf("cannot handle unexported field at %#v:\n\t%v\n%s", s.curPath, name, help))
options.go#L291: panic(fmt.Sprintf("invalid transformer function: %T", f))
options.go#L299: panic(fmt.Sprintf("invalid name: %q", name))
options.go#L340: return fmt.Sprintf("Transformer(%s, %s)", tr.name, function.NameOf(tr.fnc))
options.go#L358: panic(fmt.Sprintf("invalid comparer function: %T", f))
options.go#L388: return fmt.Sprintf("Comparer(%s)", function.NameOf(cm.fnc))
options.go#L435: panic(fmt.Sprintf("invalid struct type: %T", typ))
options.go#L558: panic(fmt.Sprintf("invalid option type: %T", opt))
path.go#L175: return fmt.Sprintf("{%s}", s)
path.go#L209: func (sf StructField) String() string { return fmt.Sprintf(".%s", sf.name) }
path.go#L232: return fmt.Sprintf("[%d]", si.xkey)
path.go#L235: return fmt.Sprintf("[%d->?]", si.xkey)
path.go#L238: return fmt.Sprintf("[?->%d]", si.ykey)
path.go#L241: return fmt.Sprintf("[%d->%d]", si.xkey, si.ykey)
path.go#L273: func (mi MapIndex) String() string { return fmt.Sprintf("[%#v]", mi.key) }
path.go#L296: func (ta TypeAssertion) String() string { return fmt.Sprintf(".(%v)", value.TypeString(ta.typ, false)) }
path.go#L308: 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()))
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#L78: return fmt.Sprintf(
stacks.go#L90: panic(fmt.Sprintf("Failed to parse stack trace: %v\n%s", err, trace))
go.uber.org/mock/gomock
call.go#L319: return fmt.Sprintf("%T.%v(%s) %s", c.receiver, c.method, arguments, c.origin)
call.go#L445: panic(fmt.Sprintf(
call.go#L501: got := fmt.Sprintf("%v (%T)", arg, arg)
controller.go#L299: return fmt.Sprintf("%s:%d", file, line)
matchers.go#L140: return fmt.Sprintf("is equal to %s (%T)", getString(e.x), e.x)
matchers.go#L264: return fmt.Sprintf("has length %d", m.i)
matchers.go#L328: return fmt.Sprintf("has the same elements as %v", m.x)
string.go#L13: return fmt.Sprintf("%T", x)
string.go#L18: return fmt.Sprintf("%v", x)
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#L321: 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#L352: panic(fmt.Sprintf("ast.Walk: unexpected node type %T", n))
go/build
build.go#L548: 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#L793: paths = append(paths, fmt.Sprintf(format, dir))
build.go#L797: paths = append(paths, fmt.Sprintf("\t%s (from $GOROOT)", tried.goroot))
build.go#L803: paths = append(paths, fmt.Sprintf(format, dir))
go/constant
value.go#L203: s := fmt.Sprintf("%.6g", x)
value.go#L207: s = fmt.Sprintf("%g", x)
value.go#L241: return fmt.Sprintf("%.6ge%+d", m, e)
value.go#L244: func (x complexVal) String() string { return fmt.Sprintf("(%s + %si)", x.re, x.im) }
value.go#L263: return fmt.Sprintf("(%s + %si)", x.re.ExactString(), x.im.ExactString())
value.go#L466: panic(fmt.Sprintf("%v is not a valid token", tok))
value.go#L487: panic(fmt.Sprintf("%v not a Bool", x))
value.go#L500: panic(fmt.Sprintf("%v not a String", x))
value.go#L516: panic(fmt.Sprintf("%v not an Int", x))
value.go#L532: panic(fmt.Sprintf("%v not an Int", x))
value.go#L553: panic(fmt.Sprintf("%v not a Float", x))
value.go#L578: panic(fmt.Sprintf("%v not a Float", x))
value.go#L658: panic(fmt.Sprintf("%v not an Int", x))
value.go#L686: panic(fmt.Sprintf("%v not numeric", x))
value.go#L710: panic(fmt.Sprintf("%v not an Int", x))
value.go#L780: panic(fmt.Sprintf("%v not Int or Float", x))
value.go#L802: panic(fmt.Sprintf("%v not Int or Float", x))
value.go#L817: panic(fmt.Sprintf("%v not Int or Float", x))
value.go#L830: panic(fmt.Sprintf("%v not numeric", x))
value.go#L845: panic(fmt.Sprintf("%v not numeric", x))
value.go#L1017: panic(fmt.Sprintf("invalid unary operation %s%v", op, y))
value.go#L1271: panic(fmt.Sprintf("invalid binary operation %v %s %v", x_, op, y_))
value.go#L1312: panic(fmt.Sprintf("invalid shift %v %s %d", x, op, s))
value.go#L1330: panic(fmt.Sprintf("invalid comparison %v %s 0", x, op))
value.go#L1409: panic(fmt.Sprintf("invalid comparison %v %s %v", x_, op, y_))
go/doc
reader.go#L40: return fmt.Sprintf("%s[%s]", recvString(t.X), recvParam(t.Index))
go/parser
parser.go#L1987: p.error(x.Pos(), fmt.Sprintf("expression in %s must not be parenthesized", callType))
parser.go#L1995: p.error(p.safePos(x.End()), fmt.Sprintf("expression in %s must be function call", callType))
parser.go#L2072: p.error(s.Pos(), fmt.Sprintf("expected %s, found %s (missing parentheses around composite literal?)", want, found))
resolver.go#L86: return fmt.Sprintf(format, args...)
resolver.go#L120: r.declErr(ident.Pos(), fmt.Sprintf("label %s undefined", ident.Name))
resolver.go#L131: panic(fmt.Sprintf("%v: identifier %s already declared or resolved", ident.Pos(), ident.Name))
resolver.go#L152: r.declErr(ident.Pos(), fmt.Sprintf("%s redeclared in this block%s", ident.Name, prevDecl))
go/printer
printer.go#L208: p.output = append(p.output, fmt.Sprintf("//line %s:%d\n", pos.Filename, pos.Line)...)
printer.go#L305: p.output = append(p.output, fmt.Sprintf("/*%s*/", pos)...) // do not update p.pos!
go/scanner
errors.go#L97: return fmt.Sprintf("%s (and %d more errors)", p[0], len(p)-1)
scanner.go#L126: panic(fmt.Sprintf("file size (%d) does not match src len (%d)", file.Size(), len(src)))
scanner.go#L155: s.error(offs, fmt.Sprintf(format, args...))
scanner.go#L589: msg := fmt.Sprintf("illegal character %#U in escape sequence", s.ch)
go/token
position.go#L52: s += fmt.Sprintf(":%d", pos.Column)
position.go#L152: panic(fmt.Sprintf("invalid line number %d (should be >= 1)", line))
position.go#L157: panic(fmt.Sprintf("invalid line number %d (should be < %d)", line, len(f.lines)))
position.go#L227: panic(fmt.Sprintf("invalid line number %d (should be >= 1)", line))
position.go#L232: panic(fmt.Sprintf("invalid line number %d (should be < %d)", line, len(f.lines)))
position.go#L286: panic(fmt.Sprintf("offset %d out of bounds [%d, %d] (position %d out of bounds [%d, %d])",
position.go#L474: panic(fmt.Sprintf("invalid base %d (should be >= %d)", base, s.base))
position.go#L478: panic(fmt.Sprintf("invalid size %d (should be >= 0)", size))
go/types
alias.go#L120: panic(fmt.Sprintf("non-terminated alias %s", a0.obj.name))
api.go#L65: return fmt.Sprintf("%s: %s", err.Fset.Position(err.Pos), err.Msg)
assignments.go#L351: return fmt.Sprintf("%d %s", x, unit)
check.go#L57: panic(fmt.Sprintf("gotypealias mutated during type checking, gotypesalias=%s, inuse=%d", v, inuse))
context.go#L100: panic(fmt.Sprintf("non-identical instances: (orig: %s, targs: %v) and %s", orig, targs, e.instance))
context.go#L123: panic(fmt.Sprintf("%s and %s are not identical", inst, e.instance))
errors.go#L24: msg = fmt.Sprintf("%s:%d: %s", file, line, msg)
errors.go#L178: url := fmt.Sprintf(check.conf._ErrorURL, code)
expr.go#L1151: panic(fmt.Sprintf("%s: unknown expression type %T", check.fset.Position(e.Pos()), e))
format.go#L76: return fmt.Sprintf(format, args...)
infer.go#L636: panic(fmt.Sprintf("unexpected %T", typ))
infer.go#L788: panic(fmt.Sprintf("unexpected %T", typ))
instantiate.go#L181: panic(fmt.Sprintf("%v: cannot instantiate %v", pos, orig))
instantiate.go#L208: panic(fmt.Sprintf("%v: %s", pos, msg))
object.go#L558: panic(fmt.Sprintf("writeObject(%T)", obj))
operand.go#L123: return fmt.Sprintf("nil (of type %s)", TypeString(x.typ, qf))
package.go#L29: scope := NewScope(Universe, nopos, nopos, fmt.Sprintf("package %q", path))
package.go#L82: return fmt.Sprintf("package %s (%q)", pkg.name, pkg.path)
resolver.go#L133: return fmt.Sprintf("file[%d]", fileNo)
signature.go#L59: panic(fmt.Sprintf("got %s, want variadic parameter with unnamed slice type or string as core type", core.String()))
typestring.go#L318: w.string(fmt.Sprintf("$%d", i))
typestring.go#L330: w.string(fmt.Sprintf(" /* with %s declared at %v */", t.obj.name, t.obj.Pos()))
typexpr.go#L227: return strings.ReplaceAll(fmt.Sprintf("%T", typ), "types.", "")
typexpr.go#L428: panic(fmt.Sprintf("unexpected type %T", t))
unify.go#L137: return fmt.Sprintf("mode %d", m)
version.go#L48: go_current = asGoVersion(fmt.Sprintf("go1.%d", goversion.Version))
golang.org/x/exp/apidiff
apidiff.go#L90: Message: fmt.Sprintf("package %s: %s", p.Path(), change),
apidiff.go#L138: ms.add(obj, part, fmt.Sprintf(format, args...))
compatibility.go#L304: part = fmt.Sprintf(", method set of %s", msname)
correspondence.go#L134: panic(fmt.Sprintf("unknown type kind %T", old))
messageset.go#L97: return fmt.Sprintf("%s%s.%s", packagePrefix, tn, obj.Name())
messageset.go#L100: return fmt.Sprintf("%s%s", packagePrefix, obj.Name())
report.go#L33: return fmt.Sprintf("!!%v", err)
golang.org/x/net/http2
databuffer.go#L59: 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", t)
frame.go#L565: fmt.Sprintf("got %s for stream %d; expected CONTINUATION following %s for stream %d",
frame.go#L571: fmt.Sprintf("got CONTINUATION for stream %d; expected stream %d",
frame.go#L575: return fr.connError(ErrCodeProtocol, fmt.Sprintf("unexpected CONTINUATION for stream %d", fh.StreamID))
frame.go#L1183: 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#L135: return fmt.Sprintf("[%v = %d]", s.ID, s.Val)
http2.go#L190: return fmt.Sprintf("UNKNOWN_SETTING_%d", uint16(s))
server.go#L541: sc.rejectConn(ErrCodeInadequateSecurity, fmt.Sprintf("Prohibited TLS 1.2 Cipher Suite: %x", sc.tlsState.CipherSuite))
server.go#L1046: panic(fmt.Sprintf("unexpected type %T", v))
server.go#L1315: panic(fmt.Sprintf("internal error: attempt to send frame on a half-closed-local stream: %v", wr))
server.go#L1318: panic(fmt.Sprintf("internal error: attempt to send frame on a closed stream: %v", wr))
server.go#L1718: panic(fmt.Sprintf("invariant; can't close stream in state %v", st.state))
server.go#L2955: panic(fmt.Sprintf("invalid WriteHeader code %v", code))
server.go#L3240: panic(fmt.Sprintf("newWriterAndRequestNoBody(%+v): %v", msg.url, err))
server.go#L3348: f(fmt.Sprintf("%s_%s_%s", typ, codeStr, name))
transport.go#L2144: return fmt.Sprintf("http2: server sent GOAWAY and closed the connection; LastStreamID=%v, ErrCode=%v, debug=%q",
transport.go#L2231: f(fmt.Sprintf("read_frame_conn_error_%s", errCode.stringToken()))
write.go#L106: 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#L324: return fmt.Sprintf("idna: invalid label %q", e.label)
idna10.0.0.go#L331: return fmt.Sprintf("idna: disallowed rune %U", e)
golang.org/x/net/internal/httpcommon
request.go#L348: return fmt.Sprintf("name %q", k)
request.go#L354: return fmt.Sprintf("value for header %q", k)
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#L128: panic(fmt.Sprintf("mustGetEnv: %v", err))
golist.go#L656: msg += fmt.Sprintf(": import stack: %v", p.Error.ImportStack)
golist.go#L834: fmt.Sprintf("-compiled=%t", cfg.Mode&(NeedCompiledGoFiles|NeedSyntax|NeedTypes|NeedTypesInfo|NeedTypesSizes) != 0),
golist.go#L835: fmt.Sprintf("-test=%t", cfg.Tests),
golist.go#L836: fmt.Sprintf("-export=%t", usesExportData(cfg)),
golist.go#L837: fmt.Sprintf("-deps=%t", cfg.Mode&NeedImports != 0),
golist.go#L840: fmt.Sprintf("-find=%t", !cfg.Tests && cfg.Mode&findFlags == 0 && !usesExportData(cfg)),
golist.go#L941: output := fmt.Sprintf(`{"ImportPath": "command-line-arguments","Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
golist.go#L948: output := fmt.Sprintf(`{"ImportPath": "command-line-arguments","Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
golist.go#L960: output := fmt.Sprintf(`{"ImportPath": %q,"Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
golist.go#L968: output := fmt.Sprintf(`{"ImportPath": "command-line-arguments","Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
golist.go#L976: output := fmt.Sprintf(`{"ImportPath": %q,"Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
golist.go#L984: output := fmt.Sprintf(`{"ImportPath": %q,"Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
golist.go#L1005: output := fmt.Sprintf(`{"ImportPath": %q,"Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
golist.go#L1050: 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, " "))
loadmode_string.go#L48: return fmt.Sprintf("LoadMode(%#x)", int(mode))
loadmode_string.go#L50: out = append(out, fmt.Sprintf("%#x", int(mode)))
packages.go#L1150: 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#L1160: appendError(Error{"-", fmt.Sprintf("sources missing for package %s", lpkg.ID), ParseError})
golang.org/x/tools/go/types/typeutil
map.go#L321: panic(fmt.Sprintf("%T: %v", t, t))
map.go#L474: panic(fmt.Sprintf("shallowHash: %T: %v", t, t))
golang.org/x/tools/internal/gcimporter
bimport.go#L18: panic(fmt.Sprintf(format, args...))
iexport.go#L1595: return internalError(fmt.Sprintf(format, args...))
golang.org/x/tools/internal/gocommand
invoke.go#L496: 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, " "))
invoke.go#L536: base := fmt.Sprintf("%d-%s", 1+len(overlays), filepath.Base(k))
golang.org/x/tools/internal/packagesinternal
packages.go#L19: return fmt.Sprintf("%s: %s (import stack: %s)", err.Pos, err.Err, err.ImportStack)
golang.org/x/tools/internal/pkgbits
sync.go#L20: res = append(res, fmt.Sprintf("%s:%v: %s +0x%v", file, line, name, offset))
golang.org/x/tools/internal/stdlib
stdlib.go#L67: versions[i] = fmt.Sprintf("go1.%d", i)
golang.org/x/tools/internal/typeparams
coretype.go#L154: panic(fmt.Sprintf("%v is not a pointer", t))
golang.org/x/tools/internal/typesinternal
classify_call.go#L37: return fmt.Sprintf("typeutil.CallKind(%d)", k)
element.go#L93: panic(fmt.Sprintf("Signature %s has Recv %s", T, T.Recv()))
zerovalue.go#L51: panic(fmt.Sprintf("ZeroString for unexpected type %v", t))
zerovalue.go#L107: panic(fmt.Sprintf("invalid type for a variable: %v", t))
zerovalue.go#L144: panic(fmt.Sprintf("ZeroExpr for unexpected type %v", t))
zerovalue.go#L195: panic(fmt.Sprintf("invalid type for a variable: %v", t))
zerovalue.go#L200: panic(fmt.Sprintf("invalid type for a variable: %v", t))
zerovalue.go#L244: Value: fmt.Sprintf("%d", t.Len()),
google.golang.org/grpc
balancer_wrapper.go#L346: return fmt.Sprintf("SubConn(id:%d)", acbw.ac.channelz.ID)
clientconn.go#L324: Desc: fmt.Sprintf("Channel %s", msg),
clientconn.go#L329: Desc: fmt.Sprintf("Nested channel(id:%d) %s", cc.channelz.ID, msg),
clientconn.go#L725: panic(fmt.Sprintf("impossible error parsing empty service config: %v", cfg.Err))
clientconn.go#L870: Desc: fmt.Sprintf("Subchannel(id:%d) created", ac.channelz.ID),
clientconn.go#L1557: Desc: fmt.Sprintf("Subchannel(id:%d) deleted", ac.channelz.ID),
picker_wrapper.go#L129: errStr = fmt.Sprintf("%v while waiting for connections to become ready", ctx.Err())
server.go#L708: s.events = newTraceEventLog("grpc.Server", fmt.Sprintf("%s:%d", file, line))
server.go#L1492: panic(fmt.Sprintf("grpc: Unexpected error (%T) from sendResponse: %v", st, st))
server.go#L1804: errDesc := fmt.Sprintf("malformed method name: %q", stream.Method())
server.go#L1857: errDesc = fmt.Sprintf("unknown service %v", service)
server.go#L1859: errDesc = fmt.Sprintf("unknown method %v for service %v", method, service)
trace.go#L127: return truncate(fmt.Sprintf("sent: %v", p.msg), truncateSize)
trace.go#L129: return truncate(fmt.Sprintf("recv: %v", p.msg), truncateSize)
trace.go#L138: return fmt.Sprintf(f.format, f.a...)
google.golang.org/grpc/attributes
attributes.go#L117: sb.WriteString(fmt.Sprintf("%q: %q ", str(k), str(v)))
attributes.go#L130: return fmt.Sprintf("<%p>", x)
google.golang.org/grpc/balancer/pickfirst
pickfirst.go#L60: b.logger = internalgrpclog.NewPrefixLogger(logger, fmt.Sprintf(logPrefix, b))
google.golang.org/grpc/balancer/pickfirst/pickfirstleaf
pickfirstleaf.go#L120: b.logger = internalgrpclog.NewPrefixLogger(logger, fmt.Sprintf(logPrefix, b))
google.golang.org/grpc/balancer/roundrobin
roundrobin.go#L55: bal.logger = internalgrpclog.NewPrefixLogger(logger, fmt.Sprintf("[%p] ", bal))
google.golang.org/grpc/credentials
credentials.go#L82: return fmt.Sprintf("invalid SecurityLevel: %v", int(s))
tls.go#L81: return fmt.Sprintf("unknown ID: %v", cipherSuiteID)
google.golang.org/grpc/grpclog
component.go#L69: c.InfoDepth(1, fmt.Sprintf(format, args...))
component.go#L73: c.WarningDepth(1, fmt.Sprintf(format, args...))
component.go#L77: c.ErrorDepth(1, fmt.Sprintf(format, args...))
component.go#L81: c.FatalDepth(1, fmt.Sprintf(format, args...))
google.golang.org/grpc/grpclog/internal
loggerv2.go#L106: var sprintf = fmt.Sprintf
google.golang.org/grpc/internal/channelz
channel.go#L59: return fmt.Sprintf("Channel #%d", c.ID)
channel.go#L61: return fmt.Sprintf("%s Channel #%d", c.Parent, c.ID)
channel.go#L153: return fmt.Sprintf("State: %v, Target: %s, CallsStarted: %v, CallsSucceeded: %v, CallsFailed: %v, LastCallStartedTimestamp: %v",
channelmap.go#L354: return fmt.Sprintf("non-existent entity #%d", d.idNotFound)
logging.go#L40: Desc: fmt.Sprintf(format, args...),
logging.go#L56: Desc: fmt.Sprintf(format, args...),
logging.go#L72: Desc: fmt.Sprintf(format, args...),
server.go#L80: return fmt.Sprintf("Server #%d", s.ID)
socket.go#L111: return fmt.Sprintf("%s %s #%d", ls.Parent, ls.SocketType, ls.ID)
subchannel.go#L43: return fmt.Sprintf("%s SubChannel #%d", sc.parent, sc.ID)
trace.go#L197: d := fmt.Sprintf("[%s]%s", e, desc.Desc)
google.golang.org/grpc/internal/grpclog
prefix_logger.go#L42: pl.logger.InfoDepth(1, fmt.Sprintf(format, args...))
prefix_logger.go#L45: grpclog.InfoDepth(1, fmt.Sprintf(format, args...))
prefix_logger.go#L52: pl.logger.WarningDepth(1, fmt.Sprintf(format, args...))
prefix_logger.go#L55: grpclog.WarningDepth(1, fmt.Sprintf(format, args...))
prefix_logger.go#L62: pl.logger.ErrorDepth(1, fmt.Sprintf(format, args...))
prefix_logger.go#L65: grpclog.ErrorDepth(1, fmt.Sprintf(format, args...))
google.golang.org/grpc/internal/pretty
pretty.go#L51: return fmt.Sprintf("%+v", ee)
pretty.go#L58: return fmt.Sprintf("%+v", e)
google.golang.org/grpc/internal/serviceconfig
duration.go#L53: str := fmt.Sprintf("%s%d.%09d", sign, sec, ns)
duration.go#L57: return []byte(fmt.Sprintf("\"%ss\"", str)), nil
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/stats
metrics_recorder_list.go#L53: panic(fmt.Sprintf("Received %d labels in call to record metric %q, but expected %d.", got, desc.Name, want))
google.golang.org/grpc/internal/status
status.go#L67: Message: fmt.Sprintf(
status.go#L82: return New(c, fmt.Sprintf(format, a...))
status.go#L97: return Err(c, fmt.Sprintf(format, a...))
status.go#L202: return fmt.Sprintf("rpc error: code = %s desc = %s", s.Code(), s.Message())
google.golang.org/grpc/internal/transport
handler_server.go#L56: msg := fmt.Sprintf("invalid gRPC request method %q", r.Method)
handler_server.go#L64: msg := fmt.Sprintf("invalid gRPC request content-type %q", contentType)
handler_server.go#L108: msg := fmt.Sprintf("malformed grpc-timeout: %v", err)
handler_server.go#L128: msg := fmt.Sprintf("malformed binary metadata %q in header %q: %v", v, k, err)
handler_server.go#L244: h.Set("Grpc-Status", fmt.Sprintf("%d", st.Code()))
http2_client.go#L1416: t.goAwayDebugMessage = fmt.Sprintf("code: %s", f.ErrCode)
http2_client.go#L1418: t.goAwayDebugMessage = fmt.Sprintf("code: %s, debug data: %q", f.ErrCode, string(f.DebugData()))
http2_client.go#L1483: contentTypeErr = fmt.Sprintf("transport: received unexpected content-type %q", hf.Value)
http2_client.go#L1494: se := status.New(codes.Internal, fmt.Sprintf("transport: malformed grpc-status: %v", err))
http2_client.go#L1511: se := status.New(codes.Internal, fmt.Sprintf("transport: malformed http-status: %v", err))
http2_client.go#L1518: httpStatusErr = fmt.Sprintf(
http2_client.go#L1529: headerError = fmt.Sprintf("transport: malformed %s: %v", hf.Name, err)
http2_server.go#L478: 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#L568: errMsg := fmt.Sprintf("Received a HEADERS frame with :method %q which should be POST", httpMethod)
logging.go#L31: return internalgrpclog.NewPrefixLogger(logger, fmt.Sprintf("[server-transport %p] ", p))
logging.go#L35: return internalgrpclog.NewPrefixLogger(logger, fmt.Sprintf("[server-handler-transport %p] ", p))
logging.go#L39: return internalgrpclog.NewPrefixLogger(logger, fmt.Sprintf("[client-transport %p] ", p))
transport.go#L439: return fmt.Sprintf("<stream: %p, %v>", s, s.method)
transport.go#L623: Desc: fmt.Sprintf(format, a...),
transport.go#L638: return fmt.Sprintf("connection error: desc = %q", e.Desc)
google.golang.org/grpc/mem
buffers.go#L205: return fmt.Sprintf("mem.Buffer(%p, data: %p, length: %d)", b, b.ReadOnlyData(), len(b.ReadOnlyData()))
google.golang.org/grpc/metadata
metadata.go#L83: panic(fmt.Sprintf("metadata: Pairs got the odd number of input pairs for metadata: %d", len(kv)))
metadata.go#L181: panic(fmt.Sprintf("metadata: AppendToOutgoingContext got an odd number of input pairs for metadata: %d", len(kv)))
metadata.go#L281: panic(fmt.Sprintf("metadata: FromOutgoingContext got an odd number of input pairs for metadata: %d", len(added)))
google.golang.org/grpc/resolver
resolver.go#L140: sb.WriteString(fmt.Sprintf("{Addr: %q, ", a.Addr))
resolver.go#L141: sb.WriteString(fmt.Sprintf("ServerName: %q, ", a.ServerName))
resolver.go#L143: sb.WriteString(fmt.Sprintf("Attributes: %v, ", a.Attributes.String()))
resolver.go#L146: sb.WriteString(fmt.Sprintf("BalancerAttributes: %v", a.BalancerAttributes.String()))
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#L107: head := fmt.Sprintf("(line %d:%d): ", line, column)
decode.go#L119: head := fmt.Sprintf("syntax error (line %d:%d): ", line, column)
decode.go#L346: panic(fmt.Sprintf("unmarshalScalar: invalid scalar kind %v", kind))
decode.go#L676: panic(fmt.Sprintf("invalid kind for map key: %v", kind))
encode.go#L345: panic(fmt.Sprintf("%v has unknown kind: %v", fd.FullName(), kind))
well_known_types.go#L603: 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#L350: panic(fmt.Sprintf("invalid scalar kind %v", kind))
encode.go#L262: panic(fmt.Sprintf("%v has unknown kind: %v", fd.FullName(), kind))
encode.go#L337: 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#L313: panic(fmt.Sprintf("unknown accessor: %v.%s", v.Type(), a.name))
stringer.go#L356: 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...)
errors.go#L96: return fmt.Sprintf("size mismatch (see https://github.com/golang/protobuf/issues/1609): calculated=%d, measured=%d", e.Calculated, e.Measured)
google.golang.org/protobuf/internal/filedesc
desc.go#L745: panic(fmt.Sprintf("detected mutation on the default bytes for %v", fd.FullName()))
desc_init.go#L256: panic(fmt.Sprintf("invalid descriptor: using edition features in a proto with syntax %s", fd.Syntax()))
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())
editions.go#L44: panic(fmt.Sprintf("unkown field number %d while unmarshalling GoFeatures", num))
editions.go#L76: panic(fmt.Sprintf("unkown field number %d while unmarshalling FeatureSet", num))
editions.go#L99: panic(fmt.Sprintf("unknown parent type %T", parentDesc))
editions.go#L150: panic(fmt.Sprintf("unkown field number %d while unmarshalling EditionDefault", num))
editions.go#L164: panic(fmt.Sprintf("unsupported edition: %v", ed))
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_opaque.go#L19: panic(fmt.Sprintf("invalid field: %v: unsupported message type %v", fd.FullName(), ft))
codec_field_opaque.go#L121: panic(fmt.Sprintf("invalid field: %v: unsupported type for opaque repeated message: %v", fd.FullName(), ft))
codec_field_opaque.go#L126: panic(fmt.Sprintf("invalid field: %v: unsupported message type %v", fd.FullName(), mt))
codec_message.go#L151: panic(fmt.Sprintf("%v: MessageSet with no extensions field", mi.Desc.FullName()))
codec_message.go#L154: panic(fmt.Sprintf("%v: MessageSet with no unknown field", mi.Desc.FullName()))
codec_message_opaque.go#L99: panic(fmt.Sprintf("%v: MessageSet with no extensions field", mi.Desc.FullName()))
codec_message_opaque.go#L102: 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#L142: panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
convert.go#L152: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L176: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L200: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L224: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L248: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L272: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L296: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L320: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L350: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L387: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L423: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L448: panic(fmt.Sprintf("invalid type: got %v, want %v", rv.Type(), reflect.PtrTo(c.goType)))
convert.go#L457: 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))
lazy.go#L52: panic(fmt.Sprintf("unsupported wrapper type %T", m))
lazy.go#L64: panic(fmt.Sprintf("lazyUnmarshal: field info for %v.%v", mi.Desc.FullName(), num))
lazy.go#L69: panic(fmt.Sprintf("lazyUnmarshal: can't find field data for %v.%v", mi.Desc.FullName(), num))
legacy_enum.go#L126: panic(fmt.Sprintf("%v already implements proto.Enum", t))
legacy_enum.go#L209: 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#L372: return filedesc.PlaceholderEnumValue(protoreflect.FullName(fmt.Sprintf("UNKNOWN_%d", n)))
merge.go#L39: panic(fmt.Sprintf("invalid value: merging into nil message"))
message.go#L87: panic(fmt.Sprintf("got %v, want *struct kind", t))
message_opaque.go#L140: panic(fmt.Sprintf("invalid type: got %v, want map kind", ft))
message_opaque.go#L172: panic(fmt.Sprintf("invalid value: setting map field to read-only value"))
message_opaque.go#L193: panic(fmt.Sprintf("invalid type: got %v, want slice kind", ft))
message_opaque.go#L224: panic(fmt.Sprintf("invalid value: setting repeated field to read-only value"))
message_opaque.go#L243: panic(fmt.Sprintf("invalid type: got %v, want slice kind", ft))
message_opaque.go#L306: panic(fmt.Sprintf("invalid value: setting repeated field to read-only value"))
message_opaque.go#L336: panic(fmt.Sprintf("invalid type: got %v, want slice kind", ft))
message_opaque.go#L381: panic(fmt.Sprintf("invalid value: setting repeated field to read-only value"))
message_opaque.go#L441: panic(fmt.Sprintf("invalid type: %v", rv.Type())) // should never happen
message_opaque.go#L580: panic(fmt.Sprintf("BUG: %v not in %v", fd.Name(), md.FullName()))
message_reflect.go#L295: panic(fmt.Sprintf("%v: assigning invalid value", xd.FullName()))
message_reflect.go#L398: panic(fmt.Sprintf("type mismatch: got %T, want %v", m, mi.GoReflectType))
message_reflect.go#L440: panic(fmt.Sprintf("mismatching field: got %v, want %v", got, want))
message_reflect.go#L442: panic(fmt.Sprintf("mismatching field: %v", fd.FullName()))
message_reflect.go#L450: panic(fmt.Sprintf("extension %v has mismatching containing message: got %v, want %v", fd.FullName(), got, want))
message_reflect.go#L453: panic(fmt.Sprintf("extension %v extends %v outside the extension range", fd.FullName(), mi.Desc.FullName()))
message_reflect.go#L457: panic(fmt.Sprintf("extension %v does not implement protoreflect.ExtensionTypeDescriptor", fd.FullName()))
message_reflect.go#L461: panic(fmt.Sprintf("field %v is invalid", fd.FullName()))
message_reflect_field.go#L64: panic(fmt.Sprintf("field %v has invalid type: got %v, want interface kind", fd.FullName(), ft))
message_reflect_field.go#L67: panic(fmt.Sprintf("field %v has invalid type: got %v, want struct kind", fd.FullName(), ot))
message_reflect_field.go#L70: panic(fmt.Sprintf("field %v has invalid type: %v does not implement %v", fd.FullName(), ot, ft))
message_reflect_field.go#L123: panic(fmt.Sprintf("field %v with invalid Mutable call on field with non-composite type", fd.FullName()))
message_reflect_field.go#L147: panic(fmt.Sprintf("field %v has invalid type: got %v, want map kind", fd.FullName(), ft))
message_reflect_field.go#L180: panic(fmt.Sprintf("map field %v cannot be set with read-only value", fd.FullName()))
message_reflect_field.go#L200: panic(fmt.Sprintf("field %v has invalid type: got %v, want slice kind", fd.FullName(), ft))
message_reflect_field.go#L233: panic(fmt.Sprintf("list field %v cannot be set with read-only value", fd.FullName()))
message_reflect_field.go#L300: panic(fmt.Sprintf("field %v has invalid type: %v", fd.FullName(), rv.Type())) // should never happen
message_reflect_field.go#L365: panic(fmt.Sprintf("field %v has invalid nil pointer", fd.FullName()))
validate.go#L55: return fmt.Sprintf("ValidationStatus(%d)", int(v))
google.golang.org/protobuf/internal/protolazy
lazy.go#L312: panic(fmt.Sprintf("findFieldInfo: error building index when looking for field %d: %v", fieldNum, err))
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#L86: 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/protoreflect
proto.go#L181: return fmt.Sprintf("<unknown:%d>", s)
proto.go#L193: return fmt.Sprintf("Syntax(%d)", s)
proto.go#L229: return fmt.Sprintf("<unknown:%d>", c)
proto.go#L243: return fmt.Sprintf("Cardinality(%d)", c)
proto.go#L329: return fmt.Sprintf("<unknown:%d>", k)
proto.go#L373: return fmt.Sprintf("Kind(%d)", k)
value_equal.go#L76: panic(fmt.Sprintf("unknown type: %T", x))
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#L40: 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#L235: return fmt.Sprintf("html/template:%s: %s", loc, e.Description)
error.go#L237: return fmt.Sprintf("html/template:%s:%d: %s", e.Name, e.Line, e.Description)
error.go#L239: return fmt.Sprintf("html/template:%s: %s", e.Name, e.Description)
error.go#L247: return &Error{k, node, "", line, fmt.Sprintf(f, args...)}
escape.go#L30: err = &Error{ErrEndContext, nil, name, 0, fmt.Sprintf("ends in a non-text context: %v", c)}
escape.go#L806: panic(fmt.Sprintf("infinite loop from %v to %v on %q..%q", c, c1, s[:i], s[i:]))
escape.go#L886: panic(fmt.Sprintf("node %s shared between templates", n))
escape.go#L894: panic(fmt.Sprintf("node %s shared between templates", n))
escape.go#L902: panic(fmt.Sprintf("node %s shared between templates", n))
js.go#L201: return fmt.Sprintf(" /* %s */null ", errStr)
internal/buildcfg
cfg.go#L382: return "GOAMD64", fmt.Sprintf("v%d", GOAMD64)
cfg.go#L392: return "GOPPC64", fmt.Sprintf("power%d", GOPPC64)
cfg.go#L406: list = append(list, fmt.Sprintf("%s.v%d", GOARCH, i))
cfg.go#L412: list = append(list, fmt.Sprintf("%s.%d", GOARCH, i))
cfg.go#L420: list = append(list, fmt.Sprintf("%s.v%d.%d", GOARCH, major, i))
cfg.go#L425: list = append(list, fmt.Sprintf("%s.v%d.%d", GOARCH, 8, i))
cfg.go#L436: list = append(list, fmt.Sprintf("%s.power%d", GOARCH, i))
internal/profile
graph.go#L127: name = append(name, fmt.Sprintf("%016x", i.Address))
graph.go#L136: name = append(name, fmt.Sprintf(":%d", i.Lineno))
graph.go#L460: s = append(s, fmt.Sprintf("%d: %s[flat=%d cum=%d] %x -> %v ", i+1, name, n.Flat, n.Cum, in, out))
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#L296: ss = append(ss, fmt.Sprintf("PeriodType: %s %s", pt.Type, pt.Unit))
profile.go#L298: ss = append(ss, fmt.Sprintf("Period: %d", p.Period))
profile.go#L300: ss = append(ss, fmt.Sprintf("Time: %v", time.Unix(0, p.TimeNanos)))
profile.go#L303: ss = append(ss, fmt.Sprintf("Duration: %v", time.Duration(p.DurationNanos)))
profile.go#L309: sh1 = sh1 + fmt.Sprintf("%s/%s ", s.Type, s.Unit)
profile.go#L315: sv = fmt.Sprintf("%s %10d", sv, v)
profile.go#L319: sv = sv + fmt.Sprintf("%d ", l.ID)
profile.go#L326: ls = ls + fmt.Sprintf("%s:%v ", k, v)
profile.go#L333: ls = ls + fmt.Sprintf("%s:%v ", k, v)
profile.go#L341: locStr := fmt.Sprintf("%6d: %#x ", l.ID, l.Address)
profile.go#L343: locStr = locStr + fmt.Sprintf("M=%d ", m.ID)
profile.go#L351: lnStr = fmt.Sprintf("%s %s:%d s=%d",
profile.go#L381: ss = append(ss, fmt.Sprintf("%d: %#x/%#x/%#x %s %s %s",
log
log.go#L289: l.Output(2, fmt.Sprintf(format, v...))
log.go#L308: s := fmt.Sprintf(format, v...)
log.go#L418: std.Output(2, fmt.Sprintf(format, v...))
log.go#L437: s := fmt.Sprintf(format, v...)
math/big
float.go#L382: return fmt.Sprintf("msb not set in last word %#x of %s", x.mant[m-1], x.Text('p', 0))
int.go#L934: panic(fmt.Sprintf("big: invalid 2nd argument to Int.Jacobi: need odd integer but got %s", y.String()))
natconv.go#L114: 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#L201: simplePart := fmt.Sprintf("%s*%d", key, n)
mime/multipart
writer.go#L91: return fmt.Sprintf("%x", buf[:])
writer.go#L139: fmt.Sprintf(`form-data; name="%s"; filename="%s"`,
writer.go#L150: fmt.Sprintf(`form-data; name="%s"`, escapeQuotes(fieldname)))
net/http
filetransport.go#L130: pr.res.Status = fmt.Sprintf("%d %s", code, StatusText(code))
fs.go#L326: w.Header().Set("Content-Range", fmt.Sprintf("bytes */%d", size))
fs.go#L995: return fmt.Sprintf("bytes %d-%d/%d", r.start, r.start+r.length-1, size)
h2_bundle.go#L1247: panic(fmt.Sprintf("unexpected buffer len=%v", len(p)))
h2_bundle.go#L1380: return fmt.Sprintf("unknown error code 0x%x", uint32(e))
h2_bundle.go#L1387: return fmt.Sprintf("ERR_UNKNOWN_%d", uint32(e))
h2_bundle.go#L1395: return fmt.Sprintf("connection error: %s", http2ErrCode(e))
h2_bundle.go#L1417: return fmt.Sprintf("stream error: stream ID %d; %v; %v", e.StreamID, e.Code, e.Cause)
h2_bundle.go#L1419: return fmt.Sprintf("stream error: stream ID %d; %v", e.StreamID, e.Code)
h2_bundle.go#L1444: return fmt.Sprintf("http2: connection error: %v: %v", e.Code, e.Reason)
h2_bundle.go#L1450: return fmt.Sprintf("invalid pseudo-header %q", string(e))
h2_bundle.go#L1456: return fmt.Sprintf("duplicate pseudo-header %q", string(e))
h2_bundle.go#L1462: return fmt.Sprintf("invalid header field name %q", string(e))
h2_bundle.go#L1468: return fmt.Sprintf("invalid header field value for %q", string(e))
h2_bundle.go#L1627: return fmt.Sprintf("UNKNOWN_FRAME_TYPE_%d", uint8(t))
h2_bundle.go#L2125: fmt.Sprintf("got %s for stream %d; expected CONTINUATION following %s for stream %d",
h2_bundle.go#L2131: fmt.Sprintf("got CONTINUATION for stream %d; expected stream %d",
h2_bundle.go#L2135: return fr.connError(http2ErrCodeProtocol, fmt.Sprintf("unexpected CONTINUATION for stream %d", fh.StreamID))
h2_bundle.go#L2743: return nil, http2connError{http2ErrCodeFrameSize, fmt.Sprintf("PRIORITY frame payload size was %d; want 5", len(payload))}
h2_bundle.go#L3304: panic(fmt.Sprintf("No space found in %q", b))
h2_bundle.go#L3309: panic(fmt.Sprintf("Failed to parse goroutine ID out of %q: %v", b, err))
h2_bundle.go#L3612: return fmt.Sprintf("[%v = %d]", s.ID, s.Val)
h2_bundle.go#L3667: return fmt.Sprintf("UNKNOWN_SETTING_%d", uint16(s))
h2_bundle.go#L4588: sc.rejectConn(http2ErrCodeInadequateSecurity, fmt.Sprintf("Prohibited TLS 1.2 Cipher Suite: %x", sc.tlsState.CipherSuite))
h2_bundle.go#L5097: panic(fmt.Sprintf("unexpected type %T", v))
h2_bundle.go#L5366: panic(fmt.Sprintf("internal error: attempt to send frame on a half-closed-local stream: %v", wr))
h2_bundle.go#L5369: panic(fmt.Sprintf("internal error: attempt to send frame on a closed stream: %v", wr))
h2_bundle.go#L5769: panic(fmt.Sprintf("invariant; can't close stream in state %v", st.state))
h2_bundle.go#L7051: panic(fmt.Sprintf("invalid WriteHeader code %v", code))
h2_bundle.go#L7336: panic(fmt.Sprintf("newWriterAndRequestNoBody(%+v): %v", msg.url, err))
h2_bundle.go#L7444: f(fmt.Sprintf("%s_%s_%s", typ, codeStr, name))
h2_bundle.go#L9496: return fmt.Sprintf("name %q", k)
h2_bundle.go#L9502: return fmt.Sprintf("value for header %q", k)
h2_bundle.go#L9829: return fmt.Sprintf("http2: server sent GOAWAY and closed the connection; LastStreamID=%v, ErrCode=%v, debug=%q",
h2_bundle.go#L9906: f(fmt.Sprintf("read_frame_conn_error_%s", errCode.stringToken()))
h2_bundle.go#L11088: return fmt.Sprintf("writeData(stream=%d, p=%d, endStream=%v)", w.streamID, len(w.p), w.endStream)
h2_bundle.go#L11526: des = fmt.Sprintf("%T", wr.write)
h2_bundle.go#L11528: return fmt.Sprintf("[FrameWriteRequest stream=%d, ch=%v, writer=%v]", wr.StreamID(), wr.done != nil, des)
h2_bundle.go#L11540: panic(fmt.Sprintf("unbuffered done channel passed in for type %T", wr.write))
h2_bundle.go#L11865: panic(fmt.Sprintf("stream %d already opened", streamID))
h2_bundle.go#L11897: panic(fmt.Sprintf("violation of WriteScheduler interface: unknown stream %d", streamID))
h2_bundle.go#L11900: panic(fmt.Sprintf("violation of WriteScheduler interface: stream %d already closed", streamID))
pattern.go#L380: panic(fmt.Sprintf("unknown relationship %q", r1))
pattern.go#L411: return fmt.Sprintf("%s matches the same requests as %s", p1, p2)
pattern.go#L417: return fmt.Sprintf(`%[1]s and %[2]s both match some paths, like %[3]q.
pattern.go#L424: return fmt.Sprintf("%s matches more methods than %s, but has a more specific path pattern", p1, p2)
pattern.go#L427: return fmt.Sprintf("%s matches fewer methods than %s, but has a more general path pattern", p1, p2)
pattern.go#L429: return fmt.Sprintf("bug: unexpected way for two patterns %s and %s to conflict: methods %s, paths %s", p1, p2, mrel, prel)
pattern.go#L519: panic(fmt.Sprintf("literals differ: %q and %q", s1.s, s2.s))
request.go#L465: s := fmt.Sprintf("%s=%s", sanitizeCookieName(c.Name), sanitizeCookieValue(c.Value, c.Quoted))
server.go#L1170: panic(fmt.Sprintf("invalid WriteHeader code %v", code))
server.go#L2266: panic("unexpected type " + fmt.Sprintf("%T", rc))
server.go#L2282: panic("unexpected type " + fmt.Sprintf("%T", rc))
server.go#L2898: pat.loc = fmt.Sprintf("%s:%d", file, line)
server.go#L3993: name: fmt.Sprintf("%s-%d", baseName, uniqNameNext[baseName]),
transfer.go#L648: return &unsupportedTEError{fmt.Sprintf("too many transfer encodings: %q", raw)}
transfer.go#L651: return &unsupportedTEError{fmt.Sprintf("unsupported transfer encoding: %q", raw[0])}
transport.go#L568: return fmt.Sprintf("field name %q", k)
transport.go#L574: return fmt.Sprintf("field value for %q", k)
transport.go#L1031: return fmt.Sprintf("net/http: Transport failed to read from server: %v", e.err)
transport.go#L2060: return fmt.Sprintf("%s|%s%s|%s", k.proxy, k.scheme, h1, k.addr)
transport.go#L2810: panic(fmt.Sprintf("internal error: exactly one of res or err should be set; nil=%v", re.res == nil))
net/http/pprof
pprof.go#L160: fmt.Sprintf("Could not enable CPU profiling: %s", err))
pprof.go#L186: fmt.Sprintf("Could not enable tracing: %s", err))
pprof.go#L270: w.Header().Set("Content-Disposition", fmt.Sprintf(`attachment; filename="%s"`, name))
pprof.go#L335: w.Header().Set("Content-Disposition", fmt.Sprintf(`attachment; filename="%s-delta"`, name))
net/textproto
reader.go#L606: return ProtocolError(fmt.Sprintf("malformed MIME header: missing colon: %q", line))
textproto.go#L41: return fmt.Sprintf("%03d %s", e.Code, e.Msg)
net/url
url.go#L32: 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#L51: keyVals = append(keyVals, fmt.Sprintf("%q:%q", lbl.key, lbl.value))
proto.go#L445: panic(fmt.Sprintf("stack too short to match cached location; stk = %#x, l.pcs = %#x, original stk = %#x", stk, l.pcs, origStk))
runtime/trace
annotation.go#L106: userLog(id, category, fmt.Sprintf(format, args...))
testing
benchmark.go#L46: return fmt.Sprintf("%dx", f.n)
benchmark.go#L420: panic(fmt.Sprintf("unknown loop stop condition: %#x", b.loop.i))
benchmark.go#L648: return fmt.Sprintf("%8d B/op\t%8d allocs/op",
benchmark.go#L655: return fmt.Sprintf("%s-%d", name, n)
example.go#L76: fail = fmt.Sprintf("got:\n%s\nwant (unordered):\n%s\n", stdout, eg.Output)
example.go#L80: 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#L405: name := fmt.Sprintf("%s/%s", f.name, filepath.Base(e.Path))
match.go#L241: name := fmt.Sprintf("%s#%02d", base, n)
testing.go#L720: panic(fmt.Sprintf("testing: f.%s was called inside the fuzz target, use t.%s instead", name, name))
testing.go#L909: return fmt.Sprintf("%.2fs", d.Seconds())
testing.go#L1097: c.log(fmt.Sprintf(format, args...))
testing.go#L1110: c.log(fmt.Sprintf(format, args...))
testing.go#L1124: c.log(fmt.Sprintf(format, args...))
testing.go#L1138: c.log(fmt.Sprintf(format, args...))
testing.go#L1283: dir := fmt.Sprintf("%s%c%03d", c.tempDir, os.PathSeparator, seq)
testing.go#L2460: return fmt.Sprintf("%s%c%s", *outputDir, os.PathSeparator, path)
testing.go#L2484: panic(fmt.Sprintf("test timed out after %v%s", *timeout, extra))
testing.go#L2493: list = append(list, fmt.Sprintf("%s (%v)", k.(string), highPrecisionTimeSince(v.(highPrecisionTime)).Round(time.Second)))
text/tabwriter
tabwriter.go#L480: panic(fmt.Sprintf("tabwriter: panic during %s (%v)", op, e))
text/template
exec.go#L138: format = fmt.Sprintf("template: %s: %s", name, format)
exec.go#L141: format = fmt.Sprintf("template: %s: executing %q at <%s>: %s", location, name, doublePercent(context), format)
funcs.go#L51: "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#L217: l.item = 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#L118: panic(fmt.Sprintf("id (%v) <= evictCount (%v)", id, t.evictCount))
vendor/golang.org/x/net/idna
idna10.0.0.go#L324: return fmt.Sprintf("idna: invalid label %q", e.label)
idna10.0.0.go#L331: 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)