github.com/wuhuizuo/gomplate@v3.5.0+incompatible/regexp/regexp_test.go (about)

     1  package regexp
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/assert"
     7  )
     8  
     9  func TestFind(t *testing.T) {
    10  	f, err := Find(`[a-z]+`, `foo bar baz`)
    11  	assert.NoError(t, err)
    12  	assert.Equal(t, "foo", f)
    13  
    14  	_, err = Find(`[a-`, "")
    15  	assert.Error(t, err)
    16  }
    17  
    18  func TestFindAll(t *testing.T) {
    19  	_, err := FindAll(`[a-`, 42, "")
    20  	assert.Error(t, err)
    21  
    22  	testdata := []struct {
    23  		re       string
    24  		n        int
    25  		in       string
    26  		expected []string
    27  	}{
    28  		{`[a-z]+`, -1, `foo bar baz`, []string{"foo", "bar", "baz"}},
    29  		{`[a-z]+`, 0, `foo bar baz`, nil},
    30  		{`[a-z]+`, 2, `foo bar baz`, []string{"foo", "bar"}},
    31  		{`[a-z]+`, 14, `foo bar baz`, []string{"foo", "bar", "baz"}},
    32  	}
    33  
    34  	for _, d := range testdata {
    35  		f, err := FindAll(d.re, d.n, d.in)
    36  		assert.NoError(t, err)
    37  		assert.EqualValues(t, d.expected, f)
    38  	}
    39  }
    40  func TestMatch(t *testing.T) {
    41  	assert.True(t, Match(`^[a-z]+\[[0-9]+\]$`, "adam[23]"))
    42  	assert.True(t, Match(`^[a-z]+\[[0-9]+\]$`, "eve[7]"))
    43  	assert.False(t, Match(`^[a-z]+\[[0-9]+\]$`, "Job[48]"))
    44  	assert.False(t, Match(`^[a-z]+\[[0-9]+\]$`, "snakey"))
    45  }
    46  
    47  func TestReplace(t *testing.T) {
    48  	testdata := []struct {
    49  		expected    string
    50  		expression  string
    51  		replacement string
    52  		input       string
    53  	}{
    54  		{"-T-T-", "a(x*)b", "T", "-ab-axxb-"},
    55  		{"--xx-", "a(x*)b", "$1", "-ab-axxb-"},
    56  		{"---", "a(x*)b", "$1W", "-ab-axxb-"},
    57  		{"-W-xxW-", "a(x*)b", "${1}W", "-ab-axxb-"},
    58  		{"Turing, Alan", "(?P<first>[a-zA-Z]+) (?P<last>[a-zA-Z]+)", "${last}, ${first}", "Alan Turing"},
    59  	}
    60  	for _, d := range testdata {
    61  		assert.Equal(t, d.expected, Replace(d.expression, d.replacement, d.input))
    62  	}
    63  }
    64  
    65  func TestReplaceLiteral(t *testing.T) {
    66  	_, err := ReplaceLiteral(`[a-`, "", "")
    67  	assert.Error(t, err)
    68  
    69  	testdata := []struct {
    70  		expected    string
    71  		expression  string
    72  		replacement string
    73  		input       string
    74  	}{
    75  		{"-T-T-", "a(x*)b", "T", "-ab-axxb-"},
    76  		{"-$1-$1-", "a(x*)b", "$1", "-ab-axxb-"},
    77  		{"-$1W-$1W-", "a(x*)b", "$1W", "-ab-axxb-"},
    78  		{"-${1}W-${1}W-", "a(x*)b", "${1}W", "-ab-axxb-"},
    79  		{"${last}, ${first}", "(?P<first>[a-zA-Z]+) (?P<last>[a-zA-Z]+)", "${last}, ${first}", "Alan Turing"},
    80  	}
    81  	for _, d := range testdata {
    82  		r, err := ReplaceLiteral(d.expression, d.replacement, d.input)
    83  		assert.NoError(t, err)
    84  		assert.Equal(t, d.expected, r)
    85  	}
    86  }
    87  
    88  func TestSplit(t *testing.T) {
    89  	_, err := Split(`[a-`, 42, "")
    90  	assert.Error(t, err)
    91  
    92  	testdata := []struct {
    93  		re       string
    94  		n        int
    95  		in       string
    96  		expected []string
    97  	}{
    98  		{`\s+`, -1, "foo  bar baz\tqux", []string{"foo", "bar", "baz", "qux"}},
    99  		{`,`, 0, `foo bar baz`, nil},
   100  		{` `, 2, `foo bar baz`, []string{"foo", "bar baz"}},
   101  		{`[\s,.]`, 14, `foo bar.baz,qux`, []string{"foo", "bar", "baz", "qux"}},
   102  	}
   103  
   104  	for _, d := range testdata {
   105  		f, err := Split(d.re, d.n, d.in)
   106  		assert.NoError(t, err)
   107  		assert.EqualValues(t, d.expected, f)
   108  	}
   109  }