File 0008-govis-switch-to-testify-tests.patch of Package go-mtree
From d02f298ad457f115fddac9a8fa51d16b5f83b986 Mon Sep 17 00:00:00 2001
From: Aleksa Sarai <cyphar@cyphar.com>
Date: Sat, 20 Sep 2025 06:08:34 +1000
Subject: [PATCH 08/25] govis: switch to testify tests
testify makes most bog-standard test checks much easier to read and
maintain, and is quite widely used. It wasn't really well known back
when govis was first written, but the migration is fairly
straight-forward for most tests.
Signed-off-by: Aleksa Sarai <cyphar@cyphar.com>
---
pkg/govis/govis.go | 42 ++++++++
pkg/govis/govis_test.go | 234 ++++++++++++++++++++++------------------
pkg/govis/unvis_test.go | 80 ++++++--------
pkg/govis/vis_test.go | 57 +++++-----
4 files changed, 233 insertions(+), 180 deletions(-)
diff --git a/pkg/govis/govis.go b/pkg/govis/govis.go
index 9888c27670cb..e8dfb3a8c67c 100644
--- a/pkg/govis/govis.go
+++ b/pkg/govis/govis.go
@@ -17,6 +17,11 @@
package govis
+import (
+ "strconv"
+ "strings"
+)
+
// VisFlag manipulates how the characters are encoded/decoded
type VisFlag uint
@@ -37,3 +42,40 @@ const (
VisWhite VisFlag = (VisSpace | VisTab | VisNewline)
)
+
+// String pretty-prints VisFlag.
+func (vflags VisFlag) String() string {
+ flagNames := []struct {
+ name string
+ bits VisFlag
+ }{
+ {"VisOctal", VisOctal},
+ {"VisCStyle", VisCStyle},
+ {"VisSpace", VisSpace},
+ {"VisTab", VisTab},
+ {"VisNewline", VisNewline},
+ {"VisSafe", VisSafe},
+ {"VisNoSlash", VisNoSlash},
+ {"VisHTTPStyle", VisHTTPStyle},
+ {"VisGlob", VisGlob},
+ }
+ var (
+ flagSet = make([]string, 0, len(flagNames))
+ seenBits VisFlag
+ )
+ for _, flag := range flagNames {
+ if vflags&flag.bits == flag.bits {
+ seenBits |= flag.bits
+ flagSet = append(flagSet, flag.name)
+ }
+ }
+ // If there were any remaining flags specified we don't know the name of,
+ // just add them in an 0x... format.
+ if remaining := vflags &^ seenBits; remaining != 0 {
+ flagSet = append(flagSet, "0x"+strconv.FormatUint(uint64(remaining), 16))
+ }
+ if len(flagSet) == 0 {
+ return "0"
+ }
+ return strings.Join(flagSet, "|")
+}
diff --git a/pkg/govis/govis_test.go b/pkg/govis/govis_test.go
index 312cec34f14d..eaab701fc53d 100644
--- a/pkg/govis/govis_test.go
+++ b/pkg/govis/govis_test.go
@@ -18,9 +18,11 @@
package govis
import (
- "bytes"
"crypto/rand"
"testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
)
const DefaultVisFlags = VisWhite | VisOctal | VisGlob
@@ -31,31 +33,29 @@ func TestRandomVisUnvis(t *testing.T) {
for i := 0; i < N; i++ {
testBytes := make([]byte, 256)
- if n, err := rand.Read(testBytes); n != cap(testBytes) || err != nil {
- t.Fatalf("could not read enough bytes: err=%v n=%d", err, n)
- }
+
+ n, err := rand.Read(testBytes)
+ require.NoErrorf(t, err, "read %d random bytes", len(testBytes))
+ require.Equal(t, len(testBytes), n, "read unexpected number of bytes")
+
test := string(testBytes)
for flag := VisFlag(0); flag <= visMask; flag++ {
- // VisNoSlash is frankly just a dumb flag, and it is impossible for us
- // to actually preserve things in a round-trip.
+ // VisNoSlash is frankly just a dumb flag, and it is impossible
+ // for us to actually preserve things in a round-trip.
if flag&VisNoSlash == VisNoSlash {
continue
}
enc, err := Vis(test, flag)
- if err != nil {
- t.Errorf("unexpected error doing vis(%q, %b): %s", test, flag, err)
- continue
- }
+ require.NoErrorf(t, err, "vis(%q, %s)", test, flag)
+
dec, err := Unvis(enc, flag)
- if err != nil {
- t.Errorf("unexpected error doing unvis(%q, %b): %s", enc, flag, err)
+ require.NoErrorf(t, err, "unvis(%q, %s)", enc, flag)
+
+ if !assert.Equalf(t, test, dec, "unvis(vis(%q, %b) = %q, %b) round-trip", test, flag, enc, flag) {
continue
}
- if dec != test {
- t.Errorf("roundtrip failed: unvis(vis(%q, %b) = %q, %b) = %q", test, flag, enc, flag, dec)
- }
}
}
}
@@ -66,93 +66,88 @@ func TestRandomVisVisUnvisUnvis(t *testing.T) {
for i := 0; i < N; i++ {
testBytes := make([]byte, 256)
- if n, err := rand.Read(testBytes); n != cap(testBytes) || err != nil {
- t.Fatalf("could not read enough bytes: err=%v n=%d", err, n)
- }
+
+ n, err := rand.Read(testBytes)
+ require.NoErrorf(t, err, "read %d random bytes", len(testBytes))
+ require.Equal(t, len(testBytes), n, "read unexpected number of bytes")
+
test := string(testBytes)
for flag := VisFlag(0); flag <= visMask; flag++ {
- // VisNoSlash is frankly just a dumb flag, and it is impossible for us
- // to actually preserve things in a round-trip.
+ // VisNoSlash is frankly just a dumb flag, and it is impossible
+ // for us to actually preserve things in a round-trip.
if flag&VisNoSlash == VisNoSlash {
continue
}
enc, err := Vis(test, flag)
- if err != nil {
- t.Errorf("unexpected error doing vis(%q, %b): %s", test, flag, err)
- continue
- }
+ require.NoErrorf(t, err, "vis(%q, %s)", test, flag)
+
enc2, err := Vis(enc, flag)
- if err != nil {
- t.Errorf("unexpected error doing vis(%q, %b): %s", enc, flag, err)
- continue
- }
- dec, err := Unvis(enc2, flag)
- if err != nil {
- t.Errorf("unexpected error doing unvis(%q, %b): %s", enc2, flag, err)
- continue
- }
- dec2, err := Unvis(dec, flag)
- if err != nil {
- t.Errorf("unexpected error doing unvis(%q, %b): %s", dec, flag, err)
+ require.NoErrorf(t, err, "vis(%q, %s)", enc, flag)
+
+ dec2, err := Unvis(enc2, flag)
+ require.NoErrorf(t, err, "unvis(%q, %s)", enc2, flag)
+
+ dec, err := Unvis(dec2, flag)
+ require.NoErrorf(t, err, "unvis(%q, %s)", dec2, flag)
+
+ if !assert.Equalf(t, test, dec, "unvis(unvis(vis(vis(%q) = %q) = %q) = %q, %b) round-trip", test, enc, enc2, dec2, flag) {
continue
}
- if dec2 != test {
- t.Errorf("roundtrip failed: unvis(unvis(vis(vis(%q) = %q) = %q) = %q, %b) = %q", test, enc, enc2, dec, flag, dec2)
- }
}
}
}
func TestVisUnvis(t *testing.T) {
- for flag := VisFlag(0); flag <= visMask; flag++ {
- // VisNoSlash is frankly just a dumb flag, and it is impossible for us
- // to actually preserve things in a round-trip.
- if flag&VisNoSlash == VisNoSlash {
- continue
- }
-
- // Round-trip testing.
- for _, test := range []string{
- "",
- "hello world",
- "THIS\\IS_A_TEST1234",
- "this.is.a.normal_string",
- "AC_Ra\u00edz_Certic\u00e1mara_S.A..pem",
- "NetLock_Arany_=Class_Gold=_F\u0151tan\u00fas\u00edtv\u00e1ny.pem",
- "T\u00dcB\u0130TAK_UEKAE_K\u00f6k_Sertifika_Hizmet_Sa\u011flay\u0131c\u0131s\u0131_-_S\u00fcr\u00fcm_3.pem",
- "hello world [ this string needs=enco ding! ]",
- "even \n more encoding necessary\a\a ",
- "\024 <-- some more weird characters --> \u4f60\u597d\uff0c\u4e16\u754c",
- "\\xff\\n double encoding is also great fun \\x",
- "AC_Ra\\M-C\\M--z_Certic\\M-C\\M-!mara_S.A..pem",
- "z^i3i$\u00d3\u008anqgh5/t\u00e5<86>\u00b2kzla\\e^lv\u00df\u0093nv\u00df\u00aea|3}\u00d8\u0088\u00d6\u0084",
- `z^i3i$\M-C\M^S\M-B\M^Jnqgh5/t\M-C\M-%<86>\M-B\M-2kzla\\e^lv\M-C\M^_\M-B\M^Snv\M-C\M^_\M-B\M-.a|3}\M-C\M^X\M-B\M^H\M-C\M^V\M-B\M^D`,
- "@?e1xs+.R_Kjo]7s8pgRP:*nXCE4{!c",
- "62_\u00c6\u00c62\u00ae\u00b7m\u00db\u00c3r^\u00bfp\u00c6u'q\u00fbc2\u00f0u\u00b8\u00dd\u00e8v\u00ff\u00b0\u00dc\u00c2\u00f53\u00db-k\u00f2sd4\\p\u00da\u00a6\u00d3\u00eea<\u00e6s{\u00a0p\u00f0\u00ffj\u00e0\u00e8\u00b8\u00b8\u00bc\u00fcb",
- `62_\M-C\M^F\M-C\M^F2\M-B\M-.\M-B\M-7m\M-C\M^[\M-C\M^Cr^\M-B\M-?p\M-C\M^Fu'q\M-C\M-;c2\M-C\M-0u\M-B\M-8\M-C\M^]\M-C\M-(v\M-C\M-?\M-B\M-0\M-C\M^\\M-C\M^B\M-C\M-53\M-C\M^[-k\M-C\M-2sd4\\p\M-C\M^Z\M-B\M-&\M-C\M^S\M-C\M-.a<\M-C\M-&s{\M-B\240p\M-C\M-0\M-C\M-?j\M-C\240\M-C\M-(\M-B\M-8\M-B\M-8\M-B\M-<\M-C\M-<b`,
- "\u9003\"9v1)T798|o;fly jnKX\u0489Be=",
- `\M-i\M^@\M^C"9v1)T798|o;fly jnKX\M-R\M^IBe=`,
- "'3Ze\u050e|\u02del\u069du-Rpct4+Z5b={@_{b",
- `'3Ze\M-T\M^N|\M-K\M^^l\M-Z\M^]u-Rpct4+Z5b={@_{b`,
- "1\u00c6\u00abTcz+Vda?)k1%\\\"P;`po`h",
- `1%C3%86%C2%ABTcz+Vda%3F)k1%25%5C%22P%3B%60po%60h`,
- } {
- enc, err := Vis(test, flag)
- if err != nil {
- t.Errorf("unexpected error doing vis(%q, %b): %s", test, flag, err)
- continue
- }
- dec, err := Unvis(enc, flag)
- if err != nil {
- t.Errorf("unexpected error doing unvis(%q, %b): %s", enc, flag, err)
- continue
- }
- if dec != test {
- t.Errorf("roundtrip failed: unvis(vis(%q, %b) = %q, %b) = %q", test, flag, enc, flag, dec)
+ // Round-trip testing.
+ for _, test := range []struct {
+ name string
+ input string
+ }{
+ {"Empty", ""},
+ {"Plain", "hello world"},
+ {"Backslash", "THIS\\IS_A_TEST1234"},
+ {"Punctuation", "this.is.a.normal_string"},
+ {"Unicode1", "AC_Ra\u00edz_Certic\u00e1mara_S.A..pem"},
+ {"Unicode2", "NetLock_Arany_=Class_Gold=_F\u0151tan\u00fas\u00edtv\u00e1ny.pem"},
+ {"Unicode3", "T\u00dcB\u0130TAK_UEKAE_K\u00f6k_Sertifika_Hizmet_Sa\u011flay\u0131c\u0131s\u0131_-_S\u00fcr\u00fcm_3.pem"},
+ {"ExtraPunctuation", "hello world [ this string needs=enco ding! ]"},
+ {"Whitespace", "even \n more encoding necessary\a\a "},
+ {"WeirdChars", "\024 <-- some more weird characters --> \u4f60\u597d\uff0c\u4e16\u754c"},
+ {"DoubleEncoding", "\\xff\\n double encoding is also great fun \\x"},
+ {"Unicode1-Encoded", "AC_Ra\\M-C\\M--z_Certic\\M-C\\M-!mara_S.A..pem"},
+ {"Rand1", "z^i3i$\u00d3\u008anqgh5/t\u00e5<86>\u00b2kzla\\e^lv\u00df\u0093nv\u00df\u00aea|3}\u00d8\u0088\u00d6\u0084"},
+ {"Rand2", `z^i3i$\M-C\M^S\M-B\M^Jnqgh5/t\M-C\M-%<86>\M-B\M-2kzla\\e^lv\M-C\M^_\M-B\M^Snv\M-C\M^_\M-B\M-.a|3}\M-C\M^X\M-B\M^H\M-C\M^V\M-B\M^D`},
+ {"Rand3", "@?e1xs+.R_Kjo]7s8pgRP:*nXCE4{!c"},
+ {"Rand4", "62_\u00c6\u00c62\u00ae\u00b7m\u00db\u00c3r^\u00bfp\u00c6u'q\u00fbc2\u00f0u\u00b8\u00dd\u00e8v\u00ff\u00b0\u00dc\u00c2\u00f53\u00db-k\u00f2sd4\\p\u00da\u00a6\u00d3\u00eea<\u00e6s{\u00a0p\u00f0\u00ffj\u00e0\u00e8\u00b8\u00b8\u00bc\u00fcb"},
+ {"Rand4-Encoded", `62_\M-C\M^F\M-C\M^F2\M-B\M-.\M-B\M-7m\M-C\M^[\M-C\M^Cr^\M-B\M-?p\M-C\M^Fu'q\M-C\M-;c2\M-C\M-0u\M-B\M-8\M-C\M^]\M-C\M-(v\M-C\M-?\M-B\M-0\M-C\M^\\M-C\M^B\M-C\M-53\M-C\M^[-k\M-C\M-2sd4\\p\M-C\M^Z\M-B\M-&\M-C\M^S\M-C\M-.a<\M-C\M-&s{\M-B\240p\M-C\M-0\M-C\M-?j\M-C\240\M-C\M-(\M-B\M-8\M-B\M-8\M-B\M-<\M-C\M-<b`},
+ {"Rand5", "\u9003\"9v1)T798|o;fly jnKX\u0489Be="},
+ {"Rand5-Encoded", `\M-i\M^@\M^C"9v1)T798|o;fly jnKX\M-R\M^IBe=`},
+ {"Rand6", "'3Ze\u050e|\u02del\u069du-Rpct4+Z5b={@_{b"},
+ {"Rand6-Encoded", `'3Ze\M-T\M^N|\M-K\M^^l\M-Z\M^]u-Rpct4+Z5b={@_{b`},
+ {"Rand7", "1\u00c6\u00abTcz+Vda?)k1%\\\"P;`po`h"},
+ {"Rand7-Encoded", `1%C3%86%C2%ABTcz+Vda%3F)k1%25%5C%22P%3B%60po%60h`},
+ } {
+ t.Run(test.name, func(t *testing.T) {
+ for flag := VisFlag(0); flag <= visMask; flag++ {
+ // VisNoSlash is frankly just a dumb flag, and it is impossible for us
+ // to actually preserve things in a round-trip.
+ if flag&VisNoSlash == VisNoSlash {
+ continue
+ }
+
+ enc, err := Vis(test.input, flag)
+ require.NoErrorf(t, err, "vis(%q, %s)", test.input, flag)
+
+ dec, err := Unvis(enc, flag)
+ require.NoErrorf(t, err, "unvis(%q, %s)", enc, flag)
+
+ if !assert.Equalf(t, test.input, dec, "unvis(vis(%q, %b) = %q, %b) round-trip", test, flag, enc, flag) {
+ continue
+ }
}
- }
+ })
}
}
@@ -162,33 +157,60 @@ func TestByteStrings(t *testing.T) {
// identical but bit-stream non-identical strings (causing much confusion
// when trying to access such files).
- for _, test := range [][]byte{
- []byte("This is a man in business suit levitating: \U0001f574"),
- {0x7f, 0x17, 0x01, 0x33},
+ for _, test := range []struct {
+ name string
+ input []byte
+ }{
+ {"Unicode", []byte("This is a man in business suit levitating: \U0001f574")},
+ {"ASCII", []byte{0x7f, 0x17, 0x01, 0x33}},
// TODO: Test arbitrary byte streams like the one below. Currently this
// fails because Vis() is messing around with it (converting it
// to a rune and spacing it out).
//{'\xef', '\xae', 'h', '\077', 'k'},
} {
- testString := string(test)
- enc, err := Vis(testString, DefaultVisFlags)
- if err != nil {
- t.Errorf("unexpected error doing vis(%q): %s", test, err)
- continue
- }
- dec, err := Unvis(enc, DefaultVisFlags)
- if err != nil {
- t.Errorf("unexpected error doing unvis(%q): %s", enc, err)
- continue
- }
- decBytes := []byte(dec)
+ t.Run(test.name, func(t *testing.T) {
+ testString := string(test.input)
- if dec != testString {
- t.Errorf("roundtrip failed [string comparison]: unvis(vis(%q) = %q) = %q", test, enc, dec)
- }
- if !bytes.Equal(decBytes, test) {
- t.Errorf("roundtrip failed [byte comparison]: unvis(vis(%q) = %q) = %q", test, enc, dec)
- }
+ enc, err := Vis(testString, DefaultVisFlags)
+ require.NoErrorf(t, err, "vis(%q)", testString)
+
+ dec, err := Unvis(enc, DefaultVisFlags)
+ require.NoErrorf(t, err, "unvis(%q)", enc)
+
+ assert.Equalf(t, testString, dec, "unvis(vis(%q) = %q) round-trip", testString, enc)
+ assert.Equalf(t, test.input, []byte(dec), "unvis(vis(%q) = %q) round-trip", testString, enc)
+ })
}
+}
+func TestVisFlagsString(t *testing.T) {
+ for _, test := range []struct {
+ name string
+ flags VisFlag
+ expected string
+ }{
+ {"Empty", VisFlag(0), "0"},
+ // Single valid flags.
+ {"Single-VisOctal", VisOctal, "VisOctal"},
+ {"Single-VisCStyle", VisCStyle, "VisCStyle"},
+ {"Single-VisSpace", VisSpace, "VisSpace"},
+ {"Single-VisTab", VisTab, "VisTab"},
+ {"Single-VisNewline", VisNewline, "VisNewline"},
+ {"Single-VisSafe", VisSafe, "VisSafe"},
+ {"Single-VisNoSlash", VisNoSlash, "VisNoSlash"},
+ {"Single-VisHTTPStyle", VisHTTPStyle, "VisHTTPStyle"},
+ {"Single-VisGlob", VisGlob, "VisGlob"},
+ // Invalid flag value.
+ {"Unknown", VisFlag(0xff000), "0xff000"},
+ // Multiple flag values.
+ {"VisWhite", VisWhite, "VisSpace|VisTab|VisNewline"},
+ {"DefaultVisFlags", DefaultVisFlags, "VisOctal|VisSpace|VisTab|VisNewline|VisGlob"},
+ {"Multiple-Valid", VisOctal | VisCStyle | VisNoSlash | VisHTTPStyle, "VisOctal|VisCStyle|VisNoSlash|VisHTTPStyle"},
+ {"Multiple-Mixed", VisOctal | VisSafe | 0xbeef0000, "VisOctal|VisSafe|0xbeef0000"},
+ } {
+ t.Run(test.name, func(t *testing.T) {
+ got := test.flags.String()
+ assert.Equal(t, test.expected, got, "VisFlag(%+x).String")
+ })
+ }
}
diff --git a/pkg/govis/unvis_test.go b/pkg/govis/unvis_test.go
index 44e0a1a57b45..5b3c5d1e491d 100644
--- a/pkg/govis/unvis_test.go
+++ b/pkg/govis/unvis_test.go
@@ -19,19 +19,24 @@ package govis
import (
"testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
)
func TestUnvisError(t *testing.T) {
for _, test := range []string{
- // Octal escape codes allow you to specify invalid byte values.
+ // Octal escape codes allow you to specify invalid ASCII values.
"\\777",
"\\420\\322\\455",
"\\652\\233",
} {
- got, err := Unvis(test, DefaultVisFlags)
- if err == nil {
- t.Errorf("expected unvis(%q) to give an error, got %q", test, got)
- }
+ t.Run(test, func(t *testing.T) {
+ _, err := Unvis(test, DefaultVisFlags)
+ require.Errorf(t, err, "invalid octal escape should give an error")
+ assert.ErrorContains(t, err, "escape base 8")
+ assert.ErrorContains(t, err, "outside latin-1 encoding")
+ })
}
}
@@ -52,14 +57,11 @@ func TestUnvisCStyleEscape(t *testing.T) {
{"test\\\ning", "testing"},
{"test\\$\\$ing", "testing"},
} {
- got, err := Unvis(test.input, DefaultVisFlags)
- if err != nil {
- t.Errorf("unexpected error doing unvis(%q): %q", test.input, err)
- continue
- }
- if got != test.expected {
- t.Errorf("expected unvis(%q) = %q, got %q", test.input, test.expected, got)
- }
+ t.Run(test.input, func(t *testing.T) {
+ got, err := Unvis(test.input, DefaultVisFlags)
+ require.NoErrorf(t, err, "unvis(%q)", test.input)
+ assert.Equal(t, test.expected, got, "unvis(%q)", test.input)
+ })
}
}
@@ -76,14 +78,11 @@ func TestUnvisMetaEscape(t *testing.T) {
// TODO: Add some more of these tests, but I need to have some
// secondary source to verify these outputs properly.
} {
- got, err := Unvis(test.input, DefaultVisFlags)
- if err != nil {
- t.Errorf("unexpected error doing unvis(%q): %q", test.input, err)
- continue
- }
- if got != test.expected {
- t.Errorf("expected unvis(%q) = %q, got %q", test.input, test.expected, got)
- }
+ t.Run(test.input, func(t *testing.T) {
+ got, err := Unvis(test.input, DefaultVisFlags)
+ require.NoErrorf(t, err, "unvis(%q)", test.input)
+ assert.Equal(t, test.expected, got, "unvis(%q)", test.input)
+ })
}
}
@@ -106,14 +105,11 @@ func TestUnvisOctalEscape(t *testing.T) {
// Some invalid characters...
{"\\377\\2\\225\\264", "\xff\x02\x95\xb4"},
} {
- got, err := Unvis(test.input, DefaultVisFlags)
- if err != nil {
- t.Errorf("unexpected error doing unvis(%q): %q", test.input, err)
- continue
- }
- if got != test.expected {
- t.Errorf("expected unvis(%q) = %q, got %q", test.input, test.expected, got)
- }
+ t.Run(test.input, func(t *testing.T) {
+ got, err := Unvis(test.input, DefaultVisFlags)
+ require.NoErrorf(t, err, "unvis(%q)", test.input)
+ assert.Equal(t, test.expected, got, "unvis(%q)", test.input)
+ })
}
}
@@ -134,14 +130,11 @@ func TestUnvisHexEscape(t *testing.T) {
// Some invalid characters...
{"\\xff\\x02\\x95\\xb4", "\xff\x02\x95\xb4"},
} {
- got, err := Unvis(test.input, DefaultVisFlags)
- if err != nil {
- t.Errorf("unexpected error doing unvis(%q): %q", test.input, err)
- continue
- }
- if got != test.expected {
- t.Errorf("expected unvis(%q) = %q, got %q", test.input, test.expected, got)
- }
+ t.Run(test.input, func(t *testing.T) {
+ got, err := Unvis(test.input, DefaultVisFlags)
+ require.NoErrorf(t, err, "unvis(%q)", test.input)
+ assert.Equal(t, test.expected, got, "unvis(%q)", test.input)
+ })
}
}
@@ -154,13 +147,10 @@ func TestUnvisUnicode(t *testing.T) {
"NetLock_Arany_=Class_Gold=_Főtanúsítvány.pem",
"TÜBİTAK_UEKAE_Kök_Sertifika_Hizmet_Sağlayıcısı_-_Sürüm_3.pem",
} {
- got, err := Unvis(test, DefaultVisFlags)
- if err != nil {
- t.Errorf("unexpected error doing unvis(%q): %s", test, err)
- continue
- }
- if got != test {
- t.Errorf("expected %q to be unchanged, got %q", test, got)
- }
+ t.Run(test, func(t *testing.T) {
+ enc, err := Unvis(test, DefaultVisFlags)
+ require.NoErrorf(t, err, "unvis(%q)", test)
+ assert.Equalf(t, test, enc, "decoding of %q should be the same as original", test)
+ })
}
}
diff --git a/pkg/govis/vis_test.go b/pkg/govis/vis_test.go
index 5177a585d229..a04d8a59e00f 100644
--- a/pkg/govis/vis_test.go
+++ b/pkg/govis/vis_test.go
@@ -18,34 +18,37 @@
package govis
import (
+ "fmt"
"testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
)
func TestVisUnchanged(t *testing.T) {
for _, test := range []struct {
+ name string
input string
flag VisFlag
}{
- {"", DefaultVisFlags},
- {"helloworld", DefaultVisFlags},
- {"THIS_IS_A_TEST1234", DefaultVisFlags},
- {"SomeEncodingsAreCool", DefaultVisFlags},
- {"spaces are totally safe", DefaultVisFlags &^ VisSpace},
- {"tabs\tare\talso\tsafe!!", DefaultVisFlags &^ VisTab},
- {"just\a\atrustme\r\b\b!!", DefaultVisFlags | VisSafe},
+ {"Empty", "", DefaultVisFlags},
+ {"Plain1", "helloworld", DefaultVisFlags},
+ {"Plain2", "THIS_IS_A_TEST1234", DefaultVisFlags},
+ {"Plain3", "SomeEncodingsAreCool", DefaultVisFlags},
+ {"Spaces", "spaces are totally safe", DefaultVisFlags &^ VisSpace},
+ {"Tabs", "tabs\tare\talso\tsafe!!", DefaultVisFlags &^ VisTab},
+ {"BasicCtrlChars", "just\a\atrustme\r\b\b!!", DefaultVisFlags | VisSafe},
} {
- enc, err := Vis(test.input, test.flag)
- if err != nil {
- t.Errorf("unexpected error with %q: %s", test, err)
- }
- if enc != test.input {
- t.Errorf("expected encoding of %q (flag=%q) to be unchanged, got %q", test.input, test.flag, enc)
- }
+ t.Run(test.name, func(t *testing.T) {
+ enc, err := Vis(test.input, test.flag)
+ require.NoErrorf(t, err, "vis(%q, %s)", test.input, test.flag)
+ assert.Equalf(t, test.input, enc, "encoding of vis(%q, %s) should be unchanged", test.input, test.flag)
+ })
}
}
func TestVisFlags(t *testing.T) {
- for _, test := range []struct {
+ for idx, test := range []struct {
input string
output string
flag VisFlag
@@ -100,13 +103,11 @@ func TestVisFlags(t *testing.T) {
{"'3Ze\u050e|\u02del\u069du-Rpct4+Z5b={@_{b", `'3Ze\M-T\M^N|\M-K\M^^l\M-Z\M^]u-Rpct4+Z5b={@_{b`, VisGlob},
{"'3Ze\u050e|\u02del\u069du-Rpct4+Z5b={@_{b", `'3Ze\324\216|\313\236l\332\235u-Rpct4+Z5b={@_{b`, VisGlob | VisOctal},
} {
- enc, err := Vis(test.input, test.flag)
- if err != nil {
- t.Errorf("unexpected error with %q: %s", test, err)
- }
- if enc != test.output {
- t.Errorf("expected vis(%q, flag=%b) = %q, got %q", test.input, test.flag, test.output, enc)
- }
+ t.Run(fmt.Sprintf("Test%.2d", idx), func(t *testing.T) {
+ enc, err := Vis(test.input, test.flag)
+ require.NoErrorf(t, err, "vis(%q, %s)", test.input, test.flag)
+ assert.Equalf(t, test.output, enc, "vis(%q, %s)", test.input, test.flag)
+ })
}
}
@@ -116,12 +117,10 @@ func TestVisChanged(t *testing.T) {
"THIS\\IS_A_TEST1234",
"AC_Ra\u00edz_Certic\u00e1mara_S.A..pem",
} {
- enc, err := Vis(test, DefaultVisFlags)
- if err != nil {
- t.Errorf("unexpected error with %q: %s", test, err)
- }
- if enc == test {
- t.Errorf("expected encoding of %q to be changed", test)
- }
+ t.Run(test, func(t *testing.T) {
+ enc, err := Vis(test, DefaultVisFlags)
+ require.NoErrorf(t, err, "vis(%q)", test)
+ assert.NotEqualf(t, test, enc, "encoding of %q should be different to original", test)
+ })
}
}
--
2.51.0
