Restructure and Support for Slice Assertion

src/integrationtest/assertion/Hard_test.go → src/integrationtest/assert_type/HardAssert_test.go

@@ -1,9 +1,9 @@
-package assertion
+package assert_type
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/assertion"
-	"github.com/sku0x20/assertG/src/pkg/message"
-	"github.com/sku0x20/assertG/src/pkg/message/verbs"
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/message"
+	"github.com/sku0x20/assertG/src/main/message/verbs"
 	"github.com/sku0x20/gRunner/src/pkg/runner"
 	"strings"
 	"testing"
@@ -33,16 +33,16 @@ func Test_Hard(t *testing.T) {
 }
 
 func hardReal(t *testing.T) {
-	r := runner.NewTestsRunner[*assertion.Hard](t, initE)
+	r := runner.NewTestsRunner[*assert_type.HardAssert](t, initE)
 	r.Add(printsMsg)
 	r.Run()
 }
 
-func initE(t *testing.T) *assertion.Hard {
-	return assertion.NewHard(t)
+func initE(t *testing.T) *assert_type.HardAssert {
+	return assert_type.NewHardAssert(t)
 }
 
-func printsMsg(t *testing.T, h *assertion.Hard) {
+func printsMsg(t *testing.T, h *assert_type.HardAssert) {
 	msg := message.Expected().
 		Verb(verbs.ToBeNil)
 	h.FailWith(msg)

src/integrationtest/assertion/utils.go → src/integrationtest/assert_type/utils.go

@@ -1,4 +1,4 @@
-package assertion
+package assert_type
 
 import (
 	"os"

src/main/assert/bool.go

@@ -0,0 +1,16 @@
+package assert
+
+import (
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/asserter"
+	"github.com/sku0x20/assertG/src/main/registry"
+)
+
+func ThatBool(val bool) *asserter.Bool {
+	at := registry.GlobalRegistryGetAssertType()
+	return ThatBoolWith(at, val)
+}
+
+func ThatBoolWith(a assert_type.AssertType, val bool) *asserter.Bool {
+	return asserter.NewBool(a, val)
+}

src/main/assert/generic.go

@@ -0,0 +1,24 @@
+package assert
+
+import (
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/asserter"
+	"github.com/sku0x20/assertG/src/main/equator"
+	"github.com/sku0x20/assertG/src/main/registry"
+)
+
+// methods cannot have type parameters
+// using global registry for AssertType
+
+func That[T any](value T) *asserter.Generic[T] {
+	at := registry.GlobalRegistryGetAssertType()
+	return ThatWith(at, equator.NewReflectDeepEquator[T](), value)
+}
+
+func ThatWith[T any](
+	at assert_type.AssertType,
+	equator equator.Equator[T],
+	value T,
+) *asserter.Generic[T] {
+	return asserter.NewGeneric(at, equator, value)
+}

src/main/assert/slice.go

@@ -0,0 +1,21 @@
+package assert
+
+import (
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/asserter"
+	"github.com/sku0x20/assertG/src/main/equator"
+	"github.com/sku0x20/assertG/src/main/registry"
+)
+
+func ThatSlice[T any](value []T) *asserter.Slice[T] {
+	at := registry.GlobalRegistryGetAssertType()
+	return ThatSliceWith(at, equator.NewReflectDeepEquator[T](), value)
+}
+
+func ThatSliceWith[T any](
+	a assert_type.AssertType,
+	elemEquator equator.Equator[T],
+	value []T,
+) *asserter.Slice[T] {
+	return asserter.NewSlice(a, elemEquator, value)
+}

src/main/assert/string.go

@@ -0,0 +1,16 @@
+package assert
+
+import (
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/asserter"
+	"github.com/sku0x20/assertG/src/main/registry"
+)
+
+func ThatString(value string) *asserter.String {
+	at := registry.GlobalRegistryGetAssertType()
+	return ThatStringWith(at, value)
+}
+
+func ThatStringWith(a assert_type.AssertType, value string) *asserter.String {
+	return asserter.NewString(a, value)
+}

src/main/assert_type/AssertType.go

@@ -0,0 +1,7 @@
+package assert_type
+
+import "github.com/sku0x20/assertG/src/main/message"
+
+type AssertType interface {
+	FailWith(msg *message.Message)
+}

src/main/assert_type/HardAssert.go

@@ -0,0 +1,18 @@
+package assert_type
+
+import (
+	"github.com/sku0x20/assertG/src/main/message"
+	"testing"
+)
+
+func NewHardAssert(t *testing.T) *HardAssert {
+	return &HardAssert{t: t}
+}
+
+type HardAssert struct {
+	t *testing.T
+}
+
+func (h *HardAssert) FailWith(msg *message.Message) {
+	h.t.Fatalf("%s", msg.ToString())
+}

src/main/assert_type/SoftAssert.go

@@ -0,0 +1,25 @@
+package assert_type
+
+import (
+	"github.com/sku0x20/assertG/src/main/message"
+	"testing"
+)
+
+func NewSoftAssert(t *testing.T) *SoftAssert {
+	return &SoftAssert{t, false}
+}
+
+type SoftAssert struct {
+	t      *testing.T
+	failed bool
+}
+
+func (s *SoftAssert) FailWith(msg *message.Message) {
+	s.failed = true
+	s.t.Helper()
+	s.t.Logf(msg.ToString())
+}
+
+func (s *SoftAssert) Failed() bool {
+	return s.failed
+}

src/pkg/asserter/Bool.go → src/main/asserter/Bool.go

@@ -1,17 +1,17 @@
 package asserter
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/assertion"
-	"github.com/sku0x20/assertG/src/pkg/message"
-	"github.com/sku0x20/assertG/src/pkg/message/verbs"
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/message"
+	"github.com/sku0x20/assertG/src/main/message/verbs"
 )
 
-func NewBool(a assertion.Assertion, val bool) *Bool {
+func NewBool(a assert_type.AssertType, val bool) *Bool {
 	return &Bool{a: a, e: val}
 }
 
 type Bool struct {
-	a assertion.Assertion
+	a assert_type.AssertType
 	e bool
 }
 

src/main/asserter/Generic.go

@@ -0,0 +1,57 @@
+package asserter
+
+import (
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/equator"
+	"github.com/sku0x20/assertG/src/main/message"
+	"github.com/sku0x20/assertG/src/main/message/verbs"
+	"reflect"
+)
+
+func NewGeneric[T any](
+	a assert_type.AssertType,
+	equator equator.Equator[T],
+	value T,
+) *Generic[T] {
+	return &Generic[T]{assertion: a, equator: equator, actual: value}
+}
+
+type Generic[T any] struct {
+	assertion assert_type.AssertType
+	equator   equator.Equator[T]
+	actual    T
+}
+
+func (g *Generic[T]) IsEqualTo(val any) *Generic[T] {
+	if !g.equator.AreEqual(g.actual, val) {
+		g.assertion.FailWith(
+			message.Expected().
+				Value(g.actual).
+				Verb(verbs.ToEqual).
+				Value(val),
+		)
+	}
+	return g
+}
+
+func (g *Generic[T]) IsNil() *Generic[T] {
+	if !reflect.DeepEqual(g.actual, nil) {
+		g.assertion.FailWith(
+			message.Expected().
+				Value(g.actual).
+				Verb(verbs.ToBeNil),
+		)
+	}
+	return g
+}
+
+func (g *Generic[T]) IsNotNil() *Generic[T] {
+	if reflect.DeepEqual(g.actual, nil) {
+		g.assertion.FailWith(
+			message.Expected().
+				Value(g.actual).
+				Verb(verbs.NotToBeNil),
+		)
+	}
+	return g
+}

src/main/asserter/Slice.go

@@ -0,0 +1,99 @@
+package asserter
+
+import (
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/equator"
+	"github.com/sku0x20/assertG/src/main/message"
+	"github.com/sku0x20/assertG/src/main/message/verbs"
+)
+
+func NewSlice[T any](
+	a assert_type.AssertType,
+	elemEquator equator.Equator[T],
+	val []T,
+) *Slice[T] {
+	return &Slice[T]{a, elemEquator, val}
+}
+
+type Slice[T any] struct {
+	assertion   assert_type.AssertType
+	elemEquator equator.Equator[T]
+	actual      []T
+}
+
+func (s *Slice[T]) HasLength(l int) *Slice[T] {
+	if len(s.actual) != l {
+		s.assertion.FailWith(
+			message.Expected().
+				Value(s.actual).
+				Verb(verbs.ToHaveLength).
+				Value(l).
+				Verb(verbs.ButWas).
+				Value(len(s.actual)),
+		)
+	}
+	return s
+}
+
+func (s *Slice[T]) Contains(elem T) *Slice[T] {
+	for _, actual := range s.actual {
+		if s.elemEquator.AreEqual(actual, elem) {
+			break
+		}
+		s.assertion.FailWith(
+			message.Expected().
+				Value(s.actual).
+				Verb(verbs.ToContain).
+				Value(elem),
+		)
+	}
+	return s
+}
+
+func (s *Slice[T]) NotContains(elem T) *Slice[T] {
+	for _, actual := range s.actual {
+		if s.elemEquator.AreEqual(actual, elem) {
+			s.assertion.FailWith(
+				message.Expected().
+					Value(s.actual).
+					Verb(verbs.NotToContain).
+					Value(elem),
+			)
+		}
+	}
+	return s
+}
+
+func (s *Slice[T]) IsEqualTo(expected []T) *Slice[T] {
+	s.HasLength(len(expected))
+	for i := 0; i < len(expected); i++ {
+		if !s.elemEquator.AreEqual(s.actual[i], expected[i]) {
+			s.assertion.FailWith(
+				message.Expected().
+					Value(s.actual).
+					Verb(verbs.ToEqual).
+					Value(expected),
+			)
+		}
+	}
+	return s
+}
+
+func (s *Slice[T]) IsEqualToIgnoringOrder(expected []T) *Slice[T] {
+	s.HasLength(len(expected))
+outer:
+	for _, elem := range expected {
+		for _, actual := range s.actual {
+			if s.elemEquator.AreEqual(actual, elem) {
+				continue outer
+			}
+		}
+		s.assertion.FailWith(
+			message.Expected().
+				Value(s.actual).
+				Verb(verbs.ToEqual).
+				Value(expected),
+		)
+	}
+	return s
+}

src/pkg/asserter/String.go → src/main/asserter/String.go

@@ -1,18 +1,18 @@
 package asserter
 
 import (
-	"github.com/sku0x20/assertG/src/pkg/assertion"
-	"github.com/sku0x20/assertG/src/pkg/message"
-	"github.com/sku0x20/assertG/src/pkg/message/verbs"
+	"github.com/sku0x20/assertG/src/main/assert_type"
+	"github.com/sku0x20/assertG/src/main/message"
+	"github.com/sku0x20/assertG/src/main/message/verbs"
 	"strings"
 )
 
-func NewString(a assertion.Assertion, val string) *String {
+func NewString(a assert_type.AssertType, val string) *String {
 	return &String{a, val}
 }
 
 type String struct {
-	a assertion.Assertion
+	a assert_type.AssertType
 	e string
 }
 

src/main/equator/ComparableEquator.go

@@ -0,0 +1,12 @@
+package equator
+
+type ComparableEquator[T comparable] struct {
+}
+
+func NewComparableEquator[T comparable]() *ComparableEquator[T] {
+	return &ComparableEquator[T]{}
+}
+
+func (c *ComparableEquator[T]) AreEqual(a T, b any) bool {
+	return a == b
+}

src/main/equator/Equator.go

@@ -0,0 +1,5 @@
+package equator
+
+type Equator[T any] interface {
+	AreEqual(a T, b any) bool
+}