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

     1  package ameda
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/assert"
     7  )
     8  
     9  func TestIntsConcat(t *testing.T) {
    10  	a := []int{1}
    11  	b := []int{2}
    12  	c := []int{3}
    13  	r := IntsConcat(a, b, c)
    14  	assert.Equal(t, []int{1, 2, 3}, r)
    15  }
    16  
    17  func TestIntsCopyWithin(t *testing.T) {
    18  	slice := []int{1, 2, 3, 4, 5}
    19  	IntsCopyWithin(slice, 0, 3, 4)
    20  	assert.Equal(t, []int{4, 2, 3, 4, 5}, slice)
    21  	IntsCopyWithin(slice, 1, -2)
    22  	assert.Equal(t, []int{4, 4, 5, 4, 5}, slice)
    23  }
    24  
    25  func TestIntsEvery(t *testing.T) {
    26  	slice := []int{1, 30, 39, 29, 10, 13}
    27  	isBelowThreshold := IntsEvery(slice, func(i []int, k int, v int) bool {
    28  		return v < 40
    29  	})
    30  	assert.Equal(t, true, isBelowThreshold)
    31  }
    32  
    33  func TestIntsFill(t *testing.T) {
    34  	slice := []int{1, 2, 3, 4}
    35  	IntsFill(slice, 9999, 2, 4)
    36  	assert.Equal(t, []int{1, 2, 9999, 9999}, slice)
    37  	IntsFill(slice, 5, -1)
    38  	assert.Equal(t, []int{1, 2, 9999, 5}, slice)
    39  }
    40  
    41  func TestIntsFilter(t *testing.T) {
    42  	slice := []int{301, 302, 303, 304, 305, 306}
    43  	result := IntsFilter(slice, func(i []int, k int, v int) bool {
    44  		return v > 303
    45  	})
    46  	assert.Equal(t, []int{304, 305, 306}, result)
    47  }
    48  
    49  func TestIntsFind(t *testing.T) {
    50  	slice := []int{301, 302, 303, 304, 305, 306}
    51  	k, v := IntsFind(slice, func(i []int, k int, v int) bool {
    52  		return v > 303
    53  	})
    54  	assert.Equal(t, 3, k)
    55  	assert.Equal(t, 304, v)
    56  }
    57  
    58  func TestIntsIncludes(t *testing.T) {
    59  	slice := []int{301, 302, 303, 304, 305, 306}
    60  	had := IntsIncludes(slice, 302)
    61  	assert.True(t, had)
    62  	had = IntsIncludes(slice, 302, 1)
    63  	assert.True(t, had)
    64  	had = IntsIncludes(slice, 302, 2)
    65  	assert.False(t, had)
    66  }
    67  
    68  func TestIntsIndexOf(t *testing.T) {
    69  	slice := []int{301, 302, 303, 304, 305, 306}
    70  	idx := IntsIndexOf(slice, 302)
    71  	assert.Equal(t, 1, idx)
    72  	idx = IntsIndexOf(slice, 302, 1)
    73  	assert.Equal(t, 1, idx)
    74  	idx = IntsIndexOf(slice, 302, 10)
    75  	assert.Equal(t, -1, idx)
    76  }
    77  
    78  func TestIntsLastIndexOf(t *testing.T) {
    79  	slice := []int{101, 102, 103, 101}
    80  	idx := IntsLastIndexOf(slice, 101)
    81  	assert.Equal(t, 3, idx)
    82  	idx = IntsLastIndexOf(slice, 101, 1)
    83  	assert.Equal(t, 3, idx)
    84  	idx = IntsLastIndexOf(slice, 101, 10)
    85  	assert.Equal(t, -1, idx)
    86  	idx = IntsLastIndexOf(slice, 9999)
    87  	assert.Equal(t, -1, idx)
    88  }
    89  
    90  func TestIntsMap(t *testing.T) {
    91  	slice := []int{101, 102, 103, 101}
    92  	ret := IntsMap(slice, func(i []int, k int, v int) int {
    93  		return k + v
    94  	})
    95  	assert.Equal(t, []int{101 + 0, 102 + 1, 103 + 2, 101 + 3}, ret)
    96  }
    97  
    98  func TestIntsPop(t *testing.T) {
    99  	slice := []int{201, 202}
   100  	last, ok := IntsPop(&slice)
   101  	assert.True(t, ok)
   102  	assert.Equal(t, 202, last)
   103  	last, ok = IntsPop(&slice)
   104  	assert.True(t, ok)
   105  	assert.Equal(t, 201, last)
   106  	last, ok = IntsPop(&slice)
   107  	assert.False(t, ok)
   108  	assert.Equal(t, 0, last)
   109  }
   110  
   111  func TestIntsPushDistinct(t *testing.T) {
   112  	slice := []int{1, 2, 3, 4}
   113  	slice = IntsPushDistinct(slice, 1, 5, 6, 1, 5, 6)
   114  	assert.Equal(t, []int{1, 2, 3, 4, 5, 6}, slice)
   115  }
   116  
   117  func TestIntsReduce(t *testing.T) {
   118  	slice := []int{1, 2, 3, 4}
   119  	reducer := IntsReduce(slice, func(i []int, k int, v int, accumulator int) int {
   120  		return accumulator - v
   121  	})
   122  	assert.Equal(t, 1-2-3-4, reducer)
   123  	reducer = IntsReduce(slice, func(i []int, k int, v int, accumulator int) int {
   124  		return accumulator - v
   125  	}, 100)
   126  	assert.Equal(t, 100-1-2-3-4, reducer)
   127  }
   128  
   129  func TestIntsReduceRight(t *testing.T) {
   130  	slice := []int{1, 2, 3, 4}
   131  	reducer := IntsReduceRight(slice, func(i []int, k int, v int, accumulator int) int {
   132  		return accumulator - v
   133  	})
   134  	assert.Equal(t, 4-3-2-1, reducer)
   135  	reducer = IntsReduceRight(slice, func(i []int, k int, v int, accumulator int) int {
   136  		return accumulator - v
   137  	}, 100)
   138  	assert.Equal(t, 100-4-3-2-1, reducer)
   139  }
   140  
   141  func TestIntsReverse(t *testing.T) {
   142  	slice := []int{1, 2, 3, 4}
   143  	IntsReverse(slice)
   144  	assert.Equal(t, []int{4, 3, 2, 1}, slice)
   145  }
   146  
   147  func TestIntsShift(t *testing.T) {
   148  	slice := []int{1, 2}
   149  	first, ok := IntsShift(&slice)
   150  	assert.True(t, ok)
   151  	assert.Equal(t, 1, first)
   152  	first, ok = IntsPop(&slice)
   153  	assert.True(t, ok)
   154  	assert.Equal(t, 2, first)
   155  	first, ok = IntsPop(&slice)
   156  	assert.False(t, ok)
   157  	assert.Equal(t, 0, first)
   158  }
   159  
   160  func TestIntsSlice(t *testing.T) {
   161  	slice := []int{1, 2, 3, 4, 5}
   162  	sub := IntsSlice(slice, 3)
   163  	assert.Equal(t, []int{4, 5}, sub)
   164  	sub = IntsSlice(slice, 3, 4)
   165  	assert.Equal(t, []int{4}, sub)
   166  	sub = IntsSlice(slice, 1, -2)
   167  	assert.Equal(t, []int{2, 3}, sub)
   168  	sub[0] = 999
   169  	assert.Equal(t, []int{999, 3}, sub)
   170  	assert.Equal(t, []int{1, 2, 3, 4, 5}, slice)
   171  }
   172  
   173  func TestIntsSome(t *testing.T) {
   174  	slice := []int{1, 30, 39, 29, 10, 13}
   175  	even := IntsSome(slice, func(i []int, k int, v int) bool {
   176  		return v%2 == 0
   177  	})
   178  	assert.Equal(t, true, even)
   179  }
   180  
   181  func TestIntsSplice(t *testing.T) {
   182  	slice := []int{0, 1, 2, 3, 4}
   183  	IntsSplice(&slice, 0, 0, 1, 2)
   184  	assert.Equal(t, []int{1, 2, 0, 1, 2, 3, 4}, slice)
   185  
   186  	slice = []int{0, 1, 2, 3, 4}
   187  	IntsSplice(&slice, 10, 0, 1, 2)
   188  	assert.Equal(t, []int{0, 1, 2, 3, 4, 1, 2}, slice)
   189  
   190  	slice = []int{0, 1, 2, 3, 4}
   191  	IntsSplice(&slice, 1, 0, 1, 2)
   192  	assert.Equal(t, []int{0, 1, 2, 1, 2, 3, 4}, slice)
   193  
   194  	slice = []int{0, 1, 2, 3, 4}
   195  	IntsSplice(&slice, 1, 2, 1, 2)
   196  	assert.Equal(t, []int{0, 1, 2, 3, 4}, slice)
   197  
   198  	slice = []int{0, 1, 2, 3, 4}
   199  	IntsSplice(&slice, 1, 10, 1, 2)
   200  	assert.Equal(t, []int{0, 1, 2}, slice)
   201  }
   202  
   203  func TestIntsUnshift(t *testing.T) {
   204  	slice := []int{0, 1, 2, 3, 4}
   205  	n := IntsUnshift(&slice, 1, 2)
   206  	assert.Equal(t, len(slice), n)
   207  	assert.Equal(t, []int{1, 2, 0, 1, 2, 3, 4}, slice)
   208  }
   209  
   210  func TestIntsUnshiftDistinct(t *testing.T) {
   211  	slice := []int{1, 2, 3, 4}
   212  	n := IntsUnshiftDistinct(&slice, -1, 0, -1, 0, 1, 1)
   213  	assert.Equal(t, len(slice), n)
   214  	assert.Equal(t, []int{-1, 0, 1, 2, 3, 4}, slice)
   215  }
   216  
   217  func TestIntsDistinct(t *testing.T) {
   218  	slice := []int{-1, 0, -1, 0, 1, 1}
   219  	r := IntsDistinct(&slice, true)
   220  	assert.Equal(t, len(slice), len(r))
   221  	assert.Equal(t, []int{-1, 0, 1}, slice)
   222  	assert.Equal(t, map[int]int{-1: 2, 0: 2, 1: 2}, r)
   223  }
   224  
   225  func TestIntsRemoveOne(t *testing.T) {
   226  	slice := []int{-1, 0, -1, 0, 1, 1}
   227  	n := IntsRemoveFirst(&slice, 0)
   228  	assert.Equal(t, len(slice), n)
   229  	assert.Equal(t, []int{-1, -1, 0, 1, 1}, slice)
   230  }
   231  
   232  func TestIntsRemoveEvery(t *testing.T) {
   233  	slice := []int{-1, 0, -1, 0, 1, 1}
   234  	n := IntsRemoveEvery(&slice, 0)
   235  	assert.Equal(t, len(slice), n)
   236  	assert.Equal(t, []int{-1, -1, 1, 1}, slice)
   237  }