addrset_test.gno

  1package addrset
  2
  3import (
  4	"std"
  5	"testing"
  6
  7	"gno.land/p/demo/uassert"
  8)
  9
 10func TestSet(t *testing.T) {
 11	addr1 := std.Address("addr1")
 12	addr2 := std.Address("addr2")
 13	addr3 := std.Address("addr3")
 14
 15	tests := []struct {
 16		name    string
 17		actions func(s *Set)
 18		size    int
 19		has     map[std.Address]bool
 20		addrs   []std.Address // for iteration checks
 21	}{
 22		{
 23			name:    "empty set",
 24			actions: func(s *Set) {},
 25			size:    0,
 26			has:     map[std.Address]bool{addr1: false},
 27		},
 28		{
 29			name: "single address",
 30			actions: func(s *Set) {
 31				s.Add(addr1)
 32			},
 33			size: 1,
 34			has: map[std.Address]bool{
 35				addr1: true,
 36				addr2: false,
 37			},
 38			addrs: []std.Address{addr1},
 39		},
 40		{
 41			name: "multiple addresses",
 42			actions: func(s *Set) {
 43				s.Add(addr1)
 44				s.Add(addr2)
 45				s.Add(addr3)
 46			},
 47			size: 3,
 48			has: map[std.Address]bool{
 49				addr1: true,
 50				addr2: true,
 51				addr3: true,
 52			},
 53			addrs: []std.Address{addr1, addr2, addr3},
 54		},
 55		{
 56			name: "remove address",
 57			actions: func(s *Set) {
 58				s.Add(addr1)
 59				s.Add(addr2)
 60				s.Remove(addr1)
 61			},
 62			size: 1,
 63			has: map[std.Address]bool{
 64				addr1: false,
 65				addr2: true,
 66			},
 67			addrs: []std.Address{addr2},
 68		},
 69		{
 70			name: "duplicate adds",
 71			actions: func(s *Set) {
 72				uassert.True(t, s.Add(addr1))     // first add returns true
 73				uassert.False(t, s.Add(addr1))    // second add returns false
 74				uassert.True(t, s.Remove(addr1))  // remove existing returns true
 75				uassert.False(t, s.Remove(addr1)) // remove non-existing returns false
 76			},
 77			size: 0,
 78			has: map[std.Address]bool{
 79				addr1: false,
 80			},
 81		},
 82	}
 83
 84	for _, tt := range tests {
 85		t.Run(tt.name, func(t *testing.T) {
 86			var set Set
 87
 88			// Execute test actions
 89			tt.actions(&set)
 90
 91			// Check size
 92			uassert.Equal(t, tt.size, set.Size())
 93
 94			// Check existence
 95			for addr, expected := range tt.has {
 96				uassert.Equal(t, expected, set.Has(addr))
 97			}
 98
 99			// Check iteration if addresses are specified
100			if tt.addrs != nil {
101				collected := []std.Address{}
102				set.IterateByOffset(0, 10, func(addr std.Address) bool {
103					collected = append(collected, addr)
104					return false
105				})
106
107				// Check length
108				uassert.Equal(t, len(tt.addrs), len(collected))
109
110				// Check each address
111				for i, addr := range tt.addrs {
112					uassert.Equal(t, addr, collected[i])
113				}
114			}
115		})
116	}
117}
118
119func TestSetIterationLimits(t *testing.T) {
120	tests := []struct {
121		name     string
122		addrs    []std.Address
123		offset   int
124		limit    int
125		expected int
126	}{
127		{
128			name:     "zero offset full list",
129			addrs:    []std.Address{"a1", "a2", "a3"},
130			offset:   0,
131			limit:    10,
132			expected: 3,
133		},
134		{
135			name:     "offset with limit",
136			addrs:    []std.Address{"a1", "a2", "a3", "a4"},
137			offset:   1,
138			limit:    2,
139			expected: 2,
140		},
141		{
142			name:     "offset beyond size",
143			addrs:    []std.Address{"a1", "a2"},
144			offset:   3,
145			limit:    1,
146			expected: 0,
147		},
148	}
149
150	for _, tt := range tests {
151		t.Run(tt.name, func(t *testing.T) {
152			var set Set
153			for _, addr := range tt.addrs {
154				set.Add(addr)
155			}
156
157			// Test forward iteration
158			count := 0
159			set.IterateByOffset(tt.offset, tt.limit, func(addr std.Address) bool {
160				count++
161				return false
162			})
163			uassert.Equal(t, tt.expected, count)
164
165			// Test reverse iteration
166			count = 0
167			set.ReverseIterateByOffset(tt.offset, tt.limit, func(addr std.Address) bool {
168				count++
169				return false
170			})
171			uassert.Equal(t, tt.expected, count)
172		})
173	}
174}