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         "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 }
1505
1506 func TestFlagParser(t *testing.T) {
1507         var flagprinter flagPrinter
1508         for _, tt := range flagtests {
1509                 s := Sprintf(tt.in, &flagprinter)
1510                 if s != tt.out {
1511                         t.Errorf("Sprintf(%q, &flagprinter) => %q, want %q", tt.in, s, tt.out)
1512                 }
1513         }
1514 }
1515
1516 func TestStructPrinter(t *testing.T) {
1517         type T struct {
1518                 a string
1519                 b string
1520                 c int
1521         }
1522         var s T
1523         s.a = "abc"
1524         s.b = "def"
1525         s.c = 123
1526         var tests = []struct {
1527                 fmt string
1528                 out string
1529         }{
1530                 {"%v", "{abc def 123}"},
1531                 {"%+v", "{a:abc b:def c:123}"},
1532                 {"%#v", `fmt_test.T{a:"abc", b:"def", c:123}`},
1533         }
1534         for _, tt := range tests {
1535                 out := Sprintf(tt.fmt, s)
1536                 if out != tt.out {
1537                         t.Errorf("Sprintf(%q, s) = %#q, want %#q", tt.fmt, out, tt.out)
1538                 }
1539                 // The same but with a pointer.
1540                 out = Sprintf(tt.fmt, &s)
1541                 if out != "&"+tt.out {
1542                         t.Errorf("Sprintf(%q, &s) = %#q, want %#q", tt.fmt, out, "&"+tt.out)
1543                 }
1544         }
1545 }
1546
1547 func TestSlicePrinter(t *testing.T) {
1548         slice := []int{}
1549         s := Sprint(slice)
1550         if s != "[]" {
1551                 t.Errorf("empty slice printed as %q not %q", s, "[]")
1552         }
1553         slice = []int{1, 2, 3}
1554         s = Sprint(slice)
1555         if s != "[1 2 3]" {
1556                 t.Errorf("slice: got %q expected %q", s, "[1 2 3]")
1557         }
1558         s = Sprint(&slice)
1559         if s != "&[1 2 3]" {
1560                 t.Errorf("&slice: got %q expected %q", s, "&[1 2 3]")
1561         }
1562 }
1563
1564 // presentInMap checks map printing using substrings so we don't depend on the
1565 // print order.
1566 func presentInMap(s string, a []string, t *testing.T) {
1567         for i := 0; i < len(a); i++ {
1568                 loc := strings.Index(s, a[i])
1569                 if loc < 0 {
1570                         t.Errorf("map print: expected to find %q in %q", a[i], s)
1571                 }
1572                 // make sure the match ends here
1573                 loc += len(a[i])
1574                 if loc >= len(s) || (s[loc] != ' ' && s[loc] != ']') {
1575                         t.Errorf("map print: %q not properly terminated in %q", a[i], s)
1576                 }
1577         }
1578 }
1579
1580 func TestMapPrinter(t *testing.T) {
1581         m0 := make(map[int]string)
1582         s := Sprint(m0)
1583         if s != "map[]" {
1584                 t.Errorf("empty map printed as %q not %q", s, "map[]")
1585         }
1586         m1 := map[int]string{1: "one", 2: "two", 3: "three"}
1587         a := []string{"1:one", "2:two", "3:three"}
1588         presentInMap(Sprintf("%v", m1), a, t)
1589         presentInMap(Sprint(m1), a, t)
1590         // Pointer to map prints the same but with initial &.
1591         if !strings.HasPrefix(Sprint(&m1), "&") {
1592                 t.Errorf("no initial & for address of map")
1593         }
1594         presentInMap(Sprintf("%v", &m1), a, t)
1595         presentInMap(Sprint(&m1), a, t)
1596 }
1597
1598 func TestEmptyMap(t *testing.T) {
1599         const emptyMapStr = "map[]"
1600         var m map[string]int
1601         s := Sprint(m)
1602         if s != emptyMapStr {
1603                 t.Errorf("nil map printed as %q not %q", s, emptyMapStr)
1604         }
1605         m = make(map[string]int)
1606         s = Sprint(m)
1607         if s != emptyMapStr {
1608                 t.Errorf("empty map printed as %q not %q", s, emptyMapStr)
1609         }
1610 }
1611
1612 // TestBlank checks that Sprint (and hence Print, Fprint) puts spaces in the
1613 // right places, that is, between arg pairs in which neither is a string.
1614 func TestBlank(t *testing.T) {
1615         got := Sprint("<", 1, ">:", 1, 2, 3, "!")
1616         expect := "<1>:1 2 3!"
1617         if got != expect {
1618                 t.Errorf("got %q expected %q", got, expect)
1619         }
1620 }
1621
1622 // TestBlankln checks that Sprintln (and hence Println, Fprintln) puts spaces in
1623 // the right places, that is, between all arg pairs.
1624 func TestBlankln(t *testing.T) {
1625         got := Sprintln("<", 1, ">:", 1, 2, 3, "!")
1626         expect := "< 1 >: 1 2 3 !\n"
1627         if got != expect {
1628                 t.Errorf("got %q expected %q", got, expect)
1629         }
1630 }
1631
1632 // TestFormatterPrintln checks Formatter with Sprint, Sprintln, Sprintf.
1633 func TestFormatterPrintln(t *testing.T) {
1634         f := F(1)
1635         expect := "<v=F(1)>\n"
1636         s := Sprint(f, "\n")
1637         if s != expect {
1638                 t.Errorf("Sprint wrong with Formatter: expected %q got %q", expect, s)
1639         }
1640         s = Sprintln(f)
1641         if s != expect {
1642                 t.Errorf("Sprintln wrong with Formatter: expected %q got %q", expect, s)
1643         }
1644         s = Sprintf("%v\n", f)
1645         if s != expect {
1646                 t.Errorf("Sprintf wrong with Formatter: expected %q got %q", expect, s)
1647         }
1648 }
1649
1650 func args(a ...any) []any { return a }
1651
1652 var startests = []struct {
1653         fmt string
1654         in  []any
1655         out string
1656 }{
1657         {"%*d", args(4, 42), "  42"},
1658         {"%-*d", args(4, 42), "42  "},
1659         {"%*d", args(-4, 42), "42  "},
1660         {"%-*d", args(-4, 42), "42  "},
1661         {"%.*d", args(4, 42), "0042"},
1662         {"%*.*d", args(8, 4, 42), "    0042"},
1663         {"%0*d", args(4, 42), "0042"},
1664         // Some non-int types for width. (Issue 10732).
1665         {"%0*d", args(uint(4), 42), "0042"},
1666         {"%0*d", args(uint64(4), 42), "0042"},
1667         {"%0*d", args('\x04', 42), "0042"},
1668         {"%0*d", args(uintptr(4), 42), "0042"},
1669
1670         // erroneous
1671         {"%*d", args(nil, 42), "%!(BADWIDTH)42"},
1672         {"%*d", args(int(1e7), 42), "%!(BADWIDTH)42"},
1673         {"%*d", args(int(-1e7), 42), "%!(BADWIDTH)42"},
1674         {"%.*d", args(nil, 42), "%!(BADPREC)42"},
1675         {"%.*d", args(-1, 42), "%!(BADPREC)42"},
1676         {"%.*d", args(int(1e7), 42), "%!(BADPREC)42"},
1677         {"%.*d", args(uint(1e7), 42), "%!(BADPREC)42"},
1678         {"%.*d", args(uint64(1<<63), 42), "%!(BADPREC)42"},   // Huge negative (-inf).
1679         {"%.*d", args(uint64(1<<64-1), 42), "%!(BADPREC)42"}, // Small negative (-1).
1680         {"%*d", args(5, "foo"), "%!d(string=  foo)"},
1681         {"%*% %d", args(20, 5), "% 5"},
1682         {"%*", args(4), "%!(NOVERB)"},
1683 }
1684
1685 func TestWidthAndPrecision(t *testing.T) {
1686         for i, tt := range startests {
1687                 s := Sprintf(tt.fmt, tt.in...)
1688                 if s != tt.out {
1689                         t.Errorf("#%d: %q: got %q expected %q", i, tt.fmt, s, tt.out)
1690                 }
1691         }
1692 }
1693
1694 // PanicS is a type that panics in String.
1695 type PanicS struct {
1696         message any
1697 }
1698
1699 // Value receiver.
1700 func (p PanicS) String() string {
1701         panic(p.message)
1702 }
1703
1704 // PanicGo is a type that panics in GoString.
1705 type PanicGo struct {
1706         message any
1707 }
1708
1709 // Value receiver.
1710 func (p PanicGo) GoString() string {
1711         panic(p.message)
1712 }
1713
1714 // PanicF is a type that panics in Format.
1715 type PanicF struct {
1716         message any
1717 }
1718
1719 // Value receiver.
1720 func (p PanicF) Format(f State, c rune) {
1721         panic(p.message)
1722 }
1723
1724 var panictests = []struct {
1725         fmt string
1726         in  any
1727         out string
1728 }{
1729         // String
1730         {"%s", (*PanicS)(nil), "<nil>"}, // nil pointer special case
1731         {"%s", PanicS{io.ErrUnexpectedEOF}, "%!s(PANIC=String method: unexpected EOF)"},
1732         {"%s", PanicS{3}, "%!s(PANIC=String method: 3)"},
1733         // GoString
1734         {"%#v", (*PanicGo)(nil), "<nil>"}, // nil pointer special case
1735         {"%#v", PanicGo{io.ErrUnexpectedEOF}, "%!v(PANIC=GoString method: unexpected EOF)"},
1736         {"%#v", PanicGo{3}, "%!v(PANIC=GoString method: 3)"},
1737         // Issue 18282. catchPanic should not clear fmtFlags permanently.
1738         {"%#v", []any{PanicGo{3}, PanicGo{3}}, "[]interface {}{%!v(PANIC=GoString method: 3), %!v(PANIC=GoString method: 3)}"},
1739         // Format
1740         {"%s", (*PanicF)(nil), "<nil>"}, // nil pointer special case
1741         {"%s", PanicF{io.ErrUnexpectedEOF}, "%!s(PANIC=Format method: unexpected EOF)"},
1742         {"%s", PanicF{3}, "%!s(PANIC=Format method: 3)"},
1743 }
1744
1745 func TestPanics(t *testing.T) {
1746         for i, tt := range panictests {
1747                 s := Sprintf(tt.fmt, tt.in)
1748                 if s != tt.out {
1749                         t.Errorf("%d: %q: got %q expected %q", i, tt.fmt, s, tt.out)
1750                 }
1751         }
1752 }
1753
1754 // recurCount tests that erroneous String routine doesn't cause fatal recursion.
1755 var recurCount = 0
1756
1757 type Recur struct {
1758         i      int
1759         failed *bool
1760 }
1761
1762 func (r *Recur) String() string {
1763         if recurCount++; recurCount > 10 {
1764                 *r.failed = true
1765                 return "FAIL"
1766         }
1767         // This will call badVerb. Before the fix, that would cause us to recur into
1768         // this routine to print %!p(value). Now we don't call the user's method
1769         // during an error.
1770         return Sprintf("recur@%p value: %d", r, r.i)
1771 }
1772
1773 func TestBadVerbRecursion(t *testing.T) {
1774         failed := false
1775         r := &Recur{3, &failed}
1776         _ = Sprintf("recur@%p value: %d\n", &r, r.i)
1777         if failed {
1778                 t.Error("fail with pointer")
1779         }
1780         failed = false
1781         r = &Recur{4, &failed}
1782         _ = Sprintf("recur@%p, value: %d\n", r, r.i)
1783         if failed {
1784                 t.Error("fail with value")
1785         }
1786 }
1787
1788 func TestIsSpace(t *testing.T) {
1789         // This tests the internal isSpace function.
1790         // IsSpace = isSpace is defined in export_test.go.
1791         for i := rune(0); i <= unicode.MaxRune; i++ {
1792                 if IsSpace(i) != unicode.IsSpace(i) {
1793                         t.Errorf("isSpace(%U) = %v, want %v", i, IsSpace(i), unicode.IsSpace(i))
1794                 }
1795         }
1796 }
1797
1798 func hideFromVet(s string) string { return s }
1799
1800 func TestNilDoesNotBecomeTyped(t *testing.T) {
1801         type A struct{}
1802         type B struct{}
1803         var a *A = nil
1804         var b B = B{}
1805         got := Sprintf(hideFromVet("%s %s %s %s %s"), nil, a, nil, b, nil)
1806         const expect = "%!s(<nil>) %!s(*fmt_test.A=<nil>) %!s(<nil>) {} %!s(<nil>)"
1807         if got != expect {
1808                 t.Errorf("expected:\n\t%q\ngot:\n\t%q", expect, got)
1809         }
1810 }
1811
1812 var formatterFlagTests = []struct {
1813         in  string
1814         val any
1815         out string
1816 }{
1817         // scalar values with the (unused by fmt) 'a' verb.
1818         {"%a", flagPrinter{}, "[%a]"},
1819         {"%-a", flagPrinter{}, "[%-a]"},
1820         {"%+a", flagPrinter{}, "[%+a]"},
1821         {"%#a", flagPrinter{}, "[%#a]"},
1822         {"% a", flagPrinter{}, "[% a]"},
1823         {"%0a", flagPrinter{}, "[%0a]"},
1824         {"%1.2a", flagPrinter{}, "[%1.2a]"},
1825         {"%-1.2a", flagPrinter{}, "[%-1.2a]"},
1826         {"%+1.2a", flagPrinter{}, "[%+1.2a]"},
1827         {"%-+1.2a", flagPrinter{}, "[%+-1.2a]"},
1828         {"%-+1.2abc", flagPrinter{}, "[%+-1.2a]bc"},
1829         {"%-1.2abc", flagPrinter{}, "[%-1.2a]bc"},
1830
1831         // composite values with the 'a' verb
1832         {"%a", [1]flagPrinter{}, "[[%a]]"},
1833         {"%-a", [1]flagPrinter{}, "[[%-a]]"},
1834         {"%+a", [1]flagPrinter{}, "[[%+a]]"},
1835         {"%#a", [1]flagPrinter{}, "[[%#a]]"},
1836         {"% a", [1]flagPrinter{}, "[[% a]]"},
1837         {"%0a", [1]flagPrinter{}, "[[%0a]]"},
1838         {"%1.2a", [1]flagPrinter{}, "[[%1.2a]]"},
1839         {"%-1.2a", [1]flagPrinter{}, "[[%-1.2a]]"},
1840         {"%+1.2a", [1]flagPrinter{}, "[[%+1.2a]]"},
1841         {"%-+1.2a", [1]flagPrinter{}, "[[%+-1.2a]]"},
1842         {"%-+1.2abc", [1]flagPrinter{}, "[[%+-1.2a]]bc"},
1843         {"%-1.2abc", [1]flagPrinter{}, "[[%-1.2a]]bc"},
1844
1845         // simple values with the 'v' verb
1846         {"%v", flagPrinter{}, "[%v]"},
1847         {"%-v", flagPrinter{}, "[%-v]"},
1848         {"%+v", flagPrinter{}, "[%+v]"},
1849         {"%#v", flagPrinter{}, "[%#v]"},
1850         {"% v", flagPrinter{}, "[% v]"},
1851         {"%0v", flagPrinter{}, "[%0v]"},
1852         {"%1.2v", flagPrinter{}, "[%1.2v]"},
1853         {"%-1.2v", flagPrinter{}, "[%-1.2v]"},
1854         {"%+1.2v", flagPrinter{}, "[%+1.2v]"},
1855         {"%-+1.2v", flagPrinter{}, "[%+-1.2v]"},
1856         {"%-+1.2vbc", flagPrinter{}, "[%+-1.2v]bc"},
1857         {"%-1.2vbc", flagPrinter{}, "[%-1.2v]bc"},
1858
1859         // composite values with the 'v' verb.
1860         {"%v", [1]flagPrinter{}, "[[%v]]"},
1861         {"%-v", [1]flagPrinter{}, "[[%-v]]"},
1862         {"%+v", [1]flagPrinter{}, "[[%+v]]"},
1863         {"%#v", [1]flagPrinter{}, "[1]fmt_test.flagPrinter{[%#v]}"},
1864         {"% v", [1]flagPrinter{}, "[[% v]]"},
1865         {"%0v", [1]flagPrinter{}, "[[%0v]]"},
1866         {"%1.2v", [1]flagPrinter{}, "[[%1.2v]]"},
1867         {"%-1.2v", [1]flagPrinter{}, "[[%-1.2v]]"},
1868         {"%+1.2v", [1]flagPrinter{}, "[[%+1.2v]]"},
1869         {"%-+1.2v", [1]flagPrinter{}, "[[%+-1.2v]]"},
1870         {"%-+1.2vbc", [1]flagPrinter{}, "[[%+-1.2v]]bc"},
1871         {"%-1.2vbc", [1]flagPrinter{}, "[[%-1.2v]]bc"},
1872 }
1873
1874 func TestFormatterFlags(t *testing.T) {
1875         for _, tt := range formatterFlagTests {
1876                 s := Sprintf(tt.in, tt.val)
1877                 if s != tt.out {
1878                         t.Errorf("Sprintf(%q, %T) = %q, want %q", tt.in, tt.val, s, tt.out)
1879                 }
1880         }
1881 }
1882
1883 func TestParsenum(t *testing.T) {
1884         testCases := []struct {
1885                 s          string
1886                 start, end int
1887                 num        int
1888                 isnum      bool
1889                 newi       int
1890         }{
1891                 {"a123", 0, 4, 0, false, 0},
1892                 {"1234", 1, 1, 0, false, 1},
1893                 {"123a", 0, 4, 123, true, 3},
1894                 {"12a3", 0, 4, 12, true, 2},
1895                 {"1234", 0, 4, 1234, true, 4},
1896                 {"1a234", 1, 3, 0, false, 1},
1897         }
1898         for _, tt := range testCases {
1899                 num, isnum, newi := Parsenum(tt.s, tt.start, tt.end)
1900                 if num != tt.num || isnum != tt.isnum || newi != tt.newi {
1901                         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)
1902                 }
1903         }
1904 }
1905
1906 // Test the various Append printers. The details are well tested above;
1907 // here we just make sure the byte slice is updated.
1908
1909 const (
1910         appendResult = "hello world, 23"
1911         hello        = "hello "
1912 )
1913
1914 func TestAppendf(t *testing.T) {
1915         b := make([]byte, 100)
1916         b = b[:copy(b, hello)]
1917         got := Appendf(b, "world, %d", 23)
1918         if string(got) != appendResult {
1919                 t.Fatalf("Appendf returns %q not %q", got, appendResult)
1920         }
1921         if &b[0] != &got[0] {
1922                 t.Fatalf("Appendf allocated a new slice")
1923         }
1924 }
1925
1926 func TestAppend(t *testing.T) {
1927         b := make([]byte, 100)
1928         b = b[:copy(b, hello)]
1929         got := Append(b, "world", ", ", 23)
1930         if string(got) != appendResult {
1931                 t.Fatalf("Append returns %q not %q", got, appendResult)
1932         }
1933         if &b[0] != &got[0] {
1934                 t.Fatalf("Append allocated a new slice")
1935         }
1936 }
1937
1938 func TestAppendln(t *testing.T) {
1939         b := make([]byte, 100)
1940         b = b[:copy(b, hello)]
1941         got := Appendln(b, "world,", 23)
1942         if string(got) != appendResult+"\n" {
1943                 t.Fatalf("Appendln returns %q not %q", got, appendResult+"\n")
1944         }
1945         if &b[0] != &got[0] {
1946                 t.Fatalf("Appendln allocated a new slice")
1947         }
1948 }