set: add proprty based tests

very cool that this is builtin to go!

Signed-off-by: oppiliappan <[e-mail]>

gen.go

···
+package set
+
+import (
+	"math/rand"
+	"reflect"
+	"testing/quick"
+)
+
+func (_ Set[T]) Generate(rand *rand.Rand, size int) reflect.Value {
+	s := New[T]()
+
+	var zero T
+	itemType := reflect.TypeOf(zero)
+
+	for {
+		if s.Len() >= size {
+			break
+		}
+
+		item, ok := quick.Value(itemType, rand)
+		if !ok {
+			continue
+		}
+
+		if val, ok := item.Interface().(T); ok {
+			s.Insert(val)
+		}
+	}
+
+	return reflect.ValueOf(s)
+}

set_test.go

···
 import (
 	"slices"
 	"testing"
+	"testing/quick"
 )
 
 func TestNew(t *testing.T) {
···
 		t.Error("Difference set should contain 1")
 	}
 }
+
+func TestPropertyInsertIdempotent(t *testing.T) {
+	f := func(s Set[int], item int) bool {
+		clone := s.Clone()
+
+		clone.Insert(item)
+		firstLen := clone.Len()
+
+		clone.Insert(item)
+		secondLen := clone.Len()
+
+		return firstLen == secondLen
+	}
+
+	if err := quick.Check(f, nil); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestPropertyUnionCommutative(t *testing.T) {
+	f := func(s1 Set[int], s2 Set[int]) bool {
+		union1 := Collect(s1.Union(s2))
+		union2 := Collect(s2.Union(s1))
+		return union1.Equal(union2)
+	}
+
+	if err := quick.Check(f, nil); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestPropertyIntersectionCommutative(t *testing.T) {
+	f := func(s1 Set[int], s2 Set[int]) bool {
+		inter1 := Collect(s1.Intersection(s2))
+		inter2 := Collect(s2.Intersection(s1))
+		return inter1.Equal(inter2)
+	}
+
+	if err := quick.Check(f, nil); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestPropertyCloneEquals(t *testing.T) {
+	f := func(s Set[int]) bool {
+		clone := s.Clone()
+		return s.Equal(clone)
+	}
+
+	if err := quick.Check(f, nil); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestPropertyIntersectionIsSubset(t *testing.T) {
+	f := func(s1 Set[int], s2 Set[int]) bool {
+		inter := Collect(s1.Intersection(s2))
+		return inter.IsSubset(s1) && inter.IsSubset(s2)
+	}
+
+	if err := quick.Check(f, nil); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestPropertyUnionIsSuperset(t *testing.T) {
+	f := func(s1 Set[int], s2 Set[int]) bool {
+		union := Collect(s1.Union(s2))
+		return union.IsSuperset(s1) && union.IsSuperset(s2)
+	}
+
+	if err := quick.Check(f, nil); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestPropertyDifferenceDisjoint(t *testing.T) {
+	f := func(s1 Set[int], s2 Set[int]) bool {
+		diff := Collect(s1.Difference(s2))
+		return diff.IsDisjoint(s2)
+	}
+
+	if err := quick.Check(f, nil); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestPropertySymmetricDifferenceCommutative(t *testing.T) {
+	f := func(s1 Set[int], s2 Set[int]) bool {
+		symDiff1 := Collect(s1.SymmetricDifference(s2))
+		symDiff2 := Collect(s2.SymmetricDifference(s1))
+		return symDiff1.Equal(symDiff2)
+	}
+
+	if err := quick.Check(f, nil); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestPropertyRemoveWorks(t *testing.T) {
+	f := func(s Set[int], item int) bool {
+		clone := s.Clone()
+		clone.Insert(item)
+		clone.Remove(item)
+		return !clone.Contains(item)
+	}
+
+	if err := quick.Check(f, nil); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestPropertyClearEmpty(t *testing.T) {
+	f := func(s Set[int]) bool {
+		s.Clear()
+		return s.IsEmpty() && s.Len() == 0
+	}
+
+	if err := quick.Check(f, nil); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestPropertyIsSubsetReflexive(t *testing.T) {
+	f := func(s Set[int]) bool {
+		return s.IsSubset(s)
+	}
+
+	if err := quick.Check(f, nil); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestPropertyDeMorganUnion(t *testing.T) {
+	f := func(s1 Set[int], s2 Set[int], universe Set[int]) bool {
+		// create a universe that contains both sets
+		u := universe.Clone()
+		for item := range s1.All() {
+			u.Insert(item)
+		}
+		for item := range s2.All() {
+			u.Insert(item)
+		}
+
+		// (A u B)' = A' n B'
+		union := Collect(s1.Union(s2))
+		complementUnion := Collect(u.Difference(union))
+
+		complementS1 := Collect(u.Difference(s1))
+		complementS2 := Collect(u.Difference(s2))
+		intersectionComplements := Collect(complementS1.Intersection(complementS2))
+
+		return complementUnion.Equal(intersectionComplements)
+	}
+
+	if err := quick.Check(f, nil); err != nil {
+		t.Error(err)
+	}
+}