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.
|
|
|
|
|
|
|
|
package fmt
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt";
|
2008-12-11 17:53:33 -07:00
|
|
|
"io";
|
2009-01-22 17:23:44 -07:00
|
|
|
"math";
|
2008-11-24 15:51:33 -07:00
|
|
|
"syscall";
|
|
|
|
"testing";
|
|
|
|
)
|
|
|
|
|
2009-01-20 15:40:40 -07:00
|
|
|
func TestFmtInterface(t *testing.T) {
|
2008-11-24 15:51:33 -07:00
|
|
|
var i1 interface{};
|
|
|
|
i1 = "abc";
|
2009-01-15 14:48:11 -07:00
|
|
|
s := fmt.Sprintf("%s", i1);
|
2008-11-24 15:51:33 -07:00
|
|
|
if s != "abc" {
|
2009-01-15 14:48:11 -07:00
|
|
|
t.Errorf(`fmt.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 {
|
2008-11-24 15:51:33 -07:00
|
|
|
fmt string;
|
|
|
|
val interface { };
|
|
|
|
out string;
|
|
|
|
}
|
|
|
|
|
2009-01-15 17:03:27 -07:00
|
|
|
const b32 uint32 = 1<<32 - 1
|
|
|
|
const b64 uint64 = 1<<64 - 1
|
2009-02-13 15:48:32 -07:00
|
|
|
var array = []int(1, 2, 3, 4, 5)
|
2008-12-23 10:34:38 -07:00
|
|
|
|
2008-11-24 15:51:33 -07:00
|
|
|
|
2009-02-13 15:48:32 -07:00
|
|
|
var fmttests = []fmtTest(
|
2008-11-24 15:51:33 -07:00
|
|
|
// basic string
|
2009-02-13 15:48:32 -07: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-02-13 15:48:32 -07:00
|
|
|
fmtTest( "%s", io.StringBytes("abc"), "abc" ),
|
|
|
|
fmtTest( "%x", io.StringBytes("abc"), "616263" ),
|
|
|
|
fmtTest( "% x", io.StringBytes("abc"), "61 62 63" ),
|
|
|
|
fmtTest( "%x", io.StringBytes("xyz"), "78797a" ),
|
|
|
|
fmtTest( "%X", io.StringBytes("xyz"), "78797A" ),
|
|
|
|
fmtTest( "%q", io.StringBytes("abc"), `"abc"` ),
|
2008-11-24 15:51:33 -07:00
|
|
|
|
|
|
|
// escaped strings
|
2009-02-13 15:48:32 -07: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-02-13 15:48:32 -07:00
|
|
|
fmtTest( "%5s", "abc", " abc" ),
|
|
|
|
fmtTest( "%-5s", "abc", "abc " ),
|
|
|
|
fmtTest( "%05s", "abc", "00abc" ),
|
2008-11-24 15:51:33 -07:00
|
|
|
|
|
|
|
// integers
|
2009-02-13 15:48:32 -07: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" ),
|
|
|
|
fmtTest( "% d", -12345, "-12345" ),
|
2008-11-24 15:51:33 -07:00
|
|
|
|
2008-12-23 10:34:38 -07:00
|
|
|
// arrays
|
|
|
|
// TODO: when arrays work in interfaces, enable this line
|
|
|
|
// and delete the TestArrayPrinter routine below
|
2009-01-15 17:03:27 -07:00
|
|
|
// fmtTest{ "%v", array, "[1 2 3 4 5]" },
|
2009-02-13 15:48:32 -07:00
|
|
|
fmtTest( "%v", &array, "&[1 2 3 4 5]" ),
|
2008-12-23 10:34:38 -07:00
|
|
|
|
2008-11-24 15:51:33 -07:00
|
|
|
// old test/fmt_test.go
|
2009-02-13 15:48:32 -07: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", uint32(b32), "37777777777" ),
|
|
|
|
fmtTest( "%o", uint64(b64), "1777777777777777777777" ),
|
|
|
|
fmtTest( "%x", 0x1234abcd, "1234abcd" ),
|
|
|
|
fmtTest( "%x", b32-0x1234567, "fedcba98" ),
|
|
|
|
fmtTest( "%X", 0x1234abcd, "1234ABCD" ),
|
|
|
|
fmtTest( "%X", b32-0x1234567, "FEDCBA98" ),
|
|
|
|
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( "%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( "%.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" ),
|
|
|
|
)
|
2008-11-24 15:51:33 -07:00
|
|
|
|
2009-01-20 15:40:40 -07:00
|
|
|
func TestSprintf(t *testing.T) {
|
2008-11-24 15:51:33 -07:00
|
|
|
for i := 0; i < len(fmttests); i++ {
|
|
|
|
tt := fmttests[i];
|
2009-01-15 14:48:11 -07:00
|
|
|
s := fmt.Sprintf(tt.fmt, tt.val);
|
2008-11-24 15:51:33 -07:00
|
|
|
if s != tt.out {
|
|
|
|
if ss, ok := tt.val.(string); ok {
|
|
|
|
// Don't requote the already-quoted strings.
|
|
|
|
// It's too confusing to read the errors.
|
2009-01-15 14:48:11 -07:00
|
|
|
t.Errorf("fmt.Sprintf(%q, %q) = %s want %s", tt.fmt, tt.val, s, tt.out);
|
2008-11-24 15:51:33 -07:00
|
|
|
} else {
|
2009-01-15 14:48:11 -07:00
|
|
|
t.Errorf("fmt.Sprintf(%q, %v) = %q want %q", tt.fmt, tt.val, s, tt.out);
|
2008-11-24 15:51:33 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-15 17:03:27 -07:00
|
|
|
type flagPrinter struct { }
|
|
|
|
func (*flagPrinter) Format(f fmt.Formatter, c int) {
|
2008-12-11 17:53:33 -07:00
|
|
|
s := "%";
|
|
|
|
for i := 0; i < 128; i++ {
|
|
|
|
if f.Flag(i) {
|
|
|
|
s += string(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if w, ok := f.Width(); ok {
|
2009-01-15 14:48:11 -07:00
|
|
|
s += fmt.Sprintf("%d", w);
|
2008-12-11 17:53:33 -07:00
|
|
|
}
|
|
|
|
if p, ok := f.Precision(); ok {
|
2009-01-15 14:48:11 -07:00
|
|
|
s += fmt.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 {
|
2008-12-11 17:53:33 -07:00
|
|
|
in string;
|
|
|
|
out string;
|
|
|
|
}
|
|
|
|
|
2009-02-13 15:48:32 -07: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" ),
|
|
|
|
)
|
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;
|
2008-12-11 17:53:33 -07:00
|
|
|
for i := 0; i < len(flagtests); i++ {
|
|
|
|
tt := flagtests[i];
|
2009-01-15 14:48:11 -07:00
|
|
|
s := fmt.Sprintf(tt.in, &flagprinter);
|
2008-12-11 17:53:33 -07:00
|
|
|
if s != tt.out {
|
2009-01-15 14:48:11 -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 {
|
|
|
|
a string;
|
|
|
|
b string;
|
|
|
|
c int;
|
|
|
|
};
|
|
|
|
s.a = "abc";
|
|
|
|
s.b = "def";
|
|
|
|
s.c = 123;
|
|
|
|
type Test struct {
|
|
|
|
fmt string;
|
|
|
|
out string;
|
|
|
|
}
|
2009-02-13 15:48:32 -07:00
|
|
|
var tests = []Test (
|
|
|
|
Test( "%v", "{abc def 123}" ),
|
|
|
|
Test( "%+v", "{a=abc b=def c=123}" ),
|
|
|
|
);
|
2008-12-11 17:53:33 -07:00
|
|
|
for i := 0; i < len(tests); i++ {
|
|
|
|
tt := tests[i];
|
2009-01-15 14:48:11 -07:00
|
|
|
out := fmt.Sprintf(tt.fmt, s);
|
2008-12-11 17:53:33 -07:00
|
|
|
if out != tt.out {
|
2009-01-15 14:48:11 -07:00
|
|
|
t.Errorf("Sprintf(%q, &s) = %q, want %q", tt.fmt, out, tt.out);
|
2008-12-11 17:53:33 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2008-12-22 12:04:17 -07:00
|
|
|
|
2009-01-20 15:40:40 -07:00
|
|
|
func TestArrayPrinter(t *testing.T) {
|
2009-02-13 15:48:32 -07:00
|
|
|
a := []int(1, 2, 3, 4, 5);
|
2008-12-22 12:04:17 -07:00
|
|
|
want := "[1 2 3 4 5]";
|
2009-01-15 14:48:11 -07:00
|
|
|
out := fmt.Sprintf("%v", a);
|
2008-12-22 12:04:17 -07:00
|
|
|
if out != want {
|
2009-01-15 14:48:11 -07:00
|
|
|
t.Errorf("Sprintf(%%v, array) = %q, want %q", out, want);
|
2008-12-22 12:04:17 -07:00
|
|
|
}
|
|
|
|
want = "&" + want;
|
2009-01-15 14:48:11 -07:00
|
|
|
out = fmt.Sprintf("%v", &a);
|
2008-12-22 12:04:17 -07:00
|
|
|
if out != want {
|
2009-01-15 14:48:11 -07:00
|
|
|
t.Errorf("Sprintf(%%v, &array) = %q, want %q", out, want);
|
2008-12-22 12:04:17 -07:00
|
|
|
}
|
|
|
|
}
|