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-11-05 10:40:28 -07:00
|
|
|
. "fmt";
|
|
|
|
"io";
|
|
|
|
"math";
|
|
|
|
"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{}
|
2008-11-24 15:51:33 -07:00
|
|
|
i1 = "abc";
|
2009-07-09 18:30:07 -06:00
|
|
|
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-10-06 16:38:57 -06: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-10-06 16:38:57 -06:00
|
|
|
i int;
|
|
|
|
j uint;
|
|
|
|
s string;
|
|
|
|
x []int;
|
2009-08-31 17:38:30 -06: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
|
2009-10-06 16:38:57 -06:00
|
|
|
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"`},
|
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"},
|
|
|
|
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"},
|
|
|
|
fmtTest{"% d", 12345, " 12345"},
|
2008-11-24 15:51:33 -07:00
|
|
|
|
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"},
|
|
|
|
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
|
|
|
|
|
|
|
// 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
|
|
|
|
|
|
|
// 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"},
|
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-07-09 18:30:07 -06: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 {
|
|
|
|
j := i+2;
|
|
|
|
for ; j < len(s); j++ {
|
|
|
|
c := s[j];
|
|
|
|
if (c < '0' || c > '9') && (c < 'a' || c > 'f') {
|
2009-11-09 13:07:39 -07:00
|
|
|
break
|
2009-08-31 17:38:30 -06:00
|
|
|
}
|
|
|
|
}
|
2009-10-06 16:38:57 -06:00
|
|
|
s = s[0:i]+"PTR"+s[j:len(s)];
|
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-11-09 13:07:39 -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-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) {
|
2008-12-11 17:53:33 -07:00
|
|
|
s := "%";
|
|
|
|
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
|
|
|
}
|
|
|
|
s += string(c);
|
|
|
|
io.WriteString(f, "["+s+"]");
|
|
|
|
}
|
|
|
|
|
2009-01-15 17:03:27 -07:00
|
|
|
type flagTest struct {
|
2009-10-06 16:38:57 -06: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-01-15 17:03:27 -07:00
|
|
|
var flagprinter flagPrinter;
|
2009-09-15 10:41:59 -06:00
|
|
|
for _, tt := range flagtests {
|
2009-07-09 18:30:07 -06: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-10-06 16:38:57 -06:00
|
|
|
a string;
|
|
|
|
b string;
|
|
|
|
c int;
|
|
|
|
}
|
2008-12-11 17:53:33 -07:00
|
|
|
s.a = "abc";
|
|
|
|
s.b = "def";
|
|
|
|
s.c = 123;
|
|
|
|
type Test struct {
|
2009-10-06 16:38:57 -06: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-03-03 09:39:12 -07:00
|
|
|
};
|
2009-09-15 10:41:59 -06:00
|
|
|
for _, tt := range tests {
|
2009-07-09 18:30:07 -06: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++ {
|
|
|
|
loc := strings.Index(s, a[i]);
|
|
|
|
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
|
|
|
|
loc += len(a[i]);
|
|
|
|
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-10-06 16:38:57 -06:00
|
|
|
m0 := make(map[int]string);
|
2009-07-09 18:30:07 -06:00
|
|
|
s := Sprint(m0);
|
|
|
|
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-10-06 16:38:57 -06:00
|
|
|
m1 := map[int]string{1: "one", 2: "two", 3: "three"};
|
2009-07-09 18:30:07 -06:00
|
|
|
a := []string{"1:one", "2:two", "3:three"};
|
|
|
|
presentInMap(Sprintf("%v", m1), a, t);
|
|
|
|
presentInMap(Sprint(m1), a, t);
|
|
|
|
}
|
2009-08-03 14:34:20 -06:00
|
|
|
|
|
|
|
func TestEmptyMap(t *testing.T) {
|
|
|
|
const emptyMapStr = "map[]";
|
|
|
|
var m map[string]int;
|
|
|
|
s := Sprint(m);
|
|
|
|
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
|
|
|
}
|
|
|
|
m = make(map[string]int);
|
|
|
|
s = Sprint(m);
|
|
|
|
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
|
|
|
}
|
|
|
|
}
|