2008-11-24 15:51:33 -07:00
|
|
|
// 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.
|
|
|
|
|
2009-08-12 14:18:37 -06:00
|
|
|
package fmt_test
|
2008-11-24 15:51:33 -07:00
|
|
|
|
|
|
|
import (
|
2009-12-15 16:27:16 -07:00
|
|
|
. "fmt"
|
|
|
|
"io"
|
|
|
|
"math"
|
2010-02-03 17:31:34 -07:00
|
|
|
"runtime" // for the malloc count test only
|
2009-12-15 16:27:16 -07:00
|
|
|
"strings"
|
|
|
|
"testing"
|
2008-11-24 15:51:33 -07:00
|
|
|
)
|
|
|
|
|
2009-01-20 15:40:40 -07:00
|
|
|
func TestFmtInterface(t *testing.T) {
|
2009-10-06 16:38:57 -06:00
|
|
|
var i1 interface{}
|
2009-12-15 16:27:16 -07:00
|
|
|
i1 = "abc"
|
|
|
|
s := Sprintf("%s", i1)
|
2008-11-24 15:51:33 -07:00
|
|
|
if s != "abc" {
|
2009-11-09 13:07:39 -07:00
|
|
|
t.Errorf(`Sprintf("%%s", empty("abc")) = %q want %q`, s, "abc")
|
2008-11-24 15:51:33 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-15 17:03:27 -07:00
|
|
|
type fmtTest struct {
|
2009-12-15 16:27:16 -07:00
|
|
|
fmt string
|
|
|
|
val interface{}
|
|
|
|
out string
|
2008-11-24 15:51:33 -07:00
|
|
|
}
|
|
|
|
|
2009-01-15 17:03:27 -07:00
|
|
|
const b32 uint32 = 1<<32 - 1
|
|
|
|
const b64 uint64 = 1<<64 - 1
|
2009-10-06 16:38:57 -06:00
|
|
|
|
2009-03-03 09:39:12 -07:00
|
|
|
var array = []int{1, 2, 3, 4, 5}
|
2009-04-06 22:28:04 -06:00
|
|
|
var iarray = []interface{}{1, "hello", 2.5, nil}
|
2008-11-24 15:51:33 -07:00
|
|
|
|
2009-08-31 17:38:30 -06:00
|
|
|
type A struct {
|
2009-12-15 16:27:16 -07:00
|
|
|
i int
|
|
|
|
j uint
|
|
|
|
s string
|
|
|
|
x []int
|
2009-08-31 17:38:30 -06:00
|
|
|
}
|
|
|
|
|
2009-11-17 23:14:34 -07:00
|
|
|
type I int
|
|
|
|
|
2009-12-15 16:27:16 -07:00
|
|
|
func (i I) String() string { return Sprintf("<%d>", i) }
|
2009-11-17 23:14:34 -07:00
|
|
|
|
|
|
|
type B struct {
|
2009-12-15 16:27:16 -07:00
|
|
|
i I
|
|
|
|
j int
|
2009-11-17 23:14:34 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
type C struct {
|
2009-12-15 16:27:16 -07:00
|
|
|
i int
|
|
|
|
B
|
2009-11-17 23:14:34 -07:00
|
|
|
}
|
|
|
|
|
2009-10-06 16:38:57 -06:00
|
|
|
var b byte
|
2009-08-31 17:38:30 -06:00
|
|
|
|
2009-03-03 09:39:12 -07:00
|
|
|
var fmttests = []fmtTest{
|
2008-11-24 15:51:33 -07:00
|
|
|
// basic string
|
2009-10-06 16:38:57 -06:00
|
|
|
fmtTest{"%s", "abc", "abc"},
|
|
|
|
fmtTest{"%x", "abc", "616263"},
|
|
|
|
fmtTest{"%x", "xyz", "78797a"},
|
|
|
|
fmtTest{"%X", "xyz", "78797A"},
|
|
|
|
fmtTest{"%q", "abc", `"abc"`},
|
2008-11-24 15:51:33 -07:00
|
|
|
|
|
|
|
// basic bytes
|
2010-02-25 17:01:29 -07:00
|
|
|
fmtTest{"%s", []byte("abc"), "abc"},
|
|
|
|
fmtTest{"%x", []byte("abc"), "616263"},
|
|
|
|
fmtTest{"% x", []byte("abc"), "61 62 63"},
|
|
|
|
fmtTest{"%x", []byte("xyz"), "78797a"},
|
|
|
|
fmtTest{"%X", []byte("xyz"), "78797A"},
|
|
|
|
fmtTest{"%q", []byte("abc"), `"abc"`},
|
2008-11-24 15:51:33 -07:00
|
|
|
|
|
|
|
// escaped strings
|
2009-10-06 16:38:57 -06:00
|
|
|
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"`},
|
2008-11-24 15:51:33 -07:00
|
|
|
|
|
|
|
// width
|
2009-10-06 16:38:57 -06:00
|
|
|
fmtTest{"%5s", "abc", " abc"},
|
2010-02-28 03:15:56 -07:00
|
|
|
fmtTest{"%2s", "\u263a", " \u263a"},
|
2009-10-06 16:38:57 -06:00
|
|
|
fmtTest{"%-5s", "abc", "abc "},
|
|
|
|
fmtTest{"%05s", "abc", "00abc"},
|
2008-11-24 15:51:33 -07:00
|
|
|
|
|
|
|
// integers
|
2009-10-06 16:38:57 -06:00
|
|
|
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"},
|
2009-11-20 12:04:51 -07:00
|
|
|
fmtTest{"%+d", 0, "+0"},
|
|
|
|
fmtTest{"% d", 0, " 0"},
|
2009-10-06 16:38:57 -06:00
|
|
|
fmtTest{"% d", 12345, " 12345"},
|
2008-11-24 15:51:33 -07:00
|
|
|
|
2009-11-20 12:04:51 -07:00
|
|
|
// 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"},
|
|
|
|
|
2010-03-06 14:38:14 -07:00
|
|
|
// complex values
|
|
|
|
fmtTest{"%+.3e", 0i, "(+0.000e+00+0.000e+00i)"},
|
|
|
|
fmtTest{"%+.3f", 0i, "(+0.000+0.000i)"},
|
|
|
|
fmtTest{"%+.3g", 0i, "(+0+0i)"},
|
|
|
|
fmtTest{"%+.3e", 1 + 2i, "(+1.000e+00+2.000e+00i)"},
|
|
|
|
fmtTest{"%+.3f", 1 + 2i, "(+1.000+2.000i)"},
|
|
|
|
fmtTest{"%+.3g", 1 + 2i, "(+1+2i)"},
|
|
|
|
fmtTest{"%.3e", 0i, "(0.000e+00+0.000e+00i)"},
|
|
|
|
fmtTest{"%.3f", 0i, "(0.000+0.000i)"},
|
|
|
|
fmtTest{"%.3g", 0i, "(0+0i)"},
|
|
|
|
fmtTest{"%.3e", 1 + 2i, "(1.000e+00+2.000e+00i)"},
|
|
|
|
fmtTest{"%.3f", 1 + 2i, "(1.000+2.000i)"},
|
|
|
|
fmtTest{"%.3g", 1 + 2i, "(1+2i)"},
|
|
|
|
fmtTest{"%.3e", -1 - 2i, "(-1.000e+00-2.000e+00i)"},
|
|
|
|
fmtTest{"%.3f", -1 - 2i, "(-1.000-2.000i)"},
|
|
|
|
fmtTest{"%.3g", -1 - 2i, "(-1-2i)"},
|
|
|
|
fmtTest{"% .3E", -1 - 2i, "(-1.000E+00-2.000E+00i)"},
|
|
|
|
fmtTest{"%+.3g", complex64(1 + 2i), "(+1+2i)"},
|
|
|
|
fmtTest{"%+.3g", complex128(1 + 2i), "(+1+2i)"},
|
|
|
|
|
2009-08-28 14:02:34 -06:00
|
|
|
// erroneous formats
|
2009-10-06 16:38:57 -06:00
|
|
|
fmtTest{"", 2, "?(extra int=2)"},
|
|
|
|
fmtTest{"%d", "hello", "%d(string=hello)"},
|
2009-08-28 14:02:34 -06:00
|
|
|
|
2008-11-24 15:51:33 -07:00
|
|
|
// old test/fmt_test.go
|
2009-10-06 16:38:57 -06:00
|
|
|
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"},
|
2010-04-12 11:20:06 -06:00
|
|
|
fmtTest{"%b", -6, "-110"},
|
2009-10-06 16:38:57 -06:00
|
|
|
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"},
|
2009-08-31 17:38:30 -06:00
|
|
|
|
|
|
|
// arrays
|
2009-10-06 16:38:57 -06:00
|
|
|
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>]"},
|
2009-08-31 17:38:30 -06:00
|
|
|
|
2010-03-06 14:38:14 -07:00
|
|
|
// complexes with %v
|
|
|
|
fmtTest{"%v", 1 + 2i, "(1+2i)"},
|
|
|
|
fmtTest{"%v", complex64(1 + 2i), "(1+2i)"},
|
|
|
|
fmtTest{"%v", complex128(1 + 2i), "(1+2i)"},
|
|
|
|
|
2009-08-31 17:38:30 -06:00
|
|
|
// structs
|
2009-10-06 16:38:57 -06:00
|
|
|
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]}`},
|
2009-08-31 17:38:30 -06:00
|
|
|
|
2009-11-17 23:14:34 -07:00
|
|
|
// +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}}`},
|
|
|
|
|
2010-02-24 23:29:37 -07:00
|
|
|
// q on Stringable items
|
|
|
|
fmtTest{"%q", I(23), `"<23>"`},
|
|
|
|
|
2009-12-21 23:02:00 -07:00
|
|
|
// %p on non-pointers
|
|
|
|
fmtTest{"%p", make(chan int), "PTR"},
|
|
|
|
fmtTest{"%p", make(map[int]int), "PTR"},
|
|
|
|
fmtTest{"%p", make([]int, 1), "PTR"},
|
|
|
|
|
2009-08-31 17:38:30 -06:00
|
|
|
// go syntax
|
2009-10-06 16:38:57 -06:00
|
|
|
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"},
|
2010-02-04 17:23:25 -07:00
|
|
|
|
|
|
|
// erroneous things
|
|
|
|
fmtTest{"%d", "hello", "%d(string=hello)"},
|
|
|
|
fmtTest{"no args", "hello", "no args?(extra string=hello)"},
|
|
|
|
fmtTest{"%s", nil, "%s(<nil>)"},
|
2009-03-03 09:39:12 -07:00
|
|
|
}
|
2008-11-24 15:51:33 -07:00
|
|
|
|
2009-01-20 15:40:40 -07:00
|
|
|
func TestSprintf(t *testing.T) {
|
2009-09-15 10:41:59 -06:00
|
|
|
for _, tt := range fmttests {
|
2009-12-15 16:27:16 -07:00
|
|
|
s := Sprintf(tt.fmt, tt.val)
|
2009-08-31 17:38:30 -06:00
|
|
|
if i := strings.Index(s, "0x"); i >= 0 && strings.Index(tt.out, "PTR") >= 0 {
|
2009-12-15 16:27:16 -07:00
|
|
|
j := i + 2
|
2009-08-31 17:38:30 -06:00
|
|
|
for ; j < len(s); j++ {
|
2009-12-15 16:27:16 -07:00
|
|
|
c := s[j]
|
2009-12-21 23:02:00 -07:00
|
|
|
if (c < '0' || c > '9') && (c < 'a' || c > 'f') && (c < 'A' || c > 'F') {
|
2009-11-09 13:07:39 -07:00
|
|
|
break
|
2009-08-31 17:38:30 -06:00
|
|
|
}
|
|
|
|
}
|
2009-12-15 16:27:16 -07:00
|
|
|
s = s[0:i] + "PTR" + s[j:]
|
2009-08-31 17:38:30 -06:00
|
|
|
}
|
2008-11-24 15:51:33 -07:00
|
|
|
if s != tt.out {
|
2009-09-15 10:41:59 -06:00
|
|
|
if _, ok := tt.val.(string); ok {
|
2008-11-24 15:51:33 -07:00
|
|
|
// Don't requote the already-quoted strings.
|
|
|
|
// It's too confusing to read the errors.
|
2009-12-06 13:03:52 -07:00
|
|
|
t.Errorf("Sprintf(%q, %q) = <%s> want <%s>", tt.fmt, tt.val, s, tt.out)
|
2008-11-24 15:51:33 -07:00
|
|
|
} else {
|
2009-11-09 13:07:39 -07:00
|
|
|
t.Errorf("Sprintf(%q, %v) = %q want %q", tt.fmt, tt.val, s, tt.out)
|
2008-11-24 15:51:33 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-11-24 01:21:50 -07:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-12-06 13:03:52 -07:00
|
|
|
func BenchmarkSprintfIntInt(b *testing.B) {
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
Sprintf("%d %d", 5, 6)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestCountMallocs(t *testing.T) {
|
2010-02-03 17:31:34 -07:00
|
|
|
mallocs := 0 - runtime.MemStats.Mallocs
|
2009-12-06 13:03:52 -07:00
|
|
|
for i := 0; i < 100; i++ {
|
|
|
|
Sprintf("")
|
|
|
|
}
|
2010-02-03 17:31:34 -07:00
|
|
|
mallocs += runtime.MemStats.Mallocs
|
2009-12-15 16:27:16 -07:00
|
|
|
Printf("mallocs per Sprintf(\"\"): %d\n", mallocs/100)
|
2010-02-03 17:31:34 -07:00
|
|
|
mallocs = 0 - runtime.MemStats.Mallocs
|
2009-12-06 13:03:52 -07:00
|
|
|
for i := 0; i < 100; i++ {
|
|
|
|
Sprintf("xxx")
|
|
|
|
}
|
2010-02-03 17:31:34 -07:00
|
|
|
mallocs += runtime.MemStats.Mallocs
|
2009-12-15 16:27:16 -07:00
|
|
|
Printf("mallocs per Sprintf(\"xxx\"): %d\n", mallocs/100)
|
2010-02-03 17:31:34 -07:00
|
|
|
mallocs = 0 - runtime.MemStats.Mallocs
|
2009-12-06 13:03:52 -07:00
|
|
|
for i := 0; i < 100; i++ {
|
|
|
|
Sprintf("%x", i)
|
|
|
|
}
|
2010-02-03 17:31:34 -07:00
|
|
|
mallocs += runtime.MemStats.Mallocs
|
2009-12-15 16:27:16 -07:00
|
|
|
Printf("mallocs per Sprintf(\"%%x\"): %d\n", mallocs/100)
|
2010-02-03 17:31:34 -07:00
|
|
|
mallocs = 0 - runtime.MemStats.Mallocs
|
2009-12-06 13:03:52 -07:00
|
|
|
for i := 0; i < 100; i++ {
|
|
|
|
Sprintf("%x %x", i, i)
|
|
|
|
}
|
2010-02-03 17:31:34 -07:00
|
|
|
mallocs += runtime.MemStats.Mallocs
|
2009-12-15 16:27:16 -07:00
|
|
|
Printf("mallocs per Sprintf(\"%%x %%x\"): %d\n", mallocs/100)
|
2009-12-06 13:03:52 -07:00
|
|
|
}
|
|
|
|
|
2009-10-06 16:38:57 -06:00
|
|
|
type flagPrinter struct{}
|
|
|
|
|
2009-07-09 18:30:07 -06:00
|
|
|
func (*flagPrinter) Format(f State, c int) {
|
2009-12-15 16:27:16 -07:00
|
|
|
s := "%"
|
2008-12-11 17:53:33 -07:00
|
|
|
for i := 0; i < 128; i++ {
|
|
|
|
if f.Flag(i) {
|
2009-11-09 13:07:39 -07:00
|
|
|
s += string(i)
|
2008-12-11 17:53:33 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if w, ok := f.Width(); ok {
|
2009-11-09 13:07:39 -07:00
|
|
|
s += Sprintf("%d", w)
|
2008-12-11 17:53:33 -07:00
|
|
|
}
|
|
|
|
if p, ok := f.Precision(); ok {
|
2009-11-09 13:07:39 -07:00
|
|
|
s += Sprintf(".%d", p)
|
2008-12-11 17:53:33 -07:00
|
|
|
}
|
2009-12-15 16:27:16 -07:00
|
|
|
s += string(c)
|
|
|
|
io.WriteString(f, "["+s+"]")
|
2008-12-11 17:53:33 -07:00
|
|
|
}
|
|
|
|
|
2009-01-15 17:03:27 -07:00
|
|
|
type flagTest struct {
|
2009-12-15 16:27:16 -07:00
|
|
|
in string
|
|
|
|
out string
|
2008-12-11 17:53:33 -07:00
|
|
|
}
|
|
|
|
|
2009-10-06 16:38:57 -06:00
|
|
|
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"},
|
2009-03-03 09:39:12 -07:00
|
|
|
}
|
2008-12-11 17:53:33 -07:00
|
|
|
|
2009-01-20 15:40:40 -07:00
|
|
|
func TestFlagParser(t *testing.T) {
|
2009-12-15 16:27:16 -07:00
|
|
|
var flagprinter flagPrinter
|
2009-09-15 10:41:59 -06:00
|
|
|
for _, tt := range flagtests {
|
2009-12-15 16:27:16 -07:00
|
|
|
s := Sprintf(tt.in, &flagprinter)
|
2008-12-11 17:53:33 -07:00
|
|
|
if s != tt.out {
|
2009-11-09 13:07:39 -07:00
|
|
|
t.Errorf("Sprintf(%q, &flagprinter) => %q, want %q", tt.in, s, tt.out)
|
2008-12-11 17:53:33 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-20 15:40:40 -07:00
|
|
|
func TestStructPrinter(t *testing.T) {
|
2008-12-11 17:53:33 -07:00
|
|
|
var s struct {
|
2009-12-15 16:27:16 -07:00
|
|
|
a string
|
|
|
|
b string
|
|
|
|
c int
|
2009-10-06 16:38:57 -06:00
|
|
|
}
|
2009-12-15 16:27:16 -07:00
|
|
|
s.a = "abc"
|
|
|
|
s.b = "def"
|
|
|
|
s.c = 123
|
2008-12-11 17:53:33 -07:00
|
|
|
type Test struct {
|
2009-12-15 16:27:16 -07:00
|
|
|
fmt string
|
|
|
|
out string
|
2008-12-11 17:53:33 -07:00
|
|
|
}
|
2009-10-06 16:38:57 -06:00
|
|
|
var tests = []Test{
|
|
|
|
Test{"%v", "{abc def 123}"},
|
|
|
|
Test{"%+v", "{a:abc b:def c:123}"},
|
2009-12-15 16:27:16 -07:00
|
|
|
}
|
2009-09-15 10:41:59 -06:00
|
|
|
for _, tt := range tests {
|
2009-12-15 16:27:16 -07:00
|
|
|
out := Sprintf(tt.fmt, s)
|
2008-12-11 17:53:33 -07:00
|
|
|
if out != tt.out {
|
2009-11-09 13:07:39 -07:00
|
|
|
t.Errorf("Sprintf(%q, &s) = %q, want %q", tt.fmt, out, tt.out)
|
2008-12-11 17:53:33 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-07-09 18:30:07 -06:00
|
|
|
|
|
|
|
// 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++ {
|
2009-12-15 16:27:16 -07:00
|
|
|
loc := strings.Index(s, a[i])
|
2009-07-09 18:30:07 -06:00
|
|
|
if loc < 0 {
|
2009-11-09 13:07:39 -07:00
|
|
|
t.Errorf("map print: expected to find %q in %q", a[i], s)
|
2009-07-09 18:30:07 -06:00
|
|
|
}
|
|
|
|
// make sure the match ends here
|
2009-12-15 16:27:16 -07:00
|
|
|
loc += len(a[i])
|
2009-07-09 18:30:07 -06:00
|
|
|
if loc >= len(s) || (s[loc] != ' ' && s[loc] != ']') {
|
2009-11-09 13:07:39 -07:00
|
|
|
t.Errorf("map print: %q not properly terminated in %q", a[i], s)
|
2009-07-09 18:30:07 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestMapPrinter(t *testing.T) {
|
2009-12-15 16:27:16 -07:00
|
|
|
m0 := make(map[int]string)
|
|
|
|
s := Sprint(m0)
|
2009-07-09 18:30:07 -06:00
|
|
|
if s != "map[]" {
|
2009-11-09 13:07:39 -07:00
|
|
|
t.Errorf("empty map printed as %q not %q", s, "map[]")
|
2009-07-09 18:30:07 -06:00
|
|
|
}
|
2009-12-15 16:27:16 -07:00
|
|
|
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)
|
2009-07-09 18:30:07 -06:00
|
|
|
}
|
2009-08-03 14:34:20 -06:00
|
|
|
|
|
|
|
func TestEmptyMap(t *testing.T) {
|
2009-12-15 16:27:16 -07:00
|
|
|
const emptyMapStr = "map[]"
|
|
|
|
var m map[string]int
|
|
|
|
s := Sprint(m)
|
2009-08-03 14:34:20 -06:00
|
|
|
if s != emptyMapStr {
|
2009-11-09 13:07:39 -07:00
|
|
|
t.Errorf("nil map printed as %q not %q", s, emptyMapStr)
|
2009-08-03 14:34:20 -06:00
|
|
|
}
|
2009-12-15 16:27:16 -07:00
|
|
|
m = make(map[string]int)
|
|
|
|
s = Sprint(m)
|
2009-08-03 14:34:20 -06:00
|
|
|
if s != emptyMapStr {
|
2009-11-09 13:07:39 -07:00
|
|
|
t.Errorf("empty map printed as %q not %q", s, emptyMapStr)
|
2009-08-03 14:34:20 -06:00
|
|
|
}
|
|
|
|
}
|