github.com/andeya/ameda@v1.5.3/strings_test.go (about)

     1  package ameda
     2  
     3  import (
     4  	"strconv"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  )
     9  
    10  func TestStringsConcat(t *testing.T) {
    11  	a := []string{"a", "0"}
    12  	b := []string{"b", "1"}
    13  	c := []string{"c", "2"}
    14  	r := StringsConcat(a, b, c)
    15  	assert.Equal(t, []string{"a", "0", "b", "1", "c", "2"}, r)
    16  }
    17  
    18  func TestStringsIntersect(t *testing.T) {
    19  	x := []string{"a", "b", "a", "b", "b", "a", "a"}
    20  	y := []string{"a", "b", "c", "a", "b", "c", "b", "c", "c"}
    21  	z := []string{"a", "b", "c", "d", "a", "b", "c", "d", "b", "c", "d", "c", "d", "d"}
    22  	r := StringsIntersect(x, y, z)
    23  	assert.Equal(t, map[string]int{"a": 2, "b": 3}, r)
    24  }
    25  
    26  func TestStringsCopyWithin(t *testing.T) {
    27  	slice := []string{"a", "b", "c", "d", "e"}
    28  	StringsCopyWithin(slice, 0, 3, 4)
    29  	assert.Equal(t, []string{"d", "b", "c", "d", "e"}, slice)
    30  	StringsCopyWithin(slice, 1, -2)
    31  	assert.Equal(t, []string{"d", "d", "e", "d", "e"}, slice)
    32  }
    33  
    34  func TestStringsEvery(t *testing.T) {
    35  	slice := []string{"1", "30", "39", "29", "10", "13"}
    36  	isBelowThreshold := StringsEvery(slice, func(s []string, k int, v string) bool {
    37  		i, _ := strconv.Atoi(v)
    38  		return i < 40
    39  	})
    40  	assert.Equal(t, true, isBelowThreshold)
    41  }
    42  
    43  func TestStringsFill(t *testing.T) {
    44  	slice := []string{"a", "b", "c", "d"}
    45  	StringsFill(slice, "?", 2, 4)
    46  	assert.Equal(t, []string{"a", "b", "?", "?"}, slice)
    47  	StringsFill(slice, "e", -1)
    48  	assert.Equal(t, []string{"a", "b", "?", "e"}, slice)
    49  }
    50  
    51  func TestStringsFilter(t *testing.T) {
    52  	slice := []string{"spray", "limit", "elite", "exuberant", "destruction", "present"}
    53  	result := StringsFilter(slice, func(s []string, k int, v string) bool {
    54  		return len(v) > 6
    55  	})
    56  	assert.Equal(t, []string{"exuberant", "destruction", "present"}, result)
    57  }
    58  
    59  func TestStringsFind(t *testing.T) {
    60  	slice := []string{"spray", "limit", "elite", "exuberant", "destruction", "present"}
    61  	k, v := StringsFind(slice, func(s []string, k int, v string) bool {
    62  		return len(v) > 6
    63  	})
    64  	assert.Equal(t, 3, k)
    65  	assert.Equal(t, "exuberant", v)
    66  }
    67  
    68  func TestStringsIncludes(t *testing.T) {
    69  	slice := []string{"spray", "limit", "elite", "exuberant", "destruction", "present"}
    70  	had := StringsIncludes(slice, "limit")
    71  	assert.True(t, had)
    72  	had = StringsIncludes(slice, "limit", 1)
    73  	assert.True(t, had)
    74  	had = StringsIncludes(slice, "limit", 2)
    75  	assert.False(t, had)
    76  }
    77  
    78  func TestStringsIndexOf(t *testing.T) {
    79  	slice := []string{"spray", "limit", "elite", "exuberant", "destruction", "present"}
    80  	idx := StringsIndexOf(slice, "limit")
    81  	assert.Equal(t, 1, idx)
    82  	idx = StringsIndexOf(slice, "limit", 1)
    83  	assert.Equal(t, 1, idx)
    84  	idx = StringsIndexOf(slice, "limit", 10)
    85  	assert.Equal(t, -1, idx)
    86  }
    87  
    88  func TestStringsLastIndexOf(t *testing.T) {
    89  	slice := []string{"Dodo", "Tiger", "Penguin", "Dodo"}
    90  	idx := StringsLastIndexOf(slice, "Dodo")
    91  	assert.Equal(t, 3, idx)
    92  	idx = StringsLastIndexOf(slice, "Dodo", 1)
    93  	assert.Equal(t, 3, idx)
    94  	idx = StringsLastIndexOf(slice, "Dodo", 10)
    95  	assert.Equal(t, -1, idx)
    96  	idx = StringsLastIndexOf(slice, "?")
    97  	assert.Equal(t, -1, idx)
    98  }
    99  
   100  func TestStringsMap(t *testing.T) {
   101  	slice := []string{"Dodo", "Tiger", "Penguin", "Dodo"}
   102  	ret := StringsMap(slice, func(s []string, k int, v string) string {
   103  		return strconv.Itoa(k+1) + ":" + v
   104  	})
   105  	assert.Equal(t, []string{"1:Dodo", "2:Tiger", "3:Penguin", "4:Dodo"}, ret)
   106  }
   107  
   108  func TestStringsPop(t *testing.T) {
   109  	slice := []string{"kale", "tomato"}
   110  	last, ok := StringsPop(&slice)
   111  	assert.True(t, ok)
   112  	assert.Equal(t, "tomato", last)
   113  	last, ok = StringsPop(&slice)
   114  	assert.True(t, ok)
   115  	assert.Equal(t, "kale", last)
   116  	last, ok = StringsPop(&slice)
   117  	assert.False(t, ok)
   118  	assert.Equal(t, "", last)
   119  }
   120  
   121  func TestStringsPushDistinct(t *testing.T) {
   122  	slice := []string{"1", "2", "3", "4"}
   123  	slice = StringsPushDistinct(slice, "1", "5", "6", "1", "5", "6")
   124  	assert.Equal(t, []string{"1", "2", "3", "4", "5", "6"}, slice)
   125  }
   126  
   127  func TestStringsReduce(t *testing.T) {
   128  	slice := []string{"1", "2", "3", "4"}
   129  	reducer := StringsReduce(slice, func(s []string, k int, v string, accumulator string) string {
   130  		return accumulator + "+" + v
   131  	})
   132  	assert.Equal(t, "1+2+3+4", reducer)
   133  	reducer = StringsReduce(slice, func(s []string, k int, v string, accumulator string) string {
   134  		return accumulator + "+" + v
   135  	}, "100")
   136  	assert.Equal(t, "100+1+2+3+4", reducer)
   137  }
   138  
   139  func TestStringsReduceRight(t *testing.T) {
   140  	slice := []string{"1", "2", "3", "4"}
   141  	reducer := StringsReduceRight(slice, func(s []string, k int, v string, accumulator string) string {
   142  		return accumulator + "+" + v
   143  	})
   144  	assert.Equal(t, "4+3+2+1", reducer)
   145  	reducer = StringsReduceRight(slice, func(s []string, k int, v string, accumulator string) string {
   146  		return accumulator + "+" + v
   147  	}, "100")
   148  	assert.Equal(t, "100+4+3+2+1", reducer)
   149  }
   150  
   151  func TestStringsReverse(t *testing.T) {
   152  	slice := []string{"1", "2", "3", "4"}
   153  	StringsReverse(slice)
   154  	assert.Equal(t, []string{"4", "3", "2", "1"}, slice)
   155  }
   156  
   157  func TestStringsShift(t *testing.T) {
   158  	slice := []string{"kale", "tomato"}
   159  	first, ok := StringsShift(&slice)
   160  	assert.True(t, ok)
   161  	assert.Equal(t, "kale", first)
   162  	first, ok = StringsPop(&slice)
   163  	assert.True(t, ok)
   164  	assert.Equal(t, "tomato", first)
   165  	first, ok = StringsPop(&slice)
   166  	assert.False(t, ok)
   167  	assert.Equal(t, "", first)
   168  }
   169  
   170  func TestStringsSlice(t *testing.T) {
   171  	slice := []string{"a", "b", "c", "d", "e"}
   172  	sub := StringsSlice(slice, 3)
   173  	assert.Equal(t, []string{"d", "e"}, sub)
   174  	sub = StringsSlice(slice, 3, 4)
   175  	assert.Equal(t, []string{"d"}, sub)
   176  	sub = StringsSlice(slice, 1, -2)
   177  	assert.Equal(t, []string{"b", "c"}, sub)
   178  	sub[0] = "x"
   179  	assert.Equal(t, []string{"x", "c"}, sub)
   180  	assert.Equal(t, []string{"a", "b", "c", "d", "e"}, slice)
   181  }
   182  
   183  func TestStringsSome(t *testing.T) {
   184  	slice := []string{"1", "30", "39", "29", "10", "13"}
   185  	even := StringsSome(slice, func(s []string, k int, v string) bool {
   186  		i, _ := strconv.Atoi(v)
   187  		return i%2 == 0
   188  	})
   189  	assert.Equal(t, true, even)
   190  }
   191  
   192  func TestStringsSplice(t *testing.T) {
   193  	slice := []string{"0", "1", "2", "3", "4"}
   194  	StringsSplice(&slice, 0, 0, "a", "b")
   195  	assert.Equal(t, []string{"a", "b", "0", "1", "2", "3", "4"}, slice)
   196  
   197  	slice = []string{"0", "1", "2", "3", "4"}
   198  	StringsSplice(&slice, 10, 0, "a", "b")
   199  	assert.Equal(t, []string{"0", "1", "2", "3", "4", "a", "b"}, slice)
   200  
   201  	slice = []string{"0", "1", "2", "3", "4"}
   202  	StringsSplice(&slice, 1, 0, "a", "b")
   203  	assert.Equal(t, []string{"0", "a", "b", "1", "2", "3", "4"}, slice)
   204  
   205  	slice = []string{"0", "1", "2", "3", "4"}
   206  	StringsSplice(&slice, 1, 2, "a", "b")
   207  	assert.Equal(t, []string{"0", "a", "b", "3", "4"}, slice)
   208  
   209  	slice = []string{"0", "1", "2", "3", "4"}
   210  	StringsSplice(&slice, 1, 10, "a", "b")
   211  	assert.Equal(t, []string{"0", "a", "b"}, slice)
   212  }
   213  
   214  func TestStringsUnshift(t *testing.T) {
   215  	slice := []string{"0", "1", "2", "3", "4"}
   216  	n := StringsUnshift(&slice, "a", "b")
   217  	assert.Equal(t, len(slice), n)
   218  	assert.Equal(t, []string{"a", "b", "0", "1", "2", "3", "4"}, slice)
   219  }
   220  
   221  func TestStringsUnshiftDistinct(t *testing.T) {
   222  	slice := []string{"1", "2", "3", "4"}
   223  	n := StringsUnshiftDistinct(&slice, "-1", "0", "-1", "0", "1", "1")
   224  	assert.Equal(t, len(slice), n)
   225  	assert.Equal(t, []string{"-1", "0", "1", "2", "3", "4"}, slice)
   226  }
   227  
   228  func TestStringsDistinct(t *testing.T) {
   229  	slice := []string{"-1", "0", "-1", "0", "1", "1"}
   230  	distinctCount := StringsDistinct(&slice, true)
   231  	assert.Equal(t, len(slice), len(distinctCount))
   232  	assert.Equal(t, []string{"-1", "0", "1"}, slice)
   233  	assert.Equal(t, map[string]int{"-1": 2, "0": 2, "1": 2}, distinctCount)
   234  }
   235  
   236  func TestStringsRemoveFirst(t *testing.T) {
   237  	slice := []string{"-1", "0", "-1", "0", "1", "1"}
   238  	n := StringsRemoveFirst(&slice, "0")
   239  	assert.Equal(t, len(slice), n)
   240  	assert.Equal(t, []string{"-1", "-1", "0", "1", "1"}, slice)
   241  }
   242  
   243  func TestStringsRemoveEvery(t *testing.T) {
   244  	slice := []string{"-1", "0", "-1", "0", "1", "1"}
   245  	n := StringsRemoveEvery(&slice, "0")
   246  	assert.Equal(t, len(slice), n)
   247  	assert.Equal(t, []string{"-1", "-1", "1", "1"}, slice)
   248  }
   249  
   250  func TestStringSet(t *testing.T) {
   251  	set1 := []string{"1", "2", "3", "6", "8"}
   252  	set2 := []string{"2", "3", "5", "0"}
   253  	set3 := []string{"2", "6", "7"}
   254  	un := StringSetUnion(set1, set2, set3)
   255  	assert.Equal(t, []string{"1", "2", "3", "6", "8", "5", "0", "7"}, un)
   256  	in := StringSetIntersect(set1, set2, set3)
   257  	assert.Equal(t, []string{"2"}, in)
   258  	di := StringSetDifference(set1, set2, set3)
   259  	assert.Equal(t, []string{"1", "8"}, di)
   260  }