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

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