github.com/m4gshm/gollections@v0.0.10/collection/immutable/ordered/set/test/set_test.go (about)

     1  package test
     2  
     3  import (
     4  	"strconv"
     5  	"testing"
     6  
     7  	"github.com/m4gshm/gollections/collection"
     8  	"github.com/m4gshm/gollections/collection/immutable/ordered/set"
     9  	"github.com/m4gshm/gollections/convert/ptr"
    10  	"github.com/m4gshm/gollections/iter"
    11  	"github.com/m4gshm/gollections/loop"
    12  	"github.com/m4gshm/gollections/op"
    13  	"github.com/m4gshm/gollections/slice"
    14  
    15  	"github.com/m4gshm/gollections/walk/group"
    16  	"github.com/stretchr/testify/assert"
    17  )
    18  
    19  func Test_Set_From(t *testing.T) {
    20  	set := set.From(loop.Of(1, 1, 2, 2, 3, 4, 3, 2, 1))
    21  	assert.Equal(t, slice.Of(1, 2, 3, 4), set.Slice())
    22  }
    23  
    24  func Test_Set_Iterate(t *testing.T) {
    25  	set := set.Of(1, 1, 2, 4, 3, 1)
    26  	values := set.Slice()
    27  
    28  	assert.Equal(t, 4, len(values))
    29  
    30  	expected := slice.Of(1, 2, 4, 3)
    31  	assert.Equal(t, expected, values)
    32  
    33  	loopService := loop.Slice(ptr.Of(set.Head()).Next)
    34  	assert.Equal(t, expected, loopService)
    35  
    36  	out := make([]int, 0)
    37  	for it, v, ok := set.First(); ok; v, ok = it.Next() {
    38  		out = append(out, v)
    39  	}
    40  	assert.Equal(t, expected, out)
    41  
    42  	out = make([]int, 0)
    43  	set.ForEach(func(v int) { out = append(out, v) })
    44  
    45  	assert.Equal(t, expected, out)
    46  }
    47  
    48  func Test_Set_Contains(t *testing.T) {
    49  	set := set.Of(1, 1, 2, 4, 3, 1)
    50  	assert.True(t, set.Contains(1))
    51  	assert.True(t, set.Contains(2))
    52  	assert.True(t, set.Contains(4))
    53  	assert.True(t, set.Contains(3))
    54  	assert.False(t, set.Contains(0))
    55  	assert.False(t, set.Contains(-1))
    56  }
    57  
    58  func Test_Set_FilterReduce(t *testing.T) {
    59  	s := set.Of(1, 1, 2, 4, 3, 1).Reduce(op.Sum[int])
    60  	assert.Equal(t, 1+2+3+4, s)
    61  }
    62  
    63  func Test_Set_FilterMapReduce(t *testing.T) {
    64  	s := set.Of(1, 1, 2, 4, 3, 1).Filter(func(i int) bool { return i%2 == 0 }).Convert(func(i int) int { return i * 2 }).Reduce(op.Sum[int])
    65  	assert.Equal(t, 12, s)
    66  }
    67  
    68  func Test_Set_Group_By_Walker(t *testing.T) {
    69  	groups := group.Of(set.Of(0, 1, 1, 2, 4, 3, 1, 6, 7), func(e int) bool { return e%2 == 0 })
    70  
    71  	assert.Equal(t, len(groups), 2)
    72  	assert.Equal(t, []int{1, 3, 7}, groups[false])
    73  	assert.Equal(t, []int{0, 2, 4, 6}, groups[true])
    74  }
    75  
    76  func Test_Set_Group_By_Iterator(t *testing.T) {
    77  	groups := iter.Group(set.Of(0, 1, 1, 2, 4, 3, 1, 6, 7).Iter(), func(e int) bool { return e%2 == 0 }).Map()
    78  
    79  	assert.Equal(t, len(groups), 2)
    80  	assert.Equal(t, []int{1, 3, 7}, groups[false])
    81  	assert.Equal(t, []int{0, 2, 4, 6}, groups[true])
    82  }
    83  
    84  func Test_Set_Sort(t *testing.T) {
    85  	var (
    86  		elements = set.Of(3, 3, 1, 1, 1, 5, 6, 8, 8, 0, -2, -2)
    87  		sorted   = elements.Sort(func(e1, e2 int) bool { return e1 < e2 })
    88  	)
    89  	assert.Equal(t, set.Of(-2, 0, 1, 3, 5, 6, 8), sorted)
    90  }
    91  func Test_Set_SortStructByField(t *testing.T) {
    92  	var (
    93  		anonymous = &user{"Anonymous", 0}
    94  		cherlie   = &user{"Cherlie", 25}
    95  		alise     = &user{"Alise", 20}
    96  		bob       = &user{"Bob", 19}
    97  
    98  		elements     = set.Of(anonymous, cherlie, alise, bob)
    99  		sortedByName = set.Sort(elements, (*user).Name)
   100  		sortedByAge  = set.Sort(elements, (*user).Age)
   101  	)
   102  	assert.Equal(t, set.Of(alise, anonymous, bob, cherlie), sortedByName)
   103  	assert.Equal(t, set.Of(anonymous, bob, alise, cherlie), sortedByAge)
   104  }
   105  
   106  func Test_Set_Convert(t *testing.T) {
   107  	var (
   108  		ints     = set.Of(3, 3, 1, 1, 1, 5, 6, 8, 8, 0, -2, -2)
   109  		strings  = loop.Slice(iter.Filter(set.Convert(ints, strconv.Itoa), func(s string) bool { return len(s) == 1 }).Next)
   110  		strings2 = set.Convert(ints, strconv.Itoa).Filter(func(s string) bool { return len(s) == 1 }).Slice()
   111  	)
   112  	assert.Equal(t, slice.Of("3", "1", "5", "6", "8", "0"), strings)
   113  	assert.Equal(t, strings, strings2)
   114  }
   115  
   116  func Test_Set_Flatt(t *testing.T) {
   117  	var (
   118  		ints        = set.Of(3, 3, 1, 1, 1, 5, 6, 8, 8, 0, -2, -2)
   119  		fints       = set.Flat(ints, func(i int) []int { return slice.Of(i) })
   120  		stringsPipe = collection.Filter(collection.Convert(fints, strconv.Itoa).Filter(func(s string) bool { return len(s) == 1 }), func(s string) bool { return len(s) == 1 })
   121  	)
   122  	assert.Equal(t, slice.Of("3", "1", "5", "6", "8", "0"), stringsPipe.Slice())
   123  }
   124  
   125  func Test_Set_DoubleConvert(t *testing.T) {
   126  	var (
   127  		ints               = set.Of(3, 1, 5, 6, 8, 0, -2)
   128  		stringsPipe        = set.Convert(ints, strconv.Itoa).Filter(func(s string) bool { return len(s) == 1 })
   129  		prefixedStrinsPipe = collection.Convert(stringsPipe, func(s string) string { return "_" + s })
   130  	)
   131  	assert.Equal(t, slice.Of("_3", "_1", "_5", "_6", "_8", "_0"), prefixedStrinsPipe.Slice())
   132  
   133  	//second call do nothing
   134  	var no []string
   135  	assert.Equal(t, no, stringsPipe.Slice())
   136  }
   137  
   138  type user struct {
   139  	name string
   140  	age  int
   141  }
   142  
   143  func (u *user) Name() string { return u.name }
   144  func (u *user) Age() int     { return u.age }