fifo_test.gno
5.77 Kb · 294 lines
1package fifo
2
3import (
4 "testing"
5
6 "gno.land/p/nt/uassert/v0"
7)
8
9func TestNew(t *testing.T) {
10 l := New(5)
11 uassert.Equal(t, 5, l.MaxSize())
12 uassert.Equal(t, 0, l.Size())
13}
14
15func TestAppend(t *testing.T) {
16 l := New(3)
17
18 // Test adding within capacity
19 l.Append(1)
20 l.Append(2)
21 uassert.Equal(t, 2, l.Size())
22 uassert.Equal(t, 1, l.Get(0))
23 uassert.Equal(t, 2, l.Get(1))
24
25 // Test overflow behavior
26 l.Append(3)
27 l.Append(4)
28 uassert.Equal(t, 3, l.Size())
29 uassert.Equal(t, 2, l.Get(0))
30 uassert.Equal(t, 3, l.Get(1))
31 uassert.Equal(t, 4, l.Get(2))
32}
33
34func TestPrepend(t *testing.T) {
35 l := New(3)
36
37 // Test adding within capacity
38 l.Prepend(1)
39 l.Prepend(2)
40 uassert.Equal(t, 2, l.Size())
41 uassert.Equal(t, 2, l.Get(0))
42 uassert.Equal(t, 1, l.Get(1))
43
44 // Test overflow behavior
45 l.Prepend(3)
46 l.Prepend(4)
47 uassert.Equal(t, 3, l.Size())
48 uassert.Equal(t, 4, l.Get(0))
49 uassert.Equal(t, 3, l.Get(1))
50 uassert.Equal(t, 2, l.Get(2))
51}
52
53func TestGet(t *testing.T) {
54 l := New(3)
55 l.Append(1)
56 l.Append(2)
57 l.Append(3)
58
59 // Test valid indices
60 uassert.Equal(t, 1, l.Get(0))
61 uassert.Equal(t, 2, l.Get(1))
62 uassert.Equal(t, 3, l.Get(2))
63
64 // Test invalid indices
65 uassert.True(t, l.Get(-1) == nil)
66 uassert.True(t, l.Get(3) == nil)
67}
68
69func TestEntries(t *testing.T) {
70 l := New(3)
71 l.Append(1)
72 l.Append(2)
73 l.Append(3)
74
75 entries := l.Entries()
76 uassert.Equal(t, 3, len(entries))
77 uassert.Equal(t, 1, entries[0])
78 uassert.Equal(t, 2, entries[1])
79 uassert.Equal(t, 3, entries[2])
80}
81
82func TestLatest(t *testing.T) {
83 l := New(5)
84
85 // Test empty list
86 uassert.True(t, l.Latest() == nil)
87
88 // Test single entry
89 l.Append(1)
90 uassert.Equal(t, 1, l.Latest())
91
92 // Test multiple entries
93 l.Append(2)
94 l.Append(3)
95 uassert.Equal(t, 3, l.Latest())
96
97 // Test after overflow
98 l.Append(4)
99 l.Append(5)
100 l.Append(6)
101 uassert.Equal(t, 6, l.Latest())
102}
103
104func TestIterator(t *testing.T) {
105 l := New(3)
106 l.Append(1)
107 l.Append(2)
108 l.Append(3)
109
110 iter := l.Iterator()
111 uassert.Equal(t, 1, iter())
112 uassert.Equal(t, 2, iter())
113 uassert.Equal(t, 3, iter())
114 uassert.True(t, iter() == nil)
115}
116
117func TestMixedOperations(t *testing.T) {
118 l := New(3)
119
120 // Mix of append and prepend operations
121 l.Append(1) // [1]
122 l.Prepend(2) // [2,1]
123 l.Append(3) // [2,1,3]
124 l.Prepend(4) // [4,2,1]
125
126 entries := l.Entries()
127 uassert.Equal(t, 3, len(entries))
128 uassert.Equal(t, 4, entries[0])
129 uassert.Equal(t, 2, entries[1])
130 uassert.Equal(t, 1, entries[2])
131}
132
133func TestEmptyList(t *testing.T) {
134 l := New(3)
135
136 // Test operations on empty list
137 uassert.Equal(t, 0, l.Size())
138 uassert.True(t, l.Get(0) == nil)
139 uassert.Equal(t, 0, len(l.Entries()))
140 uassert.True(t, l.Latest() == nil)
141
142 iter := l.Iterator()
143 uassert.True(t, iter() == nil)
144}
145
146func TestEdgeCases(t *testing.T) {
147 // Test zero-size list
148 l := New(0)
149 uassert.Equal(t, 0, l.MaxSize())
150 l.Append(1) // Should be no-op
151 uassert.Equal(t, 0, l.Size())
152
153 // Test single-element list
154 l = New(1)
155 l.Append(1)
156 l.Append(2) // Should replace 1
157 uassert.Equal(t, 1, l.Size())
158 uassert.Equal(t, 2, l.Latest())
159
160 // Test rapid append/prepend alternation
161 l = New(3)
162 l.Append(1) // [1]
163 l.Prepend(2) // [2,1]
164 l.Append(3) // [2,1,3]
165 l.Prepend(4) // [4,2,1]
166 l.Append(5) // [2,1,5]
167 uassert.Equal(t, 3, l.Size())
168 entries := l.Entries()
169 uassert.Equal(t, 2, entries[0])
170 uassert.Equal(t, 1, entries[1])
171 uassert.Equal(t, 5, entries[2])
172
173 // Test nil values
174 l = New(2)
175 l.Append(nil)
176 l.Prepend(nil)
177 uassert.Equal(t, 2, l.Size())
178 uassert.True(t, l.Get(0) == nil)
179 uassert.True(t, l.Get(1) == nil)
180
181 // Test index bounds
182 l = New(3)
183 l.Append(1)
184 uassert.True(t, l.Get(-1) == nil)
185 uassert.True(t, l.Get(1) == nil)
186
187 // Test iterator exhaustion
188 l = New(2)
189 l.Append(1)
190 l.Append(2)
191 iter := l.Iterator()
192 uassert.Equal(t, 1, iter())
193 uassert.Equal(t, 2, iter())
194 uassert.True(t, iter() == nil)
195 uassert.True(t, iter() == nil)
196
197 // Test prepend on full list
198 l = New(2)
199 l.Append(1)
200 l.Append(2) // [1,2]
201 l.Prepend(3) // [3,1]
202 uassert.Equal(t, 2, l.Size())
203 entries = l.Entries()
204 uassert.Equal(t, 3, entries[0])
205 uassert.Equal(t, 1, entries[1])
206}
207
208func TestSetMaxSize(t *testing.T) {
209 l := New(5)
210
211 // Fill the list
212 l.Append(1)
213 l.Append(2)
214 l.Append(3)
215 l.Append(4)
216 l.Append(5)
217
218 // Test increasing maxSize
219 l.SetMaxSize(7)
220 uassert.Equal(t, 7, l.MaxSize())
221 uassert.Equal(t, 5, l.Size())
222
223 // Test reducing maxSize
224 l.SetMaxSize(3)
225 uassert.Equal(t, 3, l.Size())
226 entries := l.Entries()
227 uassert.Equal(t, 3, entries[0])
228 uassert.Equal(t, 4, entries[1])
229 uassert.Equal(t, 5, entries[2])
230
231 // Test setting to zero
232 l.SetMaxSize(0)
233 uassert.Equal(t, 0, l.Size())
234 uassert.True(t, l.head == nil)
235 uassert.True(t, l.tail == nil)
236
237 // Test negative maxSize
238 l.SetMaxSize(-1)
239 uassert.Equal(t, 0, l.MaxSize())
240
241 // Test setting back to positive
242 l.SetMaxSize(2)
243 l.Append(1)
244 l.Append(2)
245 l.Append(3)
246 uassert.Equal(t, 2, l.Size())
247 entries = l.Entries()
248 uassert.Equal(t, 2, entries[0])
249 uassert.Equal(t, 3, entries[1])
250}
251
252func TestDelete(t *testing.T) {
253 l := New(5)
254
255 // Test delete on empty list
256 uassert.False(t, l.Delete(0))
257 uassert.False(t, l.Delete(-1))
258
259 // Fill list
260 l.Append(1)
261 l.Append(2)
262 l.Append(3)
263 l.Append(4)
264
265 // Test invalid indices
266 uassert.False(t, l.Delete(-1))
267 uassert.False(t, l.Delete(4))
268
269 // Test deleting from middle
270 uassert.True(t, l.Delete(1))
271 uassert.Equal(t, 3, l.Size())
272 entries := l.Entries()
273 uassert.Equal(t, 1, entries[0])
274 uassert.Equal(t, 3, entries[1])
275 uassert.Equal(t, 4, entries[2])
276
277 // Test deleting from head
278 uassert.True(t, l.Delete(0))
279 uassert.Equal(t, 2, l.Size())
280 entries = l.Entries()
281 uassert.Equal(t, 3, entries[0])
282 uassert.Equal(t, 4, entries[1])
283
284 // Test deleting from tail
285 uassert.True(t, l.Delete(1))
286 uassert.Equal(t, 1, l.Size())
287 uassert.Equal(t, 3, l.Latest())
288
289 // Test deleting last element
290 uassert.True(t, l.Delete(0))
291 uassert.Equal(t, 0, l.Size())
292 uassert.True(t, l.head == nil)
293 uassert.True(t, l.tail == nil)
294}
