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

     1  package test
     2  
     3  import (
     4  	"strconv"
     5  	"testing"
     6  
     7  	"github.com/m4gshm/gollections/collection"
     8  	cGroup "github.com/m4gshm/gollections/collection/group"
     9  	"github.com/m4gshm/gollections/collection/mutable"
    10  	"github.com/m4gshm/gollections/collection/mutable/set"
    11  	"github.com/m4gshm/gollections/collection/mutable/vector"
    12  	"github.com/m4gshm/gollections/iter"
    13  	"github.com/m4gshm/gollections/loop"
    14  	"github.com/m4gshm/gollections/op"
    15  	"github.com/m4gshm/gollections/slice"
    16  	"github.com/m4gshm/gollections/slice/sort"
    17  	"github.com/m4gshm/gollections/walk/group"
    18  
    19  	"github.com/stretchr/testify/assert"
    20  )
    21  
    22  func Test_Set_From(t *testing.T) {
    23  	set := set.From(iter.Of(1, 1, 2, 2, 3, 4, 3, 2, 1).Next)
    24  	assert.Equal(t, slice.Of(1, 2, 3, 4), sort.Of(set.Slice()))
    25  }
    26  
    27  func Test_Set_Iterate(t *testing.T) {
    28  	set := set.Of(1, 1, 2, 4, 3, 1)
    29  	values := sort.Of(set.Slice())
    30  
    31  	assert.Equal(t, 4, len(values))
    32  
    33  	expected := slice.Of(1, 2, 3, 4)
    34  	assert.Equal(t, expected, values)
    35  
    36  	iterSlice := sort.Of(loop.Slice[int](set.Iter().Next))
    37  	assert.Equal(t, expected, iterSlice)
    38  
    39  	out := make(map[int]int, 0)
    40  	it := set.Iter()
    41  	for v, ok := it.Next(); ok; v, ok = it.Next() {
    42  		out[v] = v
    43  	}
    44  
    45  	assert.Equal(t, len(expected), len(out))
    46  	for k := range out {
    47  		assert.True(t, set.Contains(k))
    48  	}
    49  
    50  	out = make(map[int]int, 0)
    51  	set.ForEach(func(n int) { out[n] = n })
    52  
    53  	assert.Equal(t, len(expected), len(out))
    54  	for k := range out {
    55  		assert.True(t, set.Contains(k))
    56  	}
    57  }
    58  
    59  func Test_Set_AddVerify(t *testing.T) {
    60  	set := set.NewCap[int](0)
    61  	added := set.AddNew(1, 2, 4, 3)
    62  	assert.Equal(t, added, true)
    63  	added = set.AddOneNew(1)
    64  	assert.Equal(t, added, false)
    65  
    66  	values := sort.Of(set.Slice())
    67  
    68  	assert.Equal(t, slice.Of(1, 2, 3, 4), values)
    69  }
    70  
    71  func Test_Set_AddAll(t *testing.T) {
    72  	set := set.NewCap[int](0)
    73  	set.AddAll(vector.Of(1, 2))
    74  	set.AddAll(vector.Of(4, 3))
    75  
    76  	values := sort.Of(set.Slice())
    77  
    78  	assert.Equal(t, slice.Of(1, 2, 3, 4), values)
    79  }
    80  
    81  func Test_Set_AddAllNew(t *testing.T) {
    82  	set := set.NewCap[int](0)
    83  	added := set.AddAllNew(vector.Of(1, 2))
    84  	assert.True(t, added)
    85  	//4, 3 are new
    86  	added = set.AddAllNew(vector.Of(1, 4, 3))
    87  	assert.True(t, added)
    88  	added = set.AddAllNew(vector.Of(2, 4, 3))
    89  	assert.False(t, added)
    90  
    91  	values := sort.Of(set.Slice())
    92  	assert.Equal(t, slice.Of(1, 2, 3, 4), values)
    93  }
    94  
    95  func Test_Set_Delete(t *testing.T) {
    96  	set := set.Of(1, 1, 2, 4, 3, 1)
    97  	values := set.Slice()
    98  
    99  	for _, v := range values {
   100  		set.Delete(v)
   101  	}
   102  
   103  	assert.Equal(t, 0, len(set.Slice()))
   104  }
   105  
   106  func Test_Set_DeleteByIterator(t *testing.T) {
   107  	set := set.Of(1, 1, 2, 4, 3, 1)
   108  	iterator := set.IterEdit()
   109  
   110  	i := 0
   111  	for _, ok := iterator.Next(); ok; _, ok = iterator.Next() {
   112  		i++
   113  		iterator.Delete()
   114  	}
   115  
   116  	assert.Equal(t, 4, i)
   117  	assert.Equal(t, 0, len(set.Slice()))
   118  }
   119  
   120  func Test_Set_Contains(t *testing.T) {
   121  	set := set.Of(1, 1, 2, 4, 3, 1)
   122  	assert.True(t, set.Contains(1))
   123  	assert.True(t, set.Contains(2))
   124  	assert.True(t, set.Contains(4))
   125  	assert.True(t, set.Contains(3))
   126  	assert.False(t, set.Contains(0))
   127  	assert.False(t, set.Contains(-1))
   128  }
   129  
   130  func Test_Set_FilterMapReduce(t *testing.T) {
   131  	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])
   132  	assert.Equal(t, 12, s)
   133  }
   134  
   135  func Test_Set_Group_By_Walker(t *testing.T) {
   136  	groups := group.Of(set.Of(0, 1, 1, 2, 4, 3, 1, 6, 7), func(e int) bool { return e%2 == 0 })
   137  
   138  	fg := sort.Of(groups[false])
   139  	tg := sort.Of(groups[true])
   140  	assert.Equal(t, len(groups), 2)
   141  	assert.Equal(t, []int{1, 3, 7}, fg)
   142  	assert.Equal(t, []int{0, 2, 4, 6}, tg)
   143  }
   144  
   145  func Test_Set_Group_By_Iterator(t *testing.T) {
   146  	groups := cGroup.Of(set.Of(0, 1, 1, 2, 4, 3, 1, 6, 7), func(e int) bool { return e%2 == 0 }).Map()
   147  
   148  	assert.Equal(t, len(groups), 2)
   149  	fg := sort.Of(groups[false])
   150  	tg := sort.Of(groups[true])
   151  
   152  	assert.Equal(t, []int{1, 3, 7}, fg)
   153  	assert.Equal(t, []int{0, 2, 4, 6}, tg)
   154  }
   155  
   156  func Test_Set_Convert(t *testing.T) {
   157  	var (
   158  		ints     = set.Of(3, 3, 1, 1, 1, 5, 6, 8, 8, 0, -2, -2)
   159  		strings  = sort.Of(loop.Slice[string](iter.Filter(set.Convert(ints, strconv.Itoa), func(s string) bool { return len(s) == 1 }).Next))
   160  		strings2 = sort.Of(set.Convert(ints, strconv.Itoa).Filter(func(s string) bool { return len(s) == 1 }).Slice())
   161  	)
   162  	assert.Equal(t, slice.Of("0", "1", "3", "5", "6", "8"), strings)
   163  	assert.Equal(t, strings, strings2)
   164  }
   165  
   166  func Test_Set_Flatt(t *testing.T) {
   167  	var (
   168  		ints        = set.Of(3, 3, 1, 1, 1, 5, 6, 8, 8, 0, -2, -2)
   169  		fints       = set.Flat(ints, func(i int) []int { return slice.Of(i) })
   170  		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 })
   171  	)
   172  	assert.Equal(t, slice.Of("0", "1", "3", "5", "6", "8"), sort.Of(stringsPipe.Slice()))
   173  }
   174  
   175  func Test_Set_DoubleConvert(t *testing.T) {
   176  	var (
   177  		ints               = set.Of(3, 1, 5, 6, 8, 0, -2)
   178  		stringsPipe        = set.Convert(ints, strconv.Itoa).Filter(func(s string) bool { return len(s) == 1 })
   179  		prefixedStrinsPipe = collection.Convert(stringsPipe, func(s string) string { return "_" + s })
   180  	)
   181  	s := prefixedStrinsPipe.Slice()
   182  	assert.Equal(t, slice.Of("_0", "_1", "_3", "_5", "_6", "_8"), sort.Of(s))
   183  
   184  	//second call do nothing
   185  	var no []string
   186  	assert.Equal(t, no, stringsPipe.Slice())
   187  }
   188  
   189  func Test_Set_Nil(t *testing.T) {
   190  	var set *mutable.Set[int]
   191  	var nils []int
   192  	set.Add(1, 2, 3)
   193  	set.Add(nils...)
   194  	set.AddOne(4)
   195  	set.AddAll(set)
   196  
   197  	set.Delete(1, 2, 3)
   198  	set.Delete(nils...)
   199  	set.DeleteOne(4)
   200  
   201  	set.IsEmpty()
   202  	set.Len()
   203  
   204  	_ = set.For(nil)
   205  	set.ForEach(nil)
   206  
   207  	set.Slice()
   208  
   209  	head := set.Head()
   210  	_, ok := head.Next()
   211  	assert.False(t, ok)
   212  	head.Delete()
   213  }
   214  
   215  func Test_Set_Zero(t *testing.T) {
   216  	var mset mutable.Set[int]
   217  	var nils []int
   218  	mset.Add(1, 2, 3)
   219  	assert.False(t, mset.IsEmpty())
   220  	mset.Add(nils...)
   221  	mset.AddOne(4)
   222  	mset.AddAll(&mset)
   223  
   224  	assert.Equal(t, *set.Of(1, 2, 3, 4), mset)
   225  	assert.Equal(t, slice.Of(1, 2, 3, 4), sort.Of(mset.Slice()))
   226  
   227  	mset.Delete(1, 2, 3)
   228  	mset.Delete(nils...)
   229  	mset.DeleteOne(4)
   230  
   231  	assert.True(t, mset.IsEmpty())
   232  	assert.Equal(t, 0, mset.Len())
   233  
   234  	mset.For(nil)
   235  	mset.ForEach(nil)
   236  
   237  	head := mset.Head()
   238  	_, ok := head.Next()
   239  	assert.False(t, ok)
   240  	head.Delete()
   241  }
   242  
   243  func Test_Set_new(t *testing.T) {
   244  	var mset = new(mutable.Set[int])
   245  	var nils []int
   246  	mset.Add(1, 2, 3)
   247  	assert.False(t, mset.IsEmpty())
   248  	mset.Add(nils...)
   249  	mset.AddOne(4)
   250  	mset.AddAll(mset)
   251  
   252  	assert.Equal(t, set.Of(1, 2, 3, 4), mset)
   253  	assert.Equal(t, slice.Of(1, 2, 3, 4), sort.Of(mset.Slice()))
   254  
   255  	mset.Delete(1, 2, 3)
   256  	mset.Delete(nils...)
   257  	mset.DeleteOne(4)
   258  
   259  	assert.True(t, mset.IsEmpty())
   260  	assert.Equal(t, 0, mset.Len())
   261  
   262  	mset.For(nil)
   263  	mset.ForEach(nil)
   264  
   265  	head := mset.Head()
   266  	_, ok := head.Next()
   267  	assert.False(t, ok)
   268  	head.Delete()
   269  }