github.com/blend/go-sdk@v1.20240719.1/collections/ring_buffer_test.go (about)

     1  /*
     2  
     3  Copyright (c) 2024 - Present. Blend Labs, Inc. All rights reserved
     4  Use of this source code is governed by a MIT license that can be found in the LICENSE file.
     5  
     6  */
     7  
     8  package collections
     9  
    10  import (
    11  	"testing"
    12  
    13  	"github.com/blend/go-sdk/assert"
    14  )
    15  
    16  func Test_RingBuffer(t *testing.T) {
    17  	a := assert.New(t)
    18  
    19  	buffer := NewRingBuffer[int]()
    20  
    21  	buffer.Enqueue(1)
    22  	a.Equal(1, buffer.Len())
    23  	a.Equal(1, buffer.Peek())
    24  	a.Equal(1, buffer.PeekBack())
    25  
    26  	buffer.Enqueue(2)
    27  	a.Equal(2, buffer.Len())
    28  	a.Equal(1, buffer.Peek())
    29  	a.Equal(2, buffer.PeekBack())
    30  
    31  	buffer.Enqueue(3)
    32  	a.Equal(3, buffer.Len())
    33  	a.Equal(1, buffer.Peek())
    34  	a.Equal(3, buffer.PeekBack())
    35  
    36  	buffer.Enqueue(4)
    37  	a.Equal(4, buffer.Len())
    38  	a.Equal(1, buffer.Peek())
    39  	a.Equal(4, buffer.PeekBack())
    40  
    41  	buffer.Enqueue(5)
    42  	a.Equal(5, buffer.Len())
    43  	a.Equal(1, buffer.Peek())
    44  	a.Equal(5, buffer.PeekBack())
    45  
    46  	buffer.Enqueue(6)
    47  	a.Equal(6, buffer.Len())
    48  	a.Equal(1, buffer.Peek())
    49  	a.Equal(6, buffer.PeekBack())
    50  
    51  	buffer.Enqueue(7)
    52  	a.Equal(7, buffer.Len())
    53  	a.Equal(1, buffer.Peek())
    54  	a.Equal(7, buffer.PeekBack())
    55  
    56  	buffer.Enqueue(8)
    57  	a.Equal(8, buffer.Len())
    58  	a.Equal(1, buffer.Peek())
    59  	a.Equal(8, buffer.PeekBack())
    60  
    61  	value := buffer.Dequeue()
    62  	a.Equal(1, value)
    63  	a.Equal(7, buffer.Len())
    64  	a.Equal(2, buffer.Peek())
    65  	a.Equal(8, buffer.PeekBack())
    66  
    67  	value = buffer.Dequeue()
    68  	a.Equal(2, value)
    69  	a.Equal(6, buffer.Len())
    70  	a.Equal(3, buffer.Peek())
    71  	a.Equal(8, buffer.PeekBack())
    72  
    73  	value = buffer.Dequeue()
    74  	a.Equal(3, value)
    75  	a.Equal(5, buffer.Len())
    76  	a.Equal(4, buffer.Peek())
    77  	a.Equal(8, buffer.PeekBack())
    78  
    79  	value = buffer.Dequeue()
    80  	a.Equal(4, value)
    81  	a.Equal(4, buffer.Len())
    82  	a.Equal(5, buffer.Peek())
    83  	a.Equal(8, buffer.PeekBack())
    84  
    85  	value = buffer.Dequeue()
    86  	a.Equal(5, value)
    87  	a.Equal(3, buffer.Len())
    88  	a.Equal(6, buffer.Peek())
    89  	a.Equal(8, buffer.PeekBack())
    90  
    91  	value = buffer.Dequeue()
    92  	a.Equal(6, value)
    93  	a.Equal(2, buffer.Len())
    94  	a.Equal(7, buffer.Peek())
    95  	a.Equal(8, buffer.PeekBack())
    96  
    97  	value = buffer.Dequeue()
    98  	a.Equal(7, value)
    99  	a.Equal(1, buffer.Len())
   100  	a.Equal(8, buffer.Peek())
   101  	a.Equal(8, buffer.PeekBack())
   102  
   103  	value = buffer.Dequeue()
   104  	a.Equal(8, value)
   105  	a.Equal(0, buffer.Len())
   106  	a.Empty(buffer.Peek())
   107  	a.Empty(buffer.PeekBack())
   108  }
   109  
   110  func TestRingBufferClear(t *testing.T) {
   111  	a := assert.New(t)
   112  
   113  	buffer := NewRingBuffer[int]()
   114  	buffer.Enqueue(1)
   115  	buffer.Enqueue(1)
   116  	buffer.Enqueue(1)
   117  	buffer.Enqueue(1)
   118  	buffer.Enqueue(1)
   119  	buffer.Enqueue(1)
   120  	buffer.Enqueue(1)
   121  	buffer.Enqueue(1)
   122  
   123  	a.Equal(8, buffer.Len())
   124  
   125  	buffer.Clear()
   126  	a.Equal(0, buffer.Len())
   127  	a.Empty(buffer.Peek())
   128  	a.Empty(buffer.PeekBack())
   129  }
   130  
   131  func TestRingBufferContents(t *testing.T) {
   132  	a := assert.New(t)
   133  
   134  	buffer := NewRingBuffer[int]()
   135  	buffer.Enqueue(1)
   136  	buffer.Enqueue(2)
   137  	buffer.Enqueue(3)
   138  	buffer.Enqueue(4)
   139  	buffer.Enqueue(5)
   140  
   141  	contents := buffer.Contents()
   142  	a.Len(contents, 5)
   143  	a.Equal(1, contents[0])
   144  	a.Equal(2, contents[1])
   145  	a.Equal(3, contents[2])
   146  	a.Equal(4, contents[3])
   147  	a.Equal(5, contents[4])
   148  }
   149  
   150  func TestRingBufferDrain(t *testing.T) {
   151  	a := assert.New(t)
   152  
   153  	buffer := NewRingBuffer[int]()
   154  	buffer.Enqueue(1)
   155  	buffer.Enqueue(2)
   156  	buffer.Enqueue(3)
   157  	buffer.Enqueue(4)
   158  	buffer.Enqueue(5)
   159  
   160  	contents := buffer.Drain()
   161  	a.Len(contents, 5)
   162  	a.Equal(1, contents[0])
   163  	a.Equal(2, contents[1])
   164  	a.Equal(3, contents[2])
   165  	a.Equal(4, contents[3])
   166  	a.Equal(5, contents[4])
   167  
   168  	a.Equal(0, buffer.Len())
   169  	a.Empty(buffer.Peek())
   170  	a.Empty(buffer.PeekBack())
   171  }
   172  
   173  func TestRingBufferEach(t *testing.T) {
   174  	assert := assert.New(t)
   175  
   176  	buffer := NewRingBuffer[int]()
   177  
   178  	for x := 1; x < 17; x++ {
   179  		buffer.Enqueue(x)
   180  	}
   181  
   182  	called := 0
   183  	buffer.Each(func(v int) {
   184  		if v == (called + 1) {
   185  			called++
   186  		}
   187  	})
   188  
   189  	assert.Equal(16, called)
   190  }
   191  
   192  func TestRingBufferEachUntil(t *testing.T) {
   193  	assert := assert.New(t)
   194  
   195  	buffer := NewRingBuffer[int]()
   196  
   197  	for x := 1; x < 17; x++ {
   198  		buffer.Enqueue(x)
   199  	}
   200  
   201  	called := 0
   202  	buffer.EachUntil(func(v int) bool {
   203  		if v > 10 {
   204  			return false
   205  		}
   206  		if v == (called + 1) {
   207  			called++
   208  		}
   209  		return true
   210  	})
   211  
   212  	assert.Equal(10, called)
   213  }
   214  
   215  func TestRingBufferReverseEachUntil(t *testing.T) {
   216  	assert := assert.New(t)
   217  
   218  	buffer := NewRingBufferWithCapacity[int](32)
   219  
   220  	for x := 1; x < 17; x++ {
   221  		buffer.Enqueue(x)
   222  	}
   223  
   224  	var values []int
   225  	buffer.ReverseEachUntil(func(v int) bool {
   226  		if v < 10 {
   227  			return false
   228  		}
   229  		values = append(values, v)
   230  		return true
   231  	})
   232  
   233  	assert.Len(values, 7)
   234  	assert.Equal(16, values[0])
   235  	assert.Equal(10, values[6])
   236  }
   237  
   238  func TestRingBufferReverseEachUntilUndersized(t *testing.T) {
   239  	assert := assert.New(t)
   240  
   241  	buffer := NewRingBuffer[int]()
   242  
   243  	for x := 1; x < 17; x++ {
   244  		buffer.Enqueue(x)
   245  	}
   246  
   247  	var values []int
   248  	buffer.ReverseEachUntil(func(v int) bool {
   249  		if v < 10 {
   250  			return false
   251  		}
   252  		values = append(values, v)
   253  		return true
   254  	})
   255  
   256  	assert.Len(values, 7)
   257  	assert.Equal(16, values[0])
   258  	assert.Equal(10, values[6])
   259  }
   260  
   261  func TestRingBufferConsume(t *testing.T) {
   262  	assert := assert.New(t)
   263  
   264  	buffer := NewRingBuffer[int]()
   265  
   266  	for x := 1; x < 17; x++ {
   267  		buffer.Enqueue(x)
   268  	}
   269  
   270  	assert.Equal(16, buffer.Len())
   271  
   272  	var called int
   273  	buffer.Consume(func(v int) {
   274  		called++
   275  	})
   276  
   277  	assert.Equal(16, called)
   278  	assert.Zero(buffer.Len())
   279  }
   280  
   281  func TestRingBufferDequeueBack(t *testing.T) {
   282  	a := assert.New(t)
   283  
   284  	q := NewRingBuffer[int]()
   285  	q.Enqueue(1)
   286  	q.Enqueue(2)
   287  	q.Enqueue(3)
   288  	q.Enqueue(4)
   289  
   290  	a.Equal(4, q.DequeueBack())
   291  	a.Equal(3, q.DequeueBack())
   292  	a.Equal(2, q.DequeueBack())
   293  	a.Equal(1, q.DequeueBack())
   294  	a.Empty(q.DequeueBack())
   295  	a.Empty(q.DequeueBack())
   296  
   297  	q.Enqueue(1)
   298  	q.Enqueue(2)
   299  	q.Enqueue(3)
   300  	q.Enqueue(4)
   301  
   302  	a.Equal(4, q.DequeueBack())
   303  	a.Equal(3, q.DequeueBack())
   304  	a.Equal(2, q.DequeueBack())
   305  	a.Equal(1, q.DequeueBack())
   306  	a.Empty(q.DequeueBack())
   307  }