1 package sprig
2
3 import (
4 "testing"
5
6 "github.com/stretchr/testify/assert"
7 )
8
9 func TestRegexMatch(t *testing.T) {
10 regex := "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}"
11
12 assert.True(t, regexMatch(regex, "test@acme.com"))
13 assert.True(t, regexMatch(regex, "Test@Acme.Com"))
14 assert.False(t, regexMatch(regex, "test"))
15 assert.False(t, regexMatch(regex, "test.com"))
16 assert.False(t, regexMatch(regex, "test@acme"))
17 }
18
19 func TestMustRegexMatch(t *testing.T) {
20 regex := "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}"
21
22 o, err := mustRegexMatch(regex, "test@acme.com")
23 assert.True(t, o)
24 assert.Nil(t, err)
25
26 o, err = mustRegexMatch(regex, "Test@Acme.Com")
27 assert.True(t, o)
28 assert.Nil(t, err)
29
30 o, err = mustRegexMatch(regex, "test")
31 assert.False(t, o)
32 assert.Nil(t, err)
33
34 o, err = mustRegexMatch(regex, "test.com")
35 assert.False(t, o)
36 assert.Nil(t, err)
37
38 o, err = mustRegexMatch(regex, "test@acme")
39 assert.False(t, o)
40 assert.Nil(t, err)
41 }
42
43 func TestRegexFindAll(t *testing.T) {
44 regex := "a{2}"
45 assert.Equal(t, 1, len(regexFindAll(regex, "aa", -1)))
46 assert.Equal(t, 1, len(regexFindAll(regex, "aaaaaaaa", 1)))
47 assert.Equal(t, 2, len(regexFindAll(regex, "aaaa", -1)))
48 assert.Equal(t, 0, len(regexFindAll(regex, "none", -1)))
49 }
50
51 func TestMustRegexFindAll(t *testing.T) {
52 type args struct {
53 regex, s string
54 n int
55 }
56 cases := []struct {
57 expected int
58 args args
59 }{
60 {1, args{"a{2}", "aa", -1}},
61 {1, args{"a{2}", "aaaaaaaa", 1}},
62 {2, args{"a{2}", "aaaa", -1}},
63 {0, args{"a{2}", "none", -1}},
64 }
65
66 for _, c := range cases {
67 res, err := mustRegexFindAll(c.args.regex, c.args.s, c.args.n)
68 if err != nil {
69 t.Errorf("regexFindAll test case %v failed with err %s", c, err)
70 }
71 assert.Equal(t, c.expected, len(res), "case %#v", c.args)
72 }
73 }
74
75 func TestRegexFindl(t *testing.T) {
76 regex := "fo.?"
77 assert.Equal(t, "foo", regexFind(regex, "foorbar"))
78 assert.Equal(t, "foo", regexFind(regex, "foo foe fome"))
79 assert.Equal(t, "", regexFind(regex, "none"))
80 }
81
82 func TestMustRegexFindl(t *testing.T) {
83 type args struct{ regex, s string }
84 cases := []struct {
85 expected string
86 args args
87 }{
88 {"foo", args{"fo.?", "foorbar"}},
89 {"foo", args{"fo.?", "foo foe fome"}},
90 {"", args{"fo.?", "none"}},
91 }
92
93 for _, c := range cases {
94 res, err := mustRegexFind(c.args.regex, c.args.s)
95 if err != nil {
96 t.Errorf("regexFind test case %v failed with err %s", c, err)
97 }
98 assert.Equal(t, c.expected, res, "case %#v", c.args)
99 }
100 }
101
102 func TestRegexReplaceAll(t *testing.T) {
103 regex := "a(x*)b"
104 assert.Equal(t, "-T-T-", regexReplaceAll(regex, "-ab-axxb-", "T"))
105 assert.Equal(t, "--xx-", regexReplaceAll(regex, "-ab-axxb-", "$1"))
106 assert.Equal(t, "---", regexReplaceAll(regex, "-ab-axxb-", "$1W"))
107 assert.Equal(t, "-W-xxW-", regexReplaceAll(regex, "-ab-axxb-", "${1}W"))
108 }
109
110 func TestMustRegexReplaceAll(t *testing.T) {
111 type args struct{ regex, s, repl string }
112 cases := []struct {
113 expected string
114 args args
115 }{
116 {"-T-T-", args{"a(x*)b", "-ab-axxb-", "T"}},
117 {"--xx-", args{"a(x*)b", "-ab-axxb-", "$1"}},
118 {"---", args{"a(x*)b", "-ab-axxb-", "$1W"}},
119 {"-W-xxW-", args{"a(x*)b", "-ab-axxb-", "${1}W"}},
120 }
121
122 for _, c := range cases {
123 res, err := mustRegexReplaceAll(c.args.regex, c.args.s, c.args.repl)
124 if err != nil {
125 t.Errorf("regexReplaceAll test case %v failed with err %s", c, err)
126 }
127 assert.Equal(t, c.expected, res, "case %#v", c.args)
128 }
129 }
130
131 func TestRegexReplaceAllLiteral(t *testing.T) {
132 regex := "a(x*)b"
133 assert.Equal(t, "-T-T-", regexReplaceAllLiteral(regex, "-ab-axxb-", "T"))
134 assert.Equal(t, "-$1-$1-", regexReplaceAllLiteral(regex, "-ab-axxb-", "$1"))
135 assert.Equal(t, "-${1}-${1}-", regexReplaceAllLiteral(regex, "-ab-axxb-", "${1}"))
136 }
137
138 func TestMustRegexReplaceAllLiteral(t *testing.T) {
139 type args struct{ regex, s, repl string }
140 cases := []struct {
141 expected string
142 args args
143 }{
144 {"-T-T-", args{"a(x*)b", "-ab-axxb-", "T"}},
145 {"-$1-$1-", args{"a(x*)b", "-ab-axxb-", "$1"}},
146 {"-${1}-${1}-", args{"a(x*)b", "-ab-axxb-", "${1}"}},
147 }
148
149 for _, c := range cases {
150 res, err := mustRegexReplaceAllLiteral(c.args.regex, c.args.s, c.args.repl)
151 if err != nil {
152 t.Errorf("regexReplaceAllLiteral test case %v failed with err %s", c, err)
153 }
154 assert.Equal(t, c.expected, res, "case %#v", c.args)
155 }
156 }
157
158 func TestRegexSplit(t *testing.T) {
159 regex := "a"
160 assert.Equal(t, 4, len(regexSplit(regex, "banana", -1)))
161 assert.Equal(t, 0, len(regexSplit(regex, "banana", 0)))
162 assert.Equal(t, 1, len(regexSplit(regex, "banana", 1)))
163 assert.Equal(t, 2, len(regexSplit(regex, "banana", 2)))
164
165 regex = "z+"
166 assert.Equal(t, 2, len(regexSplit(regex, "pizza", -1)))
167 assert.Equal(t, 0, len(regexSplit(regex, "pizza", 0)))
168 assert.Equal(t, 1, len(regexSplit(regex, "pizza", 1)))
169 assert.Equal(t, 2, len(regexSplit(regex, "pizza", 2)))
170 }
171
172 func TestMustRegexSplit(t *testing.T) {
173 type args struct {
174 regex, s string
175 n int
176 }
177 cases := []struct {
178 expected int
179 args args
180 }{
181 {4, args{"a", "banana", -1}},
182 {0, args{"a", "banana", 0}},
183 {1, args{"a", "banana", 1}},
184 {2, args{"a", "banana", 2}},
185 {2, args{"z+", "pizza", -1}},
186 {0, args{"z+", "pizza", 0}},
187 {1, args{"z+", "pizza", 1}},
188 {2, args{"z+", "pizza", 2}},
189 }
190
191 for _, c := range cases {
192 res, err := mustRegexSplit(c.args.regex, c.args.s, c.args.n)
193 if err != nil {
194 t.Errorf("regexSplit test case %v failed with err %s", c, err)
195 }
196 assert.Equal(t, c.expected, len(res), "case %#v", c.args)
197 }
198 }
199
200 func TestRegexQuoteMeta(t *testing.T) {
201 assert.Equal(t, "1\\.2\\.3", regexQuoteMeta("1.2.3"))
202 assert.Equal(t, "pretzel", regexQuoteMeta("pretzel"))
203 }
204
View as plain text