src/lib/fmt/fmt_test.go

// 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";
	"io";
	"math";
	"testing";
)

func TestFmtInterface(t *testing.T) {
	var i1 interface{};
	i1 = "abc";
	s := fmt.Sprintf("%s", i1);
	if s != "abc" {
		t.Errorf(`fmt.Sprintf("%%s", empty("abc")) = %q want %q`, s, "abc");
	}
}

type fmtTest struct {
	fmt string;
	val interface { };
	out string;
}

const b32 uint32 = 1<<32 - 1
const b64 uint64 = 1<<64 - 1
var array = []int{1, 2, 3, 4, 5}


var fmttests = []fmtTest{
	// basic string
	fmtTest{ "%s",	"abc",	"abc" },
	fmtTest{ "%x",	"abc",	"616263" },
	fmtTest{ "%x",	"xyz",	"78797a" },
	fmtTest{ "%X",	"xyz",	"78797A" },
	fmtTest{ "%q",	"abc",	`"abc"` },

	// basic bytes
	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"` },

	// escaped strings
	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"` },

	// width
	fmtTest{ "%5s",		"abc",	"  abc" },
	fmtTest{ "%-5s",	"abc",	"abc  " },
	fmtTest{ "%05s",	"abc",	"00abc" },

	// integers
	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" },

	// arrays
	// TODO: when arrays work in interfaces, enable this line
	// and delete the TestArrayPrinter routine below
	// fmtTest{ "%v",		array,			"[1 2 3 4 5]" },
	fmtTest{ "%v",		&array,			"&[1 2 3 4 5]" },

	// old test/fmt_test.go
	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" },
}

func TestSprintf(t *testing.T) {
	for i := 0; i < len(fmttests); i++ {
		tt := fmttests[i];
		s := fmt.Sprintf(tt.fmt, tt.val);
		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.
				t.Errorf("fmt.Sprintf(%q, %q) = %s want %s", tt.fmt, tt.val, s, tt.out);
			} else {
				t.Errorf("fmt.Sprintf(%q, %v) = %q want %q", tt.fmt, tt.val, s, tt.out);
			}
		}
	}
}

type flagPrinter struct { }
func (*flagPrinter) Format(f fmt.Formatter, c int) {
	s := "%";
	for i := 0; i < 128; i++ {
		if f.Flag(i) {
			s += string(i);
		}
	}
	if w, ok := f.Width(); ok {
		s += fmt.Sprintf("%d", w);
	}
	if p, ok := f.Precision(); ok {
		s += fmt.Sprintf(".%d", p);
	}
	s += string(c);
	io.WriteString(f, "["+s+"]");
}

type flagTest struct {
	in string;
	out string;
}

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" },
}

func TestFlagParser(t *testing.T) {
	var flagprinter flagPrinter;
	for i := 0; i < len(flagtests); i++ {
		tt := flagtests[i];
		s := fmt.Sprintf(tt.in, &flagprinter);
		if s != tt.out {
			t.Errorf("Sprintf(%q, &flagprinter) => %q, want %q", tt.in, s, tt.out);
		}
	}
}

func TestStructPrinter(t *testing.T) {
	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;
	}
	var tests = []Test {
		Test{ "%v", "{abc def 123}" },
		Test{ "%+v", "{a=abc b=def c=123}" },
	};
	for i := 0; i < len(tests); i++ {
		tt := tests[i];
		out := fmt.Sprintf(tt.fmt, s);
		if out != tt.out {
			t.Errorf("Sprintf(%q, &s) = %q, want %q", tt.fmt, out, tt.out);
		}
	}
}

func TestArrayPrinter(t *testing.T) {
	a := []int{1, 2, 3, 4, 5};
	want := "[1 2 3 4 5]";
	out := fmt.Sprintf("%v", a);
	if out != want {
		t.Errorf("Sprintf(%%v, array) = %q, want %q", out, want);
	}
	want = "&" + want;
	out = fmt.Sprintf("%v", &a);
	if out != want {
		t.Errorf("Sprintf(%%v, &array) = %q, want %q", out, want);
	}
}