go/src/fmt/fmt_test.go

type renamedBool

type renamedInt

type renamedInt8

type renamedInt16

type renamedInt32

type renamedInt64

type renamedUint

type renamedUint8

type renamedUint16

type renamedUint32

type renamedUint64

type renamedUintptr

type renamedString

type renamedBytes

type renamedFloat32

type renamedFloat64

type renamedComplex64

type renamedComplex128

func TestFmtInterface(t *testing.T) {}

var NaN

var posInf

var negInf

var intVar

var array

var iarray

var slice

var islice

type A

type I

func (i I) String() string {}

type B

type C

type F

func (f F) Format(s State, c rune) {}

type G

func (g G) GoString() string {}

type S

type SI

type P

var pValue

func (p *P) String() string {}

var barray

var bslice

type byteStringer

func (byteStringer) String() string {}

var byteStringerSlice

type byteFormatter

func (byteFormatter) Format(f State, _ rune) {}

var byteFormatterSlice

type writeStringFormatter

func (sf writeStringFormatter) Format(f State, c rune) {}

var fmtTests

// zeroFill generates zero-filled strings of the specified width. The length
// of the suffix (but not the prefix) is compensated for in the width calculation.
func zeroFill(prefix string, width int, suffix string) string {}

func TestSprintf(t *testing.T) {}

// TestComplexFormatting checks that a complex always formats to the same
// thing as if done by hand with two singleton prints.
func TestComplexFormatting(t *testing.T) {}

type SE

var reorderTests

func TestReorder(t *testing.T) {}

func BenchmarkSprintfPadding(b *testing.B) {}

func BenchmarkSprintfEmpty(b *testing.B) {}

func BenchmarkSprintfString(b *testing.B) {}

func BenchmarkSprintfTruncateString(b *testing.B) {}

func BenchmarkSprintfTruncateBytes(b *testing.B) {}

func BenchmarkSprintfSlowParsingPath(b *testing.B) {}

func BenchmarkSprintfQuoteString(b *testing.B) {}

func BenchmarkSprintfInt(b *testing.B) {}

func BenchmarkSprintfIntInt(b *testing.B) {}

func BenchmarkSprintfPrefixedInt(b *testing.B) {}

func BenchmarkSprintfFloat(b *testing.B) {}

func BenchmarkSprintfComplex(b *testing.B) {}

func BenchmarkSprintfBoolean(b *testing.B) {}

func BenchmarkSprintfHexString(b *testing.B) {}

func BenchmarkSprintfHexBytes(b *testing.B) {}

func BenchmarkSprintfBytes(b *testing.B) {}

func BenchmarkSprintfStringer(b *testing.B) {}

func BenchmarkSprintfStructure(b *testing.B) {}

func BenchmarkManyArgs(b *testing.B) {}

func BenchmarkFprintInt(b *testing.B) {}

func BenchmarkFprintfBytes(b *testing.B) {}

func BenchmarkFprintIntNoAlloc(b *testing.B) {}

var mallocBuf

var mallocPointer

var mallocTest

var _

func TestCountMallocs(t *testing.T) {}

type flagPrinter

func (flagPrinter) Format(f State, c rune) {}

var flagtests

func TestFlagParser(t *testing.T) {}

func TestStructPrinter(t *testing.T) {}

func TestSlicePrinter(t *testing.T) {}

// presentInMap checks map printing using substrings so we don't depend on the
// print order.
func presentInMap(s string, a []string, t *testing.T) {}

func TestMapPrinter(t *testing.T) {}

func TestEmptyMap(t *testing.T) {}

// TestBlank checks that Sprint (and hence Print, Fprint) puts spaces in the
// right places, that is, between arg pairs in which neither is a string.
func TestBlank(t *testing.T) {}

// TestBlankln checks that Sprintln (and hence Println, Fprintln) puts spaces in
// the right places, that is, between all arg pairs.
func TestBlankln(t *testing.T) {}

// TestFormatterPrintln checks Formatter with Sprint, Sprintln, Sprintf.
func TestFormatterPrintln(t *testing.T) {}

func args(a ...any) []any {}

var startests

func TestWidthAndPrecision(t *testing.T) {}

type PanicS

// Value receiver.
func (p PanicS) String() string {}

type PanicGo

// Value receiver.
func (p PanicGo) GoString() string {}

type PanicF

// Value receiver.
func (p PanicF) Format(f State, c rune) {}

var panictests

func TestPanics(t *testing.T) {}

var recurCount

type Recur

func (r *Recur) String() string {}

func TestBadVerbRecursion(t *testing.T) {}

func TestIsSpace(t *testing.T) {}

func hideFromVet(s string) string {}

func TestNilDoesNotBecomeTyped(t *testing.T) {}

var formatterFlagTests

func TestFormatterFlags(t *testing.T) {}

func TestParsenum(t *testing.T) {}

const appendResult

const hello

func TestAppendf(t *testing.T) {}

func TestAppend(t *testing.T) {}

func TestAppendln(t *testing.T) {}