github.com/antlabs/stl@v0.0.1/list/list_test.go (about)

     1  package list
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  	"unsafe"
     7  
     8  	"github.com/stretchr/testify/assert"
     9  )
    10  
    11  type student struct {
    12  	ID int
    13  	Head
    14  }
    15  
    16  func Test_ListDel(t *testing.T) {
    17  	s := &student{}
    18  
    19  	s.Init()
    20  
    21  	s1 := student{ID: 1}
    22  	s2 := student{ID: 2}
    23  	s3 := student{ID: 3}
    24  
    25  	s.Add(&s1.Head)
    26  	s.Add(&s2.Head)
    27  	s.Add(&s3.Head)
    28  
    29  	offset := unsafe.Offsetof(s.Head)
    30  	s.ForEachSafe(func(pos *Head) {
    31  		s.Del(pos)
    32  		posEntry := (*student)(pos.Entry(offset))
    33  		fmt.Printf("%d\n", posEntry.ID)
    34  	})
    35  
    36  	assert.Equal(t, s.Len(), 0)
    37  }
    38  
    39  func Test_ForEachPrev(t *testing.T) {
    40  	s := &student{}
    41  
    42  	s.Init()
    43  
    44  	s1 := student{ID: 1}
    45  	s2 := student{ID: 2}
    46  	s3 := student{ID: 3}
    47  	s4 := student{ID: 4}
    48  	s5 := student{ID: 5}
    49  
    50  	s.AddTail(&s1.Head)
    51  	s.AddTail(&s2.Head)
    52  	s.AddTail(&s3.Head)
    53  	s.AddTail(&s4.Head)
    54  	s.AddTail(&s5.Head)
    55  
    56  	assert.Equal(t, s.Len(), 5)
    57  
    58  	offset := unsafe.Offsetof(s.Head)
    59  
    60  	need := []int{5, 4, 3, 2, 1}
    61  	i := 0
    62  	s.ForEachPrev(func(pos *Head) {
    63  
    64  		s := (*student)(pos.Entry(offset))
    65  
    66  		assert.Equal(t, s.ID, need[i])
    67  		i++
    68  	})
    69  }
    70  
    71  func Test_ForEachPrevSafe(t *testing.T) {
    72  	s := &student{}
    73  
    74  	s.Init()
    75  
    76  	s1 := student{ID: 1}
    77  	s2 := student{ID: 2}
    78  	s3 := student{ID: 3}
    79  	s4 := student{ID: 4}
    80  	s5 := student{ID: 5}
    81  
    82  	s.AddTail(&s1.Head)
    83  	s.AddTail(&s2.Head)
    84  	s.AddTail(&s3.Head)
    85  	s.AddTail(&s4.Head)
    86  	s.AddTail(&s5.Head)
    87  
    88  	assert.Equal(t, s.Len(), 5)
    89  
    90  	offset := unsafe.Offsetof(s.Head)
    91  
    92  	need := []int{5, 4, 3, 2, 1}
    93  	i := 0
    94  	s.ForEachPrevSafe(func(pos *Head) {
    95  
    96  		posEntry := (*student)(pos.Entry(offset))
    97  
    98  		s.Del(pos)
    99  		assert.Equal(t, posEntry.ID, need[i])
   100  		i++
   101  	})
   102  
   103  	assert.Equal(t, s.Len(), 0)
   104  }
   105  
   106  func Test_ListAddTail(t *testing.T) {
   107  	s := &student{}
   108  
   109  	s.Init()
   110  
   111  	s1 := student{ID: 1}
   112  	s2 := student{ID: 2}
   113  	s3 := student{ID: 3}
   114  	s4 := student{ID: 4}
   115  	s5 := student{ID: 5}
   116  
   117  	s.AddTail(&s1.Head)
   118  	s.AddTail(&s2.Head)
   119  	s.AddTail(&s3.Head)
   120  	s.AddTail(&s4.Head)
   121  	s.AddTail(&s5.Head)
   122  
   123  	assert.Equal(t, s.Len(), 5)
   124  
   125  	offset := unsafe.Offsetof(s.Head)
   126  
   127  	need := []int{1, 2, 3, 4, 5}
   128  	i := 0
   129  	s.ForEach(func(pos *Head) {
   130  
   131  		s := (*student)(pos.Entry(offset))
   132  
   133  		assert.Equal(t, s.ID, need[i])
   134  		i++
   135  	})
   136  }
   137  
   138  func Test_ListAdd(t *testing.T) {
   139  
   140  	s := &student{}
   141  
   142  	s.Init()
   143  
   144  	s1 := student{ID: 1}
   145  	s2 := student{ID: 2}
   146  	s3 := student{ID: 3}
   147  	s4 := student{ID: 4}
   148  	s5 := student{ID: 5}
   149  
   150  	s.Add(&s1.Head)
   151  	s.Add(&s2.Head)
   152  	s.Add(&s3.Head)
   153  	s.Add(&s4.Head)
   154  	s.Add(&s5.Head)
   155  
   156  	need := []int{5, 4, 3, 2, 1}
   157  	fmt.Printf(":%d\n", s.Len())
   158  
   159  	offset := unsafe.Offsetof(s.Head)
   160  
   161  	i := 0
   162  	s.ForEach(func(pos *Head) {
   163  
   164  		s := (*student)(pos.Entry(offset))
   165  
   166  		//s.Del(pos)
   167  
   168  		assert.Equal(t, s.ID, need[i])
   169  		fmt.Printf("hello world::%d\n", s.ID)
   170  		i++
   171  	})
   172  
   173  }
   174  
   175  func Test_FirstEntry(t *testing.T) {
   176  	s := student{}
   177  	s.Init()
   178  
   179  	s1 := student{ID: 1}
   180  	s2 := student{ID: 2}
   181  
   182  	s.AddTail(&s1.Head)
   183  	s.AddTail(&s2.Head)
   184  
   185  	offset := unsafe.Offsetof(s.Head)
   186  
   187  	firstStudent := (*student)(s.FirstEntry(offset))
   188  	assert.Equal(t, firstStudent.ID, 1)
   189  }
   190  
   191  func Test_lastEntry(t *testing.T) {
   192  	s := student{}
   193  	s.Init()
   194  
   195  	s1 := student{ID: 1}
   196  	s2 := student{ID: 2}
   197  
   198  	s.AddTail(&s1.Head)
   199  	s.AddTail(&s2.Head)
   200  
   201  	offset := unsafe.Offsetof(s.Head)
   202  
   203  	lastStudent := (*student)(s.LastEntry(offset))
   204  	assert.Equal(t, lastStudent.ID, 2)
   205  }
   206  
   207  func Test_FirstEntryOrNil(t *testing.T) {
   208  	// 返回nil
   209  	s := student{}
   210  	s.Init()
   211  
   212  	offset := unsafe.Offsetof(s.Head)
   213  	p := s.FirstEntryOrNil(offset)
   214  	assert.Equal(t, p, unsafe.Pointer(uintptr(0)))
   215  
   216  	// 返回第一个元素
   217  	s1 := student{ID: 1}
   218  	s2 := student{ID: 2}
   219  	s.AddTail(&s1.Head)
   220  	s.AddTail(&s2.Head)
   221  
   222  	first := (*student)(s.FirstEntryOrNil(offset))
   223  	assert.Equal(t, first.ID, 1)
   224  
   225  }
   226  
   227  func Test_Replace(t *testing.T) {
   228  	old := student{}
   229  	old.Init()
   230  	offset := unsafe.Offsetof(old.Head)
   231  
   232  	s1 := student{ID: 1}
   233  	s2 := student{ID: 2}
   234  	s3 := student{ID: 3}
   235  	s4 := student{ID: 4}
   236  	s5 := student{ID: 5}
   237  
   238  	old.AddTail(&s1.Head)
   239  	old.AddTail(&s2.Head)
   240  	old.AddTail(&s3.Head)
   241  	old.AddTail(&s4.Head)
   242  	old.AddTail(&s5.Head)
   243  
   244  	assert.Equal(t, old.Len(), 5)
   245  
   246  	new := student{}
   247  	new.Init()
   248  	old.Replace(&new.Head)
   249  	assert.Equal(t, new.Len(), 5)
   250  	assert.Equal(t, old.Len(), 5)
   251  
   252  	need := []int{1, 2, 3, 4, 5}
   253  	i := 0
   254  	new.ForEach(func(pos *Head) {
   255  
   256  		s := (*student)(pos.Entry(offset))
   257  
   258  		assert.Equal(t, s.ID, need[i])
   259  		i++
   260  	})
   261  
   262  	/*
   263  		i = 0
   264  		old.ForEach(func(pos *Head) {
   265  
   266  			s := (*student)(pos.Entry(offset))
   267  
   268  			fmt.Printf("replace:id:%d\n", s.ID)
   269  			assert.Equal(t, s.ID, need[i])
   270  			i++
   271  		})
   272  	*/
   273  }
   274  
   275  func Test_ReplaceInit(t *testing.T) {
   276  	old := student{}
   277  	old.Init()
   278  	offset := unsafe.Offsetof(old.Head)
   279  
   280  	s1 := student{ID: 1}
   281  	s2 := student{ID: 2}
   282  	s3 := student{ID: 3}
   283  	s4 := student{ID: 4}
   284  	s5 := student{ID: 5}
   285  
   286  	old.AddTail(&s1.Head)
   287  	old.AddTail(&s2.Head)
   288  	old.AddTail(&s3.Head)
   289  	old.AddTail(&s4.Head)
   290  	old.AddTail(&s5.Head)
   291  
   292  	assert.Equal(t, old.Len(), 5)
   293  
   294  	new := student{}
   295  	new.Init()
   296  	old.ReplaceInit(&new.Head)
   297  	assert.Equal(t, new.Len(), 5)
   298  	assert.Equal(t, old.Len(), 0)
   299  
   300  	need := []int{1, 2, 3, 4, 5}
   301  	i := 0
   302  	new.ForEach(func(pos *Head) {
   303  
   304  		s := (*student)(pos.Entry(offset))
   305  
   306  		assert.Equal(t, s.ID, need[i])
   307  		i++
   308  	})
   309  }
   310  
   311  func Test_DelInit(t *testing.T) {
   312  	s := student{}
   313  	s.Init()
   314  
   315  	s1 := student{ID: 1}
   316  	s2 := student{ID: 2}
   317  
   318  	s.Add(&s1.Head)
   319  	s.Add(&s2.Head)
   320  	assert.Equal(t, s.Len(), 2)
   321  
   322  	s.DelInit(&s1.Head)
   323  
   324  	assert.True(t, s1.IsLast())
   325  }
   326  
   327  func Test_Move(t *testing.T) {
   328  	s := &student{}
   329  
   330  	s.Init()
   331  
   332  	s1 := student{ID: 1}
   333  	s2 := student{ID: 2}
   334  	s3 := student{ID: 3}
   335  
   336  	s.AddTail(&s1.Head)
   337  	s.AddTail(&s2.Head)
   338  	s.AddTail(&s3.Head)
   339  
   340  	s.Move(&s2.Head)
   341  
   342  	need := []int{2, 1, 3}
   343  	i := 0
   344  	offset := unsafe.Offsetof(s.Head)
   345  	s.ForEach(func(pos *Head) {
   346  		posEntry := (*student)(pos.Entry(offset))
   347  		assert.Equal(t, posEntry.ID, need[i])
   348  		//fmt.Printf("%d\n", posEntry.ID)
   349  		i++
   350  	})
   351  }
   352  
   353  func Test_MoveTail(t *testing.T) {
   354  	s := &student{}
   355  
   356  	s.Init()
   357  
   358  	s1 := student{ID: 1}
   359  	s2 := student{ID: 2}
   360  	s3 := student{ID: 3}
   361  
   362  	s.AddTail(&s1.Head)
   363  	s.AddTail(&s2.Head)
   364  	s.AddTail(&s3.Head)
   365  
   366  	s.MoveTail(&s2.Head)
   367  
   368  	need := []int{1, 3, 2}
   369  	offset := unsafe.Offsetof(s.Head)
   370  	i := 0
   371  	s.ForEach(func(pos *Head) {
   372  		posEntry := (*student)(pos.Entry(offset))
   373  		assert.Equal(t, posEntry.ID, need[i])
   374  		//fmt.Printf("%d\n", posEntry.ID)
   375  		i++
   376  	})
   377  }
   378  
   379  func Test_RotateLeft(t *testing.T) {
   380  	s := &student{}
   381  
   382  	s.Init()
   383  
   384  	s1 := student{ID: 1}
   385  	s2 := student{ID: 2}
   386  	s3 := student{ID: 3}
   387  
   388  	s.AddTail(&s1.Head)
   389  	s.AddTail(&s2.Head)
   390  	s.AddTail(&s3.Head)
   391  
   392  	s.RotateLeft()
   393  
   394  	need := []int{2, 3, 1}
   395  	offset := unsafe.Offsetof(s.Head)
   396  	i := 0
   397  	s.ForEach(func(pos *Head) {
   398  		posEntry := (*student)(pos.Entry(offset))
   399  		assert.Equal(t, posEntry.ID, need[i])
   400  		//fmt.Printf("%d\n", posEntry.ID)
   401  		i++
   402  	})
   403  }
   404  
   405  func Test_Empty(t *testing.T) {
   406  	s := student{}
   407  	s.Init()
   408  
   409  	s1 := student{ID: 1}
   410  	s.Add(&s1.Head)
   411  	s.Del(&s1.Head)
   412  
   413  	assert.True(t, s.Empty())
   414  }