func fmt.Sprintf
222 uses
fmt (current package)
print.go#L217: func Sprintf(format string, a ...interface{}) string {
crypto/tls
cipher_suites.go#L108: return fmt.Sprintf("0x%04X", id)
common.go#L806: panic(fmt.Sprintf("tls: unable to generate random session ticket key: %v", err))
common.go#L868: panic(fmt.Sprintf("unable to generate random session ticket key: %v", err))
common.go#L1289: logLine := []byte(fmt.Sprintf("%s %x %x\n", label, clientRandom, secret))
conn.go#L633: msg := fmt.Sprintf("received record with version %x when expecting version %x", vers, c.vers)
conn.go#L647: msg := fmt.Sprintf("oversized record received with length %d", n)
crypto/x509
verify.go#L172: s += fmt.Sprintf(" (possibly because of %q while trying to verify candidate authority certificate %q)", e.hintErr, certName)
verify.go#L545: return CertificateInvalidError{c, CANotAuthorizedForThisName, fmt.Sprintf("%s %q is excluded by constraint %q", nameType, name, constraint)}
verify.go#L571: return CertificateInvalidError{c, CANotAuthorizedForThisName, fmt.Sprintf("%s %q is not permitted by any constraint", nameType, name)}
verify.go#L599: Detail: fmt.Sprintf("current time %s is before %s", now.Format(time.RFC3339), c.NotBefore.Format(time.RFC3339)),
verify.go#L605: Detail: fmt.Sprintf("current time %s is after %s", now.Format(time.RFC3339), c.NotAfter.Format(time.RFC3339)),
x509.go#L738: return fmt.Sprintf("x509: cannot verify signature: insecure algorithm %v", SignatureAlgorithm(e))
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/gob
type.go#L311: return fmt.Sprintf("[%d]%s", a.Len, a.Elem.gobType().safeString(seen))
type.go#L359: return fmt.Sprintf("map[%s]%s", key, elem)
type.go#L391: return fmt.Sprintf("[]%s", s.Elem.gobType().safeString(seen))
type.go#L417: str += fmt.Sprintf("%s %s; ", f.Name, f.Id.gobType().safeString(seen))
type.go#L820: panic(fmt.Sprintf("gob: registering duplicate types for %q: %s != %s", name, t, ut.user))
type.go#L826: panic(fmt.Sprintf("gob: registering duplicate names for %s: %q != %q", ut.user, n, name))
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#L883: e.error(&UnsupportedValueError{v, fmt.Sprintf("encountered a cycle via %s", v.Type())})
encode.go#L939: e.error(&UnsupportedValueError{v, fmt.Sprintf("encountered a cycle via %s", v.Type())})
flag
flag.go#L511: s := fmt.Sprintf(" -%s", flag.Name) // Two spaces before -; see next two comments.
flag.go#L530: s += fmt.Sprintf(" (default %q)", flag.DefValue)
flag.go#L532: s += fmt.Sprintf(" (default %v)", flag.DefValue)
flag.go#L866: msg = fmt.Sprintf("flag redefined: %s", name)
flag.go#L868: msg = fmt.Sprintf("%s flag redefined: %s", f.name, name)
go.etcd.io/bbolt
bucket.go#L556: panic(fmt.Sprintf("misplaced bucket header: %x -> %x", []byte(name), k))
bucket.go#L559: panic(fmt.Sprintf("unexpected bucket header flag: %x", flags))
bucket.go#L577: panic(fmt.Sprintf("pgid (%d) above high water mark (%d)", b.rootNode.pgid, b.tx.meta.pgid))
bucket.go#L710: panic(fmt.Sprintf("inline bucket non-zero page access(2): %d != 0", id))
cursor.go#L250: panic(fmt.Sprintf("invalid page type: %d: %x", p.id, p.flags))
db.go#L167: return fmt.Sprintf("bolt.DB{path:%q}", db.path)
db.go#L172: return fmt.Sprintf("DB<%q>", db.path)
db.go#L851: return fmt.Sprintf("panic: %v", p.reason)
db.go#L1003: panic(fmt.Sprintf("freepages: failed to get all reachable pages (%v)", e))
db.go#L1146: panic(fmt.Sprintf("root bucket pgid (%d) above high water mark (%d)", m.root.root, m.pgid))
db.go#L1149: panic(fmt.Sprintf("freelist pgid (%d) above high water mark (%d)", m.freelist, m.pgid))
db.go#L1172: panic(fmt.Sprintf("assertion failed: "+msg, v...))
freelist.go#L117: panic(fmt.Sprintf("invalid page allocation: %d", id))
freelist.go#L155: panic(fmt.Sprintf("cannot free page 0 or 1: %d", p.id))
freelist.go#L175: panic(fmt.Sprintf("page %d already freed", id))
freelist.go#L266: panic(fmt.Sprintf("invalid freelist page: %d, page type is %s", p.id, p.typ()))
freelist.go#L276: panic(fmt.Sprintf("leading element count %d overflows int", c))
node.go#L75: panic(fmt.Sprintf("invalid childAt(%d) on a leaf node", index))
node.go#L118: panic(fmt.Sprintf("pgid (%d) above high water mark (%d)", pgid, n.bucket.tx.meta.pgid))
node.go#L200: panic(fmt.Sprintf("inode overflow: %d (pgid=%d)", len(n.inodes), p.id))
node.go#L371: panic(fmt.Sprintf("pgid (%d) above high water mark (%d)", p.id, tx.meta.pgid))
page.go#L48: return fmt.Sprintf("unknown<%02x>", p.flags)
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))
log
log.go#L191: l.Output(2, fmt.Sprintf(format, v...))
log.go#L210: l.Output(2, fmt.Sprintf(format, v...))
log.go#L229: s := fmt.Sprintf(format, v...)
log.go#L323: std.Output(2, fmt.Sprintf(format, v...))
log.go#L340: std.Output(2, fmt.Sprintf(format, v...))
log.go#L359: s := fmt.Sprintf(format, v...)
math/big
float.go#L376: 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#L211: 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#L857: return fmt.Sprintf("bytes %d-%d/%d", r.start, r.start+r.length-1, size)
h2_bundle.go#L1000: panic(fmt.Sprintf("unexpected buffer len=%v", len(p)))
h2_bundle.go#L1132: return fmt.Sprintf("unknown error code 0x%x", uint32(e))
h2_bundle.go#L1140: return fmt.Sprintf("connection error: %s", http2ErrCode(e))
h2_bundle.go#L1157: return fmt.Sprintf("stream error: stream ID %d; %v; %v", e.StreamID, e.Code, e.Cause)
h2_bundle.go#L1159: return fmt.Sprintf("stream error: stream ID %d; %v", e.StreamID, e.Code)
h2_bundle.go#L1184: return fmt.Sprintf("http2: connection error: %v: %v", e.Code, e.Reason)
h2_bundle.go#L1190: return fmt.Sprintf("invalid pseudo-header %q", string(e))
h2_bundle.go#L1196: return fmt.Sprintf("duplicate pseudo-header %q", string(e))
h2_bundle.go#L1202: return fmt.Sprintf("invalid header field name %q", string(e))
h2_bundle.go#L1208: return fmt.Sprintf("invalid header field value %q", string(e))
h2_bundle.go#L1299: return fmt.Sprintf("UNKNOWN_FRAME_TYPE_%d", uint8(t))
h2_bundle.go#L1788: fmt.Sprintf("got %s for stream %d; expected CONTINUATION following %s for stream %d",
h2_bundle.go#L1794: fmt.Sprintf("got CONTINUATION for stream %d; expected stream %d",
h2_bundle.go#L1798: return fr.connError(http2ErrCodeProtocol, fmt.Sprintf("unexpected CONTINUATION for stream %d", fh.StreamID))
h2_bundle.go#L2376: return nil, http2connError{http2ErrCodeFrameSize, fmt.Sprintf("PRIORITY frame payload size was %d; want 5", len(payload))}
h2_bundle.go#L2916: panic(fmt.Sprintf("No space found in %q", b))
h2_bundle.go#L2921: panic(fmt.Sprintf("Failed to parse goroutine ID out of %q: %v", b, err))
h2_bundle.go#L3194: return fmt.Sprintf("[%v = %d]", s.ID, s.Val)
h2_bundle.go#L3243: return fmt.Sprintf("UNKNOWN_SETTING_%d", uint16(s))
h2_bundle.go#L4030: sc.rejectConn(http2ErrCodeInadequateSecurity, fmt.Sprintf("Prohibited TLS 1.2 Cipher Suite: %x", sc.tlsState.CipherSuite))
h2_bundle.go#L4471: panic(fmt.Sprintf("unexpected type %T", v))
h2_bundle.go#L4715: panic(fmt.Sprintf("internal error: attempt to send frame on a half-closed-local stream: %v", wr))
h2_bundle.go#L4718: panic(fmt.Sprintf("internal error: attempt to send frame on a closed stream: %v", wr))
h2_bundle.go#L5080: panic(fmt.Sprintf("invariant; can't close stream in state %v", st.state))
h2_bundle.go#L6194: panic(fmt.Sprintf("invalid WriteHeader code %v", code))
h2_bundle.go#L6458: panic(fmt.Sprintf("newWriterAndRequestNoBody(%+v): %v", msg.url, err))
h2_bundle.go#L8261: return fmt.Sprintf("http2: server sent GOAWAY and closed the connection; LastStreamID=%v, ErrCode=%v, debug=%q",
h2_bundle.go#L9353: return fmt.Sprintf("writeData(stream=%d, p=%d, endStream=%v)", w.streamID, len(w.p), w.endStream)
h2_bundle.go#L9772: des = fmt.Sprintf("%T", wr.write)
h2_bundle.go#L9774: return fmt.Sprintf("[FrameWriteRequest stream=%d, ch=%v, writer=%v]", wr.StreamID(), wr.done != nil, des)
h2_bundle.go#L9786: panic(fmt.Sprintf("unbuffered done channel passed in for type %T", wr.write))
h2_bundle.go#L10110: panic(fmt.Sprintf("stream %d already opened", streamID))
h2_bundle.go#L10142: panic(fmt.Sprintf("violation of WriteScheduler interface: unknown stream %d", streamID))
h2_bundle.go#L10145: panic(fmt.Sprintf("violation of WriteScheduler interface: stream %d already closed", streamID))
request.go#L434: s := fmt.Sprintf("%s=%s", sanitizeCookieName(c.Name), sanitizeCookieValue(c.Value))
server.go#L1112: panic(fmt.Sprintf("invalid WriteHeader code %v", code))
server.go#L2041: panic("unexpected type " + fmt.Sprintf("%T", rc))
server.go#L2057: panic("unexpected type " + fmt.Sprintf("%T", rc))
server.go#L3478: name: fmt.Sprintf("%s-%d", baseName, uniqNameNext[baseName]),
transfer.go#L639: return &unsupportedTEError{fmt.Sprintf("too many transfer encodings: %q", raw)}
transfer.go#L642: return &unsupportedTEError{fmt.Sprintf("unsupported transfer encoding: %q", raw[0])}
transport.go#L883: return fmt.Sprintf("net/http: Transport failed to read from server: %v", e.err)
transport.go#L1860: return fmt.Sprintf("%s|%s%s|%s", k.proxy, k.scheme, h1, k.addr)
transport.go#L2643: panic(fmt.Sprintf("internal error: exactly one of res or err should be set; nil=%v", re.res == nil))
net/textproto
reader.go#L559: 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...))
src.elv.sh/pkg/cli/mode
histlist.go#L106: return ui.T(fmt.Sprintf("%4d %s", entry.Seq, entry.Text))
histwalk.go#L40: content := modeLine(fmt.Sprintf(" HISTORY #%d ", cmd.Seq), false)
lastcmd.go#L123: return ui.T(fmt.Sprintf("%3s %s", index, entry.content))
location.go#L168: return ui.T(fmt.Sprintf("%s %s",
location.go#L178: return fmt.Sprintf("%3.0f", f)
src.elv.sh/pkg/cli/term
reader.go#L36: return fmt.Sprintf("%s: %q", err.msg, err.seq)
setup.go#L56: s += fmt.Sprintf("\033[?7h%s%*s\r \r", lackEOL, width-wcwidth.OfRune(lackEOLRune), "")
src.elv.sh/pkg/cli/tk
listbox_state.go#L39: return ui.T(fmt.Sprintf("%s%d", prefix, i), it.Style)
src.elv.sh/pkg/diag
context.go#L116: return fmt.Sprintf("line %d:", info.BeginLine)
context.go#L118: return fmt.Sprintf("line %d-%d:", info.BeginLine, info.EndLine)
error.go#L14: return fmt.Sprintf("%s: %d-%d in %s: %s",
error.go#L25: header := fmt.Sprintf("%s: \033[31;1m%s\033[m\n", e.Type, e.Message)
show_error.go#L25: Complain(w, fmt.Sprintf(format, args...))
src.elv.sh/pkg/edit
completion.go#L297: return fmt.Sprintf("(edit:complex-candidate %s &code-suffix=%s &display=%s)",
config_api.go#L113: name := fmt.Sprintf("%s[%d]", name, i)
config_api.go#L137: name := fmt.Sprintf("%s[%d]", name, i)
editor.go#L126: ed.app.Notify(fmt.Sprintf(format, args...))
src.elv.sh/pkg/eval
builtin_fn_container.go#L120: Actual: fmt.Sprintf("%v with %v elements", vals.Kind(v), l)}
builtin_fn_container.go#L810: Actual: fmt.Sprintf("%d values", len(outputs))}
builtin_fn_misc.go#L236: src := parse.Source{Name: fmt.Sprintf("[eval %d]", nextEvalCount()), Code: code}
closure.go#L51: return fmt.Sprintf("", c)
closure.go#L167: return fmt.Sprintf("unsupported option: %s", er.Options[0])
closure.go#L169: return fmt.Sprintf("unsupported options: %s", strings.Join(er.Options, ", "))
compile_effect.go#L463: func (err invalidFD) Error() string { return fmt.Sprintf("invalid fd: %d", err.fd) }
compiler.go#L93: Message: fmt.Sprintf(format, args...),
exception.go#L245: return fmt.Sprintf("!(BAD FLOW: %d)", f)
exception.go#L293: causeDescription := quotedName + " stopped by signal " + fmt.Sprintf("%s (pid=%d)", ws.StopSignal(), exit.Pid)
exception.go#L296: causeDescription += fmt.Sprintf(" (trapped %v)", trap)
ns.go#L72: return fmt.Sprintf("", ns)
src.elv.sh/pkg/eval/errs
errs.go#L20: return fmt.Sprintf(
errs.go#L23: return fmt.Sprintf(
errs.go#L38: return fmt.Sprintf(
errs.go#L54: return fmt.Sprintf("arity mismatch: %v must be %v, but is %v",
errs.go#L57: return fmt.Sprintf("arity mismatch: %v must be %v or more values, but is %v",
errs.go#L60: return fmt.Sprintf("arity mismatch: %v must be %v to %v values, but is %v",
errs.go#L81: return fmt.Sprintf("cannot set read-only variable %q", e.VarName)
src.elv.sh/pkg/eval/evaltest
matchers.go#L65: return fmt.Sprintf("exception with reason %v", e.reason)
matchers.go#L67: return fmt.Sprintf("exception with reason %v and stacks %v", e.reason, e.stacks)
matchers.go#L96: func (e errWithType) Error() string { return fmt.Sprintf("error with type %T", e.v) }
src.elv.sh/pkg/eval/mods/unix
umask.go#L64: return fmt.Sprintf("0o%03o", umask)
umask.go#L100: Actual: fmt.Sprintf("0o%o", umask)}
src.elv.sh/pkg/eval/vals
concat.go#L32: return fmt.Sprintf("cannot concatenate %s and %s", err.lhsKind, err.rhsKind)
conversion.go#L37: return fmt.Sprintf("wrong type: need %s, got %s", err.wantKind, err.gotKind)
conversion.go#L46: return fmt.Sprintf("cannot parse as %s: %s", err.want, err.repr)
kind.go#L43: return fmt.Sprintf("!!%T", v)
num.go#L164: panic("invalid num type " + fmt.Sprintf("%T", n))
pipe.go#L45: return fmt.Sprintf("", p.ReadEnd.Fd(), p.WriteEnd.Fd())
repr.go#L58: return fmt.Sprintf("", parse.Quote(v.Name()), v.Fd())
repr.go#L77: return fmt.Sprintf("", v)
src.elv.sh/pkg/parse
pprint.go#L127: return fmt.Sprintf("%s %s %d-%d", reflect.TypeOf(n).Elem().Name(),
source.go#L27: return fmt.Sprintf(
src.elv.sh/pkg/persistent/vector
vector.go#L413: return fmt.Sprintf("element %d: %s", err.index, err.cause)
src.elv.sh/pkg/shell
interact.go#L106: src := parse.Source{Name: fmt.Sprintf("[tty %v]", cmdNum), Code: line}
paths_unix.go#L42: tmpDirPath := filepath.Join(os.TempDir(), fmt.Sprintf("elvish-%d", os.Getuid()))
src.elv.sh/pkg/store
temp_store.go#L14: panic(fmt.Sprintf("Failed to open temp file: %v", err))
temp_store.go#L18: panic(fmt.Sprintf("Failed to create Store instance: %v", err))
src.elv.sh/pkg/testutil
testdir.go#L99: panic(fmt.Sprintf("file is neither string, Dir, or Symlink: %v", file))
src.elv.sh/pkg/tt
tt.go#L81: argsString = fmt.Sprintf(fn.argsFmt, test.args...)
tt.go#L87: retsString = fmt.Sprintf(fn.retsFmt, rets...)
tt.go#L88: wantRetsString = fmt.Sprintf(fn.retsFmt, retsMatcher...)
src.elv.sh/pkg/ui
color.go#L92: return fmt.Sprintf("#%02x%02x%02x", c.r, c.g, c.b)
color.go#L96: return fmt.Sprintf("%d;%d;%d", c.r, c.g, c.b)
text.go#L41: return fmt.Sprintf("(ui:text %s)", buf.String())
text_segment.go#L50: return fmt.Sprintf("(ui:text-segment %s %s)", s.Text, strings.TrimSpace(buf.String()))
text_segment.go#L165: return fmt.Sprintf("\033[%sm%s\033[m", sgr, s.Text)
src.elv.sh/pkg/web
web.go#L66: addr := fmt.Sprintf("localhost:%d", web.Port)
testing
benchmark.go#L45: return fmt.Sprintf("%dx", f.n)
benchmark.go#L481: return fmt.Sprintf("%8d B/op\t%8d allocs/op",
benchmark.go#L488: 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)
match.go#L115: name := fmt.Sprintf("%s/%s", parent, subname)
match.go#L128: name = fmt.Sprintf("%s#%02d", name, next)
testing.go#L625: return fmt.Sprintf("%.2fs", d.Seconds())
testing.go#L792: func (c *common) Logf(format string, args ...interface{}) { c.log(fmt.Sprintf(format, args...)) }
testing.go#L802: c.log(fmt.Sprintf(format, args...))
testing.go#L814: c.log(fmt.Sprintf(format, args...))
testing.go#L826: c.log(fmt.Sprintf(format, args...))
testing.go#L959: dir := fmt.Sprintf("%s%c%03d", c.tempDir, os.PathSeparator, seq)
testing.go#L1687: return fmt.Sprintf("%s%c%s", *outputDir, os.PathSeparator, path)
testing.go#L1700: panic(fmt.Sprintf("test timed out after %v", *timeout))
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#L291: return fmt.Sprintf("idna: invalid label %q", e.label)
idna10.0.0.go#L298: 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)