fmt: restore padding for %x on byte slices and strings

Also improve the documentation. A prior fix in this release
changed the properties for empty strings and slices, incorrectly.
Previous behavior is now restored and better documented.

Add lots of tests.

The behavior is that when using a string-like format (%s %q %x %X)
a byte slice is equivalent to a string, and printed as a unit. The padding
applies to the entire object. (The space and sharp flags apply
elementwise.)

Fixes #11422.
Fixes #10430.

Change-Id: I758f0521caf71630437e43990ec6d6c9a92655e3
Reviewed-on: https://go-review.googlesource.com/11600
Reviewed-by: Russ Cox <rsc@golang.org>

diff --git a/src/fmt/doc.go b/src/fmt/doc.go
index 2efe6ee5b490db56583d93bc7bd2a61ceea0b5bb..ef91368ef0849dcc20f03f58cfa0ab7dfc605ec5 100644 (file)
--- a/src/fmt/doc.go
+++ b/src/fmt/doc.go
@@ -40,7 +40,7 @@
                %F      synonym for %f
                %g      %e for large exponents, %f otherwise
                %G      %E for large exponents, %F otherwise
-       String and slice of bytes:
+       String and slice of bytes (treated equivalently with these verbs):
                %s      the uninterpreted bytes of the string or slice
                %q      a double-quoted string safely escaped with Go syntax
                %x      base 16, lower-case, two characters per byte
@@ -164,6 +164,9 @@
        of strings, and %6.2f will control formatting for each element
        of a floating-point array.
 
+       However, when printing a byte slice with a string-like verb
+       (%s %q %x %X), it is treated identically to a string, as a single item.
+
        To avoid recursion in cases such as
                type X string
                func (x X) String() string { return Sprintf("<%s>", x) }

diff --git a/src/fmt/fmt_test.go b/src/fmt/fmt_test.go
index 28b7e0551ac80eab144852208dfbb5092f4f4877..90a4031d5bdafca3465ff9bc923d2ff5dcfcdd74 100644 (file)
--- a/src/fmt/fmt_test.go
+++ b/src/fmt/fmt_test.go
@@ -452,10 +452,30 @@ var fmtTests = []struct {
        {"%q", []string{"a", "b"}, `["a" "b"]`},
        {"% 02x", []byte{1}, "01"},
        {"% 02x", []byte{1, 2, 3}, "01 02 03"},
-       // Special care for empty slices.
+       // Padding with byte slices.
        {"%x", []byte{}, ""},
-       {"%02x", []byte{}, ""},
-       {"% 02x", []byte{}, ""},
+       {"%02x", []byte{}, "00"},
+       {"% 02x", []byte{}, "00"},
+       {"%08x", []byte{0xab}, "000000ab"},
+       {"% 08x", []byte{0xab}, "000000ab"},
+       {"%08x", []byte{0xab, 0xcd}, "0000abcd"},
+       {"% 08x", []byte{0xab, 0xcd}, "000ab cd"},
+       {"%8x", []byte{0xab}, "      ab"},
+       {"% 8x", []byte{0xab}, "      ab"},
+       {"%8x", []byte{0xab, 0xcd}, "    abcd"},
+       {"% 8x", []byte{0xab, 0xcd}, "   ab cd"},
+       // Same for strings
+       {"%x", "", ""},
+       {"%02x", "", "00"},
+       {"% 02x", "", "00"},
+       {"%08x", "\xab", "000000ab"},
+       {"% 08x", "\xab", "000000ab"},
+       {"%08x", "\xab\xcd", "0000abcd"},
+       {"% 08x", "\xab\xcd", "000ab cd"},
+       {"%8x", "\xab", "      ab"},
+       {"% 8x", "\xab", "      ab"},
+       {"%8x", "\xab\xcd", "    abcd"},
+       {"% 8x", "\xab\xcd", "   ab cd"},
 
        // renamings
        {"%v", renamedBool(true), "true"},

diff --git a/src/fmt/format.go b/src/fmt/format.go
index ac9f6d881a2312fab1e4b5ce1692ed7e9ea09bf0..517b18f7d4378e3c60bc3f9c123d10273d42a2ac 100644 (file)
--- a/src/fmt/format.go
+++ b/src/fmt/format.go
@@ -346,7 +346,7 @@ func (f *fmt) fmt_sbx(s string, b []byte, digits string) {
                }
                buf = append(buf, digits[c>>4], digits[c&0xF])
        }
-       f.buf.Write(buf)
+       f.pad(buf)
 }
 
 // fmt_sx formats a string as a hexadecimal encoding of its bytes.