now using testsuite also for linkedmap

pkg/support/collections/linkedmap_test.go

@@ -1,130 +1,144 @@
 package collections
 
 import (
-	"github.com/stretchr/testify/assert"
-	"os"
+	"github.com/stretchr/testify/suite"
 	"testing"
 )
 
-func TestMain(m *testing.M) {
-	checkStatus = true
-	exitCode := m.Run()
-	checkStatus = false
-	os.Exit(exitCode)
+type LinkedMapTestSuite struct {
+	suite.Suite
 }
 
-func contentCheck(t *testing.T, m *LinkedMap[string, int],
+func (s *LinkedMapTestSuite) SetupSuite() {
+	checkStatus = true
+}
+
+func (s *LinkedMapTestSuite) TearDownSuite() {
+	checkStatus = false
+}
+
+func (s *LinkedMapTestSuite) SetupTest() {
+}
+
+func (s *LinkedMapTestSuite) TearDownTest() {
+}
+
+func TestLinkedMap(t *testing.T) {
+	suite.Run(t, &LinkedMapTestSuite{})
+}
+
+func (s *LinkedMapTestSuite) contentCheck(m *LinkedMap[string, int],
 	keys []string, values []int) {
 
-	assert.True(t, len(keys) == len(values), "input error expected keys and values differ in length")
+	s.True(len(keys) == len(values), "input error expected keys and values differ in length")
 
 	// keys
 	i := 0
 	for key := range m.RangeKeys() {
-		assert.True(t, i < len(keys), "Too many elements in map")
-		assert.Equal(t, keys[i], key)
+		s.True(i < len(keys), "Too many elements in map")
+		s.Equal(keys[i], key)
 		i++
 	}
-	assert.Equal(t, len(keys), i)
+	s.Equal(len(keys), i)
 
 	// values
 	i = 0
 	for value := range m.RangeValues() {
-		assert.True(t, i < len(values), "Too many elements in map")
-		assert.Equal(t, values[i], value)
+		s.True(i < len(values), "Too many elements in map")
+		s.Equal(values[i], value)
 		i++
 	}
-	assert.Equal(t, len(values), i)
+	s.Equal(len(values), i)
 
 	// Entries
 	i = 0
 	for entry := range m.RangeEntries() {
-		assert.True(t, i < len(values), "Too many elements in map")
-		assert.Equal(t, keys[i], entry.Key)
-		assert.Equal(t, values[i], entry.Value)
+		s.True(i < len(values), "Too many elements in map")
+		s.Equal(keys[i], entry.Key)
+		s.Equal(values[i], entry.Value)
 		i++
 	}
-	assert.Equal(t, len(values), i)
+	s.Equal(len(values), i)
 
 	// Get and Contains
 	for i, key := range keys {
 		v, ok := m.Get(key)
-		assert.True(t, ok)
-		assert.Equal(t, values[i], v)
-		assert.True(t, m.Contains(key))
+		s.True(ok)
+		s.Equal(values[i], v)
+		s.True(m.Contains(key))
 	}
 }
 
-func Test_emptymap(t *testing.T) {
+func (s *LinkedMapTestSuite) Test_emptymap() {
 	m := NewLinkedMap[string, int]()
-	contentCheck(t, m, []string{}, []int{})
+	s.contentCheck(m, []string{}, []int{})
 }
 
-func Test_elementAddRemove(t *testing.T) {
+func (s *LinkedMapTestSuite) Test_elementAddRemove() {
 	m := NewLinkedMap[string, int]()
 	m.Put("a", 1)
-	contentCheck(t, m, []string{"a"}, []int{1})
+	s.contentCheck(m, []string{"a"}, []int{1})
 
-	assert.False(t, m.Delete("b"))
-	contentCheck(t, m, []string{"a"}, []int{1})
+	s.False(m.Delete("b"))
+	s.contentCheck(m, []string{"a"}, []int{1})
 
-	assert.True(t, m.Delete("a"))
-	contentCheck(t, m, []string{}, []int{})
+	s.True(m.Delete("a"))
+	s.contentCheck(m, []string{}, []int{})
 }
 
-func Test_GetContainsForElementsNotInMap(t *testing.T) {
-	m := createSimpleMap(t)
+func (s *LinkedMapTestSuite) Test_GetContainsForElementsNotInMap() {
+	m := s.createSimpleMap()
 
-	assert.False(t, m.Contains("d"))
+	s.False(m.Contains("d"))
 	val, ok := m.Get("d")
-	assert.False(t, ok)
-	assert.Equal(t, 0, val)
+	s.False(ok)
+	s.Equal(0, val)
 }
 
-func Test_elementRemoveBeginning(t *testing.T) {
-	m := createSimpleMap(t)
+func (s *LinkedMapTestSuite) Test_elementRemoveBeginning() {
+	m := s.createSimpleMap()
 
-	assert.True(t, m.Delete("a"))
-	contentCheck(t, m, []string{"b", "c"}, []int{2, 3})
+	s.True(m.Delete("a"))
+	s.contentCheck(m, []string{"b", "c"}, []int{2, 3})
 }
 
-func Test_elementRemoveMiddle(t *testing.T) {
-	m := createSimpleMap(t)
+func (s *LinkedMapTestSuite) Test_elementRemoveMiddle() {
+	m := s.createSimpleMap()
 
-	assert.True(t, m.Delete("b"))
-	contentCheck(t, m, []string{"a", "c"}, []int{1, 3})
+	s.True(m.Delete("b"))
+	s.contentCheck(m, []string{"a", "c"}, []int{1, 3})
 }
 
-func Test_elementRemoveEnd(t *testing.T) {
-	m := createSimpleMap(t)
+func (s *LinkedMapTestSuite) Test_elementRemoveEnd() {
+	m := s.createSimpleMap()
 
-	assert.True(t, m.Delete("c"))
-	contentCheck(t, m, []string{"a", "b"}, []int{1, 2})
+	s.True(m.Delete("c"))
+	s.contentCheck(m, []string{"a", "b"}, []int{1, 2})
 }
 
-func Test_addSameElementAgain(t *testing.T) {
-	m := createSimpleMap(t)
+func (s *LinkedMapTestSuite) Test_addSameElementAgain() {
+	m := s.createSimpleMap()
 
 	m.Put("b", 4)
-	contentCheck(t, m, []string{"a", "c", "b"}, []int{1, 3, 4})
+	s.contentCheck(m, []string{"a", "c", "b"}, []int{1, 3, 4})
 }
 
-func createSimpleMap(t *testing.T) *LinkedMap[string, int] {
+func (s *LinkedMapTestSuite) createSimpleMap() *LinkedMap[string, int] {
 	m := NewLinkedMap[string, int]()
 	m.Put("a", 1)
 	m.Put("b", 2)
 	m.Put("c", 3)
-	contentCheck(t, m, []string{"a", "b", "c"}, []int{1, 2, 3})
+	s.contentCheck(m, []string{"a", "b", "c"}, []int{1, 2, 3})
 	return m
 }
 
-func Test_manyElements(t *testing.T) {
+func (s *LinkedMapTestSuite) Test_manyElements() {
 	m := NewLinkedMap[string, int]()
 	chars := "0123456789"
 	for i := 0; i < 10000; i++ {
 		m.Put(chars[i%10:i%10+1], i)
 	}
-	contentCheck(t, m,
+	s.contentCheck(m,
 		[]string{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"},
 		[]int{9990, 9991, 9992, 9993, 9994, 9995, 9996, 9997, 9998, 9999})
 }