code review 9680043: fmt.Printf: introduce notation for random access to arg...

src/pkg/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_test
 
 import (
         "bytes"
         . "fmt"
         "io"
@@ skipping 92 matching lines @@
 
 func (p *P) String() string {
         return "String(p)"
 }
 
 var barray = [5]renamedUint8{1, 2, 3, 4, 5}
 var bslice = barray[:]
 
 var b byte
 
-var fmttests = []struct {
+var fmtTests = []struct {
         fmt string
         val interface{}
         out string
 }{
         {"%d", 12345, "12345"},
         {"%v", 12345, "12345"},
         {"%t", true, "true"},
 
         // basic string
         {"%s", "abc", "abc"},
@@ skipping 372 matching lines @@
         // Complex fmt used to leave the plus flag set for future entries in the array
         // causing +2+0i and +3+0i instead of 2+0i and 3+0i.
         {"%v", []complex64{1, 2, 3}, "[(1+0i) (2+0i) (3+0i)]"},
         {"%v", []complex128{1, 2, 3}, "[(1+0i) (2+0i) (3+0i)]"},
 
         // Incomplete format specification caused crash.
         {"%.", 3, "%!.(int=3)"},
 }
 
 func TestSprintf(t *testing.T) {
-        for _, tt := range fmttests {
+        for _, tt := range fmtTests {
                 s := Sprintf(tt.fmt, tt.val)
                 if i := strings.Index(tt.out, "PTR"); i >= 0 {
                         pattern := "PTR"
                         chars := "0123456789abcdefABCDEF"
                         switch {
                         case strings.HasPrefix(tt.out[i:], "PTR_d"):
                                 pattern = "PTR_d"
                                 chars = chars[:10]
                         case strings.HasPrefix(tt.out[i:], "PTR_o"):
                                 pattern = "PTR_o"
@@ skipping 15 matching lines @@
                                 // Don't requote the already-quoted strings.
                                 // It's too confusing to read the errors.
                                 t.Errorf("Sprintf(%q, %q) = <%s> want <%s>", tt.fmt, tt.val, s, tt.out)
                         } else {
                                 t.Errorf("Sprintf(%q, %v) = %q want %q", tt.fmt, tt.val, s, tt.out)
                         }
                 }
         }
 }
 
+type SE []interface{} // slice of empty; notational compactness.
+
+var reorderTests = []struct {
+        fmt string
+        val SE
+        out string
+}{
+        {"%[1]d", SE{1}, "1"},
+        {"%[2]d", SE{2, 1}, "1"},
+        {"%[2]d %[1]d", SE{1, 2}, "2 1"},
+        {"%[2]*[1]d", SE{2, 5}, "    2"},
+        {"%6.2f", SE{12.0}, " 12.00"},
+        {"%[3]*[2].*[1]f", SE{12.0, 2, 6}, " 12.00"},
+        {"%[1]*[2].*[3]f", SE{6, 2, 12.0}, " 12.00"},
+        // An actual use! Print the same arguments twice.
+        {"%d %d %d %#[1]o %#o %#o", SE{11, 12, 13}, "11 12 13 013 014 015"},
+
+        // Erroneous cases.
+        {"%[]d", SE{2, 1}, "%d(BADARGNUM)"},
+        {"%[-3]d", SE{2, 1}, "%d(BADARGNUM)"},
+        {"%[x]d", SE{2, 1}, "%d(BADARGNUM)"},
+        {"%[23]d", SE{2, 1}, "%d(BADARGNUM)"},
+        {"%[3]", SE{2, 1}, "%!(NOVERB)"},
+        {"%d %d %d %#[1]o %#o %#o %#o", SE{11, 12, 13}, "11 12 13 013 014 015 %o(MISSING)"},
+}
+
+func TestReorder(t *testing.T) {
+        for _, tt := range reorderTests {
+                s := Sprintf(tt.fmt, tt.val...)
+                if s != tt.out {
+                        t.Errorf("Sprintf(%q, %v) = <%s> want <%s>", tt.fmt, tt.val, s, tt.out)
+                } else {
+                }
+        }
+}
+
 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")
         }
@@ skipping 347 matching lines @@
         type A struct{}
         type B struct{}
         var a *A = nil
         var b B = B{}
         got := Sprintf("%s %s %s %s %s", nil, a, nil, b, nil)
         const expect = "%!s(<nil>) %!s(*fmt_test.A=<nil>) %!s(<nil>) {} %!s(<nil>)"
         if got != expect {
                 t.Errorf("expected:\n\t%q\ngot:\n\t%q", expect, got)
         }
 }