github.com/matrixorigin/matrixone@v0.7.0/pkg/vectorize/regular/regular_test.go (about)

     1  // Copyright 2022 Matrix Origin
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //      http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package regular
    16  
    17  import (
    18  	"testing"
    19  
    20  	"github.com/stretchr/testify/require"
    21  )
    22  
    23  // Regular_Instr UT tests
    24  func TestRegularInstrTest1(t *testing.T) {
    25  	//Test values
    26  	expr := "Cat"
    27  	pat := "at"
    28  
    29  	//Predefined Correct Values
    30  	expected := int64(2)
    31  
    32  	result, _ := RegularInstr(expr, pat, 1, 1, 0, "")
    33  	require.Equal(t, expected, result)
    34  }
    35  
    36  func TestRegularInstrTest2(t *testing.T) {
    37  	//Test values
    38  	expr := "at"
    39  	pat := "^at"
    40  
    41  	//Predefined Correct Values
    42  	expected := int64(1)
    43  
    44  	result, _ := RegularInstr(expr, pat, 1, 1, 0, "")
    45  	require.Equal(t, expected, result)
    46  }
    47  
    48  func TestRegularInstrTest3(t *testing.T) {
    49  	//Test values
    50  	expr := "Cat Cat"
    51  	pat := "Cat"
    52  
    53  	//Predefined Correct Values
    54  	expected := int64(5)
    55  
    56  	result, _ := RegularInstr(expr, pat, 2, 1, 0, "")
    57  	require.Equal(t, expected, result)
    58  }
    59  
    60  func TestRegularInstrTest4(t *testing.T) {
    61  	//Test values
    62  	expr := "Cat Cat"
    63  	pat := "Cat"
    64  
    65  	//Predefined Correct Values
    66  	expected := int64(5)
    67  
    68  	result, _ := RegularInstr(expr, pat, 3, 1, 0, "")
    69  	require.Equal(t, expected, result)
    70  }
    71  
    72  func TestRegularInstrTest5(t *testing.T) {
    73  	//Test values
    74  	expr := "Cat City is SO Cute!"
    75  	pat := "C.t"
    76  
    77  	//different pos
    78  	pos := []int64{1, 2, 6}
    79  	//Predefined Correct Values
    80  	result := make([]int64, 3)
    81  	expected := []int64{1, 5, 16}
    82  	for i := range pos {
    83  		result[i], _ = RegularInstr(expr, pat, pos[i], 1, 0, "")
    84  	}
    85  
    86  	require.Equal(t, expected, result)
    87  }
    88  
    89  func TestRegularInstrTest6(t *testing.T) {
    90  	//Test values
    91  	expr := "Cat City is SO Cute!"
    92  	pat := "C.t"
    93  
    94  	//different pos
    95  	pos := []int64{1, 1, 1}
    96  	occ := []int64{1, 2, 3}
    97  	//Predefined Correct Values
    98  	result := make([]int64, 3)
    99  	expected := []int64{1, 5, 16}
   100  	for i := range pos {
   101  		result[i], _ = RegularInstr(expr, pat, pos[i], occ[i], 0, "")
   102  	}
   103  
   104  	require.Equal(t, expected, result)
   105  }
   106  
   107  func TestRegularInstrTest7(t *testing.T) {
   108  	//Test values
   109  	expr := "Cat City is SO Cute!"
   110  	pat := "C.t"
   111  
   112  	//different pos
   113  	pos := []int64{2, 2, 2}
   114  	occ := []int64{1, 2, 3}
   115  	//Predefined Correct Values
   116  	result := make([]int64, 3)
   117  	expected := []int64{5, 16, 0}
   118  	for i := range pos {
   119  		result[i], _ = RegularInstr(expr, pat, pos[i], occ[i], 0, "")
   120  	}
   121  
   122  	require.Equal(t, expected, result)
   123  }
   124  
   125  func TestRegularInstrTest8(t *testing.T) {
   126  	//Test values
   127  	expr := "Cat City is SO Cute!"
   128  	pat := "C.t"
   129  
   130  	//different pos
   131  	pos := []int64{1, 1, 1}
   132  	occ := []int64{1, 2, 3}
   133  	opt := []uint8{0, 0, 0}
   134  	//Predefined Correct Values
   135  	result := make([]int64, 3)
   136  	expected := []int64{1, 5, 16}
   137  	for i := range pos {
   138  		result[i], _ = RegularInstr(expr, pat, pos[i], occ[i], opt[i], "")
   139  	}
   140  
   141  	require.Equal(t, expected, result)
   142  }
   143  func TestRegularInstrTest9(t *testing.T) {
   144  	//Test values
   145  	expr := "Cat City is SO Cute!"
   146  	pat := "C.t"
   147  
   148  	//different pos
   149  	pos := []int64{1, 1, 1}
   150  	occ := []int64{1, 2, 3}
   151  	opt := []uint8{1, 1, 1}
   152  	//Predefined Correct Values"
   153  	result := make([]int64, 3)
   154  	expected := []int64{4, 8, 19}
   155  	for i := range pos {
   156  		result[i], _ = RegularInstr(expr, pat, pos[i], occ[i], opt[i], "")
   157  	}
   158  
   159  	require.Equal(t, expected, result)
   160  }
   161  
   162  // Regular_Like UT tests
   163  func TestRegularLikerTest1(t *testing.T) {
   164  	//Test values
   165  	expr := []string{"Cat", "Cat", "Cat", "Cat"}
   166  	pat := []string{".*", "b+", "^Ca", "^Da"}
   167  
   168  	//Predefined Correct Values
   169  	expected := []bool{true, false, true, false}
   170  	result := make([]bool, len(expr))
   171  	for i := range expr {
   172  		result[i], _ = RegularLike(expr[i], pat[i], "")
   173  	}
   174  	require.Equal(t, expected, result)
   175  }
   176  
   177  func TestRegularLikeTest2(t *testing.T) {
   178  	// Test for case insensitive matching.
   179  	expr := []string{"Cat"}
   180  	pat := []string{"cat"}
   181  	matchType := []string{"", "i"}
   182  
   183  	expected := []bool{false, true}
   184  	result := make([]bool, len(matchType))
   185  	for i := range matchType {
   186  		result[i], _ = RegularLike(expr[0], pat[0], matchType[i])
   187  	}
   188  	require.Equal(t, expected, result)
   189  }
   190  
   191  func TestRegularLikeTest3(t *testing.T) {
   192  	// Test for . match line-terminator.
   193  	expr := []string{"\n"}
   194  	pat := []string{"."}
   195  	matchType := []string{"", "n"}
   196  
   197  	expected := []bool{false, true}
   198  	result := make([]bool, len(matchType))
   199  	for i := range matchType {
   200  		result[i], _ = RegularLike(expr[0], pat[0], matchType[i])
   201  	}
   202  	require.Equal(t, expected, result)
   203  }
   204  
   205  func TestRegularLikeTest4(t *testing.T) {
   206  	// Test for multi-line mode.
   207  	expr := []string{"last\nday"}
   208  	pat := []string{"last$"}
   209  	matchType := []string{"", "m"}
   210  
   211  	expected := []bool{false, true}
   212  	result := make([]bool, len(matchType))
   213  	for i := range matchType {
   214  		result[i], _ = RegularLike(expr[0], pat[0], matchType[i])
   215  	}
   216  	require.Equal(t, expected, result)
   217  }
   218  
   219  func TestRegularLikeTest5(t *testing.T) {
   220  	// Test for right-most rule.
   221  	expr := []string{"ABC"}
   222  	pat := []string{"abc"}
   223  	matchType := []string{"icicc", "ccici"}
   224  
   225  	expected := []bool{false, true}
   226  	result := make([]bool, len(matchType))
   227  	for i := range matchType {
   228  		result[i], _ = RegularLike(expr[0], pat[0], matchType[i])
   229  	}
   230  	require.Equal(t, expected, result)
   231  }
   232  
   233  // Regular_Replace UT tests
   234  func TestRegularReplaceTest1(t *testing.T) {
   235  	//Test values
   236  	expr := "1abc2"
   237  	pat := "[0-9]"
   238  	repl := "#"
   239  
   240  	//Predefined Correct Values
   241  	expected := "#abc2"
   242  	result, _ := RegularReplace(expr, pat, repl, 1, 1, "")
   243  
   244  	require.Equal(t, expected, result)
   245  }
   246  
   247  func TestRegularReplaceTest2(t *testing.T) {
   248  	//Test values
   249  	expr := "12abc"
   250  	pat := "[0-9]"
   251  	repl := "#"
   252  
   253  	//Predefined Correct Values
   254  	expected := "1#abc"
   255  	result, _ := RegularReplace(expr, pat, repl, 2, 1, "")
   256  
   257  	require.Equal(t, expected, result)
   258  }
   259  
   260  func TestRegularReplaceTest3(t *testing.T) {
   261  	//Test values
   262  	expr := []string{"01234abcde56789", "01234abcde56789"}
   263  	pat := []string{"[0-9]", "[09]"}
   264  	repl := []string{"#", "#"}
   265  
   266  	//Predefined Correct Values
   267  	expected := []string{"#1234abcde56789", "#1234abcde56789"}
   268  	result := make([]string, len(expr))
   269  	for i := range expr {
   270  		result[i], _ = RegularReplace(expr[i], pat[i], repl[i], 1, 1, "")
   271  	}
   272  	require.Equal(t, expected, result)
   273  }
   274  
   275  func TestRegularReplaceTest4(t *testing.T) {
   276  	//Test values
   277  	expr := []string{"abcdefg123456ABC", "abcDEfg123456ABC", "abcDEfg123456ABC", "abcDefg123456ABC"}
   278  	pat := []string{"[0-9]", "[0-9]", "[0-9]", "[0-9]"}
   279  	repl := []string{"", "", "", ""}
   280  
   281  	//Predefined Correct Values
   282  	expected := []string{"abcdefgABC", "abcDEfgABC", "abcDEfgABC", "abcDefgABC"}
   283  	pos := []int64{4, 4, 7, 10}
   284  	result := make([]string, len(expr))
   285  	for i := range expr {
   286  		result[i], _ = RegularReplace(expr[i], pat[i], repl[i], pos[i], 0, "")
   287  	}
   288  	require.Equal(t, expected, result)
   289  }
   290  
   291  // Regular_Substr UT tests
   292  func TestRegularSubstrTest1(t *testing.T) {
   293  	//Test values
   294  	expr := []string{"abc def ghi", "abc def ghi"}
   295  	pat := []string{"[a-z]+", "[a-z]+"}
   296  	pos := []int64{1, 1}
   297  	occ := []int64{1, 3}
   298  
   299  	//Predefined Correct Values
   300  	expected := []string{"abc", "ghi"}
   301  	result := make([]string, len(expr))
   302  	for i := range expr {
   303  		temp, _ := RegularSubstr(expr[i], pat[i], pos[i], occ[i], "")
   304  		result[i] = temp[occ[i]-1]
   305  	}
   306  	require.Equal(t, expected, result)
   307  }
   308  
   309  func TestRegularSubstrTest2(t *testing.T) {
   310  	//Test values
   311  	expr := []string{"java t point", "my sql function"}
   312  	pat := []string{"[a-z]+", "[a-z]+"}
   313  	pos := []int64{2, 1}
   314  	occ := []int64{3, 3}
   315  
   316  	//Predefined Correct Values
   317  	expected := []string{"point", "function"}
   318  	result := make([]string, len(expr))
   319  	for i := range expr {
   320  		temp, _ := RegularSubstr(expr[i], pat[i], pos[i], occ[i], "")
   321  		result[i] = temp[occ[i]-1]
   322  	}
   323  	require.Equal(t, expected, result)
   324  }