github.com/jfrog/jfrog-client-go@v1.40.2/utils/parenthesesutils_test.go (about)

     1  package utils
     2  
     3  import (
     4  	"github.com/stretchr/testify/assert"
     5  	"reflect"
     6  	"testing"
     7  )
     8  
     9  func TestSortNoDuplicates(t *testing.T) {
    10  	got := []int{3, 2, 1, 4, 3, 2, 1, 4, 1}
    11  	beforSsortNoDuplicates := got
    12  	sortNoDuplicates(&got)
    13  	want := []int{1, 2, 3, 4}
    14  	if !reflect.DeepEqual(got, want) {
    15  		t.Errorf("sortNoDuplicates(%v) == %v, want %v", beforSsortNoDuplicates, got, want)
    16  	}
    17  }
    18  
    19  func TestFindParentheses(t *testing.T) {
    20  	pattern := "(a/(b)"
    21  	target := "{1}"
    22  	got := findParentheses(pattern, target)
    23  	want := []Parentheses{{3, 5}}
    24  	if !reflect.DeepEqual(got, want) {
    25  		t.Errorf("sortNoDuplicates(%s, %s) == %v, want %v", pattern, target, got, want)
    26  	}
    27  
    28  	pattern = "(a/(b"
    29  	target = "{1}"
    30  	got = findParentheses(pattern, target)
    31  	if len(got) != 0 {
    32  		t.Errorf("sortNoDuplicates(%s, %s) == %v, want []]", pattern, target, got)
    33  	}
    34  
    35  	pattern = "(a/(b)"
    36  	target = "{1"
    37  	got = findParentheses(pattern, target)
    38  	if len(got) != 0 {
    39  		t.Errorf("sortNoDuplicates(%s, %s) == %v, want []]", pattern, target, got)
    40  	}
    41  
    42  	pattern = "(a)/(b)"
    43  	target = "{1}/{2}"
    44  	got = findParentheses(pattern, target)
    45  	want = []Parentheses{{0, 2}, {4, 6}}
    46  	if !reflect.DeepEqual(got, want) {
    47  		t.Errorf("sortNoDuplicates(%s, %s) == %v, want %v", pattern, target, got, want)
    48  	}
    49  
    50  	pattern = "(a)养只/(b)"
    51  	target = "{1}/{2}"
    52  	got = findParentheses(pattern, target)
    53  	want = []Parentheses{{0, 2}, {10, 12}}
    54  	if !reflect.DeepEqual(got, want) {
    55  		t.Errorf("sortNoDuplicates(%s, %s) == %v, want %v", pattern, target, got, want)
    56  	}
    57  }
    58  
    59  func TestGetPlaceHoldersValues(t *testing.T) {
    60  	target := "{1} {2}/{3}[4]{"
    61  	got := getPlaceHoldersValues(target)
    62  	want := []int{1, 2, 3}
    63  	if !reflect.DeepEqual(got, want) {
    64  		t.Errorf("sortNoDuplicates(%v) == %v, want %v", target, got, want)
    65  	}
    66  }
    67  
    68  func TestAddEscapingParentheses(t *testing.T) {
    69  	type args struct {
    70  		pattern         string
    71  		target          string
    72  		targetInArchive string
    73  	}
    74  	tests := []struct {
    75  		name string
    76  		args args
    77  		want string
    78  	}{
    79  		{"empty parentheses", args{"()", "{2}", ""}, "\\(\\)"},
    80  		{"empty parentheses", args{"()", "{}", ""}, "\\(\\)"},
    81  		{"empty parentheses", args{"()", "{1}", ""}, "()"},
    82  		{"empty parentheses", args{")(", "{1}", ""}, "\\)\\("},
    83  		{"first parentheses", args{"(a)/(b)/(c)", "{2}/{3}", ""}, "\\(a\\)/(b)/(c)"},
    84  		{"second parentheses", args{"(a)/(b)/(c)", "{1}/{3}", ""}, "(a)/\\(b\\)/(c)"},
    85  		{"third parentheses", args{"(a)/(b)/(c)", "{1}/{2}", ""}, "(a)/(b)/\\(c\\)"},
    86  		{"empty placeholders", args{"(a)/(b)/(c)", "", ""}, "\\(a\\)/\\(b\\)/\\(c\\)"},
    87  		{"un-symmetric parentheses", args{")a)/(b)/(c(", "", ""}, "\\)a\\)/\\(b\\)/\\(c\\("},
    88  	}
    89  	for _, tt := range tests {
    90  		t.Run(tt.name, func(t *testing.T) {
    91  			assert.Equalf(t, tt.want, addEscapingParentheses(tt.args.pattern, tt.args.target), "AddEscapingParentheses(%v, %v)", tt.args.pattern, tt.args.target)
    92  		})
    93  	}
    94  }