enumerators/range_test.go at main · fgrzl/enumerators · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
package enumerators_test

import (
	"testing"

	"github.com/fgrzl/enumerators"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestShouldGenerateSequenceWhenCreatingBasicRange(t *testing.T) {
	// Arrange
	generator := func(i int) int { return i * 2 }

	// Act
	rangeEnum := enumerators.Range(0, 5, generator)
	result, err := enumerators.ToSlice(rangeEnum)

	// Assert
	assert.NoError(t, err)
	assert.Equal(t, []int{0, 2, 4, 6, 8}, result)
}

func TestShouldReturnEmptyWhenRangeCountIsZero(t *testing.T) {
	// Arrange
	generator := func(i int) int { return i }

	// Act
	rangeEnum := enumerators.Range(0, 0, generator)
	result, err := enumerators.ToSlice(rangeEnum)

	// Assert
	assert.NoError(t, err)
	assert.Empty(t, result)
}

func TestShouldGenerateOneItemWhenRangeCountIsOne(t *testing.T) {
	// Arrange
	generator := func(i int) string { return "item-" + string(rune('0'+i)) }

	// Act
	rangeEnum := enumerators.Range(5, 1, generator)
	result, err := enumerators.ToSlice(rangeEnum)

	// Assert
	assert.NoError(t, err)
	assert.Equal(t, []string{"item-5"}, result)
}

func TestShouldReturnEmptyWhenRangeCountIsNegative(t *testing.T) {
	// Arrange
	generator := func(i int) int { return i }

	// Act - negative count should produce empty result
	rangeEnum := enumerators.Range(0, -5, generator)
	result, err := enumerators.ToSlice(rangeEnum)

	// Assert
	assert.NoError(t, err)
	assert.Empty(t, result)
}

func TestRange_StringGeneration(t *testing.T) {
	// Arrange & Act
	rangeEnum := enumerators.Range(1, 3, func(i int) string {
		return "value-" + string(rune('0'+i))
	})
	result, err := enumerators.ToSlice(rangeEnum)

	// Assert
	assert.NoError(t, err)
	assert.Equal(t, []string{"value-1", "value-2", "value-3"}, result)
}

func TestRange_StepByStep(t *testing.T) {
	// Arrange
	rangeEnum := enumerators.Range(10, 3, func(i int) int { return i + 100 })

	// Act & Assert
	assert.True(t, rangeEnum.MoveNext())
	current, err := rangeEnum.Current()
	require.NoError(t, err)
	assert.Equal(t, 110, current)

	assert.True(t, rangeEnum.MoveNext())
	current, err = rangeEnum.Current()
	require.NoError(t, err)
	assert.Equal(t, 111, current)

	assert.True(t, rangeEnum.MoveNext())
	current, err = rangeEnum.Current()
	require.NoError(t, err)
	assert.Equal(t, 112, current)

	assert.False(t, rangeEnum.MoveNext())
	assert.NoError(t, rangeEnum.Err())
}

func TestRange_CurrentBeforeMoveNext(t *testing.T) {
	// Arrange
	rangeEnum := enumerators.Range(0, 3, func(i int) int { return i })

	// Act - calling Current before MoveNext should return zero value
	current, err := rangeEnum.Current()

	// Assert
	assert.NoError(t, err)
	assert.Equal(t, 0, current) // zero value for int
}

func TestRange_Dispose(t *testing.T) {
	// Arrange
	rangeEnum := enumerators.Range(0, 3, func(i int) int { return i })

	// Act
	rangeEnum.Dispose() // Should not panic

	// Assert - should still work
	assert.True(t, rangeEnum.MoveNext())
	current, err := rangeEnum.Current()
	require.NoError(t, err)
	assert.Equal(t, 0, current)
}