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

     1  package vector
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/assert"
     7  
     8  	"github.com/m4gshm/gollections/collection/mutable"
     9  	"github.com/m4gshm/gollections/collection/mutable/vector"
    10  	"github.com/m4gshm/gollections/iter"
    11  	"github.com/m4gshm/gollections/op"
    12  	"github.com/m4gshm/gollections/slice"
    13  	"github.com/m4gshm/gollections/slice/range_"
    14  	"github.com/m4gshm/gollections/walk/group"
    15  )
    16  
    17  func Test_Vector_From(t *testing.T) {
    18  	set := vector.From(iter.Of(1, 1, 2, 2, 3, 4, 3, 2, 1).Next)
    19  	assert.Equal(t, slice.Of(1, 1, 2, 2, 3, 4, 3, 2, 1), set.Slice())
    20  }
    21  
    22  func Test_VectorIterate(t *testing.T) {
    23  	expected := slice.Of(1, 2, 3, 4)
    24  	v := vector.Of(1, 2, 3, 4)
    25  	result := make([]int, v.Len())
    26  	i := 0
    27  	for it := v.Head(); it.HasNext(); {
    28  		result[i] = it.GetNext()
    29  		i++
    30  	}
    31  	assert.Equal(t, expected, result)
    32  }
    33  
    34  func Test_VectorIterate2(t *testing.T) {
    35  	expected := slice.Of(1, 2, 3, 4)
    36  	v := vector.Of(1, 2, 3, 4)
    37  	result := make([]int, v.Len())
    38  	i := 0
    39  	for it, v, ok := v.First(); ok; v, ok = it.Next() {
    40  		result[i] = v
    41  		i++
    42  	}
    43  	assert.Equal(t, expected, result)
    44  }
    45  
    46  func Test_VectorIterateOverRange(t *testing.T) {
    47  	expected := slice.Of(1, 2, 3, 4)
    48  	v := vector.Of(1, 2, 3, 4)
    49  	result := make([]int, v.Len())
    50  	for i, val := range *v {
    51  		result[i] = val
    52  		i++
    53  	}
    54  	assert.Equal(t, expected, result)
    55  }
    56  
    57  func Test_VectorReverseIteration(t *testing.T) {
    58  	expected := slice.Of(4, 3, 2, 1)
    59  	v := vector.Of(1, 2, 3, 4)
    60  	result := make([]int, v.Len())
    61  	i := 0
    62  	for it := v.Tail(); it.HasPrev(); {
    63  		result[i] = it.GetPrev()
    64  		i++
    65  	}
    66  	assert.Equal(t, expected, result)
    67  }
    68  
    69  func Test_Vector_Sort(t *testing.T) {
    70  	var (
    71  		elements = vector.Of(3, 1, 5, 6, 8, 0, -2)
    72  		sorted   = elements.Sort(func(e1, e2 int) bool { return e1 < e2 })
    73  	)
    74  	assert.Equal(t, vector.Of(-2, 0, 1, 3, 5, 6, 8), sorted)
    75  	assert.Equal(t, vector.Of(-2, 0, 1, 3, 5, 6, 8), elements)
    76  	assert.Equal(t, elements, sorted)
    77  }
    78  
    79  func Test_Vector_SortStructByField(t *testing.T) {
    80  	var (
    81  		anonymous = &user{"Anonymous", 0}
    82  		cherlie   = &user{"Cherlie", 25}
    83  		alise     = &user{"Alise", 20}
    84  		bob       = &user{"Bob", 19}
    85  
    86  		elements     = vector.Of(anonymous, cherlie, alise, bob)
    87  		sortedByName = vector.Sort(elements.Clone(), (*user).Name)
    88  		sortedByAge  = vector.Sort(elements.Clone(), (*user).Age)
    89  	)
    90  	assert.Equal(t, vector.Of(alise, anonymous, bob, cherlie), sortedByName)
    91  	assert.Equal(t, vector.Of(anonymous, bob, alise, cherlie), sortedByAge)
    92  }
    93  
    94  func Test_Vector_Nil(t *testing.T) {
    95  	var vec *mutable.Vector[int]
    96  	var nils []int
    97  	vec.Add(1, 2, 3)
    98  	vec.Add(nils...)
    99  	vec.AddOne(4)
   100  	vec.AddAll(vec)
   101  
   102  	vec.Delete(1, 2, 3)
   103  	vec.Delete(nils...)
   104  	vec.DeleteOne(4)
   105  
   106  	vec.IsEmpty()
   107  	vec.Len()
   108  
   109  	vec.For(nil)
   110  	vec.ForEach(nil)
   111  	vec.Track(nil)
   112  	vec.TrackEach(nil)
   113  
   114  	assert.Equal(t, nils, vec.Slice())
   115  
   116  	head := vec.Head()
   117  	assert.False(t, head.HasNext())
   118  	assert.False(t, head.HasPrev())
   119  
   120  	_, ok := head.Get()
   121  	assert.False(t, ok)
   122  	_, ok = head.Next()
   123  	assert.False(t, ok)
   124  	head.Cap()
   125  
   126  	tail := vec.Tail()
   127  	assert.False(t, tail.HasNext())
   128  	assert.False(t, tail.HasPrev())
   129  
   130  	_, ok = tail.Get()
   131  	assert.False(t, ok)
   132  	_, ok = tail.Next()
   133  	assert.False(t, ok)
   134  	tail.Cap()
   135  }
   136  
   137  func Test_Vector_Zero(t *testing.T) {
   138  	var vec mutable.Vector[string]
   139  
   140  	var nilValues []string
   141  	vec.Add("a", "b", "c")
   142  	vec.Add(nilValues...)
   143  	vec.AddOne("d")
   144  	vec.AddAll(&vec)
   145  
   146  	vec.Delete(0, 1, 2)
   147  	var nilIndexes []int
   148  	vec.Delete(nilIndexes...)
   149  	vec.DeleteOne(0)
   150  
   151  	e := vec.IsEmpty()
   152  	assert.False(t, e)
   153  
   154  	l := vec.Len()
   155  	assert.Equal(t, 4, l)
   156  
   157  	vec.For(func(s string) error { return nil })
   158  	vec.ForEach(func(s string) {})
   159  	vec.Track(func(i int, s string) error { return nil })
   160  	vec.TrackEach(func(i int, s string) {})
   161  
   162  	assert.Equal(t, slice.Of("a", "b", "c", "d"), vec.Slice())
   163  
   164  	head := vec.Head()
   165  	assert.True(t, head.HasNext())
   166  	assert.False(t, head.HasPrev())
   167  
   168  	_, ok := head.Get()
   169  	assert.False(t, ok)
   170  	fv, ok := head.Next()
   171  	assert.True(t, ok)
   172  	assert.Equal(t, "a", fv)
   173  	c := head.Cap()
   174  	assert.Equal(t, 4, c)
   175  
   176  	tail := vec.Tail()
   177  	assert.False(t, tail.HasNext())
   178  	assert.True(t, tail.HasPrev())
   179  
   180  	_, ok = tail.Get()
   181  	assert.False(t, ok)
   182  	tv, ok := tail.Prev()
   183  	assert.True(t, ok)
   184  	assert.Equal(t, "d", tv)
   185  	c = tail.Cap()
   186  	assert.Equal(t, 4, c)
   187  }
   188  
   189  func Test_Vector_new(t *testing.T) {
   190  	var vec = new(mutable.Vector[string])
   191  
   192  	var nilValues []string
   193  	vec.Add("a", "b", "c")
   194  	vec.Add(nilValues...)
   195  	vec.AddOne("d")
   196  	vec.AddAll(vec)
   197  
   198  	vec.Delete(0, 1, 2)
   199  	var nilIndexes []int
   200  	vec.Delete(nilIndexes...)
   201  	vec.DeleteOne(0)
   202  
   203  	e := vec.IsEmpty()
   204  	assert.False(t, e)
   205  
   206  	l := vec.Len()
   207  	assert.Equal(t, 4, l)
   208  
   209  	vec.For(func(s string) error { return nil })
   210  	vec.ForEach(func(s string) {})
   211  	vec.Track(func(i int, s string) error { return nil })
   212  	vec.TrackEach(func(i int, s string) {})
   213  
   214  	assert.Equal(t, slice.Of("a", "b", "c", "d"), vec.Slice())
   215  
   216  	head := vec.Head()
   217  	assert.True(t, head.HasNext())
   218  	assert.False(t, head.HasPrev())
   219  
   220  	_, ok := head.Get()
   221  	assert.False(t, ok)
   222  	fv, ok := head.Next()
   223  	assert.True(t, ok)
   224  	assert.Equal(t, "a", fv)
   225  	c := head.Cap()
   226  	assert.Equal(t, 4, c)
   227  
   228  	tail := vec.Tail()
   229  	assert.False(t, tail.HasNext())
   230  	assert.True(t, tail.HasPrev())
   231  
   232  	_, ok = tail.Get()
   233  	assert.False(t, ok)
   234  	tv, ok := tail.Prev()
   235  	assert.True(t, ok)
   236  	assert.Equal(t, "d", tv)
   237  	c = tail.Cap()
   238  	assert.Equal(t, 4, c)
   239  }
   240  
   241  func Test_Vector_AddAllOfSelf(t *testing.T) {
   242  	vec := vector.Of(1, 2, 3)
   243  	vec.AddAll(vec)
   244  	assert.Equal(t, vector.Of(1, 2, 3, 1, 2, 3), vec)
   245  }
   246  
   247  type user struct {
   248  	name string
   249  	age  int
   250  }
   251  
   252  func (u *user) Name() string { return u.name }
   253  func (u *user) Age() int     { return u.age }
   254  
   255  func Test_Vector_AddAndDelete(t *testing.T) {
   256  	vec := vector.NewCap[int](0)
   257  	vec.Add(range_.Closed(0, 1000)...)
   258  	deleted := false
   259  	for i := vec.Head(); i.HasNext(); {
   260  		deleted = i.DeleteNext()
   261  	}
   262  	assert.Equal(t, deleted, true)
   263  	assert.True(t, vec.IsEmpty())
   264  
   265  	vec.Add(range_.Closed(0, 10000)...)
   266  	for i := vec.Tail(); i.HasPrev(); {
   267  		deleted = i.DeletePrev()
   268  	}
   269  	assert.Equal(t, deleted, true)
   270  	assert.True(t, vec.IsEmpty())
   271  }
   272  
   273  func Test_Vector_Add(t *testing.T) {
   274  	vec := vector.NewCap[int](0)
   275  	vec.Add(1, 1, 2, 4, 3, 1)
   276  	assert.Equal(t, slice.Of(1, 1, 2, 4, 3, 1), vec.Slice())
   277  	vec.Add(1)
   278  	assert.Equal(t, slice.Of(1, 1, 2, 4, 3, 1, 1), vec.Slice())
   279  }
   280  
   281  func Test_Vector_AddAll(t *testing.T) {
   282  	vec := vector.NewCap[int](0)
   283  	vec.AddAll(vector.Of(1, 1, 2, 4, 3, 1))
   284  	assert.Equal(t, slice.Of(1, 1, 2, 4, 3, 1), vec.Slice())
   285  	vec.AddAll(vector.Of(1))
   286  	assert.Equal(t, slice.Of(1, 1, 2, 4, 3, 1, 1), vec.Slice())
   287  }
   288  
   289  func Test_Vector_Add_And_Iterate(t *testing.T) {
   290  	vec := vector.NewCap[int](0)
   291  	it, v, ok := vec.First()
   292  	//no a first element
   293  	assert.False(t, ok)
   294  	//no more elements
   295  	assert.False(t, it.HasNext())
   296  	vec.Add(1)
   297  	//exists one more
   298  	assert.True(t, it.HasNext())
   299  	v, ok = it.Get()
   300  	//but the cursor points out of the range
   301  	assert.False(t, ok)
   302  	//starts itaration
   303  	v, ok = it.Next()
   304  	//success
   305  	assert.True(t, ok)
   306  	assert.Equal(t, 1, v)
   307  	//no more
   308  	assert.False(t, it.HasNext())
   309  	//no prev
   310  	assert.False(t, it.HasPrev())
   311  	//only the current one
   312  	v, ok = it.Get()
   313  	assert.True(t, ok)
   314  	assert.Equal(t, 1, v)
   315  }
   316  
   317  func Test_Vector_Delete_And_Iterate(t *testing.T) {
   318  	vec := vector.Of(2)
   319  	it, v, ok := vec.First()
   320  	//success
   321  	assert.True(t, ok)
   322  	assert.Equal(t, 2, v)
   323  
   324  	//no more
   325  	assert.False(t, it.HasNext())
   326  	//no prev
   327  	assert.False(t, it.HasPrev())
   328  
   329  	//only the current one
   330  	v, ok = it.Get()
   331  	assert.True(t, ok)
   332  	assert.Equal(t, 2, v)
   333  
   334  	it.Delete()
   335  
   336  	//no the current one
   337  	_, ok = it.Get()
   338  	assert.False(t, ok)
   339  
   340  	//no more
   341  	assert.False(t, it.HasNext())
   342  	//no prev
   343  	assert.False(t, it.HasPrev())
   344  
   345  	assert.True(t, vec.IsEmpty())
   346  
   347  	// add values to vector
   348  	vec.Add(1, 3)
   349  
   350  	//it must to point before the first
   351  	_, ok = it.Get()
   352  	assert.False(t, ok)
   353  	assert.True(t, it.HasNext())
   354  	assert.False(t, it.HasPrev())
   355  
   356  	v, ok = it.Next()
   357  	assert.True(t, ok)
   358  	assert.Equal(t, 1, v)
   359  
   360  	assert.True(t, it.HasNext())
   361  	assert.False(t, it.HasPrev())
   362  
   363  	v, ok = it.Next()
   364  	assert.True(t, ok)
   365  	assert.Equal(t, 3, v)
   366  
   367  	assert.False(t, it.HasNext())
   368  	assert.True(t, it.HasPrev())
   369  
   370  	v, ok = it.Prev()
   371  	assert.True(t, ok)
   372  	assert.Equal(t, 1, v)
   373  
   374  	assert.True(t, it.HasNext())
   375  	assert.False(t, it.HasPrev())
   376  
   377  	//delete the first one
   378  	it.Delete()
   379  
   380  	//second must remains
   381  	assert.False(t, it.HasNext())
   382  	assert.False(t, it.HasPrev())
   383  	v, ok = it.Get()
   384  	assert.True(t, ok)
   385  	assert.Equal(t, 3, v)
   386  
   387  	assert.Equal(t, []int{3}, vec.Slice())
   388  }
   389  
   390  func Test_Vector_DeleteOne(t *testing.T) {
   391  	vec := vector.Of("1", "1", "2", "4", "3", "1")
   392  	vec.DeleteOne(3)
   393  	assert.Equal(t, slice.Of("1", "1", "2", "3", "1"), vec.Slice())
   394  	r := vec.DeleteActualOne(5)
   395  	assert.Equal(t, r, false)
   396  }
   397  
   398  func Test_Vector_DeleteMany(t *testing.T) {
   399  	vec := vector.Of("0", "1", "2", "3", "4", "5", "6")
   400  	vec.Delete(3, 0, 5)
   401  	assert.Equal(t, slice.Of("1", "2", "4", "6"), vec.Slice())
   402  	r := vec.DeleteActual(5, 4)
   403  	assert.Equal(t, r, false)
   404  }
   405  
   406  func Test_Vector_DeleteManyFromTail(t *testing.T) {
   407  	vec := vector.Of("0", "1", "2", "3", "4", "5", "6")
   408  	vec.Delete(4, 5, 6)
   409  	assert.Equal(t, slice.Of("0", "1", "2", "3"), vec.Slice())
   410  }
   411  
   412  func Test_Vector_DeleteManyFromHead(t *testing.T) {
   413  	vec := vector.Of("0", "1", "2", "3", "4", "5", "6")
   414  	vec.Delete(0, 1, 2)
   415  	assert.Equal(t, slice.Of("3", "4", "5", "6"), vec.Slice())
   416  }
   417  
   418  func Test_Vector_DeleteManyFromMiddle(t *testing.T) {
   419  	vec := vector.Of("0", "1", "2", "3", "4", "5", "6")
   420  	vec.Delete(4, 3)
   421  	assert.Equal(t, slice.Of("0", "1", "2", "5", "6"), vec.Slice())
   422  }
   423  
   424  func Test_Vector_Set(t *testing.T) {
   425  	vec := vector.Of("1", "1", "2", "4", "3", "1")
   426  	vec.Set(10, "11")
   427  	assert.Equal(t, slice.Of("1", "1", "2", "4", "3", "1", "", "", "", "", "11"), vec.Slice())
   428  }
   429  
   430  func Test_Vector_DeleteByIterator(t *testing.T) {
   431  	vec := vector.Of(1, 1, 2, 4, 3, 1)
   432  	iterator := vec.IterEdit()
   433  
   434  	i := 0
   435  	var v int
   436  	var ok bool
   437  	for v, ok = iterator.Next(); ok; v, ok = iterator.Next() {
   438  		i++
   439  		iterator.Delete()
   440  	}
   441  
   442  	_, _ = v, ok
   443  
   444  	assert.Equal(t, 6, i)
   445  	assert.Equal(t, 0, len(vec.Slice()))
   446  }
   447  
   448  func Test_Vector_DeleteByIterator_Reverse(t *testing.T) {
   449  	vec := vector.Of(1, 1, 2, 4, 3, 1)
   450  	iterator := vec.Tail()
   451  
   452  	i := 0
   453  	var v int
   454  	var ok bool
   455  	for v, ok = iterator.Prev(); ok; v, ok = iterator.Prev() {
   456  		i++
   457  		iterator.Delete()
   458  	}
   459  
   460  	_, _ = v, ok
   461  
   462  	assert.Equal(t, 6, i)
   463  	assert.Equal(t, 0, len(vec.Slice()))
   464  }
   465  
   466  func Test_Vector_FilterMapReduce(t *testing.T) {
   467  	s := vector.Of(1, 1, 2, 4, 3, 4).Filter(func(i int) bool { return i%2 == 0 }).Convert(func(i int) int { return i * 2 }).Reduce(op.Sum[int])
   468  	assert.Equal(t, 20, s)
   469  }
   470  
   471  func Test_Vector_Group(t *testing.T) {
   472  	groups := group.Of(vector.Of(0, 1, 1, 2, 4, 3, 1, 6, 7), func(e int) bool { return e%2 == 0 })
   473  
   474  	assert.Equal(t, len(groups), 2)
   475  	assert.Equal(t, []int{1, 1, 3, 1, 7}, groups[false])
   476  	assert.Equal(t, []int{0, 2, 4, 6}, groups[true])
   477  }