Source file src/fmt/fmt_test.go

Documentation: fmt

     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  	"internal/race"
    11  	"io"
    12  	"math"
    13  	"reflect"
    14  	"runtime"
    15  	"strings"
    16  	"testing"
    17  	"time"
    18  	"unicode"
    19  )
    20  
    21  type (
    22  	renamedBool       bool
    23  	renamedInt        int
    24  	renamedInt8       int8
    25  	renamedInt16      int16
    26  	renamedInt32      int32
    27  	renamedInt64      int64
    28  	renamedUint       uint
    29  	renamedUint8      uint8
    30  	renamedUint16     uint16
    31  	renamedUint32     uint32
    32  	renamedUint64     uint64
    33  	renamedUintptr    uintptr
    34  	renamedString     string
    35  	renamedBytes      []byte
    36  	renamedFloat32    float32
    37  	renamedFloat64    float64
    38  	renamedComplex64  complex64
    39  	renamedComplex128 complex128
    40  )
    41  
    42  func TestFmtInterface(t *testing.T) {
    43  	var i1 any
    44  	i1 = "abc"
    45  	s := Sprintf("%s", i1)
    46  	if s != "abc" {
    47  		t.Errorf(`Sprintf("%%s", empty("abc")) = %q want %q`, s, "abc")
    48  	}
    49  }
    50  
    51  var (
    52  	NaN    = math.NaN()
    53  	posInf = math.Inf(1)
    54  	negInf = math.Inf(-1)
    55  
    56  	intVar = 0
    57  
    58  	array  = [5]int{1, 2, 3, 4, 5}
    59  	iarray = [4]any{1, "hello", 2.5, nil}
    60  	slice  = array[:]
    61  	islice = iarray[:]
    62  )
    63  
    64  type A struct {
    65  	i int
    66  	j uint
    67  	s string
    68  	x []int
    69  }
    70  
    71  type I int
    72  
    73  func (i I) String() string { return Sprintf("<%d>", int(i)) }
    74  
    75  type B struct {
    76  	I I
    77  	j int
    78  }
    79  
    80  type C struct {
    81  	i int
    82  	B
    83  }
    84  
    85  type F int
    86  
    87  func (f F) Format(s State, c rune) {
    88  	Fprintf(s, "<%c=F(%d)>", c, int(f))
    89  }
    90  
    91  type G int
    92  
    93  func (g G) GoString() string {
    94  	return Sprintf("GoString(%d)", int(g))
    95  }
    96  
    97  type S struct {
    98  	F F // a struct field that Formats
    99  	G G // a struct field that GoStrings
   100  }
   101  
   102  type SI struct {
   103  	I any
   104  }
   105  
   106  // P is a type with a String method with pointer receiver for testing %p.
   107  type P int
   108  
   109  var pValue P
   110  
   111  func (p *P) String() string {
   112  	return "String(p)"
   113  }
   114  
   115  var barray = [5]renamedUint8{1, 2, 3, 4, 5}
   116  var bslice = barray[:]
   117  
   118  type byteStringer byte
   119  
   120  func (byteStringer) String() string {
   121  	return "X"
   122  }
   123  
   124  var byteStringerSlice = []byteStringer{'h', 'e', 'l', 'l', 'o'}
   125  
   126  type byteFormatter byte
   127  
   128  func (byteFormatter) Format(f State, _ rune) {
   129  	Fprint(f, "X")
   130  }
   131  
   132  var byteFormatterSlice = []byteFormatter{'h', 'e', 'l', 'l', 'o'}
   133  
   134  type writeStringFormatter string
   135  
   136  func (sf writeStringFormatter) Format(f State, c rune) {
   137  	if sw, ok := f.(io.StringWriter); ok {
   138  		sw.WriteString("***" + string(sf) + "***")
   139  	}
   140  }
   141  
   142  var fmtTests = []struct {
   143  	fmt string
   144  	val any
   145  	out string
   146  }{
   147  	{"%d", 12345, "12345"},
   148  	{"%v", 12345, "12345"},
   149  	{"%t", true, "true"},
   150  
   151  	// basic string
   152  	{"%s", "abc", "abc"},
   153  	{"%q", "abc", `"abc"`},
   154  	{"%x", "abc", "616263"},
   155  	{"%x", "\xff\xf0\x0f\xff", "fff00fff"},
   156  	{"%X", "\xff\xf0\x0f\xff", "FFF00FFF"},
   157  	{"%x", "", ""},
   158  	{"% x", "", ""},
   159  	{"%#x", "", ""},
   160  	{"%# x", "", ""},
   161  	{"%x", "xyz", "78797a"},
   162  	{"%X", "xyz", "78797A"},
   163  	{"% x", "xyz", "78 79 7a"},
   164  	{"% X", "xyz", "78 79 7A"},
   165  	{"%#x", "xyz", "0x78797a"},
   166  	{"%#X", "xyz", "0X78797A"},
   167  	{"%# x", "xyz", "0x78 0x79 0x7a"},
   168  	{"%# X", "xyz", "0X78 0X79 0X7A"},
   169  
   170  	// basic bytes
   171  	{"%s", []byte("abc"), "abc"},
   172  	{"%s", [3]byte{'a', 'b', 'c'}, "abc"},
   173  	{"%s", &[3]byte{'a', 'b', 'c'}, "&abc"},
   174  	{"%q", []byte("abc"), `"abc"`},
   175  	{"%x", []byte("abc"), "616263"},
   176  	{"%x", []byte("\xff\xf0\x0f\xff"), "fff00fff"},
   177  	{"%X", []byte("\xff\xf0\x0f\xff"), "FFF00FFF"},
   178  	{"%x", []byte(""), ""},
   179  	{"% x", []byte(""), ""},
   180  	{"%#x", []byte(""), ""},
   181  	{"%# x", []byte(""), ""},
   182  	{"%x", []byte("xyz"), "78797a"},
   183  	{"%X", []byte("xyz"), "78797A"},
   184  	{"% x", []byte("xyz"), "78 79 7a"},
   185  	{"% X", []byte("xyz"), "78 79 7A"},
   186  	{"%#x", []byte("xyz"), "0x78797a"},
   187  	{"%#X", []byte("xyz"), "0X78797A"},
   188  	{"%# x", []byte("xyz"), "0x78 0x79 0x7a"},
   189  	{"%# X", []byte("xyz"), "0X78 0X79 0X7A"},
   190  
   191  	// escaped strings
   192  	{"%q", "", `""`},
   193  	{"%#q", "", "``"},
   194  	{"%q", "\"", `"\""`},
   195  	{"%#q", "\"", "`\"`"},
   196  	{"%q", "`", `"` + "`" + `"`},
   197  	{"%#q", "`", `"` + "`" + `"`},
   198  	{"%q", "\n", `"\n"`},
   199  	{"%#q", "\n", `"\n"`},
   200  	{"%q", `\n`, `"\\n"`},
   201  	{"%#q", `\n`, "`\\n`"},
   202  	{"%q", "abc", `"abc"`},
   203  	{"%#q", "abc", "`abc`"},
   204  	{"%q", "日本語", `"日本語"`},
   205  	{"%+q", "日本語", `"\u65e5\u672c\u8a9e"`},
   206  	{"%#q", "日本語", "`日本語`"},
   207  	{"%#+q", "日本語", "`日本語`"},
   208  	{"%q", "\a\b\f\n\r\t\v\"\\", `"\a\b\f\n\r\t\v\"\\"`},
   209  	{"%+q", "\a\b\f\n\r\t\v\"\\", `"\a\b\f\n\r\t\v\"\\"`},
   210  	{"%#q", "\a\b\f\n\r\t\v\"\\", `"\a\b\f\n\r\t\v\"\\"`},
   211  	{"%#+q", "\a\b\f\n\r\t\v\"\\", `"\a\b\f\n\r\t\v\"\\"`},
   212  	{"%q", "☺", `"☺"`},
   213  	{"% q", "☺", `"☺"`}, // The space modifier should have no effect.
   214  	{"%+q", "☺", `"\u263a"`},
   215  	{"%#q", "☺", "`☺`"},
   216  	{"%#+q", "☺", "`☺`"},
   217  	{"%10q", "⌘", `       "⌘"`},
   218  	{"%+10q", "⌘", `  "\u2318"`},
   219  	{"%-10q", "⌘", `"⌘"       `},
   220  	{"%+-10q", "⌘", `"\u2318"  `},
   221  	{"%010q", "⌘", `0000000"⌘"`},
   222  	{"%+010q", "⌘", `00"\u2318"`},
   223  	{"%-010q", "⌘", `"⌘"       `}, // 0 has no effect when - is present.
   224  	{"%+-010q", "⌘", `"\u2318"  `},
   225  	{"%#8q", "\n", `    "\n"`},
   226  	{"%#+8q", "\r", `    "\r"`},
   227  	{"%#-8q", "\t", "`	`     "},
   228  	{"%#+-8q", "\b", `"\b"    `},
   229  	{"%q", "abc\xffdef", `"abc\xffdef"`},
   230  	{"%+q", "abc\xffdef", `"abc\xffdef"`},
   231  	{"%#q", "abc\xffdef", `"abc\xffdef"`},
   232  	{"%#+q", "abc\xffdef", `"abc\xffdef"`},
   233  	// Runes that are not printable.
   234  	{"%q", "\U0010ffff", `"\U0010ffff"`},
   235  	{"%+q", "\U0010ffff", `"\U0010ffff"`},
   236  	{"%#q", "\U0010ffff", "`􏿿`"},
   237  	{"%#+q", "\U0010ffff", "`􏿿`"},
   238  	// Runes that are not valid.
   239  	{"%q", string(rune(0x110000)), `"�"`},
   240  	{"%+q", string(rune(0x110000)), `"\ufffd"`},
   241  	{"%#q", string(rune(0x110000)), "`�`"},
   242  	{"%#+q", string(rune(0x110000)), "`�`"},
   243  
   244  	// characters
   245  	{"%c", uint('x'), "x"},
   246  	{"%c", 0xe4, "ä"},
   247  	{"%c", 0x672c, "本"},
   248  	{"%c", '日', "日"},
   249  	{"%.0c", '⌘', "⌘"}, // Specifying precision should have no effect.
   250  	{"%3c", '⌘', "  ⌘"},
   251  	{"%-3c", '⌘', "⌘  "},
   252  	{"%c", uint64(0x100000000), "\ufffd"},
   253  	// Runes that are not printable.
   254  	{"%c", '\U00000e00', "\u0e00"},
   255  	{"%c", '\U0010ffff', "\U0010ffff"},
   256  	// Runes that are not valid.
   257  	{"%c", -1, "�"},
   258  	{"%c", 0xDC80, "�"},
   259  	{"%c", rune(0x110000), "�"},
   260  	{"%c", int64(0xFFFFFFFFF), "�"},
   261  	{"%c", uint64(0xFFFFFFFFF), "�"},
   262  
   263  	// escaped characters
   264  	{"%q", uint(0), `'\x00'`},
   265  	{"%+q", uint(0), `'\x00'`},
   266  	{"%q", '"', `'"'`},
   267  	{"%+q", '"', `'"'`},
   268  	{"%q", '\'', `'\''`},
   269  	{"%+q", '\'', `'\''`},
   270  	{"%q", '`', "'`'"},
   271  	{"%+q", '`', "'`'"},
   272  	{"%q", 'x', `'x'`},
   273  	{"%+q", 'x', `'x'`},
   274  	{"%q", 'ÿ', `'ÿ'`},
   275  	{"%+q", 'ÿ', `'\u00ff'`},
   276  	{"%q", '\n', `'\n'`},
   277  	{"%+q", '\n', `'\n'`},
   278  	{"%q", '☺', `'☺'`},
   279  	{"%+q", '☺', `'\u263a'`},
   280  	{"% q", '☺', `'☺'`},  // The space modifier should have no effect.
   281  	{"%.0q", '☺', `'☺'`}, // Specifying precision should have no effect.
   282  	{"%10q", '⌘', `       '⌘'`},
   283  	{"%+10q", '⌘', `  '\u2318'`},
   284  	{"%-10q", '⌘', `'⌘'       `},
   285  	{"%+-10q", '⌘', `'\u2318'  `},
   286  	{"%010q", '⌘', `0000000'⌘'`},
   287  	{"%+010q", '⌘', `00'\u2318'`},
   288  	{"%-010q", '⌘', `'⌘'       `}, // 0 has no effect when - is present.
   289  	{"%+-010q", '⌘', `'\u2318'  `},
   290  	// Runes that are not printable.
   291  	{"%q", '\U00000e00', `'\u0e00'`},
   292  	{"%q", '\U0010ffff', `'\U0010ffff'`},
   293  	// Runes that are not valid.
   294  	{"%q", int32(-1), `'�'`},
   295  	{"%q", 0xDC80, `'�'`},
   296  	{"%q", rune(0x110000), `'�'`},
   297  	{"%q", int64(0xFFFFFFFFF), `'�'`},
   298  	{"%q", uint64(0xFFFFFFFFF), `'�'`},
   299  
   300  	// width
   301  	{"%5s", "abc", "  abc"},
   302  	{"%5s", []byte("abc"), "  abc"},
   303  	{"%2s", "\u263a", " ☺"},
   304  	{"%2s", []byte("\u263a"), " ☺"},
   305  	{"%-5s", "abc", "abc  "},
   306  	{"%-5s", []byte("abc"), "abc  "},
   307  	{"%05s", "abc", "00abc"},
   308  	{"%05s", []byte("abc"), "00abc"},
   309  	{"%5s", "abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwxyz"},
   310  	{"%5s", []byte("abcdefghijklmnopqrstuvwxyz"), "abcdefghijklmnopqrstuvwxyz"},
   311  	{"%.5s", "abcdefghijklmnopqrstuvwxyz", "abcde"},
   312  	{"%.5s", []byte("abcdefghijklmnopqrstuvwxyz"), "abcde"},
   313  	{"%.0s", "日本語日本語", ""},
   314  	{"%.0s", []byte("日本語日本語"), ""},
   315  	{"%.5s", "日本語日本語", "日本語日本"},
   316  	{"%.5s", []byte("日本語日本語"), "日本語日本"},
   317  	{"%.10s", "日本語日本語", "日本語日本語"},
   318  	{"%.10s", []byte("日本語日本語"), "日本語日本語"},
   319  	{"%08q", "abc", `000"abc"`},
   320  	{"%08q", []byte("abc"), `000"abc"`},
   321  	{"%-8q", "abc", `"abc"   `},
   322  	{"%-8q", []byte("abc"), `"abc"   `},
   323  	{"%.5q", "abcdefghijklmnopqrstuvwxyz", `"abcde"`},
   324  	{"%.5q", []byte("abcdefghijklmnopqrstuvwxyz"), `"abcde"`},
   325  	{"%.5x", "abcdefghijklmnopqrstuvwxyz", "6162636465"},
   326  	{"%.5x", []byte("abcdefghijklmnopqrstuvwxyz"), "6162636465"},
   327  	{"%.3q", "日本語日本語", `"日本語"`},
   328  	{"%.3q", []byte("日本語日本語"), `"日本語"`},
   329  	{"%.1q", "日本語", `"日"`},
   330  	{"%.1q", []byte("日本語"), `"日"`},
   331  	{"%.1x", "日本語", "e6"},
   332  	{"%.1X", []byte("日本語"), "E6"},
   333  	{"%10.1q", "日本語日本語", `       "日"`},
   334  	{"%10.1q", []byte("日本語日本語"), `       "日"`},
   335  	{"%10v", nil, "     <nil>"},
   336  	{"%-10v", nil, "<nil>     "},
   337  
   338  	// integers
   339  	{"%d", uint(12345), "12345"},
   340  	{"%d", int(-12345), "-12345"},
   341  	{"%d", ^uint8(0), "255"},
   342  	{"%d", ^uint16(0), "65535"},
   343  	{"%d", ^uint32(0), "4294967295"},
   344  	{"%d", ^uint64(0), "18446744073709551615"},
   345  	{"%d", int8(-1 << 7), "-128"},
   346  	{"%d", int16(-1 << 15), "-32768"},
   347  	{"%d", int32(-1 << 31), "-2147483648"},
   348  	{"%d", int64(-1 << 63), "-9223372036854775808"},
   349  	{"%.d", 0, ""},
   350  	{"%.0d", 0, ""},
   351  	{"%6.0d", 0, "      "},
   352  	{"%06.0d", 0, "      "},
   353  	{"% d", 12345, " 12345"},
   354  	{"%+d", 12345, "+12345"},
   355  	{"%+d", -12345, "-12345"},
   356  	{"%b", 7, "111"},
   357  	{"%b", -6, "-110"},
   358  	{"%#b", 7, "0b111"},
   359  	{"%#b", -6, "-0b110"},
   360  	{"%b", ^uint32(0), "11111111111111111111111111111111"},
   361  	{"%b", ^uint64(0), "1111111111111111111111111111111111111111111111111111111111111111"},
   362  	{"%b", int64(-1 << 63), zeroFill("-1", 63, "")},
   363  	{"%o", 01234, "1234"},
   364  	{"%o", -01234, "-1234"},
   365  	{"%#o", 01234, "01234"},
   366  	{"%#o", -01234, "-01234"},
   367  	{"%O", 01234, "0o1234"},
   368  	{"%O", -01234, "-0o1234"},
   369  	{"%o", ^uint32(0), "37777777777"},
   370  	{"%o", ^uint64(0), "1777777777777777777777"},
   371  	{"%#X", 0, "0X0"},
   372  	{"%x", 0x12abcdef, "12abcdef"},
   373  	{"%X", 0x12abcdef, "12ABCDEF"},
   374  	{"%x", ^uint32(0), "ffffffff"},
   375  	{"%X", ^uint64(0), "FFFFFFFFFFFFFFFF"},
   376  	{"%.20b", 7, "00000000000000000111"},
   377  	{"%10d", 12345, "     12345"},
   378  	{"%10d", -12345, "    -12345"},
   379  	{"%+10d", 12345, "    +12345"},
   380  	{"%010d", 12345, "0000012345"},
   381  	{"%010d", -12345, "-000012345"},
   382  	{"%20.8d", 1234, "            00001234"},
   383  	{"%20.8d", -1234, "           -00001234"},
   384  	{"%020.8d", 1234, "            00001234"},
   385  	{"%020.8d", -1234, "           -00001234"},
   386  	{"%-20.8d", 1234, "00001234            "},
   387  	{"%-20.8d", -1234, "-00001234           "},
   388  	{"%-#20.8x", 0x1234abc, "0x01234abc          "},
   389  	{"%-#20.8X", 0x1234abc, "0X01234ABC          "},
   390  	{"%-#20.8o", 01234, "00001234            "},
   391  
   392  	// Test correct f.intbuf overflow checks.
   393  	{"%068d", 1, zeroFill("", 68, "1")},
   394  	{"%068d", -1, zeroFill("-", 67, "1")},
   395  	{"%#.68x", 42, zeroFill("0x", 68, "2a")},
   396  	{"%.68d", -42, zeroFill("-", 68, "42")},
   397  	{"%+.68d", 42, zeroFill("+", 68, "42")},
   398  	{"% .68d", 42, zeroFill(" ", 68, "42")},
   399  	{"% +.68d", 42, zeroFill("+", 68, "42")},
   400  
   401  	// unicode format
   402  	{"%U", 0, "U+0000"},
   403  	{"%U", -1, "U+FFFFFFFFFFFFFFFF"},
   404  	{"%U", '\n', `U+000A`},
   405  	{"%#U", '\n', `U+000A`},
   406  	{"%+U", 'x', `U+0078`},       // Plus flag should have no effect.
   407  	{"%# U", 'x', `U+0078 'x'`},  // Space flag should have no effect.
   408  	{"%#.2U", 'x', `U+0078 'x'`}, // Precisions below 4 should print 4 digits.
   409  	{"%U", '\u263a', `U+263A`},
   410  	{"%#U", '\u263a', `U+263A '☺'`},
   411  	{"%U", '\U0001D6C2', `U+1D6C2`},
   412  	{"%#U", '\U0001D6C2', `U+1D6C2 '𝛂'`},
   413  	{"%#14.6U", '⌘', "  U+002318 '⌘'"},
   414  	{"%#-14.6U", '⌘', "U+002318 '⌘'  "},
   415  	{"%#014.6U", '⌘', "  U+002318 '⌘'"},
   416  	{"%#-014.6U", '⌘', "U+002318 '⌘'  "},
   417  	{"%.68U", uint(42), zeroFill("U+", 68, "2A")},
   418  	{"%#.68U", '日', zeroFill("U+", 68, "65E5") + " '日'"},
   419  
   420  	// floats
   421  	{"%+.3e", 0.0, "+0.000e+00"},
   422  	{"%+.3e", 1.0, "+1.000e+00"},
   423  	{"%+.3x", 0.0, "+0x0.000p+00"},
   424  	{"%+.3x", 1.0, "+0x1.000p+00"},
   425  	{"%+.3f", -1.0, "-1.000"},
   426  	{"%+.3F", -1.0, "-1.000"},
   427  	{"%+.3F", float32(-1.0), "-1.000"},
   428  	{"%+07.2f", 1.0, "+001.00"},
   429  	{"%+07.2f", -1.0, "-001.00"},
   430  	{"%-07.2f", 1.0, "1.00   "},
   431  	{"%-07.2f", -1.0, "-1.00  "},
   432  	{"%+-07.2f", 1.0, "+1.00  "},
   433  	{"%+-07.2f", -1.0, "-1.00  "},
   434  	{"%-+07.2f", 1.0, "+1.00  "},
   435  	{"%-+07.2f", -1.0, "-1.00  "},
   436  	{"%+10.2f", +1.0, "     +1.00"},
   437  	{"%+10.2f", -1.0, "     -1.00"},
   438  	{"% .3E", -1.0, "-1.000E+00"},
   439  	{"% .3e", 1.0, " 1.000e+00"},
   440  	{"% .3X", -1.0, "-0X1.000P+00"},
   441  	{"% .3x", 1.0, " 0x1.000p+00"},
   442  	{"%+.3g", 0.0, "+0"},
   443  	{"%+.3g", 1.0, "+1"},
   444  	{"%+.3g", -1.0, "-1"},
   445  	{"% .3g", -1.0, "-1"},
   446  	{"% .3g", 1.0, " 1"},
   447  	{"%b", float32(1.0), "8388608p-23"},
   448  	{"%b", 1.0, "4503599627370496p-52"},
   449  	// Test sharp flag used with floats.
   450  	{"%#g", 1e-323, "1.00000e-323"},
   451  	{"%#g", -1.0, "-1.00000"},
   452  	{"%#g", 1.1, "1.10000"},
   453  	{"%#g", 123456.0, "123456."},
   454  	{"%#g", 1234567.0, "1.234567e+06"},
   455  	{"%#g", 1230000.0, "1.23000e+06"},
   456  	{"%#g", 1000000.0, "1.00000e+06"},
   457  	{"%#.0f", 1.0, "1."},
   458  	{"%#.0e", 1.0, "1.e+00"},
   459  	{"%#.0x", 1.0, "0x1.p+00"},
   460  	{"%#.0g", 1.0, "1."},
   461  	{"%#.0g", 1100000.0, "1.e+06"},
   462  	{"%#.4f", 1.0, "1.0000"},
   463  	{"%#.4e", 1.0, "1.0000e+00"},
   464  	{"%#.4x", 1.0, "0x1.0000p+00"},
   465  	{"%#.4g", 1.0, "1.000"},
   466  	{"%#.4g", 100000.0, "1.000e+05"},
   467  	{"%#.4g", 1.234, "1.234"},
   468  	{"%#.4g", 0.1234, "0.1234"},
   469  	{"%#.4g", 1.23, "1.230"},
   470  	{"%#.4g", 0.123, "0.1230"},
   471  	{"%#.4g", 1.2, "1.200"},
   472  	{"%#.4g", 0.12, "0.1200"},
   473  	{"%#.4g", 10.2, "10.20"},
   474  	{"%#.4g", 0.0, "0.000"},
   475  	{"%#.4g", 0.012, "0.01200"},
   476  	{"%#.0f", 123.0, "123."},
   477  	{"%#.0e", 123.0, "1.e+02"},
   478  	{"%#.0x", 123.0, "0x1.p+07"},
   479  	{"%#.0g", 123.0, "1.e+02"},
   480  	{"%#.4f", 123.0, "123.0000"},
   481  	{"%#.4e", 123.0, "1.2300e+02"},
   482  	{"%#.4x", 123.0, "0x1.ec00p+06"},
   483  	{"%#.4g", 123.0, "123.0"},
   484  	{"%#.4g", 123000.0, "1.230e+05"},
   485  	{"%#9.4g", 1.0, "    1.000"},
   486  	// The sharp flag has no effect for binary float format.
   487  	{"%#b", 1.0, "4503599627370496p-52"},
   488  	// Precision has no effect for binary float format.
   489  	{"%.4b", float32(1.0), "8388608p-23"},
   490  	{"%.4b", -1.0, "-4503599627370496p-52"},
   491  	// Test correct f.intbuf boundary checks.
   492  	{"%.68f", 1.0, zeroFill("1.", 68, "")},
   493  	{"%.68f", -1.0, zeroFill("-1.", 68, "")},
   494  	// float infinites and NaNs
   495  	{"%f", posInf, "+Inf"},
   496  	{"%.1f", negInf, "-Inf"},
   497  	{"% f", NaN, " NaN"},
   498  	{"%20f", posInf, "                +Inf"},
   499  	{"% 20F", posInf, "                 Inf"},
   500  	{"% 20e", negInf, "                -Inf"},
   501  	{"% 20x", negInf, "                -Inf"},
   502  	{"%+20E", negInf, "                -Inf"},
   503  	{"%+20X", negInf, "                -Inf"},
   504  	{"% +20g", negInf, "                -Inf"},
   505  	{"%+-20G", posInf, "+Inf                "},
   506  	{"%20e", NaN, "                 NaN"},
   507  	{"%20x", NaN, "                 NaN"},
   508  	{"% +20E", NaN, "                +NaN"},
   509  	{"% +20X", NaN, "                +NaN"},
   510  	{"% -20g", NaN, " NaN                "},
   511  	{"%+-20G", NaN, "+NaN                "},
   512  	// Zero padding does not apply to infinities and NaN.
   513  	{"%+020e", posInf, "                +Inf"},
   514  	{"%+020x", posInf, "                +Inf"},
   515  	{"%-020f", negInf, "-Inf                "},
   516  	{"%-020E", NaN, "NaN                 "},
   517  	{"%-020X", NaN, "NaN                 "},
   518  
   519  	// complex values
   520  	{"%.f", 0i, "(0+0i)"},
   521  	{"% .f", 0i, "( 0+0i)"},
   522  	{"%+.f", 0i, "(+0+0i)"},
   523  	{"% +.f", 0i, "(+0+0i)"},
   524  	{"%+.3e", 0i, "(+0.000e+00+0.000e+00i)"},
   525  	{"%+.3x", 0i, "(+0x0.000p+00+0x0.000p+00i)"},
   526  	{"%+.3f", 0i, "(+0.000+0.000i)"},
   527  	{"%+.3g", 0i, "(+0+0i)"},
   528  	{"%+.3e", 1 + 2i, "(+1.000e+00+2.000e+00i)"},
   529  	{"%+.3x", 1 + 2i, "(+0x1.000p+00+0x1.000p+01i)"},
   530  	{"%+.3f", 1 + 2i, "(+1.000+2.000i)"},
   531  	{"%+.3g", 1 + 2i, "(+1+2i)"},
   532  	{"%.3e", 0i, "(0.000e+00+0.000e+00i)"},
   533  	{"%.3x", 0i, "(0x0.000p+00+0x0.000p+00i)"},
   534  	{"%.3f", 0i, "(0.000+0.000i)"},
   535  	{"%.3F", 0i, "(0.000+0.000i)"},
   536  	{"%.3F", complex64(0i), "(0.000+0.000i)"},
   537  	{"%.3g", 0i, "(0+0i)"},
   538  	{"%.3e", 1 + 2i, "(1.000e+00+2.000e+00i)"},
   539  	{"%.3x", 1 + 2i, "(0x1.000p+00+0x1.000p+01i)"},
   540  	{"%.3f", 1 + 2i, "(1.000+2.000i)"},
   541  	{"%.3g", 1 + 2i, "(1+2i)"},
   542  	{"%.3e", -1 - 2i, "(-1.000e+00-2.000e+00i)"},
   543  	{"%.3x", -1 - 2i, "(-0x1.000p+00-0x1.000p+01i)"},
   544  	{"%.3f", -1 - 2i, "(-1.000-2.000i)"},
   545  	{"%.3g", -1 - 2i, "(-1-2i)"},
   546  	{"% .3E", -1 - 2i, "(-1.000E+00-2.000E+00i)"},
   547  	{"% .3X", -1 - 2i, "(-0X1.000P+00-0X1.000P+01i)"},
   548  	{"%+.3g", 1 + 2i, "(+1+2i)"},
   549  	{"%+.3g", complex64(1 + 2i), "(+1+2i)"},
   550  	{"%#g", 1 + 2i, "(1.00000+2.00000i)"},
   551  	{"%#g", 123456 + 789012i, "(123456.+789012.i)"},
   552  	{"%#g", 1e-10i, "(0.00000+1.00000e-10i)"},
   553  	{"%#g", -1e10 - 1.11e100i, "(-1.00000e+10-1.11000e+100i)"},
   554  	{"%#.0f", 1.23 + 1.0i, "(1.+1.i)"},
   555  	{"%#.0e", 1.23 + 1.0i, "(1.e+00+1.e+00i)"},
   556  	{"%#.0x", 1.23 + 1.0i, "(0x1.p+00+0x1.p+00i)"},
   557  	{"%#.0g", 1.23 + 1.0i, "(1.+1.i)"},
   558  	{"%#.0g", 0 + 100000i, "(0.+1.e+05i)"},
   559  	{"%#.0g", 1230000 + 0i, "(1.e+06+0.i)"},
   560  	{"%#.4f", 1 + 1.23i, "(1.0000+1.2300i)"},
   561  	{"%#.4e", 123 + 1i, "(1.2300e+02+1.0000e+00i)"},
   562  	{"%#.4x", 123 + 1i, "(0x1.ec00p+06+0x1.0000p+00i)"},
   563  	{"%#.4g", 123 + 1.23i, "(123.0+1.230i)"},
   564  	{"%#12.5g", 0 + 100000i, "(      0.0000 +1.0000e+05i)"},
   565  	{"%#12.5g", 1230000 - 0i, "(  1.2300e+06     +0.0000i)"},
   566  	{"%b", 1 + 2i, "(4503599627370496p-52+4503599627370496p-51i)"},
   567  	{"%b", complex64(1 + 2i), "(8388608p-23+8388608p-22i)"},
   568  	// The sharp flag has no effect for binary complex format.
   569  	{"%#b", 1 + 2i, "(4503599627370496p-52+4503599627370496p-51i)"},
   570  	// Precision has no effect for binary complex format.
   571  	{"%.4b", 1 + 2i, "(4503599627370496p-52+4503599627370496p-51i)"},
   572  	{"%.4b", complex64(1 + 2i), "(8388608p-23+8388608p-22i)"},
   573  	// complex infinites and NaNs
   574  	{"%f", complex(posInf, posInf), "(+Inf+Infi)"},
   575  	{"%f", complex(negInf, negInf), "(-Inf-Infi)"},
   576  	{"%f", complex(NaN, NaN), "(NaN+NaNi)"},
   577  	{"%.1f", complex(posInf, posInf), "(+Inf+Infi)"},
   578  	{"% f", complex(posInf, posInf), "( Inf+Infi)"},
   579  	{"% f", complex(negInf, negInf), "(-Inf-Infi)"},
   580  	{"% f", complex(NaN, NaN), "( NaN+NaNi)"},
   581  	{"%8e", complex(posInf, posInf), "(    +Inf    +Infi)"},
   582  	{"%8x", complex(posInf, posInf), "(    +Inf    +Infi)"},
   583  	{"% 8E", complex(posInf, posInf), "(     Inf    +Infi)"},
   584  	{"% 8X", complex(posInf, posInf), "(     Inf    +Infi)"},
   585  	{"%+8f", complex(negInf, negInf), "(    -Inf    -Infi)"},
   586  	{"% +8g", complex(negInf, negInf), "(    -Inf    -Infi)"},
   587  	{"% -8G", complex(NaN, NaN), "( NaN    +NaN    i)"},
   588  	{"%+-8b", complex(NaN, NaN), "(+NaN    +NaN    i)"},
   589  	// Zero padding does not apply to infinities and NaN.
   590  	{"%08f", complex(posInf, posInf), "(    +Inf    +Infi)"},
   591  	{"%-08g", complex(negInf, negInf), "(-Inf    -Inf    i)"},
   592  	{"%-08G", complex(NaN, NaN), "(NaN     +NaN    i)"},
   593  
   594  	// old test/fmt_test.go
   595  	{"%e", 1.0, "1.000000e+00"},
   596  	{"%e", 1234.5678e3, "1.234568e+06"},
   597  	{"%e", 1234.5678e-8, "1.234568e-05"},
   598  	{"%e", -7.0, "-7.000000e+00"},
   599  	{"%e", -1e-9, "-1.000000e-09"},
   600  	{"%f", 1234.5678e3, "1234567.800000"},
   601  	{"%f", 1234.5678e-8, "0.000012"},
   602  	{"%f", -7.0, "-7.000000"},
   603  	{"%f", -1e-9, "-0.000000"},
   604  	{"%g", 1234.5678e3, "1.2345678e+06"},
   605  	{"%g", float32(1234.5678e3), "1.2345678e+06"},
   606  	{"%g", 1234.5678e-8, "1.2345678e-05"},
   607  	{"%g", -7.0, "-7"},
   608  	{"%g", -1e-9, "-1e-09"},
   609  	{"%g", float32(-1e-9), "-1e-09"},
   610  	{"%E", 1.0, "1.000000E+00"},
   611  	{"%E", 1234.5678e3, "1.234568E+06"},
   612  	{"%E", 1234.5678e-8, "1.234568E-05"},
   613  	{"%E", -7.0, "-7.000000E+00"},
   614  	{"%E", -1e-9, "-1.000000E-09"},
   615  	{"%G", 1234.5678e3, "1.2345678E+06"},
   616  	{"%G", float32(1234.5678e3), "1.2345678E+06"},
   617  	{"%G", 1234.5678e-8, "1.2345678E-05"},
   618  	{"%G", -7.0, "-7"},
   619  	{"%G", -1e-9, "-1E-09"},
   620  	{"%G", float32(-1e-9), "-1E-09"},
   621  	{"%20.5s", "qwertyuiop", "               qwert"},
   622  	{"%.5s", "qwertyuiop", "qwert"},
   623  	{"%-20.5s", "qwertyuiop", "qwert               "},
   624  	{"%20c", 'x', "                   x"},
   625  	{"%-20c", 'x', "x                   "},
   626  	{"%20.6e", 1.2345e3, "        1.234500e+03"},
   627  	{"%20.6e", 1.2345e-3, "        1.234500e-03"},
   628  	{"%20e", 1.2345e3, "        1.234500e+03"},
   629  	{"%20e", 1.2345e-3, "        1.234500e-03"},
   630  	{"%20.8e", 1.2345e3, "      1.23450000e+03"},
   631  	{"%20f", 1.23456789e3, "         1234.567890"},
   632  	{"%20f", 1.23456789e-3, "            0.001235"},
   633  	{"%20f", 12345678901.23456789, "  12345678901.234568"},
   634  	{"%-20f", 1.23456789e3, "1234.567890         "},
   635  	{"%20.8f", 1.23456789e3, "       1234.56789000"},
   636  	{"%20.8f", 1.23456789e-3, "          0.00123457"},
   637  	{"%g", 1.23456789e3, "1234.56789"},
   638  	{"%g", 1.23456789e-3, "0.00123456789"},
   639  	{"%g", 1.23456789e20, "1.23456789e+20"},
   640  
   641  	// arrays
   642  	{"%v", array, "[1 2 3 4 5]"},
   643  	{"%v", iarray, "[1 hello 2.5 <nil>]"},
   644  	{"%v", barray, "[1 2 3 4 5]"},
   645  	{"%v", &array, "&[1 2 3 4 5]"},
   646  	{"%v", &iarray, "&[1 hello 2.5 <nil>]"},
   647  	{"%v", &barray, "&[1 2 3 4 5]"},
   648  
   649  	// slices
   650  	{"%v", slice, "[1 2 3 4 5]"},
   651  	{"%v", islice, "[1 hello 2.5 <nil>]"},
   652  	{"%v", bslice, "[1 2 3 4 5]"},
   653  	{"%v", &slice, "&[1 2 3 4 5]"},
   654  	{"%v", &islice, "&[1 hello 2.5 <nil>]"},
   655  	{"%v", &bslice, "&[1 2 3 4 5]"},
   656  
   657  	// byte arrays and slices with %b,%c,%d,%o,%U and %v
   658  	{"%b", [3]byte{65, 66, 67}, "[1000001 1000010 1000011]"},
   659  	{"%c", [3]byte{65, 66, 67}, "[A B C]"},
   660  	{"%d", [3]byte{65, 66, 67}, "[65 66 67]"},
   661  	{"%o", [3]byte{65, 66, 67}, "[101 102 103]"},
   662  	{"%U", [3]byte{65, 66, 67}, "[U+0041 U+0042 U+0043]"},
   663  	{"%v", [3]byte{65, 66, 67}, "[65 66 67]"},
   664  	{"%v", [1]byte{123}, "[123]"},
   665  	{"%012v", []byte{}, "[]"},
   666  	{"%#012v", []byte{}, "[]byte{}"},
   667  	{"%6v", []byte{1, 11, 111}, "[     1     11    111]"},
   668  	{"%06v", []byte{1, 11, 111}, "[000001 000011 000111]"},
   669  	{"%-6v", []byte{1, 11, 111}, "[1      11     111   ]"},
   670  	{"%-06v", []byte{1, 11, 111}, "[1      11     111   ]"},
   671  	{"%#v", []byte{1, 11, 111}, "[]byte{0x1, 0xb, 0x6f}"},
   672  	{"%#6v", []byte{1, 11, 111}, "[]byte{   0x1,    0xb,   0x6f}"},
   673  	{"%#06v", []byte{1, 11, 111}, "[]byte{0x000001, 0x00000b, 0x00006f}"},
   674  	{"%#-6v", []byte{1, 11, 111}, "[]byte{0x1   , 0xb   , 0x6f  }"},
   675  	{"%#-06v", []byte{1, 11, 111}, "[]byte{0x1   , 0xb   , 0x6f  }"},
   676  	// f.space should and f.plus should not have an effect with %v.
   677  	{"% v", []byte{1, 11, 111}, "[ 1  11  111]"},
   678  	{"%+v", [3]byte{1, 11, 111}, "[1 11 111]"},
   679  	{"%# -6v", []byte{1, 11, 111}, "[]byte{ 0x1  ,  0xb  ,  0x6f }"},
   680  	{"%#+-6v", [3]byte{1, 11, 111}, "[3]uint8{0x1   , 0xb   , 0x6f  }"},
   681  	// f.space and f.plus should have an effect with %d.
   682  	{"% d", []byte{1, 11, 111}, "[ 1  11  111]"},
   683  	{"%+d", [3]byte{1, 11, 111}, "[+1 +11 +111]"},
   684  	{"%# -6d", []byte{1, 11, 111}, "[ 1      11     111  ]"},
   685  	{"%#+-6d", [3]byte{1, 11, 111}, "[+1     +11    +111  ]"},
   686  
   687  	// floates with %v
   688  	{"%v", 1.2345678, "1.2345678"},
   689  	{"%v", float32(1.2345678), "1.2345678"},
   690  
   691  	// complexes with %v
   692  	{"%v", 1 + 2i, "(1+2i)"},
   693  	{"%v", complex64(1 + 2i), "(1+2i)"},
   694  
   695  	// structs
   696  	{"%v", A{1, 2, "a", []int{1, 2}}, `{1 2 a [1 2]}`},
   697  	{"%+v", A{1, 2, "a", []int{1, 2}}, `{i:1 j:2 s:a x:[1 2]}`},
   698  
   699  	// +v on structs with Stringable items
   700  	{"%+v", B{1, 2}, `{I:<1> j:2}`},
   701  	{"%+v", C{1, B{2, 3}}, `{i:1 B:{I:<2> j:3}}`},
   702  
   703  	// other formats on Stringable items
   704  	{"%s", I(23), `<23>`},
   705  	{"%q", I(23), `"<23>"`},
   706  	{"%x", I(23), `3c32333e`},
   707  	{"%#x", I(23), `0x3c32333e`},
   708  	{"%# x", I(23), `0x3c 0x32 0x33 0x3e`},
   709  	// Stringer applies only to string formats.
   710  	{"%d", I(23), `23`},
   711  	// Stringer applies to the extracted value.
   712  	{"%s", reflect.ValueOf(I(23)), `<23>`},
   713  
   714  	// go syntax
   715  	{"%#v", A{1, 2, "a", []int{1, 2}}, `fmt_test.A{i:1, j:0x2, s:"a", x:[]int{1, 2}}`},
   716  	{"%#v", new(byte), "(*uint8)(0xPTR)"},
   717  	{"%#v", TestFmtInterface, "(func(*testing.T))(0xPTR)"},
   718  	{"%#v", make(chan int), "(chan int)(0xPTR)"},
   719  	{"%#v", uint64(1<<64 - 1), "0xffffffffffffffff"},
   720  	{"%#v", 1000000000, "1000000000"},
   721  	{"%#v", map[string]int{"a": 1}, `map[string]int{"a":1}`},
   722  	{"%#v", map[string]B{"a": {1, 2}}, `map[string]fmt_test.B{"a":fmt_test.B{I:1, j:2}}`},
   723  	{"%#v", []string{"a", "b"}, `[]string{"a", "b"}`},
   724  	{"%#v", SI{}, `fmt_test.SI{I:interface {}(nil)}`},
   725  	{"%#v", []int(nil), `[]int(nil)`},
   726  	{"%#v", []int{}, `[]int{}`},
   727  	{"%#v", array, `[5]int{1, 2, 3, 4, 5}`},
   728  	{"%#v", &array, `&[5]int{1, 2, 3, 4, 5}`},
   729  	{"%#v", iarray, `[4]interface {}{1, "hello", 2.5, interface {}(nil)}`},
   730  	{"%#v", &iarray, `&[4]interface {}{1, "hello", 2.5, interface {}(nil)}`},
   731  	{"%#v", map[int]byte(nil), `map[int]uint8(nil)`},
   732  	{"%#v", map[int]byte{}, `map[int]uint8{}`},
   733  	{"%#v", "foo", `"foo"`},
   734  	{"%#v", barray, `[5]fmt_test.renamedUint8{0x1, 0x2, 0x3, 0x4, 0x5}`},
   735  	{"%#v", bslice, `[]fmt_test.renamedUint8{0x1, 0x2, 0x3, 0x4, 0x5}`},
   736  	{"%#v", []int32(nil), "[]int32(nil)"},
   737  	{"%#v", 1.2345678, "1.2345678"},
   738  	{"%#v", float32(1.2345678), "1.2345678"},
   739  
   740  	// Whole number floats are printed without decimals. See Issue 27634.
   741  	{"%#v", 1.0, "1"},
   742  	{"%#v", 1000000.0, "1e+06"},
   743  	{"%#v", float32(1.0), "1"},
   744  	{"%#v", float32(1000000.0), "1e+06"},
   745  
   746  	// Only print []byte and []uint8 as type []byte if they appear at the top level.
   747  	{"%#v", []byte(nil), "[]byte(nil)"},
   748  	{"%#v", []uint8(nil), "[]byte(nil)"},
   749  	{"%#v", []byte{}, "[]byte{}"},
   750  	{"%#v", []uint8{}, "[]byte{}"},
   751  	{"%#v", reflect.ValueOf([]byte{}), "[]uint8{}"},
   752  	{"%#v", reflect.ValueOf([]uint8{}), "[]uint8{}"},
   753  	{"%#v", &[]byte{}, "&[]uint8{}"},
   754  	{"%#v", &[]byte{}, "&[]uint8{}"},
   755  	{"%#v", [3]byte{}, "[3]uint8{0x0, 0x0, 0x0}"},
   756  	{"%#v", [3]uint8{}, "[3]uint8{0x0, 0x0, 0x0}"},
   757  
   758  	// slices with other formats
   759  	{"%#x", []int{1, 2, 15}, `[0x1 0x2 0xf]`},
   760  	{"%x", []int{1, 2, 15}, `[1 2 f]`},
   761  	{"%d", []int{1, 2, 15}, `[1 2 15]`},
   762  	{"%d", []byte{1, 2, 15}, `[1 2 15]`},
   763  	{"%q", []string{"a", "b"}, `["a" "b"]`},
   764  	{"% 02x", []byte{1}, "01"},
   765  	{"% 02x", []byte{1, 2, 3}, "01 02 03"},
   766  
   767  	// Padding with byte slices.
   768  	{"%2x", []byte{}, "  "},
   769  	{"%#2x", []byte{}, "  "},
   770  	{"% 02x", []byte{}, "00"},
   771  	{"%# 02x", []byte{}, "00"},
   772  	{"%-2x", []byte{}, "  "},
   773  	{"%-02x", []byte{}, "  "},
   774  	{"%8x", []byte{0xab}, "      ab"},
   775  	{"% 8x", []byte{0xab}, "      ab"},
   776  	{"%#8x", []byte{0xab}, "    0xab"},
   777  	{"%# 8x", []byte{0xab}, "    0xab"},
   778  	{"%08x", []byte{0xab}, "000000ab"},
   779  	{"% 08x", []byte{0xab}, "000000ab"},
   780  	{"%#08x", []byte{0xab}, "00000xab"},
   781  	{"%# 08x", []byte{0xab}, "00000xab"},
   782  	{"%10x", []byte{0xab, 0xcd}, "      abcd"},
   783  	{"% 10x", []byte{0xab, 0xcd}, "     ab cd"},
   784  	{"%#10x", []byte{0xab, 0xcd}, "    0xabcd"},
   785  	{"%# 10x", []byte{0xab, 0xcd}, " 0xab 0xcd"},
   786  	{"%010x", []byte{0xab, 0xcd}, "000000abcd"},
   787  	{"% 010x", []byte{0xab, 0xcd}, "00000ab cd"},
   788  	{"%#010x", []byte{0xab, 0xcd}, "00000xabcd"},
   789  	{"%# 010x", []byte{0xab, 0xcd}, "00xab 0xcd"},
   790  	{"%-10X", []byte{0xab}, "AB        "},
   791  	{"% -010X", []byte{0xab}, "AB        "},
   792  	{"%#-10X", []byte{0xab, 0xcd}, "0XABCD    "},
   793  	{"%# -010X", []byte{0xab, 0xcd}, "0XAB 0XCD "},
   794  	// Same for strings
   795  	{"%2x", "", "  "},
   796  	{"%#2x", "", "  "},
   797  	{"% 02x", "", "00"},
   798  	{"%# 02x", "", "00"},
   799  	{"%-2x", "", "  "},
   800  	{"%-02x", "", "  "},
   801  	{"%8x", "\xab", "      ab"},
   802  	{"% 8x", "\xab", "      ab"},
   803  	{"%#8x", "\xab", "    0xab"},
   804  	{"%# 8x", "\xab", "    0xab"},
   805  	{"%08x", "\xab", "000000ab"},
   806  	{"% 08x", "\xab", "000000ab"},
   807  	{"%#08x", "\xab", "00000xab"},
   808  	{"%# 08x", "\xab", "00000xab"},
   809  	{"%10x", "\xab\xcd", "      abcd"},
   810  	{"% 10x", "\xab\xcd", "     ab cd"},
   811  	{"%#10x", "\xab\xcd", "    0xabcd"},
   812  	{"%# 10x", "\xab\xcd", " 0xab 0xcd"},
   813  	{"%010x", "\xab\xcd", "000000abcd"},
   814  	{"% 010x", "\xab\xcd", "00000ab cd"},
   815  	{"%#010x", "\xab\xcd", "00000xabcd"},
   816  	{"%# 010x", "\xab\xcd", "00xab 0xcd"},
   817  	{"%-10X", "\xab", "AB        "},
   818  	{"% -010X", "\xab", "AB        "},
   819  	{"%#-10X", "\xab\xcd", "0XABCD    "},
   820  	{"%# -010X", "\xab\xcd", "0XAB 0XCD "},
   821  
   822  	// renamings
   823  	{"%v", renamedBool(true), "true"},
   824  	{"%d", renamedBool(true), "%!d(fmt_test.renamedBool=true)"},
   825  	{"%o", renamedInt(8), "10"},
   826  	{"%d", renamedInt8(-9), "-9"},
   827  	{"%v", renamedInt16(10), "10"},
   828  	{"%v", renamedInt32(-11), "-11"},
   829  	{"%X", renamedInt64(255), "FF"},
   830  	{"%v", renamedUint(13), "13"},
   831  	{"%o", renamedUint8(14), "16"},
   832  	{"%X", renamedUint16(15), "F"},
   833  	{"%d", renamedUint32(16), "16"},
   834  	{"%X", renamedUint64(17), "11"},
   835  	{"%o", renamedUintptr(18), "22"},
   836  	{"%x", renamedString("thing"), "7468696e67"},
   837  	{"%d", renamedBytes([]byte{1, 2, 15}), `[1 2 15]`},
   838  	{"%q", renamedBytes([]byte("hello")), `"hello"`},
   839  	{"%x", []renamedUint8{'h', 'e', 'l', 'l', 'o'}, "68656c6c6f"},
   840  	{"%X", []renamedUint8{'h', 'e', 'l', 'l', 'o'}, "68656C6C6F"},
   841  	{"%s", []renamedUint8{'h', 'e', 'l', 'l', 'o'}, "hello"},
   842  	{"%q", []renamedUint8{'h', 'e', 'l', 'l', 'o'}, `"hello"`},
   843  	{"%v", renamedFloat32(22), "22"},
   844  	{"%v", renamedFloat64(33), "33"},
   845  	{"%v", renamedComplex64(3 + 4i), "(3+4i)"},
   846  	{"%v", renamedComplex128(4 - 3i), "(4-3i)"},
   847  
   848  	// Formatter
   849  	{"%x", F(1), "<x=F(1)>"},
   850  	{"%x", G(2), "2"},
   851  	{"%+v", S{F(4), G(5)}, "{F:<v=F(4)> G:5}"},
   852  
   853  	// GoStringer
   854  	{"%#v", G(6), "GoString(6)"},
   855  	{"%#v", S{F(7), G(8)}, "fmt_test.S{F:<v=F(7)>, G:GoString(8)}"},
   856  
   857  	// %T
   858  	{"%T", byte(0), "uint8"},
   859  	{"%T", reflect.ValueOf(nil), "reflect.Value"},
   860  	{"%T", (4 - 3i), "complex128"},
   861  	{"%T", renamedComplex128(4 - 3i), "fmt_test.renamedComplex128"},
   862  	{"%T", intVar, "int"},
   863  	{"%6T", &intVar, "  *int"},
   864  	{"%10T", nil, "     <nil>"},
   865  	{"%-10T", nil, "<nil>     "},
   866  
   867  	// %p with pointers
   868  	{"%p", (*int)(nil), "0x0"},
   869  	{"%#p", (*int)(nil), "0"},
   870  	{"%p", &intVar, "0xPTR"},
   871  	{"%#p", &intVar, "PTR"},
   872  	{"%p", &array, "0xPTR"},
   873  	{"%p", &slice, "0xPTR"},
   874  	{"%8.2p", (*int)(nil), "    0x00"},
   875  	{"%-20.16p", &intVar, "0xPTR  "},
   876  	// %p on non-pointers
   877  	{"%p", make(chan int), "0xPTR"},
   878  	{"%p", make(map[int]int), "0xPTR"},
   879  	{"%p", func() {}, "0xPTR"},
   880  	{"%p", 27, "%!p(int=27)"},  // not a pointer at all
   881  	{"%p", nil, "%!p(<nil>)"},  // nil on its own has no type ...
   882  	{"%#p", nil, "%!p(<nil>)"}, // ... and hence is not a pointer type.
   883  	// pointers with specified base
   884  	{"%b", &intVar, "PTR_b"},
   885  	{"%d", &intVar, "PTR_d"},
   886  	{"%o", &intVar, "PTR_o"},
   887  	{"%x", &intVar, "PTR_x"},
   888  	{"%X", &intVar, "PTR_X"},
   889  	// %v on pointers
   890  	{"%v", nil, "<nil>"},
   891  	{"%#v", nil, "<nil>"},
   892  	{"%v", (*int)(nil), "<nil>"},
   893  	{"%#v", (*int)(nil), "(*int)(nil)"},
   894  	{"%v", &intVar, "0xPTR"},
   895  	{"%#v", &intVar, "(*int)(0xPTR)"},
   896  	{"%8.2v", (*int)(nil), "   <nil>"},
   897  	{"%-20.16v", &intVar, "0xPTR  "},
   898  	// string method on pointer
   899  	{"%s", &pValue, "String(p)"}, // String method...
   900  	{"%p", &pValue, "0xPTR"},     // ... is not called with %p.
   901  
   902  	// %d on Stringer should give integer if possible
   903  	{"%s", time.Time{}.Month(), "January"},
   904  	{"%d", time.Time{}.Month(), "1"},
   905  
   906  	// erroneous things
   907  	{"", nil, "%!(EXTRA <nil>)"},
   908  	{"", 2, "%!(EXTRA int=2)"},
   909  	{"no args", "hello", "no args%!(EXTRA string=hello)"},
   910  	{"%s %", "hello", "hello %!(NOVERB)"},
   911  	{"%s %.2", "hello", "hello %!(NOVERB)"},
   912  	{"%017091901790959340919092959340919017929593813360", 0, "%!(NOVERB)%!(EXTRA int=0)"},
   913  	{"%184467440737095516170v", 0, "%!(NOVERB)%!(EXTRA int=0)"},
   914  	// Extra argument errors should format without flags set.
   915  	{"%010.2", "12345", "%!(NOVERB)%!(EXTRA string=12345)"},
   916  
   917  	// Test that maps with non-reflexive keys print all keys and values.
   918  	{"%v", map[float64]int{NaN: 1, NaN: 1}, "map[NaN:1 NaN:1]"},
   919  
   920  	// Comparison of padding rules with C printf.
   921  	/*
   922  		C program:
   923  		#include <stdio.h>
   924  
   925  		char *format[] = {
   926  			"[%.2f]",
   927  			"[% .2f]",
   928  			"[%+.2f]",
   929  			"[%7.2f]",
   930  			"[% 7.2f]",
   931  			"[%+7.2f]",
   932  			"[% +7.2f]",
   933  			"[%07.2f]",
   934  			"[% 07.2f]",
   935  			"[%+07.2f]",
   936  			"[% +07.2f]"
   937  		};
   938  
   939  		int main(void) {
   940  			int i;
   941  			for(i = 0; i < 11; i++) {
   942  				printf("%s: ", format[i]);
   943  				printf(format[i], 1.0);
   944  				printf(" ");
   945  				printf(format[i], -1.0);
   946  				printf("\n");
   947  			}
   948  		}
   949  
   950  		Output:
   951  			[%.2f]: [1.00] [-1.00]
   952  			[% .2f]: [ 1.00] [-1.00]
   953  			[%+.2f]: [+1.00] [-1.00]
   954  			[%7.2f]: [   1.00] [  -1.00]
   955  			[% 7.2f]: [   1.00] [  -1.00]
   956  			[%+7.2f]: [  +1.00] [  -1.00]
   957  			[% +7.2f]: [  +1.00] [  -1.00]
   958  			[%07.2f]: [0001.00] [-001.00]
   959  			[% 07.2f]: [ 001.00] [-001.00]
   960  			[%+07.2f]: [+001.00] [-001.00]
   961  			[% +07.2f]: [+001.00] [-001.00]
   962  
   963  	*/
   964  	{"%.2f", 1.0, "1.00"},
   965  	{"%.2f", -1.0, "-1.00"},
   966  	{"% .2f", 1.0, " 1.00"},
   967  	{"% .2f", -1.0, "-1.00"},
   968  	{"%+.2f", 1.0, "+1.00"},
   969  	{"%+.2f", -1.0, "-1.00"},
   970  	{"%7.2f", 1.0, "   1.00"},
   971  	{"%7.2f", -1.0, "  -1.00"},
   972  	{"% 7.2f", 1.0, "   1.00"},
   973  	{"% 7.2f", -1.0, "  -1.00"},
   974  	{"%+7.2f", 1.0, "  +1.00"},
   975  	{"%+7.2f", -1.0, "  -1.00"},
   976  	{"% +7.2f", 1.0, "  +1.00"},
   977  	{"% +7.2f", -1.0, "  -1.00"},
   978  	{"%07.2f", 1.0, "0001.00"},
   979  	{"%07.2f", -1.0, "-001.00"},
   980  	{"% 07.2f", 1.0, " 001.00"},
   981  	{"% 07.2f", -1.0, "-001.00"},
   982  	{"%+07.2f", 1.0, "+001.00"},
   983  	{"%+07.2f", -1.0, "-001.00"},
   984  	{"% +07.2f", 1.0, "+001.00"},
   985  	{"% +07.2f", -1.0, "-001.00"},
   986  
   987  	// Complex numbers: exhaustively tested in TestComplexFormatting.
   988  	{"%7.2f", 1 + 2i, "(   1.00  +2.00i)"},
   989  	{"%+07.2f", -1 - 2i, "(-001.00-002.00i)"},
   990  
   991  	// Use spaces instead of zero if padding to the right.
   992  	{"%0-5s", "abc", "abc  "},
   993  	{"%-05.1f", 1.0, "1.0  "},
   994  
   995  	// float and complex formatting should not change the padding width
   996  	// for other elements. See issue 14642.
   997  	{"%06v", []any{+10.0, 10}, "[000010 000010]"},
   998  	{"%06v", []any{-10.0, 10}, "[-00010 000010]"},
   999  	{"%06v", []any{+10.0 + 10i, 10}, "[(000010+00010i) 000010]"},
  1000  	{"%06v", []any{-10.0 + 10i, 10}, "[(-00010+00010i) 000010]"},
  1001  
  1002  	// integer formatting should not alter padding for other elements.
  1003  	{"%03.6v", []any{1, 2.0, "x"}, "[000001 002 00x]"},
  1004  	{"%03.0v", []any{0, 2.0, "x"}, "[    002 000]"},
  1005  
  1006  	// Complex fmt used to leave the plus flag set for future entries in the array
  1007  	// causing +2+0i and +3+0i instead of 2+0i and 3+0i.
  1008  	{"%v", []complex64{1, 2, 3}, "[(1+0i) (2+0i) (3+0i)]"},
  1009  	{"%v", []complex128{1, 2, 3}, "[(1+0i) (2+0i) (3+0i)]"},
  1010  
  1011  	// Incomplete format specification caused crash.
  1012  	{"%.", 3, "%!.(int=3)"},
  1013  
  1014  	// Padding for complex numbers. Has been bad, then fixed, then bad again.
  1015  	{"%+10.2f", +104.66 + 440.51i, "(   +104.66   +440.51i)"},
  1016  	{"%+10.2f", -104.66 + 440.51i, "(   -104.66   +440.51i)"},
  1017  	{"%+10.2f", +104.66 - 440.51i, "(   +104.66   -440.51i)"},
  1018  	{"%+10.2f", -104.66 - 440.51i, "(   -104.66   -440.51i)"},
  1019  	{"%+010.2f", +104.66 + 440.51i, "(+000104.66+000440.51i)"},
  1020  	{"%+010.2f", -104.66 + 440.51i, "(-000104.66+000440.51i)"},
  1021  	{"%+010.2f", +104.66 - 440.51i, "(+000104.66-000440.51i)"},
  1022  	{"%+010.2f", -104.66 - 440.51i, "(-000104.66-000440.51i)"},
  1023  
  1024  	// []T where type T is a byte with a Stringer method.
  1025  	{"%v", byteStringerSlice, "[X X X X X]"},
  1026  	{"%s", byteStringerSlice, "hello"},
  1027  	{"%q", byteStringerSlice, "\"hello\""},
  1028  	{"%x", byteStringerSlice, "68656c6c6f"},
  1029  	{"%X", byteStringerSlice, "68656C6C6F"},
  1030  	{"%#v", byteStringerSlice, "[]fmt_test.byteStringer{0x68, 0x65, 0x6c, 0x6c, 0x6f}"},
  1031  
  1032  	// And the same for Formatter.
  1033  	{"%v", byteFormatterSlice, "[X X X X X]"},
  1034  	{"%s", byteFormatterSlice, "hello"},
  1035  	{"%q", byteFormatterSlice, "\"hello\""},
  1036  	{"%x", byteFormatterSlice, "68656c6c6f"},
  1037  	{"%X", byteFormatterSlice, "68656C6C6F"},
  1038  	// This next case seems wrong, but the docs say the Formatter wins here.
  1039  	{"%#v", byteFormatterSlice, "[]fmt_test.byteFormatter{X, X, X, X, X}"},
  1040  
  1041  	// pp.WriteString
  1042  	{"%s", writeStringFormatter(""), "******"},
  1043  	{"%s", writeStringFormatter("xyz"), "***xyz***"},
  1044  	{"%s", writeStringFormatter("⌘/⌘"), "***⌘/⌘***"},
  1045  
  1046  	// reflect.Value handled specially in Go 1.5, making it possible to
  1047  	// see inside non-exported fields (which cannot be accessed with Interface()).
  1048  	// Issue 8965.
  1049  	{"%v", reflect.ValueOf(A{}).Field(0).String(), "<int Value>"}, // Equivalent to the old way.
  1050  	{"%v", reflect.ValueOf(A{}).Field(0), "0"},                    // Sees inside the field.
  1051  
  1052  	// verbs apply to the extracted value too.
  1053  	{"%s", reflect.ValueOf("hello"), "hello"},
  1054  	{"%q", reflect.ValueOf("hello"), `"hello"`},
  1055  	{"%#04x", reflect.ValueOf(256), "0x0100"},
  1056  
  1057  	// invalid reflect.Value doesn't crash.
  1058  	{"%v", reflect.Value{}, "<invalid reflect.Value>"},
  1059  	{"%v", &reflect.Value{}, "<invalid Value>"},
  1060  	{"%v", SI{reflect.Value{}}, "{<invalid Value>}"},
  1061  
  1062  	// Tests to check that not supported verbs generate an error string.
  1063  	{"%☠", nil, "%!☠(<nil>)"},
  1064  	{"%☠", any(nil), "%!☠(<nil>)"},
  1065  	{"%☠", int(0), "%!☠(int=0)"},
  1066  	{"%☠", uint(0), "%!☠(uint=0)"},
  1067  	{"%☠", []byte{0, 1}, "[%!☠(uint8=0) %!☠(uint8=1)]"},
  1068  	{"%☠", []uint8{0, 1}, "[%!☠(uint8=0) %!☠(uint8=1)]"},
  1069  	{"%☠", [1]byte{0}, "[%!☠(uint8=0)]"},
  1070  	{"%☠", [1]uint8{0}, "[%!☠(uint8=0)]"},
  1071  	{"%☠", "hello", "%!☠(string=hello)"},
  1072  	{"%☠", 1.2345678, "%!☠(float64=1.2345678)"},
  1073  	{"%☠", float32(1.2345678), "%!☠(float32=1.2345678)"},
  1074  	{"%☠", 1.2345678 + 1.2345678i, "%!☠(complex128=(1.2345678+1.2345678i))"},
  1075  	{"%☠", complex64(1.2345678 + 1.2345678i), "%!☠(complex64=(1.2345678+1.2345678i))"},
  1076  	{"%☠", &intVar, "%!☠(*int=0xPTR)"},
  1077  	{"%☠", make(chan int), "%!☠(chan int=0xPTR)"},
  1078  	{"%☠", func() {}, "%!☠(func()=0xPTR)"},
  1079  	{"%☠", reflect.ValueOf(renamedInt(0)), "%!☠(fmt_test.renamedInt=0)"},
  1080  	{"%☠", SI{renamedInt(0)}, "{%!☠(fmt_test.renamedInt=0)}"},
  1081  	{"%☠", &[]any{I(1), G(2)}, "&[%!☠(fmt_test.I=1) %!☠(fmt_test.G=2)]"},
  1082  	{"%☠", SI{&[]any{I(1), G(2)}}, "{%!☠(*[]interface {}=&[1 2])}"},
  1083  	{"%☠", reflect.Value{}, "<invalid reflect.Value>"},
  1084  	{"%☠", map[float64]int{NaN: 1}, "map[%!☠(float64=NaN):%!☠(int=1)]"},
  1085  }
  1086  
  1087  // zeroFill generates zero-filled strings of the specified width. The length
  1088  // of the suffix (but not the prefix) is compensated for in the width calculation.
  1089  func zeroFill(prefix string, width int, suffix string) string {
  1090  	return prefix + strings.Repeat("0", width-len(suffix)) + suffix
  1091  }
  1092  
  1093  func TestSprintf(t *testing.T) {
  1094  	for _, tt := range fmtTests {
  1095  		s := Sprintf(tt.fmt, tt.val)
  1096  		i := strings.Index(tt.out, "PTR")
  1097  		if i >= 0 && i < len(s) {
  1098  			var pattern, chars string
  1099  			switch {
  1100  			case strings.HasPrefix(tt.out[i:], "PTR_b"):
  1101  				pattern = "PTR_b"
  1102  				chars = "01"
  1103  			case strings.HasPrefix(tt.out[i:], "PTR_o"):
  1104  				pattern = "PTR_o"
  1105  				chars = "01234567"
  1106  			case strings.HasPrefix(tt.out[i:], "PTR_d"):
  1107  				pattern = "PTR_d"
  1108  				chars = "0123456789"
  1109  			case strings.HasPrefix(tt.out[i:], "PTR_x"):
  1110  				pattern = "PTR_x"
  1111  				chars = "0123456789abcdef"
  1112  			case strings.HasPrefix(tt.out[i:], "PTR_X"):
  1113  				pattern = "PTR_X"
  1114  				chars = "0123456789ABCDEF"
  1115  			default:
  1116  				pattern = "PTR"
  1117  				chars = "0123456789abcdefABCDEF"
  1118  			}
  1119  			p := s[:i] + pattern
  1120  			for j := i; j < len(s); j++ {
  1121  				if !strings.ContainsRune(chars, rune(s[j])) {
  1122  					p += s[j:]
  1123  					break
  1124  				}
  1125  			}
  1126  			s = p
  1127  		}
  1128  		if s != tt.out {
  1129  			if _, ok := tt.val.(string); ok {
  1130  				// Don't requote the already-quoted strings.
  1131  				// It's too confusing to read the errors.
  1132  				t.Errorf("Sprintf(%q, %q) = <%s> want <%s>", tt.fmt, tt.val, s, tt.out)
  1133  			} else {
  1134  				t.Errorf("Sprintf(%q, %v) = %q want %q", tt.fmt, tt.val, s, tt.out)
  1135  			}
  1136  		}
  1137  	}
  1138  }
  1139  
  1140  // TestComplexFormatting checks that a complex always formats to the same
  1141  // thing as if done by hand with two singleton prints.
  1142  func TestComplexFormatting(t *testing.T) {
  1143  	var yesNo = []bool{true, false}
  1144  	var values = []float64{1, 0, -1, posInf, negInf, NaN}
  1145  	for _, plus := range yesNo {
  1146  		for _, zero := range yesNo {
  1147  			for _, space := range yesNo {
  1148  				for _, char := range "fFeEgG" {
  1149  					realFmt := "%"
  1150  					if zero {
  1151  						realFmt += "0"
  1152  					}
  1153  					if space {
  1154  						realFmt += " "
  1155  					}
  1156  					if plus {
  1157  						realFmt += "+"
  1158  					}
  1159  					realFmt += "10.2"
  1160  					realFmt += string(char)
  1161  					// Imaginary part always has a sign, so force + and ignore space.
  1162  					imagFmt := "%"
  1163  					if zero {
  1164  						imagFmt += "0"
  1165  					}
  1166  					imagFmt += "+"
  1167  					imagFmt += "10.2"
  1168  					imagFmt += string(char)
  1169  					for _, realValue := range values {
  1170  						for _, imagValue := range values {
  1171  							one := Sprintf(realFmt, complex(realValue, imagValue))
  1172  							two := Sprintf("("+realFmt+imagFmt+"i)", realValue, imagValue)
  1173  							if one != two {
  1174  								t.Error(f, one, two)
  1175  							}
  1176  						}
  1177  					}
  1178  				}
  1179  			}
  1180  		}
  1181  	}
  1182  }
  1183  
  1184  type SE []any // slice of empty; notational compactness.
  1185  
  1186  var reorderTests = []struct {
  1187  	fmt string
  1188  	val SE
  1189  	out string
  1190  }{
  1191  	{"%[1]d", SE{1}, "1"},
  1192  	{"%[2]d", SE{2, 1}, "1"},
  1193  	{"%[2]d %[1]d", SE{1, 2}, "2 1"},
  1194  	{"%[2]*[1]d", SE{2, 5}, "    2"},
  1195  	{"%6.2f", SE{12.0}, " 12.00"}, // Explicit version of next line.
  1196  	{"%[3]*.[2]*[1]f", SE{12.0, 2, 6}, " 12.00"},
  1197  	{"%[1]*.[2]*[3]f", SE{6, 2, 12.0}, " 12.00"},
  1198  	{"%10f", SE{12.0}, " 12.000000"},
  1199  	{"%[1]*[3]f", SE{10, 99, 12.0}, " 12.000000"},
  1200  	{"%.6f", SE{12.0}, "12.000000"}, // Explicit version of next line.
  1201  	{"%.[1]*[3]f", SE{6, 99, 12.0}, "12.000000"},
  1202  	{"%6.f", SE{12.0}, "    12"}, //  // Explicit version of next line; empty precision means zero.
  1203  	{"%[1]*.[3]f", SE{6, 3, 12.0}, "    12"},
  1204  	// An actual use! Print the same arguments twice.
  1205  	{"%d %d %d %#[1]o %#o %#o", SE{11, 12, 13}, "11 12 13 013 014 015"},
  1206  
  1207  	// Erroneous cases.
  1208  	{"%[d", SE{2, 1}, "%!d(BADINDEX)"},
  1209  	{"%]d", SE{2, 1}, "%!](int=2)d%!(EXTRA int=1)"},
  1210  	{"%[]d", SE{2, 1}, "%!d(BADINDEX)"},
  1211  	{"%[-3]d", SE{2, 1}, "%!d(BADINDEX)"},
  1212  	{"%[99]d", SE{2, 1}, "%!d(BADINDEX)"},
  1213  	{"%[3]", SE{2, 1}, "%!(NOVERB)"},
  1214  	{"%[1].2d", SE{5, 6}, "%!d(BADINDEX)"},
  1215  	{"%[1]2d", SE{2, 1}, "%!d(BADINDEX)"},
  1216  	{"%3.[2]d", SE{7}, "%!d(BADINDEX)"},
  1217  	{"%.[2]d", SE{7}, "%!d(BADINDEX)"},
  1218  	{"%d %d %d %#[1]o %#o %#o %#o", SE{11, 12, 13}, "11 12 13 013 014 015 %!o(MISSING)"},
  1219  	{"%[5]d %[2]d %d", SE{1, 2, 3}, "%!d(BADINDEX) 2 3"},
  1220  	{"%d %[3]d %d", SE{1, 2}, "1 %!d(BADINDEX) 2"}, // Erroneous index does not affect sequence.
  1221  	{"%.[]", SE{}, "%!](BADINDEX)"},                // Issue 10675
  1222  	{"%.-3d", SE{42}, "%!-(int=42)3d"},             // TODO: Should this set return better error messages?
  1223  	{"%2147483648d", SE{42}, "%!(NOVERB)%!(EXTRA int=42)"},
  1224  	{"%-2147483648d", SE{42}, "%!(NOVERB)%!(EXTRA int=42)"},
  1225  	{"%.2147483648d", SE{42}, "%!(NOVERB)%!(EXTRA int=42)"},
  1226  }
  1227  
  1228  func TestReorder(t *testing.T) {
  1229  	for _, tt := range reorderTests {
  1230  		s := Sprintf(tt.fmt, tt.val...)
  1231  		if s != tt.out {
  1232  			t.Errorf("Sprintf(%q, %v) = <%s> want <%s>", tt.fmt, tt.val, s, tt.out)
  1233  		} else {
  1234  		}
  1235  	}
  1236  }
  1237  
  1238  func BenchmarkSprintfPadding(b *testing.B) {
  1239  	b.RunParallel(func(pb *testing.PB) {
  1240  		for pb.Next() {
  1241  			_ = Sprintf("%16f", 1.0)
  1242  		}
  1243  	})
  1244  }
  1245  
  1246  func BenchmarkSprintfEmpty(b *testing.B) {
  1247  	b.RunParallel(func(pb *testing.PB) {
  1248  		for pb.Next() {
  1249  			_ = Sprintf("")
  1250  		}
  1251  	})
  1252  }
  1253  
  1254  func BenchmarkSprintfString(b *testing.B) {
  1255  	b.RunParallel(func(pb *testing.PB) {
  1256  		for pb.Next() {
  1257  			_ = Sprintf("%s", "hello")
  1258  		}
  1259  	})
  1260  }
  1261  
  1262  func BenchmarkSprintfTruncateString(b *testing.B) {
  1263  	b.RunParallel(func(pb *testing.PB) {
  1264  		for pb.Next() {
  1265  			_ = Sprintf("%.3s", "日本語日本語日本語日本語")
  1266  		}
  1267  	})
  1268  }
  1269  
  1270  func BenchmarkSprintfTruncateBytes(b *testing.B) {
  1271  	var bytes any = []byte("日本語日本語日本語日本語")
  1272  	b.RunParallel(func(pb *testing.PB) {
  1273  		for pb.Next() {
  1274  			_ = Sprintf("%.3s", bytes)
  1275  		}
  1276  	})
  1277  }
  1278  
  1279  func BenchmarkSprintfSlowParsingPath(b *testing.B) {
  1280  	b.RunParallel(func(pb *testing.PB) {
  1281  		for pb.Next() {
  1282  			_ = Sprintf("%.v", nil)
  1283  		}
  1284  	})
  1285  }
  1286  
  1287  func BenchmarkSprintfQuoteString(b *testing.B) {
  1288  	b.RunParallel(func(pb *testing.PB) {
  1289  		for pb.Next() {
  1290  			_ = Sprintf("%q", "日本語日本語日本語")
  1291  		}
  1292  	})
  1293  }
  1294  
  1295  func BenchmarkSprintfInt(b *testing.B) {
  1296  	b.RunParallel(func(pb *testing.PB) {
  1297  		for pb.Next() {
  1298  			_ = Sprintf("%d", 5)
  1299  		}
  1300  	})
  1301  }
  1302  
  1303  func BenchmarkSprintfIntInt(b *testing.B) {
  1304  	b.RunParallel(func(pb *testing.PB) {
  1305  		for pb.Next() {
  1306  			_ = Sprintf("%d %d", 5, 6)
  1307  		}
  1308  	})
  1309  }
  1310  
  1311  func BenchmarkSprintfPrefixedInt(b *testing.B) {
  1312  	b.RunParallel(func(pb *testing.PB) {
  1313  		for pb.Next() {
  1314  			_ = Sprintf("This is some meaningless prefix text that needs to be scanned %d", 6)
  1315  		}
  1316  	})
  1317  }
  1318  
  1319  func BenchmarkSprintfFloat(b *testing.B) {
  1320  	b.RunParallel(func(pb *testing.PB) {
  1321  		for pb.Next() {
  1322  			_ = Sprintf("%g", 5.23184)
  1323  		}
  1324  	})
  1325  }
  1326  
  1327  func BenchmarkSprintfComplex(b *testing.B) {
  1328  	b.RunParallel(func(pb *testing.PB) {
  1329  		for pb.Next() {
  1330  			_ = Sprintf("%f", 5.23184+5.23184i)
  1331  		}
  1332  	})
  1333  }
  1334  
  1335  func BenchmarkSprintfBoolean(b *testing.B) {
  1336  	b.RunParallel(func(pb *testing.PB) {
  1337  		for pb.Next() {
  1338  			_ = Sprintf("%t", true)
  1339  		}
  1340  	})
  1341  }
  1342  
  1343  func BenchmarkSprintfHexString(b *testing.B) {
  1344  	b.RunParallel(func(pb *testing.PB) {
  1345  		for pb.Next() {
  1346  			_ = Sprintf("% #x", "0123456789abcdef")
  1347  		}
  1348  	})
  1349  }
  1350  
  1351  func BenchmarkSprintfHexBytes(b *testing.B) {
  1352  	data := []byte("0123456789abcdef")
  1353  	b.RunParallel(func(pb *testing.PB) {
  1354  		for pb.Next() {
  1355  			_ = Sprintf("% #x", data)
  1356  		}
  1357  	})
  1358  }
  1359  
  1360  func BenchmarkSprintfBytes(b *testing.B) {
  1361  	data := []byte("0123456789abcdef")
  1362  	b.RunParallel(func(pb *testing.PB) {
  1363  		for pb.Next() {
  1364  			_ = Sprintf("%v", data)
  1365  		}
  1366  	})
  1367  }
  1368  
  1369  func BenchmarkSprintfStringer(b *testing.B) {
  1370  	stringer := I(12345)
  1371  	b.RunParallel(func(pb *testing.PB) {
  1372  		for pb.Next() {
  1373  			_ = Sprintf("%v", stringer)
  1374  		}
  1375  	})
  1376  }
  1377  
  1378  func BenchmarkSprintfStructure(b *testing.B) {
  1379  	s := &[]any{SI{12345}, map[int]string{0: "hello"}}
  1380  	b.RunParallel(func(pb *testing.PB) {
  1381  		for pb.Next() {
  1382  			_ = Sprintf("%#v", s)
  1383  		}
  1384  	})
  1385  }
  1386  
  1387  func BenchmarkManyArgs(b *testing.B) {
  1388  	b.RunParallel(func(pb *testing.PB) {
  1389  		var buf bytes.Buffer
  1390  		for pb.Next() {
  1391  			buf.Reset()
  1392  			Fprintf(&buf, "%2d/%2d/%2d %d:%d:%d %s %s\n", 3, 4, 5, 11, 12, 13, "hello", "world")
  1393  		}
  1394  	})
  1395  }
  1396  
  1397  func BenchmarkFprintInt(b *testing.B) {
  1398  	var buf bytes.Buffer
  1399  	for i := 0; i < b.N; i++ {
  1400  		buf.Reset()
  1401  		Fprint(&buf, 123456)
  1402  	}
  1403  }
  1404  
  1405  func BenchmarkFprintfBytes(b *testing.B) {
  1406  	data := []byte(string("0123456789"))
  1407  	var buf bytes.Buffer
  1408  	for i := 0; i < b.N; i++ {
  1409  		buf.Reset()
  1410  		Fprintf(&buf, "%s", data)
  1411  	}
  1412  }
  1413  
  1414  func BenchmarkFprintIntNoAlloc(b *testing.B) {
  1415  	var x any = 123456
  1416  	var buf bytes.Buffer
  1417  	for i := 0; i < b.N; i++ {
  1418  		buf.Reset()
  1419  		Fprint(&buf, x)
  1420  	}
  1421  }
  1422  
  1423  var mallocBuf bytes.Buffer
  1424  var mallocPointer *int // A pointer so we know the interface value won't allocate.
  1425  
  1426  var mallocTest = []struct {
  1427  	count int
  1428  	desc  string
  1429  	fn    func()
  1430  }{
  1431  	{0, `Sprintf("")`, func() { _ = Sprintf("") }},
  1432  	{1, `Sprintf("xxx")`, func() { _ = Sprintf("xxx") }},
  1433  	{0, `Sprintf("%x")`, func() { _ = Sprintf("%x", 7) }},
  1434  	{1, `Sprintf("%x")`, func() { _ = Sprintf("%x", 1<<16) }},
  1435  	{3, `Sprintf("%80000s")`, func() { _ = Sprintf("%80000s", "hello") }}, // large buffer (>64KB)
  1436  	{1, `Sprintf("%s")`, func() { _ = Sprintf("%s", "hello") }},
  1437  	{1, `Sprintf("%x %x")`, func() { _ = Sprintf("%x %x", 7, 112) }},
  1438  	{1, `Sprintf("%g")`, func() { _ = Sprintf("%g", float32(3.14159)) }},
  1439  	{0, `Fprintf(buf, "%s")`, func() { mallocBuf.Reset(); Fprintf(&mallocBuf, "%s", "hello") }},
  1440  	{0, `Fprintf(buf, "%x")`, func() { mallocBuf.Reset(); Fprintf(&mallocBuf, "%x", 7) }},
  1441  	{0, `Fprintf(buf, "%x")`, func() { mallocBuf.Reset(); Fprintf(&mallocBuf, "%x", 1<<16) }},
  1442  	{2, `Fprintf(buf, "%80000s")`, func() { mallocBuf.Reset(); Fprintf(&mallocBuf, "%80000s", "hello") }}, // large buffer (>64KB)
  1443  	// If the interface value doesn't need to allocate, amortized allocation overhead should be zero.
  1444  	{0, `Fprintf(buf, "%x %x %x")`, func() {
  1445  		mallocBuf.Reset()
  1446  		Fprintf(&mallocBuf, "%x %x %x", mallocPointer, mallocPointer, mallocPointer)
  1447  	}},
  1448  }
  1449  
  1450  var _ bytes.Buffer
  1451  
  1452  func TestCountMallocs(t *testing.T) {
  1453  	switch {
  1454  	case testing.Short():
  1455  		t.Skip("skipping malloc count in short mode")
  1456  	case runtime.GOMAXPROCS(0) > 1:
  1457  		t.Skip("skipping; GOMAXPROCS>1")
  1458  	case race.Enabled:
  1459  		t.Skip("skipping malloc count under race detector")
  1460  	}
  1461  	for _, mt := range mallocTest {
  1462  		mallocs := testing.AllocsPerRun(100, mt.fn)
  1463  		if got, max := mallocs, float64(mt.count); got > max {
  1464  			t.Errorf("%s: got %v allocs, want <=%v", mt.desc, got, max)
  1465  		}
  1466  	}
  1467  }
  1468  
  1469  type flagPrinter struct{}
  1470  
  1471  func (flagPrinter) Format(f State, c rune) {
  1472  	s := "%"
  1473  	for i := 0; i < 128; i++ {
  1474  		if f.Flag(i) {
  1475  			s += string(rune(i))
  1476  		}
  1477  	}
  1478  	if w, ok := f.Width(); ok {
  1479  		s += Sprintf("%d", w)
  1480  	}
  1481  	if p, ok := f.Precision(); ok {
  1482  		s += Sprintf(".%d", p)
  1483  	}
  1484  	s += string(c)
  1485  	io.WriteString(f, "["+s+"]")
  1486  }
  1487  
  1488  var flagtests = []struct {
  1489  	in  string
  1490  	out string
  1491  }{
  1492  	{"%a", "[%a]"},
  1493  	{"%-a", "[%-a]"},
  1494  	{"%+a", "[%+a]"},
  1495  	{"%#a", "[%#a]"},
  1496  	{"% a", "[% a]"},
  1497  	{"%0a", "[%0a]"},
  1498  	{"%1.2a", "[%1.2a]"},
  1499  	{"%-1.2a", "[%-1.2a]"},
  1500  	{"%+1.2a", "[%+1.2a]"},
  1501  	{"%-+1.2a", "[%+-1.2a]"},
  1502  	{"%-+1.2abc", "[%+-1.2a]bc"},
  1503  	{"%-1.2abc", "[%-1.2a]bc"},
  1504  	{"%-0abc", "[%-0a]bc"},
  1505  }
  1506  
  1507  func TestFlagParser(t *testing.T) {
  1508  	var flagprinter flagPrinter
  1509  	for _, tt := range flagtests {
  1510  		s := Sprintf(tt.in, &flagprinter)
  1511  		if s != tt.out {
  1512  			t.Errorf("Sprintf(%q, &flagprinter) => %q, want %q", tt.in, s, tt.out)
  1513  		}
  1514  	}
  1515  }
  1516  
  1517  func TestStructPrinter(t *testing.T) {
  1518  	type T struct {
  1519  		a string
  1520  		b string
  1521  		c int
  1522  	}
  1523  	var s T
  1524  	s.a = "abc"
  1525  	s.b = "def"
  1526  	s.c = 123
  1527  	var tests = []struct {
  1528  		fmt string
  1529  		out string
  1530  	}{
  1531  		{"%v", "{abc def 123}"},
  1532  		{"%+v", "{a:abc b:def c:123}"},
  1533  		{"%#v", `fmt_test.T{a:"abc", b:"def", c:123}`},
  1534  	}
  1535  	for _, tt := range tests {
  1536  		out := Sprintf(tt.fmt, s)
  1537  		if out != tt.out {
  1538  			t.Errorf("Sprintf(%q, s) = %#q, want %#q", tt.fmt, out, tt.out)
  1539  		}
  1540  		// The same but with a pointer.
  1541  		out = Sprintf(tt.fmt, &s)
  1542  		if out != "&"+tt.out {
  1543  			t.Errorf("Sprintf(%q, &s) = %#q, want %#q", tt.fmt, out, "&"+tt.out)
  1544  		}
  1545  	}
  1546  }
  1547  
  1548  func TestSlicePrinter(t *testing.T) {
  1549  	slice := []int{}
  1550  	s := Sprint(slice)
  1551  	if s != "[]" {
  1552  		t.Errorf("empty slice printed as %q not %q", s, "[]")
  1553  	}
  1554  	slice = []int{1, 2, 3}
  1555  	s = Sprint(slice)
  1556  	if s != "[1 2 3]" {
  1557  		t.Errorf("slice: got %q expected %q", s, "[1 2 3]")
  1558  	}
  1559  	s = Sprint(&slice)
  1560  	if s != "&[1 2 3]" {
  1561  		t.Errorf("&slice: got %q expected %q", s, "&[1 2 3]")
  1562  	}
  1563  }
  1564  
  1565  // presentInMap checks map printing using substrings so we don't depend on the
  1566  // print order.
  1567  func presentInMap(s string, a []string, t *testing.T) {
  1568  	for i := 0; i < len(a); i++ {
  1569  		loc := strings.Index(s, a[i])
  1570  		if loc < 0 {
  1571  			t.Errorf("map print: expected to find %q in %q", a[i], s)
  1572  		}
  1573  		// make sure the match ends here
  1574  		loc += len(a[i])
  1575  		if loc >= len(s) || (s[loc] != ' ' && s[loc] != ']') {
  1576  			t.Errorf("map print: %q not properly terminated in %q", a[i], s)
  1577  		}
  1578  	}
  1579  }
  1580  
  1581  func TestMapPrinter(t *testing.T) {
  1582  	m0 := make(map[int]string)
  1583  	s := Sprint(m0)
  1584  	if s != "map[]" {
  1585  		t.Errorf("empty map printed as %q not %q", s, "map[]")
  1586  	}
  1587  	m1 := map[int]string{1: "one", 2: "two", 3: "three"}
  1588  	a := []string{"1:one", "2:two", "3:three"}
  1589  	presentInMap(Sprintf("%v", m1), a, t)
  1590  	presentInMap(Sprint(m1), a, t)
  1591  	// Pointer to map prints the same but with initial &.
  1592  	if !strings.HasPrefix(Sprint(&m1), "&") {
  1593  		t.Errorf("no initial & for address of map")
  1594  	}
  1595  	presentInMap(Sprintf("%v", &m1), a, t)
  1596  	presentInMap(Sprint(&m1), a, t)
  1597  }
  1598  
  1599  func TestEmptyMap(t *testing.T) {
  1600  	const emptyMapStr = "map[]"
  1601  	var m map[string]int
  1602  	s := Sprint(m)
  1603  	if s != emptyMapStr {
  1604  		t.Errorf("nil map printed as %q not %q", s, emptyMapStr)
  1605  	}
  1606  	m = make(map[string]int)
  1607  	s = Sprint(m)
  1608  	if s != emptyMapStr {
  1609  		t.Errorf("empty map printed as %q not %q", s, emptyMapStr)
  1610  	}
  1611  }
  1612  
  1613  // TestBlank checks that Sprint (and hence Print, Fprint) puts spaces in the
  1614  // right places, that is, between arg pairs in which neither is a string.
  1615  func TestBlank(t *testing.T) {
  1616  	got := Sprint("<", 1, ">:", 1, 2, 3, "!")
  1617  	expect := "<1>:1 2 3!"
  1618  	if got != expect {
  1619  		t.Errorf("got %q expected %q", got, expect)
  1620  	}
  1621  }
  1622  
  1623  // TestBlankln checks that Sprintln (and hence Println, Fprintln) puts spaces in
  1624  // the right places, that is, between all arg pairs.
  1625  func TestBlankln(t *testing.T) {
  1626  	got := Sprintln("<", 1, ">:", 1, 2, 3, "!")
  1627  	expect := "< 1 >: 1 2 3 !\n"
  1628  	if got != expect {
  1629  		t.Errorf("got %q expected %q", got, expect)
  1630  	}
  1631  }
  1632  
  1633  // TestFormatterPrintln checks Formatter with Sprint, Sprintln, Sprintf.
  1634  func TestFormatterPrintln(t *testing.T) {
  1635  	f := F(1)
  1636  	expect := "<v=F(1)>\n"
  1637  	s := Sprint(f, "\n")
  1638  	if s != expect {
  1639  		t.Errorf("Sprint wrong with Formatter: expected %q got %q", expect, s)
  1640  	}
  1641  	s = Sprintln(f)
  1642  	if s != expect {
  1643  		t.Errorf("Sprintln wrong with Formatter: expected %q got %q", expect, s)
  1644  	}
  1645  	s = Sprintf("%v\n", f)
  1646  	if s != expect {
  1647  		t.Errorf("Sprintf wrong with Formatter: expected %q got %q", expect, s)
  1648  	}
  1649  }
  1650  
  1651  func args(a ...any) []any { return a }
  1652  
  1653  var startests = []struct {
  1654  	fmt string
  1655  	in  []any
  1656  	out string
  1657  }{
  1658  	{"%*d", args(4, 42), "  42"},
  1659  	{"%-*d", args(4, 42), "42  "},
  1660  	{"%*d", args(-4, 42), "42  "},
  1661  	{"%-*d", args(-4, 42), "42  "},
  1662  	{"%.*d", args(4, 42), "0042"},
  1663  	{"%*.*d", args(8, 4, 42), "    0042"},
  1664  	{"%0*d", args(4, 42), "0042"},
  1665  	// Some non-int types for width. (Issue 10732).
  1666  	{"%0*d", args(uint(4), 42), "0042"},
  1667  	{"%0*d", args(uint64(4), 42), "0042"},
  1668  	{"%0*d", args('\x04', 42), "0042"},
  1669  	{"%0*d", args(uintptr(4), 42), "0042"},
  1670  
  1671  	// erroneous
  1672  	{"%*d", args(nil, 42), "%!(BADWIDTH)42"},
  1673  	{"%*d", args(int(1e7), 42), "%!(BADWIDTH)42"},
  1674  	{"%*d", args(int(-1e7), 42), "%!(BADWIDTH)42"},
  1675  	{"%.*d", args(nil, 42), "%!(BADPREC)42"},
  1676  	{"%.*d", args(-1, 42), "%!(BADPREC)42"},
  1677  	{"%.*d", args(int(1e7), 42), "%!(BADPREC)42"},
  1678  	{"%.*d", args(uint(1e7), 42), "%!(BADPREC)42"},
  1679  	{"%.*d", args(uint64(1<<63), 42), "%!(BADPREC)42"},   // Huge negative (-inf).
  1680  	{"%.*d", args(uint64(1<<64-1), 42), "%!(BADPREC)42"}, // Small negative (-1).
  1681  	{"%*d", args(5, "foo"), "%!d(string=  foo)"},
  1682  	{"%*% %d", args(20, 5), "% 5"},
  1683  	{"%*", args(4), "%!(NOVERB)"},
  1684  }
  1685  
  1686  func TestWidthAndPrecision(t *testing.T) {
  1687  	for i, tt := range startests {
  1688  		s := Sprintf(tt.fmt, tt.in...)
  1689  		if s != tt.out {
  1690  			t.Errorf("#%d: %q: got %q expected %q", i, tt.fmt, s, tt.out)
  1691  		}
  1692  	}
  1693  }
  1694  
  1695  // PanicS is a type that panics in String.
  1696  type PanicS struct {
  1697  	message any
  1698  }
  1699  
  1700  // Value receiver.
  1701  func (p PanicS) String() string {
  1702  	panic(p.message)
  1703  }
  1704  
  1705  // PanicGo is a type that panics in GoString.
  1706  type PanicGo struct {
  1707  	message any
  1708  }
  1709  
  1710  // Value receiver.
  1711  func (p PanicGo) GoString() string {
  1712  	panic(p.message)
  1713  }
  1714  
  1715  // PanicF is a type that panics in Format.
  1716  type PanicF struct {
  1717  	message any
  1718  }
  1719  
  1720  // Value receiver.
  1721  func (p PanicF) Format(f State, c rune) {
  1722  	panic(p.message)
  1723  }
  1724  
  1725  var panictests = []struct {
  1726  	fmt string
  1727  	in  any
  1728  	out string
  1729  }{
  1730  	// String
  1731  	{"%s", (*PanicS)(nil), "<nil>"}, // nil pointer special case
  1732  	{"%s", PanicS{io.ErrUnexpectedEOF}, "%!s(PANIC=String method: unexpected EOF)"},
  1733  	{"%s", PanicS{3}, "%!s(PANIC=String method: 3)"},
  1734  	// GoString
  1735  	{"%#v", (*PanicGo)(nil), "<nil>"}, // nil pointer special case
  1736  	{"%#v", PanicGo{io.ErrUnexpectedEOF}, "%!v(PANIC=GoString method: unexpected EOF)"},
  1737  	{"%#v", PanicGo{3}, "%!v(PANIC=GoString method: 3)"},
  1738  	// Issue 18282. catchPanic should not clear fmtFlags permanently.
  1739  	{"%#v", []any{PanicGo{3}, PanicGo{3}}, "[]interface {}{%!v(PANIC=GoString method: 3), %!v(PANIC=GoString method: 3)}"},
  1740  	// Format
  1741  	{"%s", (*PanicF)(nil), "<nil>"}, // nil pointer special case
  1742  	{"%s", PanicF{io.ErrUnexpectedEOF}, "%!s(PANIC=Format method: unexpected EOF)"},
  1743  	{"%s", PanicF{3}, "%!s(PANIC=Format method: 3)"},
  1744  }
  1745  
  1746  func TestPanics(t *testing.T) {
  1747  	for i, tt := range panictests {
  1748  		s := Sprintf(tt.fmt, tt.in)
  1749  		if s != tt.out {
  1750  			t.Errorf("%d: %q: got %q expected %q", i, tt.fmt, s, tt.out)
  1751  		}
  1752  	}
  1753  }
  1754  
  1755  // recurCount tests that erroneous String routine doesn't cause fatal recursion.
  1756  var recurCount = 0
  1757  
  1758  type Recur struct {
  1759  	i      int
  1760  	failed *bool
  1761  }
  1762  
  1763  func (r *Recur) String() string {
  1764  	if recurCount++; recurCount > 10 {
  1765  		*r.failed = true
  1766  		return "FAIL"
  1767  	}
  1768  	// This will call badVerb. Before the fix, that would cause us to recur into
  1769  	// this routine to print %!p(value). Now we don't call the user's method
  1770  	// during an error.
  1771  	return Sprintf("recur@%p value: %d", r, r.i)
  1772  }
  1773  
  1774  func TestBadVerbRecursion(t *testing.T) {
  1775  	failed := false
  1776  	r := &Recur{3, &failed}
  1777  	_ = Sprintf("recur@%p value: %d\n", &r, r.i)
  1778  	if failed {
  1779  		t.Error("fail with pointer")
  1780  	}
  1781  	failed = false
  1782  	r = &Recur{4, &failed}
  1783  	_ = Sprintf("recur@%p, value: %d\n", r, r.i)
  1784  	if failed {
  1785  		t.Error("fail with value")
  1786  	}
  1787  }
  1788  
  1789  func TestIsSpace(t *testing.T) {
  1790  	// This tests the internal isSpace function.
  1791  	// IsSpace = isSpace is defined in export_test.go.
  1792  	for i := rune(0); i <= unicode.MaxRune; i++ {
  1793  		if IsSpace(i) != unicode.IsSpace(i) {
  1794  			t.Errorf("isSpace(%U) = %v, want %v", i, IsSpace(i), unicode.IsSpace(i))
  1795  		}
  1796  	}
  1797  }
  1798  
  1799  func hideFromVet(s string) string { return s }
  1800  
  1801  func TestNilDoesNotBecomeTyped(t *testing.T) {
  1802  	type A struct{}
  1803  	type B struct{}
  1804  	var a *A = nil
  1805  	var b B = B{}
  1806  	got := Sprintf(hideFromVet("%s %s %s %s %s"), nil, a, nil, b, nil)
  1807  	const expect = "%!s(<nil>) %!s(*fmt_test.A=<nil>) %!s(<nil>) {} %!s(<nil>)"
  1808  	if got != expect {
  1809  		t.Errorf("expected:\n\t%q\ngot:\n\t%q", expect, got)
  1810  	}
  1811  }
  1812  
  1813  var formatterFlagTests = []struct {
  1814  	in  string
  1815  	val any
  1816  	out string
  1817  }{
  1818  	// scalar values with the (unused by fmt) 'a' verb.
  1819  	{"%a", flagPrinter{}, "[%a]"},
  1820  	{"%-a", flagPrinter{}, "[%-a]"},
  1821  	{"%+a", flagPrinter{}, "[%+a]"},
  1822  	{"%#a", flagPrinter{}, "[%#a]"},
  1823  	{"% a", flagPrinter{}, "[% a]"},
  1824  	{"%0a", flagPrinter{}, "[%0a]"},
  1825  	{"%1.2a", flagPrinter{}, "[%1.2a]"},
  1826  	{"%-1.2a", flagPrinter{}, "[%-1.2a]"},
  1827  	{"%+1.2a", flagPrinter{}, "[%+1.2a]"},
  1828  	{"%-+1.2a", flagPrinter{}, "[%+-1.2a]"},
  1829  	{"%-+1.2abc", flagPrinter{}, "[%+-1.2a]bc"},
  1830  	{"%-1.2abc", flagPrinter{}, "[%-1.2a]bc"},
  1831  	{"%-0abc", flagPrinter{}, "[%-0a]bc"},
  1832  
  1833  	// composite values with the 'a' verb
  1834  	{"%a", [1]flagPrinter{}, "[[%a]]"},
  1835  	{"%-a", [1]flagPrinter{}, "[[%-a]]"},
  1836  	{"%+a", [1]flagPrinter{}, "[[%+a]]"},
  1837  	{"%#a", [1]flagPrinter{}, "[[%#a]]"},
  1838  	{"% a", [1]flagPrinter{}, "[[% a]]"},
  1839  	{"%0a", [1]flagPrinter{}, "[[%0a]]"},
  1840  	{"%1.2a", [1]flagPrinter{}, "[[%1.2a]]"},
  1841  	{"%-1.2a", [1]flagPrinter{}, "[[%-1.2a]]"},
  1842  	{"%+1.2a", [1]flagPrinter{}, "[[%+1.2a]]"},
  1843  	{"%-+1.2a", [1]flagPrinter{}, "[[%+-1.2a]]"},
  1844  	{"%-+1.2abc", [1]flagPrinter{}, "[[%+-1.2a]]bc"},
  1845  	{"%-1.2abc", [1]flagPrinter{}, "[[%-1.2a]]bc"},
  1846  	{"%-0abc", [1]flagPrinter{}, "[[%-0a]]bc"},
  1847  
  1848  	// simple values with the 'v' verb
  1849  	{"%v", flagPrinter{}, "[%v]"},
  1850  	{"%-v", flagPrinter{}, "[%-v]"},
  1851  	{"%+v", flagPrinter{}, "[%+v]"},
  1852  	{"%#v", flagPrinter{}, "[%#v]"},
  1853  	{"% v", flagPrinter{}, "[% v]"},
  1854  	{"%0v", flagPrinter{}, "[%0v]"},
  1855  	{"%1.2v", flagPrinter{}, "[%1.2v]"},
  1856  	{"%-1.2v", flagPrinter{}, "[%-1.2v]"},
  1857  	{"%+1.2v", flagPrinter{}, "[%+1.2v]"},
  1858  	{"%-+1.2v", flagPrinter{}, "[%+-1.2v]"},
  1859  	{"%-+1.2vbc", flagPrinter{}, "[%+-1.2v]bc"},
  1860  	{"%-1.2vbc", flagPrinter{}, "[%-1.2v]bc"},
  1861  	{"%-0vbc", flagPrinter{}, "[%-0v]bc"},
  1862  
  1863  	// composite values with the 'v' verb.
  1864  	{"%v", [1]flagPrinter{}, "[[%v]]"},
  1865  	{"%-v", [1]flagPrinter{}, "[[%-v]]"},
  1866  	{"%+v", [1]flagPrinter{}, "[[%+v]]"},
  1867  	{"%#v", [1]flagPrinter{}, "[1]fmt_test.flagPrinter{[%#v]}"},
  1868  	{"% v", [1]flagPrinter{}, "[[% v]]"},
  1869  	{"%0v", [1]flagPrinter{}, "[[%0v]]"},
  1870  	{"%1.2v", [1]flagPrinter{}, "[[%1.2v]]"},
  1871  	{"%-1.2v", [1]flagPrinter{}, "[[%-1.2v]]"},
  1872  	{"%+1.2v", [1]flagPrinter{}, "[[%+1.2v]]"},
  1873  	{"%-+1.2v", [1]flagPrinter{}, "[[%+-1.2v]]"},
  1874  	{"%-+1.2vbc", [1]flagPrinter{}, "[[%+-1.2v]]bc"},
  1875  	{"%-1.2vbc", [1]flagPrinter{}, "[[%-1.2v]]bc"},
  1876  	{"%-0vbc", [1]flagPrinter{}, "[[%-0v]]bc"},
  1877  }
  1878  
  1879  func TestFormatterFlags(t *testing.T) {
  1880  	for _, tt := range formatterFlagTests {
  1881  		s := Sprintf(tt.in, tt.val)
  1882  		if s != tt.out {
  1883  			t.Errorf("Sprintf(%q, %T) = %q, want %q", tt.in, tt.val, s, tt.out)
  1884  		}
  1885  	}
  1886  }
  1887  
  1888  func TestParsenum(t *testing.T) {
  1889  	testCases := []struct {
  1890  		s          string
  1891  		start, end int
  1892  		num        int
  1893  		isnum      bool
  1894  		newi       int
  1895  	}{
  1896  		{"a123", 0, 4, 0, false, 0},
  1897  		{"1234", 1, 1, 0, false, 1},
  1898  		{"123a", 0, 4, 123, true, 3},
  1899  		{"12a3", 0, 4, 12, true, 2},
  1900  		{"1234", 0, 4, 1234, true, 4},
  1901  		{"1a234", 1, 3, 0, false, 1},
  1902  	}
  1903  	for _, tt := range testCases {
  1904  		num, isnum, newi := Parsenum(tt.s, tt.start, tt.end)
  1905  		if num != tt.num || isnum != tt.isnum || newi != tt.newi {
  1906  			t.Errorf("parsenum(%q, %d, %d) = %d, %v, %d, want %d, %v, %d", tt.s, tt.start, tt.end, num, isnum, newi, tt.num, tt.isnum, tt.newi)
  1907  		}
  1908  	}
  1909  }
  1910  
  1911  // Test the various Append printers. The details are well tested above;
  1912  // here we just make sure the byte slice is updated.
  1913  
  1914  const (
  1915  	appendResult = "hello world, 23"
  1916  	hello        = "hello "
  1917  )
  1918  
  1919  func TestAppendf(t *testing.T) {
  1920  	b := make([]byte, 100)
  1921  	b = b[:copy(b, hello)]
  1922  	got := Appendf(b, "world, %d", 23)
  1923  	if string(got) != appendResult {
  1924  		t.Fatalf("Appendf returns %q not %q", got, appendResult)
  1925  	}
  1926  	if &b[0] != &got[0] {
  1927  		t.Fatalf("Appendf allocated a new slice")
  1928  	}
  1929  }
  1930  
  1931  func TestAppend(t *testing.T) {
  1932  	b := make([]byte, 100)
  1933  	b = b[:copy(b, hello)]
  1934  	got := Append(b, "world", ", ", 23)
  1935  	if string(got) != appendResult {
  1936  		t.Fatalf("Append returns %q not %q", got, appendResult)
  1937  	}
  1938  	if &b[0] != &got[0] {
  1939  		t.Fatalf("Append allocated a new slice")
  1940  	}
  1941  }
  1942  
  1943  func TestAppendln(t *testing.T) {
  1944  	b := make([]byte, 100)
  1945  	b = b[:copy(b, hello)]
  1946  	got := Appendln(b, "world,", 23)
  1947  	if string(got) != appendResult+"\n" {
  1948  		t.Fatalf("Appendln returns %q not %q", got, appendResult+"\n")
  1949  	}
  1950  	if &b[0] != &got[0] {
  1951  		t.Fatalf("Appendln allocated a new slice")
  1952  	}
  1953  }
  1954  

View as plain text