github.com/msoap/go-carpet@v1.10.1-0.20240316220419-b690da179708/utils_test.go (about)

     1  package main
     2  
     3  import (
     4  	"io"
     5  	"log"
     6  	"os"
     7  	"reflect"
     8  	"testing"
     9  )
    10  
    11  func Test_isSliceInString(t *testing.T) {
    12  	testData := []struct {
    13  		src    string
    14  		slice  []string
    15  		result bool
    16  	}{
    17  		{
    18  			src:    "one/file.go",
    19  			slice:  []string{"one.go", "file.go"},
    20  			result: true,
    21  		},
    22  		{
    23  			src:    "path/path/file.go",
    24  			slice:  []string{"one.go", "path/file.go"},
    25  			result: true,
    26  		},
    27  		{
    28  			src:    "one/file.go",
    29  			slice:  []string{"one.go", "two.go"},
    30  			result: false,
    31  		},
    32  		{
    33  			src:    "one/file.go",
    34  			slice:  []string{},
    35  			result: false,
    36  		},
    37  	}
    38  
    39  	for i, item := range testData {
    40  		result := isSliceInString(item.src, item.slice)
    41  		if result != item.result {
    42  			t.Errorf("\n%d. isSliceInString()\nexpected: %v\nreal    :%v", i, item.result, result)
    43  		}
    44  	}
    45  }
    46  
    47  func Test_isSliceInStringPrefix(t *testing.T) {
    48  	testData := []struct {
    49  		src    string
    50  		slice  []string
    51  		result bool
    52  	}{
    53  		{
    54  			src:    "one/file.go",
    55  			slice:  []string{"vendor", "Godeps"},
    56  			result: false,
    57  		},
    58  		{
    59  			src:    "vendor/path/file.go",
    60  			slice:  []string{"vendor", "Godeps"},
    61  			result: true,
    62  		},
    63  		{
    64  			src:    "Godeps/path/file.go",
    65  			slice:  []string{"vendor", "Godeps"},
    66  			result: true,
    67  		},
    68  		{
    69  			src:    "one/file.go",
    70  			slice:  []string{},
    71  			result: false,
    72  		},
    73  	}
    74  
    75  	for i, item := range testData {
    76  		result := isSliceInStringPrefix(item.src, item.slice)
    77  		if result != item.result {
    78  			t.Errorf("\n%d. isSliceInStringPrefix()\nexpected: %v\nreal     :%v", i, item.result, result)
    79  		}
    80  	}
    81  }
    82  
    83  func Test_grepEmptyStringSlice(t *testing.T) {
    84  	testData := []struct {
    85  		inSlice []string
    86  		result  []string
    87  	}{
    88  		{
    89  			inSlice: []string{},
    90  			result:  []string{},
    91  		},
    92  		{
    93  			inSlice: nil,
    94  			result:  []string{},
    95  		},
    96  		{
    97  			inSlice: []string{""},
    98  			result:  []string{},
    99  		},
   100  		{
   101  			inSlice: []string{"A", "B"},
   102  			result:  []string{"A", "B"},
   103  		},
   104  		{
   105  			inSlice: []string{"A", "", "B"},
   106  			result:  []string{"A", "B"},
   107  		},
   108  		{
   109  			inSlice: []string{"", "", "B"},
   110  			result:  []string{"B"},
   111  		},
   112  	}
   113  
   114  	for i, item := range testData {
   115  		result := grepEmptyStringSlice(item.inSlice)
   116  
   117  		if !reflect.DeepEqual(result, item.result) {
   118  			t.Errorf("\n%d. grepEmptyStringSlice()\nexpected: %#v\nreal     :%#v", i, item.result, result)
   119  		}
   120  	}
   121  }
   122  
   123  func Test_parseAdditionalArgs(t *testing.T) {
   124  	tests := []struct {
   125  		name           string
   126  		argsRaw        string
   127  		excludes       []string
   128  		wantResultArgs []string
   129  		wantErr        bool
   130  	}{
   131  		{
   132  			name:           "empty args",
   133  			argsRaw:        "",
   134  			excludes:       []string{},
   135  			wantResultArgs: nil,
   136  			wantErr:        false,
   137  		},
   138  		{
   139  			name:           "with error",
   140  			argsRaw:        "str '...",
   141  			excludes:       []string{},
   142  			wantResultArgs: nil,
   143  			wantErr:        true,
   144  		},
   145  		{
   146  			name:           "one args",
   147  			argsRaw:        `-short`,
   148  			excludes:       []string{},
   149  			wantResultArgs: []string{"-short"},
   150  			wantErr:        false,
   151  		},
   152  		{
   153  			name:           "all args",
   154  			argsRaw:        `-short    -option`,
   155  			excludes:       []string{},
   156  			wantResultArgs: []string{"-short", "-option"},
   157  			wantErr:        false,
   158  		},
   159  		{
   160  			name:           "with excludes",
   161  			argsRaw:        `-short -ex=23 -new '-ex2 "ex word"' -option`,
   162  			excludes:       []string{"-ex", "-ex2"},
   163  			wantResultArgs: []string{"-short", "-new", "-option"},
   164  			wantErr:        false,
   165  		},
   166  	}
   167  
   168  	log.SetOutput(io.Discard)
   169  
   170  	for _, tt := range tests {
   171  		t.Run(tt.name, func(t *testing.T) {
   172  			gotResultArgs, err := parseAdditionalArgs(tt.argsRaw, tt.excludes)
   173  			if (err != nil) != tt.wantErr {
   174  				t.Errorf("parseAdditionalArgs() error = %v, wantErr %v", err, tt.wantErr)
   175  				return
   176  			}
   177  			if !reflect.DeepEqual(gotResultArgs, tt.wantResultArgs) {
   178  				t.Errorf("parseAdditionalArgs() = %v, want %v", gotResultArgs, tt.wantResultArgs)
   179  			}
   180  		})
   181  	}
   182  
   183  	log.SetOutput(os.Stdout)
   184  }