fmt_test.go 11.8 KB
Newer Older
1 2 3 4
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

5
package fmt_test
6 7

import (
8 9 10 11 12 13
	. "fmt"
	"io"
	"malloc" // for the malloc count test only
	"math"
	"strings"
	"testing"
14 15
)

Russ Cox's avatar
Russ Cox committed
16
func TestFmtInterface(t *testing.T) {
17
	var i1 interface{}
18 19
	i1 = "abc"
	s := Sprintf("%s", i1)
20
	if s != "abc" {
21
		t.Errorf(`Sprintf("%%s", empty("abc")) = %q want %q`, s, "abc")
22 23 24
	}
}

Rob Pike's avatar
Rob Pike committed
25
type fmtTest struct {
26 27 28
	fmt string
	val interface{}
	out string
29 30
}

Rob Pike's avatar
Rob Pike committed
31 32
const b32 uint32 = 1<<32 - 1
const b64 uint64 = 1<<64 - 1
33

34
var array = []int{1, 2, 3, 4, 5}
35
var iarray = []interface{}{1, "hello", 2.5, nil}
36

Russ Cox's avatar
Russ Cox committed
37
type A struct {
38 39 40 41
	i int
	j uint
	s string
	x []int
Russ Cox's avatar
Russ Cox committed
42 43
}

44 45
type I int

46
func (i I) String() string { return Sprintf("<%d>", i) }
47 48

type B struct {
49 50
	i I
	j int
51 52 53
}

type C struct {
54 55
	i int
	B
56 57
}

58
var b byte
Russ Cox's avatar
Russ Cox committed
59

60
var fmttests = []fmtTest{
61
	// basic string
62 63 64 65 66
	fmtTest{"%s", "abc", "abc"},
	fmtTest{"%x", "abc", "616263"},
	fmtTest{"%x", "xyz", "78797a"},
	fmtTest{"%X", "xyz", "78797A"},
	fmtTest{"%q", "abc", `"abc"`},
67 68

	// basic bytes
69 70 71 72 73 74
	fmtTest{"%s", strings.Bytes("abc"), "abc"},
	fmtTest{"%x", strings.Bytes("abc"), "616263"},
	fmtTest{"% x", strings.Bytes("abc"), "61 62 63"},
	fmtTest{"%x", strings.Bytes("xyz"), "78797a"},
	fmtTest{"%X", strings.Bytes("xyz"), "78797A"},
	fmtTest{"%q", strings.Bytes("abc"), `"abc"`},
75 76

	// escaped strings
77 78 79 80 81 82 83 84 85
	fmtTest{"%#q", `abc`, "`abc`"},
	fmtTest{"%#q", `"`, "`\"`"},
	fmtTest{"1 %#q", `\n`, "1 `\\n`"},
	fmtTest{"2 %#q", "\n", `2 "\n"`},
	fmtTest{"%q", `"`, `"\""`},
	fmtTest{"%q", "\a\b\f\r\n\t\v", `"\a\b\f\r\n\t\v"`},
	fmtTest{"%q", "abc\xffdef", `"abc\xffdef"`},
	fmtTest{"%q", "\u263a", `"\u263a"`},
	fmtTest{"%q", "\U0010ffff", `"\U0010ffff"`},
86 87

	// width
88 89 90
	fmtTest{"%5s", "abc", "  abc"},
	fmtTest{"%-5s", "abc", "abc  "},
	fmtTest{"%05s", "abc", "00abc"},
91 92

	// integers
93 94 95 96 97 98 99 100 101 102 103 104
	fmtTest{"%d", 12345, "12345"},
	fmtTest{"%d", -12345, "-12345"},
	fmtTest{"%10d", 12345, "     12345"},
	fmtTest{"%10d", -12345, "    -12345"},
	fmtTest{"%+10d", 12345, "    +12345"},
	fmtTest{"%010d", 12345, "0000012345"},
	fmtTest{"%010d", -12345, "-000012345"},
	fmtTest{"%-10d", 12345, "12345     "},
	fmtTest{"%010.3d", 1, "       001"},
	fmtTest{"%010.3d", -1, "      -001"},
	fmtTest{"%+d", 12345, "+12345"},
	fmtTest{"%+d", -12345, "-12345"},
105 106
	fmtTest{"%+d", 0, "+0"},
	fmtTest{"% d", 0, " 0"},
107
	fmtTest{"% d", 12345, " 12345"},
108

109 110 111 112 113 114 115 116 117 118 119 120
	// floats
	fmtTest{"%+.3e", 0.0, "+0.000e+00"},
	fmtTest{"%+.3e", 1.0, "+1.000e+00"},
	fmtTest{"%+.3f", -1.0, "-1.000"},
	fmtTest{"% .3E", -1.0, "-1.000E+00"},
	fmtTest{"% .3e", 1.0, " 1.000e+00"},
	fmtTest{"%+.3g", 0.0, "+0"},
	fmtTest{"%+.3g", 1.0, "+1"},
	fmtTest{"%+.3g", -1.0, "-1"},
	fmtTest{"% .3g", -1.0, "-1"},
	fmtTest{"% .3g", 1.0, " 1"},

121
	// erroneous formats
122 123
	fmtTest{"", 2, "?(extra int=2)"},
	fmtTest{"%d", "hello", "%d(string=hello)"},
124

125
	// old test/fmt_test.go
126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204
	fmtTest{"%d", 1234, "1234"},
	fmtTest{"%d", -1234, "-1234"},
	fmtTest{"%d", uint(1234), "1234"},
	fmtTest{"%d", uint32(b32), "4294967295"},
	fmtTest{"%d", uint64(b64), "18446744073709551615"},
	fmtTest{"%o", 01234, "1234"},
	fmtTest{"%#o", 01234, "01234"},
	fmtTest{"%o", uint32(b32), "37777777777"},
	fmtTest{"%o", uint64(b64), "1777777777777777777777"},
	fmtTest{"%x", 0x1234abcd, "1234abcd"},
	fmtTest{"%#x", 0x1234abcd, "0x1234abcd"},
	fmtTest{"%x", b32 - 0x1234567, "fedcba98"},
	fmtTest{"%X", 0x1234abcd, "1234ABCD"},
	fmtTest{"%X", b32 - 0x1234567, "FEDCBA98"},
	fmtTest{"%#X", 0, "0X0"},
	fmtTest{"%x", b64, "ffffffffffffffff"},
	fmtTest{"%b", 7, "111"},
	fmtTest{"%b", b64, "1111111111111111111111111111111111111111111111111111111111111111"},
	fmtTest{"%e", float64(1), "1.000000e+00"},
	fmtTest{"%e", float64(1234.5678e3), "1.234568e+06"},
	fmtTest{"%e", float64(1234.5678e-8), "1.234568e-05"},
	fmtTest{"%e", float64(-7), "-7.000000e+00"},
	fmtTest{"%e", float64(-1e-9), "-1.000000e-09"},
	fmtTest{"%f", float64(1234.5678e3), "1234567.800000"},
	fmtTest{"%f", float64(1234.5678e-8), "0.000012"},
	fmtTest{"%f", float64(-7), "-7.000000"},
	fmtTest{"%f", float64(-1e-9), "-0.000000"},
	fmtTest{"%g", float64(1234.5678e3), "1.2345678e+06"},
	fmtTest{"%g", float32(1234.5678e3), "1.2345678e+06"},
	fmtTest{"%g", float64(1234.5678e-8), "1.2345678e-05"},
	fmtTest{"%g", float64(-7), "-7"},
	fmtTest{"%g", float64(-1e-9), "-1e-09"},
	fmtTest{"%g", float32(-1e-9), "-1e-09"},
	fmtTest{"%E", float64(1), "1.000000E+00"},
	fmtTest{"%E", float64(1234.5678e3), "1.234568E+06"},
	fmtTest{"%E", float64(1234.5678e-8), "1.234568E-05"},
	fmtTest{"%E", float64(-7), "-7.000000E+00"},
	fmtTest{"%E", float64(-1e-9), "-1.000000E-09"},
	fmtTest{"%G", float64(1234.5678e3), "1.2345678E+06"},
	fmtTest{"%G", float32(1234.5678e3), "1.2345678E+06"},
	fmtTest{"%G", float64(1234.5678e-8), "1.2345678E-05"},
	fmtTest{"%G", float64(-7), "-7"},
	fmtTest{"%G", float64(-1e-9), "-1E-09"},
	fmtTest{"%G", float32(-1e-9), "-1E-09"},
	fmtTest{"%c", 'x', "x"},
	fmtTest{"%c", 0xe4, "ä"},
	fmtTest{"%c", 0x672c, "本"},
	fmtTest{"%c", '日', "日"},
	fmtTest{"%20.8d", 1234, "            00001234"},
	fmtTest{"%20.8d", -1234, "           -00001234"},
	fmtTest{"%20d", 1234, "                1234"},
	fmtTest{"%-20.8d", 1234, "00001234            "},
	fmtTest{"%-20.8d", -1234, "-00001234           "},
	fmtTest{"%-#20.8x", 0x1234abc, "0x01234abc          "},
	fmtTest{"%-#20.8X", 0x1234abc, "0X01234ABC          "},
	fmtTest{"%-#20.8o", 01234, "00001234            "},
	fmtTest{"%.20b", 7, "00000000000000000111"},
	fmtTest{"%20.5s", "qwertyuiop", "               qwert"},
	fmtTest{"%.5s", "qwertyuiop", "qwert"},
	fmtTest{"%-20.5s", "qwertyuiop", "qwert               "},
	fmtTest{"%20c", 'x', "                   x"},
	fmtTest{"%-20c", 'x', "x                   "},
	fmtTest{"%20.6e", 1.2345e3, "        1.234500e+03"},
	fmtTest{"%20.6e", 1.2345e-3, "        1.234500e-03"},
	fmtTest{"%20e", 1.2345e3, "        1.234500e+03"},
	fmtTest{"%20e", 1.2345e-3, "        1.234500e-03"},
	fmtTest{"%20.8e", 1.2345e3, "      1.23450000e+03"},
	fmtTest{"%20f", float64(1.23456789e3), "         1234.567890"},
	fmtTest{"%20f", float64(1.23456789e-3), "            0.001235"},
	fmtTest{"%20f", float64(12345678901.23456789), "  12345678901.234568"},
	fmtTest{"%-20f", float64(1.23456789e3), "1234.567890         "},
	fmtTest{"%20.8f", float64(1.23456789e3), "       1234.56789000"},
	fmtTest{"%20.8f", float64(1.23456789e-3), "          0.00123457"},
	fmtTest{"%g", float64(1.23456789e3), "1234.56789"},
	fmtTest{"%g", float64(1.23456789e-3), "0.00123456789"},
	fmtTest{"%g", float64(1.23456789e20), "1.23456789e+20"},
	fmtTest{"%20e", math.Inf(1), "                +Inf"},
	fmtTest{"%-20f", math.Inf(-1), "-Inf                "},
	fmtTest{"%20g", math.NaN(), "                 NaN"},
Russ Cox's avatar
Russ Cox committed
205 206

	// arrays
207 208 209 210
	fmtTest{"%v", array, "[1 2 3 4 5]"},
	fmtTest{"%v", iarray, "[1 hello 2.5 <nil>]"},
	fmtTest{"%v", &array, "&[1 2 3 4 5]"},
	fmtTest{"%v", &iarray, "&[1 hello 2.5 <nil>]"},
Russ Cox's avatar
Russ Cox committed
211 212

	// structs
213 214
	fmtTest{"%v", A{1, 2, "a", []int{1, 2}}, `{1 2 a [1 2]}`},
	fmtTest{"%+v", A{1, 2, "a", []int{1, 2}}, `{i:1 j:2 s:a x:[1 2]}`},
Russ Cox's avatar
Russ Cox committed
215

216 217 218 219
	// +v on structs with Stringable items
	fmtTest{"%+v", B{1, 2}, `{i:<1> j:2}`},
	fmtTest{"%+v", C{1, B{2, 3}}, `{i:1 B:{i:<2> j:3}}`},

220 221 222 223 224
	// %p on non-pointers
	fmtTest{"%p", make(chan int), "PTR"},
	fmtTest{"%p", make(map[int]int), "PTR"},
	fmtTest{"%p", make([]int, 1), "PTR"},

Russ Cox's avatar
Russ Cox committed
225
	// go syntax
226 227 228 229 230 231
	fmtTest{"%#v", A{1, 2, "a", []int{1, 2}}, `fmt_test.A{i:1, j:0x2, s:"a", x:[]int{1, 2}}`},
	fmtTest{"%#v", &b, "(*uint8)(PTR)"},
	fmtTest{"%#v", TestFmtInterface, "(func(*testing.T))(PTR)"},
	fmtTest{"%#v", make(chan int), "(chan int)(PTR)"},
	fmtTest{"%#v", uint64(1<<64 - 1), "0xffffffffffffffff"},
	fmtTest{"%#v", 1000000000, "1000000000"},
232
}
233

Russ Cox's avatar
Russ Cox committed
234
func TestSprintf(t *testing.T) {
Russ Cox's avatar
Russ Cox committed
235
	for _, tt := range fmttests {
236
		s := Sprintf(tt.fmt, tt.val)
Russ Cox's avatar
Russ Cox committed
237
		if i := strings.Index(s, "0x"); i >= 0 && strings.Index(tt.out, "PTR") >= 0 {
238
			j := i + 2
Russ Cox's avatar
Russ Cox committed
239
			for ; j < len(s); j++ {
240
				c := s[j]
241
				if (c < '0' || c > '9') && (c < 'a' || c > 'f') && (c < 'A' || c > 'F') {
242
					break
Russ Cox's avatar
Russ Cox committed
243 244
				}
			}
245
			s = s[0:i] + "PTR" + s[j:]
Russ Cox's avatar
Russ Cox committed
246
		}
247
		if s != tt.out {
Russ Cox's avatar
Russ Cox committed
248
			if _, ok := tt.val.(string); ok {
249 250
				// Don't requote the already-quoted strings.
				// It's too confusing to read the errors.
251
				t.Errorf("Sprintf(%q, %q) = <%s> want <%s>", tt.fmt, tt.val, s, tt.out)
252
			} else {
253
				t.Errorf("Sprintf(%q, %v) = %q want %q", tt.fmt, tt.val, s, tt.out)
254 255 256 257 258
			}
		}
	}
}

259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276
func BenchmarkSprintfEmpty(b *testing.B) {
	for i := 0; i < b.N; i++ {
		Sprintf("")
	}
}

func BenchmarkSprintfString(b *testing.B) {
	for i := 0; i < b.N; i++ {
		Sprintf("%s", "hello")
	}
}

func BenchmarkSprintfInt(b *testing.B) {
	for i := 0; i < b.N; i++ {
		Sprintf("%d", 5)
	}
}

277 278 279 280 281 282 283
func BenchmarkSprintfIntInt(b *testing.B) {
	for i := 0; i < b.N; i++ {
		Sprintf("%d %d", 5, 6)
	}
}

func TestCountMallocs(t *testing.T) {
284
	mallocs := 0 - malloc.GetStats().Mallocs
285 286 287
	for i := 0; i < 100; i++ {
		Sprintf("")
	}
288 289 290
	mallocs += malloc.GetStats().Mallocs
	Printf("mallocs per Sprintf(\"\"): %d\n", mallocs/100)
	mallocs = 0 - malloc.GetStats().Mallocs
291 292 293
	for i := 0; i < 100; i++ {
		Sprintf("xxx")
	}
294 295 296
	mallocs += malloc.GetStats().Mallocs
	Printf("mallocs per Sprintf(\"xxx\"): %d\n", mallocs/100)
	mallocs = 0 - malloc.GetStats().Mallocs
297 298 299
	for i := 0; i < 100; i++ {
		Sprintf("%x", i)
	}
300 301 302
	mallocs += malloc.GetStats().Mallocs
	Printf("mallocs per Sprintf(\"%%x\"): %d\n", mallocs/100)
	mallocs = 0 - malloc.GetStats().Mallocs
303 304 305
	for i := 0; i < 100; i++ {
		Sprintf("%x %x", i, i)
	}
306 307
	mallocs += malloc.GetStats().Mallocs
	Printf("mallocs per Sprintf(\"%%x %%x\"): %d\n", mallocs/100)
308 309
}

310 311
type flagPrinter struct{}

Rob Pike's avatar
Rob Pike committed
312
func (*flagPrinter) Format(f State, c int) {
313
	s := "%"
314 315
	for i := 0; i < 128; i++ {
		if f.Flag(i) {
316
			s += string(i)
317 318 319
		}
	}
	if w, ok := f.Width(); ok {
320
		s += Sprintf("%d", w)
321 322
	}
	if p, ok := f.Precision(); ok {
323
		s += Sprintf(".%d", p)
324
	}
325 326
	s += string(c)
	io.WriteString(f, "["+s+"]")
327 328
}

Rob Pike's avatar
Rob Pike committed
329
type flagTest struct {
330 331
	in  string
	out string
332 333
}

334 335 336 337 338 339 340 341 342 343 344 345 346
var flagtests = []flagTest{
	flagTest{"%a", "[%a]"},
	flagTest{"%-a", "[%-a]"},
	flagTest{"%+a", "[%+a]"},
	flagTest{"%#a", "[%#a]"},
	flagTest{"% a", "[% a]"},
	flagTest{"%0a", "[%0a]"},
	flagTest{"%1.2a", "[%1.2a]"},
	flagTest{"%-1.2a", "[%-1.2a]"},
	flagTest{"%+1.2a", "[%+1.2a]"},
	flagTest{"%-+1.2a", "[%+-1.2a]"},
	flagTest{"%-+1.2abc", "[%+-1.2a]bc"},
	flagTest{"%-1.2abc", "[%-1.2a]bc"},
347
}
348

Russ Cox's avatar
Russ Cox committed
349
func TestFlagParser(t *testing.T) {
350
	var flagprinter flagPrinter
Russ Cox's avatar
Russ Cox committed
351
	for _, tt := range flagtests {
352
		s := Sprintf(tt.in, &flagprinter)
353
		if s != tt.out {
354
			t.Errorf("Sprintf(%q, &flagprinter) => %q, want %q", tt.in, s, tt.out)
355 356 357 358
		}
	}
}

Russ Cox's avatar
Russ Cox committed
359
func TestStructPrinter(t *testing.T) {
360
	var s struct {
361 362 363
		a string
		b string
		c int
364
	}
365 366 367
	s.a = "abc"
	s.b = "def"
	s.c = 123
368
	type Test struct {
369 370
		fmt string
		out string
371
	}
372 373 374
	var tests = []Test{
		Test{"%v", "{abc def 123}"},
		Test{"%+v", "{a:abc b:def c:123}"},
375
	}
Russ Cox's avatar
Russ Cox committed
376
	for _, tt := range tests {
377
		out := Sprintf(tt.fmt, s)
378
		if out != tt.out {
379
			t.Errorf("Sprintf(%q, &s) = %q, want %q", tt.fmt, out, tt.out)
380 381 382
		}
	}
}
Rob Pike's avatar
Rob Pike committed
383 384 385 386

// Check map printing using substrings so we don't depend on the print order.
func presentInMap(s string, a []string, t *testing.T) {
	for i := 0; i < len(a); i++ {
387
		loc := strings.Index(s, a[i])
Rob Pike's avatar
Rob Pike committed
388
		if loc < 0 {
389
			t.Errorf("map print: expected to find %q in %q", a[i], s)
Rob Pike's avatar
Rob Pike committed
390 391
		}
		// make sure the match ends here
392
		loc += len(a[i])
Rob Pike's avatar
Rob Pike committed
393
		if loc >= len(s) || (s[loc] != ' ' && s[loc] != ']') {
394
			t.Errorf("map print: %q not properly terminated in %q", a[i], s)
Rob Pike's avatar
Rob Pike committed
395 396 397 398 399
		}
	}
}

func TestMapPrinter(t *testing.T) {
400 401
	m0 := make(map[int]string)
	s := Sprint(m0)
Rob Pike's avatar
Rob Pike committed
402
	if s != "map[]" {
403
		t.Errorf("empty map printed as %q not %q", s, "map[]")
Rob Pike's avatar
Rob Pike committed
404
	}
405 406 407 408
	m1 := map[int]string{1: "one", 2: "two", 3: "three"}
	a := []string{"1:one", "2:two", "3:three"}
	presentInMap(Sprintf("%v", m1), a, t)
	presentInMap(Sprint(m1), a, t)
Rob Pike's avatar
Rob Pike committed
409
}
Rob Pike's avatar
Rob Pike committed
410 411

func TestEmptyMap(t *testing.T) {
412 413 414
	const emptyMapStr = "map[]"
	var m map[string]int
	s := Sprint(m)
Rob Pike's avatar
Rob Pike committed
415
	if s != emptyMapStr {
416
		t.Errorf("nil map printed as %q not %q", s, emptyMapStr)
Rob Pike's avatar
Rob Pike committed
417
	}
418 419
	m = make(map[string]int)
	s = Sprint(m)
Rob Pike's avatar
Rob Pike committed
420
	if s != emptyMapStr {
421
		t.Errorf("empty map printed as %q not %q", s, emptyMapStr)
Rob Pike's avatar
Rob Pike committed
422 423
	}
}