...

Source file src/fmt/fmt_test.go

     1	// Copyright 2009 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	package fmt_test
     6	
     7	import (
     8		"bytes"
     9		. "fmt"
    10		"io"
    11		"math"
    12		"reflect"
    13		"runtime"
    14		"strings"
    15		"testing"
    16		"time"
    17		"unicode"
    18	)
    19	
    20	type (
    21		renamedBool       bool
    22		renamedInt        int
    23		renamedInt8       int8
    24		renamedInt16      int16
    25		renamedInt32      int32
    26		renamedInt64      int64
    27		renamedUint       uint
    28		renamedUint8      uint8
    29		renamedUint16     uint16
    30		renamedUint32     uint32
    31		renamedUint64     uint64
    32		renamedUintptr    uintptr
    33		renamedString     string
    34		renamedBytes      []byte
    35		renamedFloat32    float32
    36		renamedFloat64    float64
    37		renamedComplex64  complex64
    38		renamedComplex128 complex128
    39	)
    40	
    41	func TestFmtInterface(t *testing.T) {
    42		var i1 interface{}
    43		i1 = "abc"
    44		s := Sprintf("%s", i1)
    45		if s != "abc" {
    46			t.Errorf(`Sprintf("%%s", empty("abc")) = %q want %q`, s, "abc")
    47		}
    48	}
    49	
    50	const b32 uint32 = 1<<32 - 1
    51	const b64 uint64 = 1<<64 - 1
    52	
    53	var array = [5]int{1, 2, 3, 4, 5}
    54	var iarray = [4]interface{}{1, "hello", 2.5, nil}
    55	var slice = array[:]
    56	var islice = iarray[:]
    57	
    58	type A struct {
    59		i int
    60		j uint
    61		s string
    62		x []int
    63	}
    64	
    65	type I int
    66	
    67	func (i I) String() string { return Sprintf("<%d>", int(i)) }
    68	
    69	type B struct {
    70		I I
    71		j int
    72	}
    73	
    74	type C struct {
    75		i int
    76		B
    77	}
    78	
    79	type F int
    80	
    81	func (f F) Format(s State, c rune) {
    82		Fprintf(s, "<%c=F(%d)>", c, int(f))
    83	}
    84	
    85	type G int
    86	
    87	func (g G) GoString() string {
    88		return Sprintf("GoString(%d)", int(g))
    89	}
    90	
    91	type S struct {
    92		F F // a struct field that Formats   // Format 方法的结构字段
    93		G G // a struct field that GoStrings // GoString 方法的结构字段
    94	}
    95	
    96	type SI struct {
    97		I interface{}
    98	}
    99	
   100	// P is a type with a String method with pointer receiver for testing %p.
   101	
   102	// P 为用于测试 %p 的类型,该类型有带指针接收者的 String 方法
   103	type P int
   104	
   105	var pValue P
   106	
   107	func (p *P) String() string {
   108		return "String(p)"
   109	}
   110	
   111	var barray = [5]renamedUint8{1, 2, 3, 4, 5}
   112	var bslice = barray[:]
   113	
   114	type byteStringer byte
   115	
   116	func (byteStringer) String() string { return "X" }
   117	
   118	var byteStringerSlice = []byteStringer{97, 98, 99, 100}
   119	
   120	type byteFormatter byte
   121	
   122	func (byteFormatter) Format(f State, _ rune) {
   123		Fprint(f, "X")
   124	}
   125	
   126	var byteFormatterSlice = []byteFormatter{97, 98, 99, 100}
   127	
   128	var b byte
   129	
   130	var fmtTests = []struct {
   131		fmt string
   132		val interface{}
   133		out string
   134	}{
   135		{"%d", 12345, "12345"},
   136		{"%v", 12345, "12345"},
   137		{"%t", true, "true"},
   138	
   139		// basic string
   140		// 基本字符串
   141		{"%s", "abc", "abc"},
   142		{"%q", "abc", `"abc"`},
   143		{"%x", "abc", "616263"},
   144		{"%x", "\xff\xf0\x0f\xff", "fff00fff"},
   145		{"%X", "\xff\xf0\x0f\xff", "FFF00FFF"},
   146		{"%x", "xyz", "78797a"},
   147		{"%X", "xyz", "78797A"},
   148		{"% x", "xyz", "78 79 7a"},
   149		{"% X", "xyz", "78 79 7A"},
   150		{"%#x", "xyz", "0x78797a"},
   151		{"%#X", "xyz", "0X78797A"},
   152		{"%# x", "xyz", "0x78 0x79 0x7a"},
   153		{"%# X", "xyz", "0X78 0X79 0X7A"},
   154	
   155		// basic bytes
   156		// 基本字节
   157		{"%s", []byte("abc"), "abc"},
   158		{"%q", []byte("abc"), `"abc"`},
   159		{"%x", []byte("abc"), "616263"},
   160		{"%x", []byte("\xff\xf0\x0f\xff"), "fff00fff"},
   161		{"%X", []byte("\xff\xf0\x0f\xff"), "FFF00FFF"},
   162		{"%x", []byte("xyz"), "78797a"},
   163		{"%X", []byte("xyz"), "78797A"},
   164		{"% x", []byte("xyz"), "78 79 7a"},
   165		{"% X", []byte("xyz"), "78 79 7A"},
   166		{"%#x", []byte("xyz"), "0x78797a"},
   167		{"%#X", []byte("xyz"), "0X78797A"},
   168		{"%# x", []byte("xyz"), "0x78 0x79 0x7a"},
   169		{"%# X", []byte("xyz"), "0X78 0X79 0X7A"},
   170	
   171		// escaped strings
   172		// 转义字符串
   173		{"%#q", `abc`, "`abc`"},
   174		{"%#q", `"`, "`\"`"},
   175		{"1 %#q", `\n`, "1 `\\n`"},
   176		{"2 %#q", "\n", `2 "\n"`},
   177		{"%q", `"`, `"\""`},
   178		{"%q", "\a\b\f\r\n\t\v", `"\a\b\f\r\n\t\v"`},
   179		{"%q", "abc\xffdef", `"abc\xffdef"`},
   180		{"%q", "\u263a", `"☺"`},
   181		{"%+q", "\u263a", `"\u263a"`},
   182		{"%q", "\U0010ffff", `"\U0010ffff"`},
   183	
   184		// escaped characters
   185		// 转义字符
   186		{"%q", 'x', `'x'`},
   187		{"%q", 0, `'\x00'`},
   188		{"%q", '\n', `'\n'`},
   189		{"%q", '\u0e00', `'\u0e00'`},         // not a printable rune.
   190		{"%q", '\U000c2345', `'\U000c2345'`}, // not a printable rune.
   191		{"%q", int64(0x7FFFFFFF), `%!q(int64=2147483647)`},
   192		{"%q", uint64(0xFFFFFFFF), `%!q(uint64=4294967295)`},
   193		{"%q", '"', `'"'`},
   194		{"%q", '\'', `'\''`},
   195		{"%q", "\u263a", `"☺"`},
   196		{"%+q", "\u263a", `"\u263a"`},
   197	
   198		// width
   199		// 宽度
   200		{"%5s", "abc", "  abc"},
   201		{"%2s", "\u263a", " ☺"},
   202		{"%-5s", "abc", "abc  "},
   203		{"%-8q", "abc", `"abc"   `},
   204		{"%05s", "abc", "00abc"},
   205		{"%08q", "abc", `000"abc"`},
   206		{"%5s", "abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwxyz"},
   207		{"%.5s", "abcdefghijklmnopqrstuvwxyz", "abcde"},
   208		{"%.5s", "日本語日本語", "日本語日本"},
   209		{"%.5s", []byte("日本語日本語"), "日本語日本"},
   210		{"%.5q", "abcdefghijklmnopqrstuvwxyz", `"abcde"`},
   211		{"%.5x", "abcdefghijklmnopqrstuvwxyz", `6162636465`},
   212		{"%.5q", []byte("abcdefghijklmnopqrstuvwxyz"), `"abcde"`},
   213		{"%.5x", []byte("abcdefghijklmnopqrstuvwxyz"), `6162636465`},
   214		{"%.3q", "日本語日本語", `"日本語"`},
   215		{"%.3q", []byte("日本語日本語"), `"日本語"`},
   216		{"%.1q", "日本語", `"日"`},
   217		{"%.1q", []byte("日本語"), `"日"`},
   218		{"%.1x", "日本語", `e6`},
   219		{"%.1X", []byte("日本語"), `E6`},
   220		{"%10.1q", "日本語日本語", `       "日"`},
   221		{"%3c", '⌘', "  ⌘"},
   222		{"%5q", '\u2026', `  '…'`},
   223		{"%10v", nil, "     <nil>"},
   224		{"%-10v", nil, "<nil>     "},
   225	
   226		// integers
   227		// 整数
   228		{"%d", 12345, "12345"},
   229		{"%d", -12345, "-12345"},
   230		{"%10d", 12345, "     12345"},
   231		{"%10d", -12345, "    -12345"},
   232		{"%+10d", 12345, "    +12345"},
   233		{"%010d", 12345, "0000012345"},
   234		{"%010d", -12345, "-000012345"},
   235		{"%-10d", 12345, "12345     "},
   236		{"%010.3d", 1, "       001"},
   237		{"%010.3d", -1, "      -001"},
   238		{"%+d", 12345, "+12345"},
   239		{"%+d", -12345, "-12345"},
   240		{"%+d", 0, "+0"},
   241		{"% d", 0, " 0"},
   242		{"% d", 12345, " 12345"},
   243		{"%.0d", 0, ""},
   244		{"%.d", 0, ""},
   245	
   246		// unicode format
   247		// Unicode格式
   248		{"%U", 0x1, "U+0001"},
   249		{"%U", uint(0x1), "U+0001"},
   250		{"%.8U", 0x2, "U+00000002"},
   251		{"%U", 0x1234, "U+1234"},
   252		{"%U", 0x12345, "U+12345"},
   253		{"%10.6U", 0xABC, "  U+000ABC"},
   254		{"%-10.6U", 0xABC, "U+000ABC  "},
   255		{"%U", '\n', `U+000A`},
   256		{"%#U", '\n', `U+000A`},
   257		{"%U", 'x', `U+0078`},
   258		{"%#U", 'x', `U+0078 'x'`},
   259		{"%U", '\u263a', `U+263A`},
   260		{"%#U", '\u263a', `U+263A '☺'`},
   261	
   262		// floats
   263		// 浮点数
   264		{"%+.3e", 0.0, "+0.000e+00"},
   265		{"%+.3e", 1.0, "+1.000e+00"},
   266		{"%+.3f", -1.0, "-1.000"},
   267		{"%+.3F", -1.0, "-1.000"},
   268		{"%+.3F", float32(-1.0), "-1.000"},
   269		{"%+07.2f", 1.0, "+001.00"},
   270		{"%+07.2f", -1.0, "-001.00"},
   271		{"%+10.2f", +1.0, "     +1.00"},
   272		{"%+10.2f", -1.0, "     -1.00"},
   273		{"% .3E", -1.0, "-1.000E+00"},
   274		{"% .3e", 1.0, " 1.000e+00"},
   275		{"%+.3g", 0.0, "+0"},
   276		{"%+.3g", 1.0, "+1"},
   277		{"%+.3g", -1.0, "-1"},
   278		{"% .3g", -1.0, "-1"},
   279		{"% .3g", 1.0, " 1"},
   280		{"%b", float32(1.0), "8388608p-23"},
   281		{"%b", 1.0, "4503599627370496p-52"},
   282	
   283		// complex values
   284		// 复数
   285		{"%+.3e", 0i, "(+0.000e+00+0.000e+00i)"},
   286		{"%+.3f", 0i, "(+0.000+0.000i)"},
   287		{"%+.3g", 0i, "(+0+0i)"},
   288		{"%+.3e", 1 + 2i, "(+1.000e+00+2.000e+00i)"},
   289		{"%+.3f", 1 + 2i, "(+1.000+2.000i)"},
   290		{"%+.3g", 1 + 2i, "(+1+2i)"},
   291		{"%.3e", 0i, "(0.000e+00+0.000e+00i)"},
   292		{"%.3f", 0i, "(0.000+0.000i)"},
   293		{"%.3F", 0i, "(0.000+0.000i)"},
   294		{"%.3F", complex64(0i), "(0.000+0.000i)"},
   295		{"%.3g", 0i, "(0+0i)"},
   296		{"%.3e", 1 + 2i, "(1.000e+00+2.000e+00i)"},
   297		{"%.3f", 1 + 2i, "(1.000+2.000i)"},
   298		{"%.3g", 1 + 2i, "(1+2i)"},
   299		{"%.3e", -1 - 2i, "(-1.000e+00-2.000e+00i)"},
   300		{"%.3f", -1 - 2i, "(-1.000-2.000i)"},
   301		{"%.3g", -1 - 2i, "(-1-2i)"},
   302		{"% .3E", -1 - 2i, "(-1.000E+00-2.000E+00i)"},
   303		{"%+.3g", complex64(1 + 2i), "(+1+2i)"},
   304		{"%+.3g", complex128(1 + 2i), "(+1+2i)"},
   305		{"%b", complex64(1 + 2i), "(8388608p-23+8388608p-22i)"},
   306		{"%b", 1 + 2i, "(4503599627370496p-52+4503599627370496p-51i)"},
   307	
   308		// erroneous formats
   309		// 错误的的格式
   310		{"", 2, "%!(EXTRA int=2)"},
   311		{"%d", "hello", "%!d(string=hello)"},
   312	
   313		// old test/fmt_test.go
   314		// 旧版 test/fmt_test.go
   315		{"%d", 1234, "1234"},
   316		{"%d", -1234, "-1234"},
   317		{"%d", uint(1234), "1234"},
   318		{"%d", uint32(b32), "4294967295"},
   319		{"%d", uint64(b64), "18446744073709551615"},
   320		{"%o", 01234, "1234"},
   321		{"%#o", 01234, "01234"},
   322		{"%o", uint32(b32), "37777777777"},
   323		{"%o", uint64(b64), "1777777777777777777777"},
   324		{"%x", 0x1234abcd, "1234abcd"},
   325		{"%#x", 0x1234abcd, "0x1234abcd"},
   326		{"%x", b32 - 0x1234567, "fedcba98"},
   327		{"%X", 0x1234abcd, "1234ABCD"},
   328		{"%X", b32 - 0x1234567, "FEDCBA98"},
   329		{"%#X", 0, "0X0"},
   330		{"%x", b64, "ffffffffffffffff"},
   331		{"%b", 7, "111"},
   332		{"%b", b64, "1111111111111111111111111111111111111111111111111111111111111111"},
   333		{"%b", -6, "-110"},
   334		{"%e", 1.0, "1.000000e+00"},
   335		{"%e", 1234.5678e3, "1.234568e+06"},
   336		{"%e", 1234.5678e-8, "1.234568e-05"},
   337		{"%e", -7.0, "-7.000000e+00"},
   338		{"%e", -1e-9, "-1.000000e-09"},
   339		{"%f", 1234.5678e3, "1234567.800000"},
   340		{"%f", 1234.5678e-8, "0.000012"},
   341		{"%f", -7.0, "-7.000000"},
   342		{"%f", -1e-9, "-0.000000"},
   343		{"%g", 1234.5678e3, "1.2345678e+06"},
   344		{"%g", float32(1234.5678e3), "1.2345678e+06"},
   345		{"%g", 1234.5678e-8, "1.2345678e-05"},
   346		{"%g", -7.0, "-7"},
   347		{"%g", -1e-9, "-1e-09"},
   348		{"%g", float32(-1e-9), "-1e-09"},
   349		{"%E", 1.0, "1.000000E+00"},
   350		{"%E", 1234.5678e3, "1.234568E+06"},
   351		{"%E", 1234.5678e-8, "1.234568E-05"},
   352		{"%E", -7.0, "-7.000000E+00"},
   353		{"%E", -1e-9, "-1.000000E-09"},
   354		{"%G", 1234.5678e3, "1.2345678E+06"},
   355		{"%G", float32(1234.5678e3), "1.2345678E+06"},
   356		{"%G", 1234.5678e-8, "1.2345678E-05"},
   357		{"%G", -7.0, "-7"},
   358		{"%G", -1e-9, "-1E-09"},
   359		{"%G", float32(-1e-9), "-1E-09"},
   360		{"%c", 'x', "x"},
   361		{"%c", 0xe4, "ä"},
   362		{"%c", 0x672c, "本"},
   363		{"%c", '日', "日"},
   364		{"%20.8d", 1234, "            00001234"},
   365		{"%20.8d", -1234, "           -00001234"},
   366		{"%20d", 1234, "                1234"},
   367		{"%-20.8d", 1234, "00001234            "},
   368		{"%-20.8d", -1234, "-00001234           "},
   369		{"%-#20.8x", 0x1234abc, "0x01234abc          "},
   370		{"%-#20.8X", 0x1234abc, "0X01234ABC          "},
   371		{"%-#20.8o", 01234, "00001234            "},
   372		{"%.20b", 7, "00000000000000000111"},
   373		{"%20.5s", "qwertyuiop", "               qwert"},
   374		{"%.5s", "qwertyuiop", "qwert"},
   375		{"%-20.5s", "qwertyuiop", "qwert               "},
   376		{"%20c", 'x', "                   x"},
   377		{"%-20c", 'x', "x                   "},
   378		{"%20.6e", 1.2345e3, "        1.234500e+03"},
   379		{"%20.6e", 1.2345e-3, "        1.234500e-03"},
   380		{"%20e", 1.2345e3, "        1.234500e+03"},
   381		{"%20e", 1.2345e-3, "        1.234500e-03"},
   382		{"%20.8e", 1.2345e3, "      1.23450000e+03"},
   383		{"%20f", 1.23456789e3, "         1234.567890"},
   384		{"%20f", 1.23456789e-3, "            0.001235"},
   385		{"%20f", 12345678901.23456789, "  12345678901.234568"},
   386		{"%-20f", 1.23456789e3, "1234.567890         "},
   387		{"%20.8f", 1.23456789e3, "       1234.56789000"},
   388		{"%20.8f", 1.23456789e-3, "          0.00123457"},
   389		{"%g", 1.23456789e3, "1234.56789"},
   390		{"%g", 1.23456789e-3, "0.00123456789"},
   391		{"%g", 1.23456789e20, "1.23456789e+20"},
   392		{"%20e", math.Inf(1), "                +Inf"},
   393		{"%-20f", math.Inf(-1), "-Inf                "},
   394		{"%20g", math.NaN(), "                 NaN"},
   395	
   396		// arrays
   397		// 数组
   398		{"%v", array, "[1 2 3 4 5]"},
   399		{"%v", iarray, "[1 hello 2.5 <nil>]"},
   400		{"%v", barray, "[1 2 3 4 5]"},
   401		{"%v", &array, "&[1 2 3 4 5]"},
   402		{"%v", &iarray, "&[1 hello 2.5 <nil>]"},
   403		{"%v", &barray, "&[1 2 3 4 5]"},
   404	
   405		// slices
   406		// 切片
   407		{"%v", slice, "[1 2 3 4 5]"},
   408		{"%v", islice, "[1 hello 2.5 <nil>]"},
   409		{"%v", bslice, "[1 2 3 4 5]"},
   410		{"%v", &slice, "&[1 2 3 4 5]"},
   411		{"%v", &islice, "&[1 hello 2.5 <nil>]"},
   412		{"%v", &bslice, "&[1 2 3 4 5]"},
   413		{"%v", []byte{1}, "[1]"},
   414		{"%v", []byte{}, "[]"},
   415	
   416		// complexes with %v
   417		// 复数的 %v 格式
   418		{"%v", 1 + 2i, "(1+2i)"},
   419		{"%v", complex64(1 + 2i), "(1+2i)"},
   420		{"%v", complex128(1 + 2i), "(1+2i)"},
   421	
   422		// structs
   423		// 结构体
   424		{"%v", A{1, 2, "a", []int{1, 2}}, `{1 2 a [1 2]}`},
   425		{"%+v", A{1, 2, "a", []int{1, 2}}, `{i:1 j:2 s:a x:[1 2]}`},
   426	
   427		// +v on structs with Stringable items
   428		// 拥有可 String 化条目的结构体的 +v 格式
   429		{"%+v", B{1, 2}, `{I:<1> j:2}`},
   430		{"%+v", C{1, B{2, 3}}, `{i:1 B:{I:<2> j:3}}`},
   431	
   432		// other formats on Stringable items
   433		// 可 String 化条目的其它格式
   434		{"%s", I(23), `<23>`},
   435		{"%q", I(23), `"<23>"`},
   436		{"%x", I(23), `3c32333e`},
   437		{"%#x", I(23), `0x3c32333e`},
   438		{"%# x", I(23), `0x3c 0x32 0x33 0x3e`},
   439		{"%d", I(23), `23`}, // Stringer applies only to string formats. // Stringer 只适用于字符串格式。
   440	
   441		// go syntax
   442		// go 语法
   443		{"%#v", A{1, 2, "a", []int{1, 2}}, `fmt_test.A{i:1, j:0x2, s:"a", x:[]int{1, 2}}`},
   444		{"%#v", &b, "(*uint8)(0xPTR)"},
   445		{"%#v", TestFmtInterface, "(func(*testing.T))(0xPTR)"},
   446		{"%#v", make(chan int), "(chan int)(0xPTR)"},
   447		{"%#v", uint64(1<<64 - 1), "0xffffffffffffffff"},
   448		{"%#v", 1000000000, "1000000000"},
   449		{"%#v", map[string]int{"a": 1}, `map[string]int{"a":1}`},
   450		{"%#v", map[string]B{"a": {1, 2}}, `map[string]fmt_test.B{"a":fmt_test.B{I:1, j:2}}`},
   451		{"%#v", []string{"a", "b"}, `[]string{"a", "b"}`},
   452		{"%#v", SI{}, `fmt_test.SI{I:interface {}(nil)}`},
   453		{"%#v", []int(nil), `[]int(nil)`},
   454		{"%#v", []int{}, `[]int{}`},
   455		{"%#v", array, `[5]int{1, 2, 3, 4, 5}`},
   456		{"%#v", &array, `&[5]int{1, 2, 3, 4, 5}`},
   457		{"%#v", iarray, `[4]interface {}{1, "hello", 2.5, interface {}(nil)}`},
   458		{"%#v", &iarray, `&[4]interface {}{1, "hello", 2.5, interface {}(nil)}`},
   459		{"%#v", map[int]byte(nil), `map[int]uint8(nil)`},
   460		{"%#v", map[int]byte{}, `map[int]uint8{}`},
   461		{"%#v", "foo", `"foo"`},
   462		{"%#v", barray, `[5]fmt_test.renamedUint8{0x1, 0x2, 0x3, 0x4, 0x5}`},
   463		{"%#v", bslice, `[]fmt_test.renamedUint8{0x1, 0x2, 0x3, 0x4, 0x5}`},
   464		{"%#v", []byte(nil), "[]byte(nil)"},
   465		{"%#v", []int32(nil), "[]int32(nil)"},
   466	
   467		// slices with other formats
   468		// 切片的其它格式
   469		{"%#x", []int{1, 2, 15}, `[0x1 0x2 0xf]`},
   470		{"%x", []int{1, 2, 15}, `[1 2 f]`},
   471		{"%d", []int{1, 2, 15}, `[1 2 15]`},
   472		{"%d", []byte{1, 2, 15}, `[1 2 15]`},
   473		{"%q", []string{"a", "b"}, `["a" "b"]`},
   474		{"% 02x", []byte{1}, "01"},
   475		{"% 02x", []byte{1, 2, 3}, "01 02 03"},
   476		// Special care for empty slices.
   477		{"%x", []byte{}, ""},
   478		{"%02x", []byte{}, ""},
   479		{"% 02x", []byte{}, ""},
   480	
   481		// renamings
   482		// 类型重命名测试
   483		{"%v", renamedBool(true), "true"},
   484		{"%d", renamedBool(true), "%!d(fmt_test.renamedBool=true)"},
   485		{"%o", renamedInt(8), "10"},
   486		{"%d", renamedInt8(-9), "-9"},
   487		{"%v", renamedInt16(10), "10"},
   488		{"%v", renamedInt32(-11), "-11"},
   489		{"%X", renamedInt64(255), "FF"},
   490		{"%v", renamedUint(13), "13"},
   491		{"%o", renamedUint8(14), "16"},
   492		{"%X", renamedUint16(15), "F"},
   493		{"%d", renamedUint32(16), "16"},
   494		{"%X", renamedUint64(17), "11"},
   495		{"%o", renamedUintptr(18), "22"},
   496		{"%x", renamedString("thing"), "7468696e67"},
   497		{"%d", renamedBytes([]byte{1, 2, 15}), `[1 2 15]`},
   498		{"%q", renamedBytes([]byte("hello")), `"hello"`},
   499		{"%x", []renamedUint8{'a', 'b', 'c'}, "616263"},
   500		{"%s", []renamedUint8{'h', 'e', 'l', 'l', 'o'}, "hello"},
   501		{"%q", []renamedUint8{'h', 'e', 'l', 'l', 'o'}, `"hello"`},
   502		{"%v", renamedFloat32(22), "22"},
   503		{"%v", renamedFloat64(33), "33"},
   504		{"%v", renamedComplex64(3 + 4i), "(3+4i)"},
   505		{"%v", renamedComplex128(4 - 3i), "(4-3i)"},
   506	
   507		// Formatter
   508		// Format 测试
   509		{"%x", F(1), "<x=F(1)>"},
   510		{"%x", G(2), "2"},
   511		{"%+v", S{F(4), G(5)}, "{F:<v=F(4)> G:5}"},
   512	
   513		// GoStringer
   514		// GoString 测试
   515		{"%#v", G(6), "GoString(6)"},
   516		{"%#v", S{F(7), G(8)}, "fmt_test.S{F:<v=F(7)>, G:GoString(8)}"},
   517	
   518		// %T
   519		{"%T", (4 - 3i), "complex128"},
   520		{"%T", renamedComplex128(4 - 3i), "fmt_test.renamedComplex128"},
   521		{"%T", intVal, "int"},
   522		{"%6T", &intVal, "  *int"},
   523		{"%10T", nil, "     <nil>"},
   524		{"%-10T", nil, "<nil>     "},
   525	
   526		// %p
   527		{"p0=%p", new(int), "p0=0xPTR"},
   528		{"p1=%s", &pValue, "p1=String(p)"}, // String method...       // String 方法...
   529		{"p2=%p", &pValue, "p2=0xPTR"},     // ... not called with %p // ...在使用 %p 时不会调用
   530		{"p3=%p", (*int)(nil), "p3=0x0"},
   531		{"p4=%#p", new(int), "p4=PTR"},
   532	
   533		// %p on non-pointers
   534		// %p 作用于非指针类型
   535		{"%p", make(chan int), "0xPTR"},
   536		{"%p", make(map[int]int), "0xPTR"},
   537		{"%p", make([]int, 1), "0xPTR"},
   538		{"%p", 27, "%!p(int=27)"}, // not a pointer at all // 根本就不是指针
   539	
   540		// %q on pointers
   541		// %q 作用于指针类型
   542		{"%q", (*int)(nil), "%!q(*int=<nil>)"},
   543		{"%q", new(int), "%!q(*int=0xPTR)"},
   544	
   545		// %v on pointers formats 0 as <nil>
   546		// %v 作用于指针,会将0格式化为 <nil>
   547		{"%v", (*int)(nil), "<nil>"},
   548		{"%v", new(int), "0xPTR"},
   549	
   550		// %d etc. pointers use specified base.
   551		// %d 等对指针应用具体的基数(进制)。
   552		{"%d", new(int), "PTR_d"},
   553		{"%o", new(int), "PTR_o"},
   554		{"%x", new(int), "PTR_x"},
   555	
   556		// %d on Stringer should give integer if possible
   557		// %d 作用于 Stringer 时,如果可能的话应当返回整数
   558		{"%s", time.Time{}.Month(), "January"},
   559		{"%d", time.Time{}.Month(), "1"},
   560	
   561		// erroneous things
   562		// 错误的的格式化对象
   563		{"%s %", "hello", "hello %!(NOVERB)"},
   564		{"%s %.2", "hello", "hello %!(NOVERB)"},
   565		{"%d", "hello", "%!d(string=hello)"},
   566		{"no args", "hello", "no args%!(EXTRA string=hello)"},
   567		{"%s", nil, "%!s(<nil>)"},
   568		{"%T", nil, "<nil>"},
   569		{"%-1", 100, "%!(NOVERB)%!(EXTRA int=100)"},
   570		{"%017091901790959340919092959340919017929593813360", 0, "%!(NOVERB)%!(EXTRA int=0)"},
   571		{"%184467440737095516170v", 0, "%!(NOVERB)%!(EXTRA int=0)"},
   572	
   573		// The "<nil>" show up because maps are printed by
   574		// first obtaining a list of keys and then looking up
   575		// each key.  Since NaNs can be map keys but cannot
   576		// be fetched directly, the lookup fails and returns a
   577		// zero reflect.Value, which formats as <nil>.
   578		// This test is just to check that it shows the two NaNs at all.
   579		//
   580		// 会显示“<nil>”是因为映射首先会获取键的列表,接着查找每一个键。由于 NaN
   581		// 可作为映射键但不能被直接获取,因此查找会失败并返回一个 reflect.Value
   582		// 的零值,它会被格式化为 <nil>。此测试只会检查它是否会显示两个 NaN。
   583		{"%v", map[float64]int{math.NaN(): 1, math.NaN(): 2}, "map[NaN:<nil> NaN:<nil>]"},
   584	
   585		// Used to crash because nByte didn't allow for a sign.
   586		// 用于崩溃测试,因为 nByte 不接受正负号。
   587		{"%b", int64(-1 << 63), zeroFill("-1", 63, "")},
   588	
   589		// Used to panic.
   590		{"%0100d", 1, zeroFill("", 100, "1")},
   591		{"%0100d", -1, zeroFill("-", 99, "1")},
   592		{"%0.100f", 1.0, zeroFill("1.", 100, "")},
   593		{"%0.100f", -1.0, zeroFill("-1.", 100, "")},
   594	
   595		// Used to panic: integer function didn't look at f.prec or f.unicode or f.width.
   596		{"%#.80x", 42, "0x0000000000000000000000000000000000000000000000000000000000000000000000000000002a"},
   597		{"%.80U", 42, "U+0000000000000000000000000000000000000000000000000000000000000000000000000000002A"},
   598		{"%#.80U", '日', "U+000000000000000000000000000000000000000000000000000000000000000000000000000065E5 '日'"},
   599		{"%+.65d", 44, "+00000000000000000000000000000000000000000000000000000000000000044"},
   600		{"% .65d", 44, " 00000000000000000000000000000000000000000000000000000000000000044"},
   601		{"%  +.65d", 44, "+00000000000000000000000000000000000000000000000000000000000000044"},
   602	
   603		// Comparison of padding rules with C printf.
   604		/*
   605			C program:
   606			#include <stdio.h>
   607	
   608			char *format[] = {
   609				"[%.2f]",
   610				"[% .2f]",
   611				"[%+.2f]",
   612				"[%7.2f]",
   613				"[% 7.2f]",
   614				"[%+7.2f]",
   615				"[%07.2f]",
   616				"[% 07.2f]",
   617				"[%+07.2f]",
   618			};
   619	
   620			int main(void) {
   621				int i;
   622				for(i = 0; i < 9; i++) {
   623					printf("%s: ", format[i]);
   624					printf(format[i], 1.0);
   625					printf(" ");
   626					printf(format[i], -1.0);
   627					printf("\n");
   628				}
   629			}
   630	
   631			Output:
   632				[%.2f]: [1.00] [-1.00]
   633				[% .2f]: [ 1.00] [-1.00]
   634				[%+.2f]: [+1.00] [-1.00]
   635				[%7.2f]: [   1.00] [  -1.00]
   636				[% 7.2f]: [   1.00] [  -1.00]
   637				[%+7.2f]: [  +1.00] [  -1.00]
   638				[%07.2f]: [0001.00] [-001.00]
   639				[% 07.2f]: [ 001.00] [-001.00]
   640				[%+07.2f]: [+001.00] [-001.00]
   641		*/
   642		{"%.2f", 1.0, "1.00"},
   643		{"%.2f", -1.0, "-1.00"},
   644		{"% .2f", 1.0, " 1.00"},
   645		{"% .2f", -1.0, "-1.00"},
   646		{"%+.2f", 1.0, "+1.00"},
   647		{"%+.2f", -1.0, "-1.00"},
   648		{"%7.2f", 1.0, "   1.00"},
   649		{"%7.2f", -1.0, "  -1.00"},
   650		{"% 7.2f", 1.0, "   1.00"},
   651		{"% 7.2f", -1.0, "  -1.00"},
   652		{"%+7.2f", 1.0, "  +1.00"},
   653		{"%+7.2f", -1.0, "  -1.00"},
   654		{"%07.2f", 1.0, "0001.00"},
   655		{"%07.2f", -1.0, "-001.00"},
   656		{"% 07.2f", 1.0, " 001.00"},
   657		{"% 07.2f", -1.0, "-001.00"},
   658		{"%+07.2f", 1.0, "+001.00"},
   659		{"%+07.2f", -1.0, "-001.00"},
   660	
   661		// Complex numbers: exhaustively tested in TestComplexFormatting.
   662		{"%7.2f", 1 + 2i, "(   1.00  +2.00i)"},
   663		{"%+07.2f", -1 - 2i, "(-001.00-002.00i)"},
   664		// Zero padding does not apply to infinities.
   665		{"%020f", math.Inf(-1), "                -Inf"},
   666		{"%020f", math.Inf(+1), "                +Inf"},
   667		{"% 020f", math.Inf(-1), "                -Inf"},
   668		{"% 020f", math.Inf(+1), "                 Inf"},
   669		{"%+020f", math.Inf(-1), "                -Inf"},
   670		{"%+020f", math.Inf(+1), "                +Inf"},
   671		{"%20f", -1.0, "           -1.000000"},
   672		// Make sure we can handle very large widths.
   673		{"%0100f", -1.0, zeroFill("-", 99, "1.000000")},
   674	
   675		// Complex fmt used to leave the plus flag set for future entries in the array
   676		// causing +2+0i and +3+0i instead of 2+0i and 3+0i.
   677		// 复数格式化用于在数组中为将来的条目留下加号,以产生 +2+0i 和 +3+0i 而非 2+0i 和 3+0i
   678		{"%v", []complex64{1, 2, 3}, "[(1+0i) (2+0i) (3+0i)]"},
   679		{"%v", []complex128{1, 2, 3}, "[(1+0i) (2+0i) (3+0i)]"},
   680	
   681		// Incomplete format specification caused crash.
   682		{"%.", 3, "%!.(int=3)"},
   683	
   684		// Used to panic with out-of-bounds for very large numeric representations.
   685		// nByte is set to handle one bit per uint64 in %b format, with a negative number.
   686		// See issue 6777.
   687		{"%#064x", 1, zeroFill("0x", 64, "1")},
   688		{"%#064x", -1, zeroFill("-0x", 63, "1")},
   689		{"%#064b", 1, zeroFill("", 64, "1")},
   690		{"%#064b", -1, zeroFill("-", 63, "1")},
   691		{"%#064o", 1, zeroFill("", 64, "1")},
   692		{"%#064o", -1, zeroFill("-", 63, "1")},
   693		{"%#064d", 1, zeroFill("", 64, "1")},
   694		{"%#064d", -1, zeroFill("-", 63, "1")},
   695		// Test that we handle the crossover above the size of uint64
   696		{"%#072x", 1, zeroFill("0x", 72, "1")},
   697		{"%#072x", -1, zeroFill("-0x", 71, "1")},
   698		{"%#072b", 1, zeroFill("", 72, "1")},
   699		{"%#072b", -1, zeroFill("-", 71, "1")},
   700		{"%#072o", 1, zeroFill("", 72, "1")},
   701		{"%#072o", -1, zeroFill("-", 71, "1")},
   702		{"%#072d", 1, zeroFill("", 72, "1")},
   703		{"%#072d", -1, zeroFill("-", 71, "1")},
   704	
   705		// Padding for complex numbers. Has been bad, then fixed, then bad again.
   706		{"%+10.2f", +104.66 + 440.51i, "(   +104.66   +440.51i)"},
   707		{"%+10.2f", -104.66 + 440.51i, "(   -104.66   +440.51i)"},
   708		{"%+10.2f", +104.66 - 440.51i, "(   +104.66   -440.51i)"},
   709		{"%+10.2f", -104.66 - 440.51i, "(   -104.66   -440.51i)"},
   710		{"%+010.2f", +104.66 + 440.51i, "(+000104.66+000440.51i)"},
   711		{"%+010.2f", -104.66 + 440.51i, "(-000104.66+000440.51i)"},
   712		{"%+010.2f", +104.66 - 440.51i, "(+000104.66-000440.51i)"},
   713		{"%+010.2f", -104.66 - 440.51i, "(-000104.66-000440.51i)"},
   714	
   715		// []T where type T is a byte with a Stringer method.
   716		{"%v", byteStringerSlice, "[X X X X]"},
   717		{"%s", byteStringerSlice, "abcd"},
   718		{"%q", byteStringerSlice, "\"abcd\""},
   719		{"%x", byteStringerSlice, "61626364"},
   720		{"%#v", byteStringerSlice, "[]fmt_test.byteStringer{0x61, 0x62, 0x63, 0x64}"},
   721	
   722		// And the same for Formatter.
   723		{"%v", byteFormatterSlice, "[X X X X]"},
   724		{"%s", byteFormatterSlice, "abcd"},
   725		{"%q", byteFormatterSlice, "\"abcd\""},
   726		{"%x", byteFormatterSlice, "61626364"},
   727		// This next case seems wrong, but the docs say the Formatter wins here.
   728		{"%#v", byteFormatterSlice, "[]fmt_test.byteFormatter{X, X, X, X}"},
   729	
   730		// reflect.Value handled specially in Go 1.5, making it possible to
   731		// see inside non-exported fields (which cannot be accessed with Interface()).
   732		// Issue 8965.
   733		{"%v", reflect.ValueOf(A{}).Field(0).String(), "<int Value>"}, // Equivalent to the old way.
   734		{"%v", reflect.ValueOf(A{}).Field(0), "0"},                    // Sees inside the field.
   735	
   736		// verbs apply to the extracted value too.
   737		{"%s", reflect.ValueOf("hello"), "hello"},
   738		{"%q", reflect.ValueOf("hello"), `"hello"`},
   739		{"%#04x", reflect.ValueOf(256), "0x0100"},
   740	
   741		// invalid reflect.Value doesn't crash.
   742		{"%v", reflect.Value{}, "<invalid reflect.Value>"},
   743	}
   744	
   745	// zeroFill generates zero-filled strings of the specified width. The length
   746	// of the suffix (but not the prefix) is compensated for in the width calculation.
   747	func zeroFill(prefix string, width int, suffix string) string {
   748		return prefix + strings.Repeat("0", width-len(suffix)) + suffix
   749	}
   750	
   751	func TestSprintf(t *testing.T) {
   752		for _, tt := range fmtTests {
   753			s := Sprintf(tt.fmt, tt.val)
   754			if i := strings.Index(tt.out, "PTR"); i >= 0 {
   755				pattern := "PTR"
   756				chars := "0123456789abcdefABCDEF"
   757				switch {
   758				case strings.HasPrefix(tt.out[i:], "PTR_d"):
   759					pattern = "PTR_d"
   760					chars = chars[:10]
   761				case strings.HasPrefix(tt.out[i:], "PTR_o"):
   762					pattern = "PTR_o"
   763					chars = chars[:8]
   764				case strings.HasPrefix(tt.out[i:], "PTR_x"):
   765					pattern = "PTR_x"
   766				}
   767				j := i
   768				for ; j < len(s); j++ {
   769					c := s[j]
   770					if !strings.ContainsRune(chars, rune(c)) {
   771						break
   772					}
   773				}
   774				s = s[0:i] + pattern + s[j:]
   775			}
   776			if s != tt.out {
   777				if _, ok := tt.val.(string); ok {
   778					// Don't requote the already-quoted strings.
   779					// It's too confusing to read the errors.
   780					// 不要给已经加上引号的字符串再加一次引号,这样错误读起来会很困扰的。
   781					t.Errorf("Sprintf(%q, %q) = <%s> want <%s>", tt.fmt, tt.val, s, tt.out)
   782				} else {
   783					t.Errorf("Sprintf(%q, %v) = %q want %q", tt.fmt, tt.val, s, tt.out)
   784				}
   785			}
   786		}
   787	}
   788	
   789	// TestComplexFormatting checks that a complex always formats to the same
   790	// thing as if done by hand with two singleton prints.
   791	func TestComplexFormatting(t *testing.T) {
   792		var yesNo = []bool{true, false}
   793		var values = []float64{1, 0, -1, math.Inf(1), math.Inf(-1), math.NaN()}
   794		for _, plus := range yesNo {
   795			for _, zero := range yesNo {
   796				for _, space := range yesNo {
   797					for _, char := range "fFeEgG" {
   798						realFmt := "%"
   799						if zero {
   800							realFmt += "0"
   801						}
   802						if space {
   803							realFmt += " "
   804						}
   805						if plus {
   806							realFmt += "+"
   807						}
   808						realFmt += "10.2"
   809						realFmt += string(char)
   810						// Imaginary part always has a sign, so force + and ignore space.
   811						imagFmt := "%"
   812						if zero {
   813							imagFmt += "0"
   814						}
   815						imagFmt += "+"
   816						imagFmt += "10.2"
   817						imagFmt += string(char)
   818						for _, realValue := range values {
   819							for _, imagValue := range values {
   820								one := Sprintf(realFmt, complex(realValue, imagValue))
   821								two := Sprintf("("+realFmt+imagFmt+"i)", realValue, imagValue)
   822								if one != two {
   823									t.Error(f, one, two)
   824								}
   825							}
   826						}
   827					}
   828				}
   829			}
   830		}
   831	}
   832	
   833	type SE []interface{} // slice of empty; notational compactness.
   834	
   835	var reorderTests = []struct {
   836		fmt string
   837		val SE
   838		out string
   839	}{
   840		{"%[1]d", SE{1}, "1"},
   841		{"%[2]d", SE{2, 1}, "1"},
   842		{"%[2]d %[1]d", SE{1, 2}, "2 1"},
   843		{"%[2]*[1]d", SE{2, 5}, "    2"},
   844		{"%6.2f", SE{12.0}, " 12.00"}, // Explicit version of next line.
   845		{"%[3]*.[2]*[1]f", SE{12.0, 2, 6}, " 12.00"},
   846		{"%[1]*.[2]*[3]f", SE{6, 2, 12.0}, " 12.00"},
   847		{"%10f", SE{12.0}, " 12.000000"},
   848		{"%[1]*[3]f", SE{10, 99, 12.0}, " 12.000000"},
   849		{"%.6f", SE{12.0}, "12.000000"}, // Explicit version of next line.
   850		{"%.[1]*[3]f", SE{6, 99, 12.0}, "12.000000"},
   851		{"%6.f", SE{12.0}, "    12"}, //  // Explicit version of next line; empty precision means zero.
   852		{"%[1]*.[3]f", SE{6, 3, 12.0}, "    12"},
   853		// An actual use! Print the same arguments twice.
   854		{"%d %d %d %#[1]o %#o %#o", SE{11, 12, 13}, "11 12 13 013 014 015"},
   855	
   856		// Erroneous cases.
   857		{"%[d", SE{2, 1}, "%!d(BADINDEX)"},
   858		{"%]d", SE{2, 1}, "%!](int=2)d%!(EXTRA int=1)"},
   859		{"%[]d", SE{2, 1}, "%!d(BADINDEX)"},
   860		{"%[-3]d", SE{2, 1}, "%!d(BADINDEX)"},
   861		{"%[99]d", SE{2, 1}, "%!d(BADINDEX)"},
   862		{"%[3]", SE{2, 1}, "%!(NOVERB)"},
   863		{"%[1].2d", SE{5, 6}, "%!d(BADINDEX)"},
   864		{"%[1]2d", SE{2, 1}, "%!d(BADINDEX)"},
   865		{"%3.[2]d", SE{7}, "%!d(BADINDEX)"},
   866		{"%.[2]d", SE{7}, "%!d(BADINDEX)"},
   867		{"%d %d %d %#[1]o %#o %#o %#o", SE{11, 12, 13}, "11 12 13 013 014 015 %!o(MISSING)"},
   868		{"%[5]d %[2]d %d", SE{1, 2, 3}, "%!d(BADINDEX) 2 3"},
   869		{"%d %[3]d %d", SE{1, 2}, "1 %!d(BADINDEX) 2"}, // Erroneous index does not affect sequence.
   870		{"%.[]", SE{}, "%!](BADINDEX)"},                // Issue 10675
   871	}
   872	
   873	func TestReorder(t *testing.T) {
   874		for _, tt := range reorderTests {
   875			s := Sprintf(tt.fmt, tt.val...)
   876			if s != tt.out {
   877				t.Errorf("Sprintf(%q, %v) = <%s> want <%s>", tt.fmt, tt.val, s, tt.out)
   878			} else {
   879			}
   880		}
   881	}
   882	
   883	func BenchmarkSprintfEmpty(b *testing.B) {
   884		b.RunParallel(func(pb *testing.PB) {
   885			for pb.Next() {
   886				Sprintf("")
   887			}
   888		})
   889	}
   890	
   891	func BenchmarkSprintfString(b *testing.B) {
   892		b.RunParallel(func(pb *testing.PB) {
   893			for pb.Next() {
   894				Sprintf("%s", "hello")
   895			}
   896		})
   897	}
   898	
   899	func BenchmarkSprintfInt(b *testing.B) {
   900		b.RunParallel(func(pb *testing.PB) {
   901			for pb.Next() {
   902				Sprintf("%d", 5)
   903			}
   904		})
   905	}
   906	
   907	func BenchmarkSprintfIntInt(b *testing.B) {
   908		b.RunParallel(func(pb *testing.PB) {
   909			for pb.Next() {
   910				Sprintf("%d %d", 5, 6)
   911			}
   912		})
   913	}
   914	
   915	func BenchmarkSprintfPrefixedInt(b *testing.B) {
   916		b.RunParallel(func(pb *testing.PB) {
   917			for pb.Next() {
   918				Sprintf("This is some meaningless prefix text that needs to be scanned %d", 6)
   919			}
   920		})
   921	}
   922	
   923	func BenchmarkSprintfFloat(b *testing.B) {
   924		b.RunParallel(func(pb *testing.PB) {
   925			for pb.Next() {
   926				Sprintf("%g", 5.23184)
   927			}
   928		})
   929	}
   930	
   931	func BenchmarkManyArgs(b *testing.B) {
   932		b.RunParallel(func(pb *testing.PB) {
   933			var buf bytes.Buffer
   934			for pb.Next() {
   935				buf.Reset()
   936				Fprintf(&buf, "%2d/%2d/%2d %d:%d:%d %s %s\n", 3, 4, 5, 11, 12, 13, "hello", "world")
   937			}
   938		})
   939	}
   940	
   941	func BenchmarkFprintInt(b *testing.B) {
   942		var buf bytes.Buffer
   943		for i := 0; i < b.N; i++ {
   944			buf.Reset()
   945			Fprint(&buf, 123456)
   946		}
   947	}
   948	
   949	func BenchmarkFprintfBytes(b *testing.B) {
   950		data := []byte(string("0123456789"))
   951		var buf bytes.Buffer
   952		for i := 0; i < b.N; i++ {
   953			buf.Reset()
   954			Fprintf(&buf, "%s", data)
   955		}
   956	}
   957	
   958	func BenchmarkFprintIntNoAlloc(b *testing.B) {
   959		var x interface{} = 123456
   960		var buf bytes.Buffer
   961		for i := 0; i < b.N; i++ {
   962			buf.Reset()
   963			Fprint(&buf, x)
   964		}
   965	}
   966	
   967	var mallocBuf bytes.Buffer
   968	var mallocPointer *int // A pointer so we know the interface value won't allocate.
   969	
   970	var mallocTest = []struct {
   971		count int
   972		desc  string
   973		fn    func()
   974	}{
   975		{0, `Sprintf("")`, func() { Sprintf("") }},
   976		{1, `Sprintf("xxx")`, func() { Sprintf("xxx") }},
   977		{2, `Sprintf("%x")`, func() { Sprintf("%x", 7) }},
   978		{2, `Sprintf("%s")`, func() { Sprintf("%s", "hello") }},
   979		{3, `Sprintf("%x %x")`, func() { Sprintf("%x %x", 7, 112) }},
   980		{2, `Sprintf("%g")`, func() { Sprintf("%g", float32(3.14159)) }}, // TODO: Can this be 1?
   981		{1, `Fprintf(buf, "%s")`, func() { mallocBuf.Reset(); Fprintf(&mallocBuf, "%s", "hello") }},
   982		// If the interface value doesn't need to allocate, amortized allocation overhead should be zero.
   983		{0, `Fprintf(buf, "%x %x %x")`, func() {
   984			mallocBuf.Reset()
   985			Fprintf(&mallocBuf, "%x %x %x", mallocPointer, mallocPointer, mallocPointer)
   986		}},
   987	}
   988	
   989	var _ bytes.Buffer
   990	
   991	func TestCountMallocs(t *testing.T) {
   992		switch {
   993		case testing.Short():
   994			t.Skip("skipping malloc count in short mode")
   995		case runtime.GOMAXPROCS(0) > 1:
   996			t.Skip("skipping; GOMAXPROCS>1")
   997		case raceenabled:
   998			t.Skip("skipping malloc count under race detector")
   999		}
  1000		for _, mt := range mallocTest {
  1001			mallocs := testing.AllocsPerRun(100, mt.fn)
  1002			if got, max := mallocs, float64(mt.count); got > max {
  1003				t.Errorf("%s: got %v allocs, want <=%v", mt.desc, got, max)
  1004			}
  1005		}
  1006	}
  1007	
  1008	type flagPrinter struct{}
  1009	
  1010	func (flagPrinter) Format(f State, c rune) {
  1011		s := "%"
  1012		for i := 0; i < 128; i++ {
  1013			if f.Flag(i) {
  1014				s += string(i)
  1015			}
  1016		}
  1017		if w, ok := f.Width(); ok {
  1018			s += Sprintf("%d", w)
  1019		}
  1020		if p, ok := f.Precision(); ok {
  1021			s += Sprintf(".%d", p)
  1022		}
  1023		s += string(c)
  1024		io.WriteString(f, "["+s+"]")
  1025	}
  1026	
  1027	var flagtests = []struct {
  1028		in  string
  1029		out string
  1030	}{
  1031		{"%a", "[%a]"},
  1032		{"%-a", "[%-a]"},
  1033		{"%+a", "[%+a]"},
  1034		{"%#a", "[%#a]"},
  1035		{"% a", "[% a]"},
  1036		{"%0a", "[%0a]"},
  1037		{"%1.2a", "[%1.2a]"},
  1038		{"%-1.2a", "[%-1.2a]"},
  1039		{"%+1.2a", "[%+1.2a]"},
  1040		{"%-+1.2a", "[%+-1.2a]"},
  1041		{"%-+1.2abc", "[%+-1.2a]bc"},
  1042		{"%-1.2abc", "[%-1.2a]bc"},
  1043	}
  1044	
  1045	func TestFlagParser(t *testing.T) {
  1046		var flagprinter flagPrinter
  1047		for _, tt := range flagtests {
  1048			s := Sprintf(tt.in, &flagprinter)
  1049			if s != tt.out {
  1050				t.Errorf("Sprintf(%q, &flagprinter) => %q, want %q", tt.in, s, tt.out)
  1051			}
  1052		}
  1053	}
  1054	
  1055	func TestStructPrinter(t *testing.T) {
  1056		type T struct {
  1057			a string
  1058			b string
  1059			c int
  1060		}
  1061		var s T
  1062		s.a = "abc"
  1063		s.b = "def"
  1064		s.c = 123
  1065		var tests = []struct {
  1066			fmt string
  1067			out string
  1068		}{
  1069			{"%v", "{abc def 123}"},
  1070			{"%+v", "{a:abc b:def c:123}"},
  1071			{"%#v", `fmt_test.T{a:"abc", b:"def", c:123}`},
  1072		}
  1073		for _, tt := range tests {
  1074			out := Sprintf(tt.fmt, s)
  1075			if out != tt.out {
  1076				t.Errorf("Sprintf(%q, s) = %#q, want %#q", tt.fmt, out, tt.out)
  1077			}
  1078			// The same but with a pointer.
  1079			out = Sprintf(tt.fmt, &s)
  1080			if out != "&"+tt.out {
  1081				t.Errorf("Sprintf(%q, &s) = %#q, want %#q", tt.fmt, out, "&"+tt.out)
  1082			}
  1083		}
  1084	}
  1085	
  1086	func TestSlicePrinter(t *testing.T) {
  1087		slice := []int{}
  1088		s := Sprint(slice)
  1089		if s != "[]" {
  1090			t.Errorf("empty slice printed as %q not %q", s, "[]")
  1091		}
  1092		slice = []int{1, 2, 3}
  1093		s = Sprint(slice)
  1094		if s != "[1 2 3]" {
  1095			t.Errorf("slice: got %q expected %q", s, "[1 2 3]")
  1096		}
  1097		s = Sprint(&slice)
  1098		if s != "&[1 2 3]" {
  1099			t.Errorf("&slice: got %q expected %q", s, "&[1 2 3]")
  1100		}
  1101	}
  1102	
  1103	// presentInMap checks map printing using substrings so we don't depend on the
  1104	// print order.
  1105	
  1106	// presentInMap 用子字符串来检查映射的打印,因此我们无需依赖打印顺序。
  1107	func presentInMap(s string, a []string, t *testing.T) {
  1108		for i := 0; i < len(a); i++ {
  1109			loc := strings.Index(s, a[i])
  1110			if loc < 0 {
  1111				t.Errorf("map print: expected to find %q in %q", a[i], s)
  1112			}
  1113			// make sure the match ends here
  1114			// 确保已经匹配到结尾
  1115			loc += len(a[i])
  1116			if loc >= len(s) || (s[loc] != ' ' && s[loc] != ']') {
  1117				t.Errorf("map print: %q not properly terminated in %q", a[i], s)
  1118			}
  1119		}
  1120	}
  1121	
  1122	func TestMapPrinter(t *testing.T) {
  1123		m0 := make(map[int]string)
  1124		s := Sprint(m0)
  1125		if s != "map[]" {
  1126			t.Errorf("empty map printed as %q not %q", s, "map[]")
  1127		}
  1128		m1 := map[int]string{1: "one", 2: "two", 3: "three"}
  1129		a := []string{"1:one", "2:two", "3:three"}
  1130		presentInMap(Sprintf("%v", m1), a, t)
  1131		presentInMap(Sprint(m1), a, t)
  1132		// Pointer to map prints the same but with initial &.
  1133		if !strings.HasPrefix(Sprint(&m1), "&") {
  1134			t.Errorf("no initial & for address of map")
  1135		}
  1136		presentInMap(Sprintf("%v", &m1), a, t)
  1137		presentInMap(Sprint(&m1), a, t)
  1138	}
  1139	
  1140	func TestEmptyMap(t *testing.T) {
  1141		const emptyMapStr = "map[]"
  1142		var m map[string]int
  1143		s := Sprint(m)
  1144		if s != emptyMapStr {
  1145			t.Errorf("nil map printed as %q not %q", s, emptyMapStr)
  1146		}
  1147		m = make(map[string]int)
  1148		s = Sprint(m)
  1149		if s != emptyMapStr {
  1150			t.Errorf("empty map printed as %q not %q", s, emptyMapStr)
  1151		}
  1152	}
  1153	
  1154	// TestBlank checks that Sprint (and hence Print, Fprint) puts spaces in the
  1155	// right places, that is, between arg pairs in which neither is a string.
  1156	
  1157	// TestBlank 检查 Sprint(同时也就检查了 Print 和 Fprint)是否将空格放到了正确的位置,
  1158	// 即,除字符串外的实参对之间。
  1159	func TestBlank(t *testing.T) {
  1160		got := Sprint("<", 1, ">:", 1, 2, 3, "!")
  1161		expect := "<1>:1 2 3!"
  1162		if got != expect {
  1163			t.Errorf("got %q expected %q", got, expect)
  1164		}
  1165	}
  1166	
  1167	// TestBlankln checks that Sprintln (and hence Println, Fprintln) puts spaces in
  1168	// the right places, that is, between all arg pairs.
  1169	
  1170	// TestBlankln 检查 Sprintln(同时也就检查了 Println 和 Fprintln)是否将空格放到了正确的位置,
  1171	// 即,所有的实参对之间。
  1172	func TestBlankln(t *testing.T) {
  1173		got := Sprintln("<", 1, ">:", 1, 2, 3, "!")
  1174		expect := "< 1 >: 1 2 3 !\n"
  1175		if got != expect {
  1176			t.Errorf("got %q expected %q", got, expect)
  1177		}
  1178	}
  1179	
  1180	// TestFormatterPrintln checks Formatter with Sprint, Sprintln, Sprintf.
  1181	
  1182	// TestFormatterPrintln 用 Sprint、Sprintln 和 Sprintf 检查 Formatter。
  1183	func TestFormatterPrintln(t *testing.T) {
  1184		f := F(1)
  1185		expect := "<v=F(1)>\n"
  1186		s := Sprint(f, "\n")
  1187		if s != expect {
  1188			t.Errorf("Sprint wrong with Formatter: expected %q got %q", expect, s)
  1189		}
  1190		s = Sprintln(f)
  1191		if s != expect {
  1192			t.Errorf("Sprintln wrong with Formatter: expected %q got %q", expect, s)
  1193		}
  1194		s = Sprintf("%v\n", f)
  1195		if s != expect {
  1196			t.Errorf("Sprintf wrong with Formatter: expected %q got %q", expect, s)
  1197		}
  1198	}
  1199	
  1200	func args(a ...interface{}) []interface{} { return a }
  1201	
  1202	var startests = []struct {
  1203		fmt string
  1204		in  []interface{}
  1205		out string
  1206	}{
  1207		{"%*d", args(4, 42), "  42"},
  1208		{"%.*d", args(4, 42), "0042"},
  1209		{"%*.*d", args(8, 4, 42), "    0042"},
  1210		{"%0*d", args(4, 42), "0042"},
  1211		{"%-*d", args(4, 42), "42  "},
  1212	
  1213		// erroneous
  1214		// 错误的
  1215		{"%*d", args(nil, 42), "%!(BADWIDTH)42"},
  1216		{"%.*d", args(nil, 42), "%!(BADPREC)42"},
  1217		{"%*d", args(5, "foo"), "%!d(string=  foo)"},
  1218		{"%*% %d", args(20, 5), "% 5"},
  1219		{"%*", args(4), "%!(NOVERB)"},
  1220		{"%*d", args(int32(4), 42), "%!(BADWIDTH)42"},
  1221	}
  1222	
  1223	func TestWidthAndPrecision(t *testing.T) {
  1224		for _, tt := range startests {
  1225			s := Sprintf(tt.fmt, tt.in...)
  1226			if s != tt.out {
  1227				t.Errorf("%q: got %q expected %q", tt.fmt, s, tt.out)
  1228			}
  1229		}
  1230	}
  1231	
  1232	// Panic is a type that panics in String.
  1233	
  1234	// Panic 为在 String 中引起panic的类型。
  1235	type Panic struct {
  1236		message interface{}
  1237	}
  1238	
  1239	// Value receiver.
  1240	
  1241	// 值接收者。
  1242	func (p Panic) GoString() string {
  1243		panic(p.message)
  1244	}
  1245	
  1246	// Value receiver.
  1247	
  1248	// 值接收者。
  1249	func (p Panic) String() string {
  1250		panic(p.message)
  1251	}
  1252	
  1253	// PanicF is a type that panics in Format.
  1254	
  1255	// PanicF 为在 Format 中引发panic的类型。
  1256	type PanicF struct {
  1257		message interface{}
  1258	}
  1259	
  1260	// Value receiver.
  1261	
  1262	// 值接收者。
  1263	func (p PanicF) Format(f State, c rune) {
  1264		panic(p.message)
  1265	}
  1266	
  1267	var panictests = []struct {
  1268		fmt string
  1269		in  interface{}
  1270		out string
  1271	}{
  1272		// String
  1273		{"%s", (*Panic)(nil), "<nil>"}, // nil pointer special case // 空指针的特殊情况
  1274		{"%s", Panic{io.ErrUnexpectedEOF}, "%!s(PANIC=unexpected EOF)"},
  1275		{"%s", Panic{3}, "%!s(PANIC=3)"},
  1276		// GoString
  1277		{"%#v", (*Panic)(nil), "<nil>"}, // nil pointer special case // 空指针的特殊情况
  1278		{"%#v", Panic{io.ErrUnexpectedEOF}, "%!v(PANIC=unexpected EOF)"},
  1279		{"%#v", Panic{3}, "%!v(PANIC=3)"},
  1280		// Format
  1281		{"%s", (*PanicF)(nil), "<nil>"}, // nil pointer special case // 空指针的特殊情况
  1282		{"%s", PanicF{io.ErrUnexpectedEOF}, "%!s(PANIC=unexpected EOF)"},
  1283		{"%s", PanicF{3}, "%!s(PANIC=3)"},
  1284	}
  1285	
  1286	func TestPanics(t *testing.T) {
  1287		for i, tt := range panictests {
  1288			s := Sprintf(tt.fmt, tt.in)
  1289			if s != tt.out {
  1290				t.Errorf("%d: %q: got %q expected %q", i, tt.fmt, s, tt.out)
  1291			}
  1292		}
  1293	}
  1294	
  1295	// recurCount tests that erroneous String routine doesn't cause fatal recursion.
  1296	
  1297	// recurCount 测试错误的 String 程序是否会产生致命的递归。
  1298	var recurCount = 0
  1299	
  1300	type Recur struct {
  1301		i      int
  1302		failed *bool
  1303	}
  1304	
  1305	func (r *Recur) String() string {
  1306		if recurCount++; recurCount > 10 {
  1307			*r.failed = true
  1308			return "FAIL"
  1309		}
  1310		// This will call badVerb. Before the fix, that would cause us to recur into
  1311		// this routine to print %!p(value). Now we don't call the user's method
  1312		// during an error.
  1313		//
  1314		// 这样会调用 badVerb。在修复之前,它会让我们重复此程序来打印 %!p(value)。
  1315		// 现在我们在发生错误时不会调用用户的方法了。
  1316		return Sprintf("recur@%p value: %d", r, r.i)
  1317	}
  1318	
  1319	func TestBadVerbRecursion(t *testing.T) {
  1320		failed := false
  1321		r := &Recur{3, &failed}
  1322		Sprintf("recur@%p value: %d\n", &r, r.i)
  1323		if failed {
  1324			t.Error("fail with pointer")
  1325		}
  1326		failed = false
  1327		r = &Recur{4, &failed}
  1328		Sprintf("recur@%p, value: %d\n", r, r.i)
  1329		if failed {
  1330			t.Error("fail with value")
  1331		}
  1332	}
  1333	
  1334	func TestIsSpace(t *testing.T) {
  1335		// This tests the internal isSpace function.
  1336		// IsSpace = isSpace is defined in export_test.go.
  1337		// 它用来测试内部的 isSpace 函数。IsSpace = isSpace 在 export_test.go 中定义。
  1338		for i := rune(0); i <= unicode.MaxRune; i++ {
  1339			if IsSpace(i) != unicode.IsSpace(i) {
  1340				t.Errorf("isSpace(%U) = %v, want %v", i, IsSpace(i), unicode.IsSpace(i))
  1341			}
  1342		}
  1343	}
  1344	
  1345	func TestNilDoesNotBecomeTyped(t *testing.T) {
  1346		type A struct{}
  1347		type B struct{}
  1348		var a *A = nil
  1349		var b B = B{}
  1350		got := Sprintf("%s %s %s %s %s", nil, a, nil, b, nil) // go vet should complain about this line.
  1351		const expect = "%!s(<nil>) %!s(*fmt_test.A=<nil>) %!s(<nil>) {} %!s(<nil>)"
  1352		if got != expect {
  1353			t.Errorf("expected:\n\t%q\ngot:\n\t%q", expect, got)
  1354		}
  1355	}
  1356	
  1357	var formatterFlagTests = []struct {
  1358		in  string
  1359		val interface{}
  1360		out string
  1361	}{
  1362		// scalar values with the (unused by fmt) 'a' verb.
  1363		{"%a", flagPrinter{}, "[%a]"},
  1364		{"%-a", flagPrinter{}, "[%-a]"},
  1365		{"%+a", flagPrinter{}, "[%+a]"},
  1366		{"%#a", flagPrinter{}, "[%#a]"},
  1367		{"% a", flagPrinter{}, "[% a]"},
  1368		{"%0a", flagPrinter{}, "[%0a]"},
  1369		{"%1.2a", flagPrinter{}, "[%1.2a]"},
  1370		{"%-1.2a", flagPrinter{}, "[%-1.2a]"},
  1371		{"%+1.2a", flagPrinter{}, "[%+1.2a]"},
  1372		{"%-+1.2a", flagPrinter{}, "[%+-1.2a]"},
  1373		{"%-+1.2abc", flagPrinter{}, "[%+-1.2a]bc"},
  1374		{"%-1.2abc", flagPrinter{}, "[%-1.2a]bc"},
  1375	
  1376		// composite values with the 'a' verb
  1377		{"%a", [1]flagPrinter{}, "[[%a]]"},
  1378		{"%-a", [1]flagPrinter{}, "[[%-a]]"},
  1379		{"%+a", [1]flagPrinter{}, "[[%+a]]"},
  1380		{"%#a", [1]flagPrinter{}, "[[%#a]]"},
  1381		{"% a", [1]flagPrinter{}, "[[% a]]"},
  1382		{"%0a", [1]flagPrinter{}, "[[%0a]]"},
  1383		{"%1.2a", [1]flagPrinter{}, "[[%1.2a]]"},
  1384		{"%-1.2a", [1]flagPrinter{}, "[[%-1.2a]]"},
  1385		{"%+1.2a", [1]flagPrinter{}, "[[%+1.2a]]"},
  1386		{"%-+1.2a", [1]flagPrinter{}, "[[%+-1.2a]]"},
  1387		{"%-+1.2abc", [1]flagPrinter{}, "[[%+-1.2a]]bc"},
  1388		{"%-1.2abc", [1]flagPrinter{}, "[[%-1.2a]]bc"},
  1389	
  1390		// simple values with the 'v' verb
  1391		{"%v", flagPrinter{}, "[%v]"},
  1392		{"%-v", flagPrinter{}, "[%-v]"},
  1393		{"%+v", flagPrinter{}, "[%+v]"},
  1394		{"%#v", flagPrinter{}, "[%#v]"},
  1395		{"% v", flagPrinter{}, "[% v]"},
  1396		{"%0v", flagPrinter{}, "[%0v]"},
  1397		{"%1.2v", flagPrinter{}, "[%1.2v]"},
  1398		{"%-1.2v", flagPrinter{}, "[%-1.2v]"},
  1399		{"%+1.2v", flagPrinter{}, "[%+1.2v]"},
  1400		{"%-+1.2v", flagPrinter{}, "[%+-1.2v]"},
  1401		{"%-+1.2vbc", flagPrinter{}, "[%+-1.2v]bc"},
  1402		{"%-1.2vbc", flagPrinter{}, "[%-1.2v]bc"},
  1403	
  1404		// composite values with the 'v' verb.
  1405		{"%v", [1]flagPrinter{}, "[[%v]]"},
  1406		{"%-v", [1]flagPrinter{}, "[[%-v]]"},
  1407		{"%+v", [1]flagPrinter{}, "[[%+v]]"},
  1408		{"%#v", [1]flagPrinter{}, "[1]fmt_test.flagPrinter{[%#v]}"},
  1409		{"% v", [1]flagPrinter{}, "[[% v]]"},
  1410		{"%0v", [1]flagPrinter{}, "[[%0v]]"},
  1411		{"%1.2v", [1]flagPrinter{}, "[[%1.2v]]"},
  1412		{"%-1.2v", [1]flagPrinter{}, "[[%-1.2v]]"},
  1413		{"%+1.2v", [1]flagPrinter{}, "[[%+1.2v]]"},
  1414		{"%-+1.2v", [1]flagPrinter{}, "[[%+-1.2v]]"},
  1415		{"%-+1.2vbc", [1]flagPrinter{}, "[[%+-1.2v]]bc"},
  1416		{"%-1.2vbc", [1]flagPrinter{}, "[[%-1.2v]]bc"},
  1417	}
  1418	
  1419	func TestFormatterFlags(t *testing.T) {
  1420		for _, tt := range formatterFlagTests {
  1421			s := Sprintf(tt.in, tt.val)
  1422			if s != tt.out {
  1423				t.Errorf("Sprintf(%q, %T) = %q, want %q", tt.in, tt.val, s, tt.out)
  1424			}
  1425		}
  1426	}
  1427	

View as plain text