github.com/decred/dcrlnd@v0.7.6/queue/circular_buf_test.go (about)

     1  package queue
     2  
     3  import (
     4  	"reflect"
     5  	"testing"
     6  )
     7  
     8  // TestNewCircularBuffer tests the size parameter check when creating a circular
     9  // buffer.
    10  func TestNewCircularBuffer(t *testing.T) {
    11  	tests := []struct {
    12  		name          string
    13  		size          int
    14  		expectedError error
    15  	}{
    16  		{
    17  			name:          "zero size",
    18  			size:          0,
    19  			expectedError: errInvalidSize,
    20  		},
    21  		{
    22  			name:          "negative size",
    23  			size:          -1,
    24  			expectedError: errInvalidSize,
    25  		},
    26  		{
    27  			name:          "ok size",
    28  			size:          1,
    29  			expectedError: nil,
    30  		},
    31  	}
    32  
    33  	for _, test := range tests {
    34  		test := test
    35  
    36  		t.Run(test.name, func(t *testing.T) {
    37  			_, err := NewCircularBuffer(test.size)
    38  			if err != test.expectedError {
    39  				t.Fatalf("expected: %v, got: %v",
    40  					test.expectedError, err)
    41  			}
    42  		})
    43  	}
    44  }
    45  
    46  // TestCircularBuffer tests the adding and listing of items in a circular
    47  // buffer.
    48  func TestCircularBuffer(t *testing.T) {
    49  	tests := []struct {
    50  		name          string
    51  		size          int
    52  		itemCount     int
    53  		expectedItems []interface{}
    54  	}{
    55  		{
    56  			name:          "no elements",
    57  			size:          5,
    58  			itemCount:     0,
    59  			expectedItems: nil,
    60  		},
    61  		{
    62  			name:      "single element",
    63  			size:      5,
    64  			itemCount: 1,
    65  			expectedItems: []interface{}{
    66  				0,
    67  			},
    68  		},
    69  		{
    70  			name:      "no wrap, not full",
    71  			size:      5,
    72  			itemCount: 4,
    73  			expectedItems: []interface{}{
    74  				0, 1, 2, 3,
    75  			},
    76  		},
    77  		{
    78  			name:      "no wrap, exactly full",
    79  			size:      5,
    80  			itemCount: 5,
    81  			expectedItems: []interface{}{
    82  				0, 1, 2, 3, 4,
    83  			},
    84  		},
    85  		{
    86  			// The underlying array should contain {5, 1, 2, 3, 4}.
    87  			name:      "wrap, one over",
    88  			size:      5,
    89  			itemCount: 6,
    90  			expectedItems: []interface{}{
    91  				1, 2, 3, 4, 5,
    92  			},
    93  		},
    94  		{
    95  			// The underlying array should contain {5, 6, 2, 3, 4}.
    96  			name:      "wrap, two over",
    97  			size:      5,
    98  			itemCount: 7,
    99  			expectedItems: []interface{}{
   100  				2, 3, 4, 5, 6,
   101  			},
   102  		},
   103  	}
   104  
   105  	for _, test := range tests {
   106  		test := test
   107  
   108  		t.Run(test.name, func(t *testing.T) {
   109  			t.Parallel()
   110  
   111  			buffer, err := NewCircularBuffer(test.size)
   112  			if err != nil {
   113  				t.Fatalf("unexpected error: %v", err)
   114  			}
   115  
   116  			for i := 0; i < test.itemCount; i++ {
   117  				buffer.Add(i)
   118  			}
   119  
   120  			// List the items in the buffer and check that the list
   121  			// is as expected.
   122  			list := buffer.List()
   123  			if !reflect.DeepEqual(test.expectedItems, list) {
   124  				t.Fatalf("expected %v, got: %v",
   125  					test.expectedItems, list)
   126  			}
   127  		})
   128  	}
   129  }
   130  
   131  // TestLatest tests fetching of the last item added to a circular buffer.
   132  func TestLatest(t *testing.T) {
   133  	tests := []struct {
   134  		name string
   135  		size int
   136  
   137  		// items is the number of items to add to the buffer.
   138  		items int
   139  
   140  		// expectedItem is the value we expect from Latest().
   141  		expectedItem interface{}
   142  	}{
   143  		{
   144  			name:         "no items",
   145  			size:         3,
   146  			items:        0,
   147  			expectedItem: nil,
   148  		},
   149  		{
   150  			name:         "one item",
   151  			size:         3,
   152  			items:        1,
   153  			expectedItem: 0,
   154  		},
   155  		{
   156  			name:         "exactly full",
   157  			size:         3,
   158  			items:        3,
   159  			expectedItem: 2,
   160  		},
   161  		{
   162  			name:         "overflow to index 0",
   163  			size:         3,
   164  			items:        4,
   165  			expectedItem: 3,
   166  		},
   167  		{
   168  			name:         "overflow twice to index 0",
   169  			size:         3,
   170  			items:        7,
   171  			expectedItem: 6,
   172  		},
   173  	}
   174  
   175  	for _, test := range tests {
   176  		test := test
   177  
   178  		t.Run(test.name, func(t *testing.T) {
   179  			//t.Parallel()
   180  
   181  			buffer, err := NewCircularBuffer(test.size)
   182  			if err != nil {
   183  				t.Fatalf("unexpected error: %v", err)
   184  			}
   185  
   186  			for i := 0; i < test.items; i++ {
   187  				buffer.Add(i)
   188  			}
   189  
   190  			latest := buffer.Latest()
   191  
   192  			if !reflect.DeepEqual(latest, test.expectedItem) {
   193  				t.Fatalf("expected: %v, got: %v",
   194  					test.expectedItem, latest)
   195  			}
   196  		})
   197  	}
   198  }