diff --git a/src/integrationtest/assertion/Hard_test.go b/src/integrationtest/assert_type/HardAssert_test.go similarity index 66% rename from src/integrationtest/assertion/Hard_test.go rename to src/integrationtest/assert_type/HardAssert_test.go index 3a0b50a..8769720 100644 --- a/src/integrationtest/assertion/Hard_test.go +++ b/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) diff --git a/src/integrationtest/assertion/utils.go b/src/integrationtest/assert_type/utils.go similarity index 97% rename from src/integrationtest/assertion/utils.go rename to src/integrationtest/assert_type/utils.go index 5d25705..65aaa97 100644 --- a/src/integrationtest/assertion/utils.go +++ b/src/integrationtest/assert_type/utils.go @@ -1,4 +1,4 @@ -package assertion +package assert_type import ( "os" diff --git a/src/main/assert/bool.go b/src/main/assert/bool.go new file mode 100644 index 0000000..a5851eb --- /dev/null +++ b/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) +} diff --git a/src/main/assert/generic.go b/src/main/assert/generic.go new file mode 100644 index 0000000..c45406f --- /dev/null +++ b/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) +} diff --git a/src/main/assert/slice.go b/src/main/assert/slice.go new file mode 100644 index 0000000..797134d --- /dev/null +++ b/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) +} diff --git a/src/main/assert/string.go b/src/main/assert/string.go new file mode 100644 index 0000000..37212d5 --- /dev/null +++ b/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) +} diff --git a/src/main/assert_type/AssertType.go b/src/main/assert_type/AssertType.go new file mode 100644 index 0000000..aa1d7f0 --- /dev/null +++ b/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) +} diff --git a/src/main/assert_type/HardAssert.go b/src/main/assert_type/HardAssert.go new file mode 100644 index 0000000..e2f53c6 --- /dev/null +++ b/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()) +} diff --git a/src/main/assert_type/SoftAssert.go b/src/main/assert_type/SoftAssert.go new file mode 100644 index 0000000..84126ed --- /dev/null +++ b/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 +} diff --git a/src/pkg/asserter/Bool.go b/src/main/asserter/Bool.go similarity index 59% rename from src/pkg/asserter/Bool.go rename to src/main/asserter/Bool.go index cfe314d..2f5082d 100644 --- a/src/pkg/asserter/Bool.go +++ b/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 } diff --git a/src/main/asserter/Generic.go b/src/main/asserter/Generic.go new file mode 100644 index 0000000..b3d5b6c --- /dev/null +++ b/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 +} diff --git a/src/main/asserter/Slice.go b/src/main/asserter/Slice.go new file mode 100644 index 0000000..8990f14 --- /dev/null +++ b/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 +} diff --git a/src/pkg/asserter/String.go b/src/main/asserter/String.go similarity index 79% rename from src/pkg/asserter/String.go rename to src/main/asserter/String.go index 9eeede1..4ea5d11 100644 --- a/src/pkg/asserter/String.go +++ b/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 } diff --git a/src/main/equator/ComparableEquator.go b/src/main/equator/ComparableEquator.go new file mode 100644 index 0000000..0db0786 --- /dev/null +++ b/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 +} diff --git a/src/main/equator/Equator.go b/src/main/equator/Equator.go new file mode 100644 index 0000000..568913c --- /dev/null +++ b/src/main/equator/Equator.go @@ -0,0 +1,5 @@ +package equator + +type Equator[T any] interface { + AreEqual(a T, b any) bool +} diff --git a/src/main/equator/ReflectDeepEquator.go b/src/main/equator/ReflectDeepEquator.go new file mode 100644 index 0000000..fbc8653 --- /dev/null +++ b/src/main/equator/ReflectDeepEquator.go @@ -0,0 +1,14 @@ +package equator + +import "reflect" + +type ReflectDeepEquator[T any] struct { +} + +func NewReflectDeepEquator[T any]() *ReflectDeepEquator[T] { + return &ReflectDeepEquator[T]{} +} + +func (r *ReflectDeepEquator[T]) AreEqual(a T, b any) bool { + return reflect.DeepEqual(a, b) +} diff --git a/src/pkg/message/Message.go b/src/main/message/Message.go similarity index 100% rename from src/pkg/message/Message.go rename to src/main/message/Message.go diff --git a/src/pkg/message/defined.go b/src/main/message/defined.go similarity index 64% rename from src/pkg/message/defined.go rename to src/main/message/defined.go index ebf7cbf..58de2c9 100644 --- a/src/pkg/message/defined.go +++ b/src/main/message/defined.go @@ -1,6 +1,6 @@ package message -import "github.com/sku0x20/assertG/src/pkg/message/verbs" +import "github.com/sku0x20/assertG/src/main/message/verbs" func Expected() *Message { return NewMessage(). diff --git a/src/pkg/message/verbs/verbs.go b/src/main/message/verbs/verbs.go similarity index 76% rename from src/pkg/message/verbs/verbs.go rename to src/main/message/verbs/verbs.go index c018cbc..4c70b0a 100644 --- a/src/pkg/message/verbs/verbs.go +++ b/src/main/message/verbs/verbs.go @@ -12,4 +12,8 @@ const ( ButWas = "ButWas" ToBeTrue = "ToBeTrue" ToBeFalse = "ToBeFalse" + Exactly = "Exactly" + Once = "Once" + InOrder = "InOrder" + InAnyOrder = "InAnyOrder" ) diff --git a/src/main/registry/GlobalRegistry.go b/src/main/registry/GlobalRegistry.go new file mode 100644 index 0000000..d170eac --- /dev/null +++ b/src/main/registry/GlobalRegistry.go @@ -0,0 +1,15 @@ +package registry + +import "github.com/sku0x20/assertG/src/main/assert_type" + +var ( + assertType assert_type.AssertType = nil +) + +func GlobalRegistryGetAssertType() assert_type.AssertType { + return assertType +} + +func GlobalRegistrySetAssertType(at assert_type.AssertType) { + assertType = at +} diff --git a/src/pkg/api/Equal.go b/src/pkg/api/Equal.go deleted file mode 100644 index ebd50e3..0000000 --- a/src/pkg/api/Equal.go +++ /dev/null @@ -1,5 +0,0 @@ -package api - -type Equal interface { - Equal(other any) bool -} diff --git a/src/pkg/assert/any.go b/src/pkg/assert/any.go deleted file mode 100644 index 1deca66..0000000 --- a/src/pkg/assert/any.go +++ /dev/null @@ -1,14 +0,0 @@ -package assert - -import ( - "github.com/sku0x20/assertG/src/pkg/asserter" - "github.com/sku0x20/assertG/src/pkg/assertion" -) - -func (a *Assert) ThatAny(value any) *asserter.Any { - return ThatAny(a.a, value) -} - -func ThatAny(a assertion.Assertion, value any) *asserter.Any { - return asserter.NewAny(a, value) -} diff --git a/src/pkg/assert/assert.go b/src/pkg/assert/assert.go deleted file mode 100644 index 08ff5d4..0000000 --- a/src/pkg/assert/assert.go +++ /dev/null @@ -1,11 +0,0 @@ -package assert - -import "github.com/sku0x20/assertG/src/pkg/assertion" - -func NewAssert(a assertion.Assertion) *Assert { - return &Assert{a: a} -} - -type Assert struct { - a assertion.Assertion -} diff --git a/src/pkg/assert/bool.go b/src/pkg/assert/bool.go deleted file mode 100644 index bfcf496..0000000 --- a/src/pkg/assert/bool.go +++ /dev/null @@ -1,14 +0,0 @@ -package assert - -import ( - "github.com/sku0x20/assertG/src/pkg/asserter" - "github.com/sku0x20/assertG/src/pkg/assertion" -) - -func (a *Assert) ThatBool(val bool) *asserter.Bool { - return ThatBool(a.a, val) -} - -func ThatBool(a assertion.Assertion, val bool) *asserter.Bool { - return asserter.NewBool(a, val) -} diff --git a/src/pkg/assert/string.go b/src/pkg/assert/string.go deleted file mode 100644 index b7a361d..0000000 --- a/src/pkg/assert/string.go +++ /dev/null @@ -1,14 +0,0 @@ -package assert - -import ( - "github.com/sku0x20/assertG/src/pkg/asserter" - "github.com/sku0x20/assertG/src/pkg/assertion" -) - -func (a *Assert) ThatString(value string) *asserter.String { - return ThatString(a.a, value) -} - -func ThatString(a assertion.Assertion, value string) *asserter.String { - return asserter.NewString(a, value) -} diff --git a/src/pkg/asserter/Any.go b/src/pkg/asserter/Any.go deleted file mode 100644 index da37eb4..0000000 --- a/src/pkg/asserter/Any.go +++ /dev/null @@ -1,59 +0,0 @@ -package asserter - -import ( - "github.com/sku0x20/assertG/src/pkg/api" - "github.com/sku0x20/assertG/src/pkg/assertion" - "github.com/sku0x20/assertG/src/pkg/message" - "github.com/sku0x20/assertG/src/pkg/message/verbs" - "reflect" -) - -func NewAny(a assertion.Assertion, value any) *Any { - return &Any{a: a, e: value} -} - -type Any struct { - a assertion.Assertion - e any -} - -func (a *Any) IsEqualTo(val any) *Any { - casted, ok := a.e.(api.Equal) - var equal bool - if ok { - equal = casted.Equal(val) - } else { - equal = reflect.DeepEqual(a.e, val) - } - if !equal { - a.a.FailWith( - message.Expected(). - Value(a.e). - Verb(verbs.ToEqual). - Value(val), - ) - } - return a -} - -func (a *Any) IsNil() *Any { - if a.e != nil { - a.a.FailWith( - message.Expected(). - Value(a.e). - Verb(verbs.ToBeNil), - ) - } - return a -} - -func (a *Any) IsNotNil() *Any { - if a.e == nil { - a.a.FailWith( - message.Expected(). - Value(a.e). - Verb(verbs.NotToBeNil), - ) - } - return a -} diff --git a/src/pkg/assertion/Assertion.go b/src/pkg/assertion/Assertion.go deleted file mode 100644 index 9b06060..0000000 --- a/src/pkg/assertion/Assertion.go +++ /dev/null @@ -1,7 +0,0 @@ -package assertion - -import "github.com/sku0x20/assertG/src/pkg/message" - -type Assertion interface { - FailWith(msg *message.Message) -} diff --git a/src/pkg/assertion/Hard.go b/src/pkg/assertion/Hard.go deleted file mode 100644 index 3d9b66d..0000000 --- a/src/pkg/assertion/Hard.go +++ /dev/null @@ -1,18 +0,0 @@ -package assertion - -import ( - "github.com/sku0x20/assertG/src/pkg/message" - "testing" -) - -func NewHard(t *testing.T) *Hard { - return &Hard{t: t} -} - -type Hard struct { - t *testing.T -} - -func (h *Hard) FailWith(msg *message.Message) { - h.t.Fatalf("%s", msg.ToString()) -} diff --git a/src/pkg/assertion/Soft.go b/src/pkg/assertion/Soft.go deleted file mode 100644 index 26c5f10..0000000 --- a/src/pkg/assertion/Soft.go +++ /dev/null @@ -1,25 +0,0 @@ -package assertion - -import ( - "github.com/sku0x20/assertG/src/pkg/message" - "testing" -) - -func NewSoft(t *testing.T) *Soft { - return &Soft{t, false} -} - -type Soft struct { - t *testing.T - failed bool -} - -func (s *Soft) FailWith(msg *message.Message) { - s.failed = true - s.t.Helper() - s.t.Logf(msg.ToString()) -} - -func (s *Soft) Failed() bool { - return s.failed -} diff --git a/src/test/api/FakeEqual.go b/src/test/api/FakeEqual.go deleted file mode 100644 index 3316634..0000000 --- a/src/test/api/FakeEqual.go +++ /dev/null @@ -1,13 +0,0 @@ -package api - -func NewFakeEqual(e bool) *FakeEqual { - return &FakeEqual{e: e} -} - -type FakeEqual struct { - e bool -} - -func (f *FakeEqual) Equal(_ any) bool { - return f.e -} diff --git a/src/test/assert/any_test.go b/src/test/assert/any_test.go deleted file mode 100644 index ea732d3..0000000 --- a/src/test/assert/any_test.go +++ /dev/null @@ -1,39 +0,0 @@ -package assert - -import ( - assertP "github.com/sku0x20/assertG/src/pkg/assert" - "github.com/sku0x20/assertG/src/pkg/asserter" - "github.com/sku0x20/assertG/src/pkg/assertion" - "github.com/sku0x20/gRunner/src/pkg/runner" - "testing" -) - -func Test_Any(t *testing.T) { - r := runner.NewTestsRunnerEmptyInit[any](t) - r.Add(viaPackage_Any) - r.Add(viaVariable_Any) - r.Run() -} - -func viaPackage_Any(t *testing.T, e any) { - var a any = assertP.ThatAny(assertion.NewSoft(t), "some val") - casted, ok := a.(*asserter.Any) - if !ok { - t.Fatalf("unable to cast") - } - if casted == nil { - t.Fatalf("casted is nil") - } -} - -func viaVariable_Any(t *testing.T, e any) { - assert := assertP.NewAssert(assertion.NewSoft(t)) - var a any = assert.ThatAny("some val") - casted, ok := a.(*asserter.Any) - if !ok { - t.Fatalf("unable to cast") - } - if casted == nil { - t.Fatalf("casted is nil") - } -} diff --git a/src/test/assert/assert_test.go b/src/test/assert/assert_test.go deleted file mode 100644 index 45de4bc..0000000 --- a/src/test/assert/assert_test.go +++ /dev/null @@ -1,19 +0,0 @@ -package assert - -import ( - assertP "github.com/sku0x20/assertG/src/pkg/assert" - "github.com/sku0x20/assertG/src/pkg/assertion" - "testing" -) - -func Test_Assert(t *testing.T) { - var assert any - assert = assertP.NewAssert(assertion.NewSoft(t)) - casted, ok := assert.(*assertP.Assert) - if !ok { - t.Fatalf("err") - } - if casted == nil { - t.Fatalf("casted is nil") - } -} diff --git a/src/test/assert/bool_test.go b/src/test/assert/bool_test.go index 7dc9a96..2422402 100644 --- a/src/test/assert/bool_test.go +++ b/src/test/assert/bool_test.go @@ -1,22 +1,22 @@ package assert import ( - assertP "github.com/sku0x20/assertG/src/pkg/assert" - "github.com/sku0x20/assertG/src/pkg/asserter" - "github.com/sku0x20/assertG/src/pkg/assertion" + "github.com/sku0x20/assertG/src/main/assert" + "github.com/sku0x20/assertG/src/main/assert_type" + "github.com/sku0x20/assertG/src/main/asserter" "github.com/sku0x20/gRunner/src/pkg/runner" "testing" ) func Test_Bool(t *testing.T) { r := runner.NewTestsRunnerEmptyInit[any](t) - r.Add(viaPackage_Bool) - r.Add(viaVariable_Bool) + r.Add(thatBool) + r.Add(thatBoolWith) r.Run() } -func viaPackage_Bool(t *testing.T, e any) { - var a any = assertP.ThatBool(assertion.NewSoft(t), true) +func thatBool(t *testing.T, _ any) { + var a any = assert.ThatBool(true) casted, ok := a.(*asserter.Bool) if !ok { t.Fatalf("unable to cast") @@ -26,9 +26,8 @@ func viaPackage_Bool(t *testing.T, e any) { } } -func viaVariable_Bool(t *testing.T, e any) { - assert := assertP.NewAssert(assertion.NewSoft(t)) - var a any = assert.ThatBool(false) +func thatBoolWith(t *testing.T, _ any) { + var a any = assert.ThatBoolWith(assert_type.NewSoftAssert(t), false) casted, ok := a.(*asserter.Bool) if !ok { t.Fatalf("unable to cast") diff --git a/src/test/assert/generic_test.go b/src/test/assert/generic_test.go new file mode 100644 index 0000000..97601a7 --- /dev/null +++ b/src/test/assert/generic_test.go @@ -0,0 +1,43 @@ +package assert + +import ( + "github.com/sku0x20/assertG/src/main/assert" + "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/gRunner/src/pkg/runner" + "testing" +) + +func Test_Generic(t *testing.T) { + r := runner.NewTestsRunnerEmptyInit[any](t) + r.Add(that) + r.Add(thatWith) + r.Run() +} + +func that(t *testing.T, _ any) { + var a any = assert.That("some val") + casted, ok := a.(*asserter.Generic[string]) + if !ok { + t.Fatalf("unable to cast") + } + if casted == nil { + t.Fatalf("casted is nil") + } +} + +func thatWith(t *testing.T, _ any) { + var a any = assert.ThatWith( + assert_type.NewSoftAssert(t), + equator.NewComparableEquator[string](), + "some val", + ) + casted, ok := a.(*asserter.Generic[string]) + if !ok { + t.Fatalf("unable to cast") + } + if casted == nil { + t.Fatalf("casted is nil") + } +} diff --git a/src/test/assert/slice_test.go b/src/test/assert/slice_test.go new file mode 100644 index 0000000..aa2aaa5 --- /dev/null +++ b/src/test/assert/slice_test.go @@ -0,0 +1,43 @@ +package assert + +import ( + "github.com/sku0x20/assertG/src/main/assert" + "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/gRunner/src/pkg/runner" + "testing" +) + +func Test_Slice(t *testing.T) { + r := runner.NewTestsRunnerEmptyInit[any](t) + r.Add(thatSlice) + r.Add(thatSliceWith) + r.Run() +} + +func thatSlice(t *testing.T, _ any) { + var a any = assert.ThatSlice([]string{"some val"}) + casted, ok := a.(*asserter.Slice[string]) + if !ok { + t.Fatalf("unable to cast") + } + if casted == nil { + t.Fatalf("casted is nil") + } +} + +func thatSliceWith(t *testing.T, _ any) { + var a any = assert.ThatSliceWith( + assert_type.NewSoftAssert(t), + equator.NewComparableEquator[string](), + []string{"some val"}, + ) + casted, ok := a.(*asserter.Slice[string]) + if !ok { + t.Fatalf("unable to cast") + } + if casted == nil { + t.Fatalf("casted is nil") + } +} diff --git a/src/test/assert/string_test.go b/src/test/assert/string_test.go index 05c2c64..dbd31dc 100644 --- a/src/test/assert/string_test.go +++ b/src/test/assert/string_test.go @@ -1,22 +1,22 @@ package assert import ( - assertP "github.com/sku0x20/assertG/src/pkg/assert" - "github.com/sku0x20/assertG/src/pkg/asserter" - "github.com/sku0x20/assertG/src/pkg/assertion" + "github.com/sku0x20/assertG/src/main/assert" + "github.com/sku0x20/assertG/src/main/assert_type" + "github.com/sku0x20/assertG/src/main/asserter" "github.com/sku0x20/gRunner/src/pkg/runner" "testing" ) func Test_String(t *testing.T) { r := runner.NewTestsRunnerEmptyInit[any](t) - r.Add(viaPackage_String) - r.Add(viaVariable_String) + r.Add(thatString) + r.Add(thatStringWith) r.Run() } -func viaPackage_String(t *testing.T, e any) { - var a any = assertP.ThatString(assertion.NewSoft(t), "some val") +func thatString(t *testing.T, _ any) { + var a any = assert.ThatString("some val") casted, ok := a.(*asserter.String) if !ok { t.Fatalf("unable to cast") @@ -26,9 +26,8 @@ func viaPackage_String(t *testing.T, e any) { } } -func viaVariable_String(t *testing.T, e any) { - assert := assertP.NewAssert(assertion.NewSoft(t)) - var a any = assert.ThatString("some val") +func thatStringWith(t *testing.T, _ any) { + var a any = assert.ThatStringWith(assert_type.NewSoftAssert(t), "some val") casted, ok := a.(*asserter.String) if !ok { t.Fatalf("unable to cast") diff --git a/src/test/assertion/Soft_test.go b/src/test/assert_type/SoftAssert_test.go similarity index 55% rename from src/test/assertion/Soft_test.go rename to src/test/assert_type/SoftAssert_test.go index 21145e7..9940724 100644 --- a/src/test/assertion/Soft_test.go +++ b/src/test/assert_type/SoftAssert_test.go @@ -1,14 +1,14 @@ -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" "testing" ) func Test_Soft(t *testing.T) { - s := assertion.NewSoft(t) + s := assert_type.NewSoftAssert(t) if s.Failed() { t.Fatalf("should not be in failed state") } diff --git a/src/test/asserter/Any_test.go b/src/test/asserter/Any_test.go deleted file mode 100644 index 652ca0d..0000000 --- a/src/test/asserter/Any_test.go +++ /dev/null @@ -1,86 +0,0 @@ -package asserter - -import ( - "github.com/sku0x20/assertG/src/pkg/asserter" - "github.com/sku0x20/assertG/src/pkg/assertion" - "github.com/sku0x20/assertG/src/test/api" - "github.com/sku0x20/gRunner/src/pkg/runner" - "testing" -) - -func init_Any(t *testing.T) *assertion.Soft { - return assertion.NewSoft(t) -} - -func Test_Any(t *testing.T) { - r := runner.NewTestsRunner[*assertion.Soft](t, init_Any) - r.Add(equalFail_Any) - r.Add(equalPass_Any) - r.Add(implementsEqual_Any) - r.Add(nilPass_Any) - r.Add(nilFail_Any) - r.Add(notNilPass_Any) - r.Add(notNilFail_Any) - r.Run() -} - -func equalFail_Any(t *testing.T, s *assertion.Soft) { - a := asserter.NewAny(s, 30) - a = a.IsEqualTo("something") - if !s.Failed() { - t.Fatalf("should have failed") - } -} - -func equalPass_Any(t *testing.T, s *assertion.Soft) { - type st struct { - s *string - } - s1 := "something" - s2 := "something" - a := asserter.NewAny(s, &st{&s1}) - a = a.IsEqualTo(&st{&s2}) - if s.Failed() { - t.Fatalf("should not have failed") - } -} - -func implementsEqual_Any(t *testing.T, s *assertion.Soft) { - a := asserter.NewAny(s, api.NewFakeEqual(false)) - a = a.IsEqualTo(api.NewFakeEqual(false)) - if !s.Failed() { - t.Fatalf("should have failed") - } -} - -func nilPass_Any(t *testing.T, s *assertion.Soft) { - a := asserter.NewAny(s, nil) - a = a.IsNil() - if s.Failed() { - t.Fatalf("should not have failed") - } -} - -func nilFail_Any(t *testing.T, s *assertion.Soft) { - a := asserter.NewAny(s, 10) - a = a.IsNil() - if !s.Failed() { - t.Fatalf("should have failed") - } -} - -func notNilPass_Any(t *testing.T, s *assertion.Soft) { - a := asserter.NewAny(s, 10) - a = a.IsNotNil() - if s.Failed() { - t.Fatalf("should not have failed") - } -} - -func notNilFail_Any(t *testing.T, s *assertion.Soft) { - a := asserter.NewAny(s, nil) - a = a.IsNotNil() - if !s.Failed() { - t.Fatalf("should have failed") - } -} diff --git a/src/test/asserter/Bool_test.go b/src/test/asserter/Bool_test.go deleted file mode 100644 index 2264e6d..0000000 --- a/src/test/asserter/Bool_test.go +++ /dev/null @@ -1,53 +0,0 @@ -package asserter - -import ( - "github.com/sku0x20/assertG/src/pkg/asserter" - "github.com/sku0x20/assertG/src/pkg/assertion" - "github.com/sku0x20/gRunner/src/pkg/runner" - "testing" -) - -func init_Bool(t *testing.T) *assertion.Soft { - return assertion.NewSoft(t) -} - -func Test_Bool(t *testing.T) { - r := runner.NewTestsRunner(t, init_Bool) - r.Add(truePass_Bool) - r.Add(trueFail_Bool) - r.Add(falsePass_Bool) - r.Add(falseFail_Bool) - r.Run() -} - -func truePass_Bool(t *testing.T, s *assertion.Soft) { - a := asserter.NewBool(s, 1 == 1) - a = a.IsTrue() - if s.Failed() { - t.Fatalf("should not have failed") - } -} - -func trueFail_Bool(t *testing.T, s *assertion.Soft) { - a := asserter.NewBool(s, 2 == 1) - a = a.IsTrue() - if !s.Failed() { - t.Fatalf("should have failed") - } -} - -func falsePass_Bool(t *testing.T, s *assertion.Soft) { - a := asserter.NewBool(s, 2 == 1) - a = a.IsFalse() - if s.Failed() { - t.Fatalf("should not have failed") - } -} - -func falseFail_Bool(t *testing.T, s *assertion.Soft) { - a := asserter.NewBool(s, 1 == 1) - a = a.IsFalse() - if !s.Failed() { - t.Fatalf("should have failed") - } -} diff --git a/src/test/asserter/bool/Bool_test.go b/src/test/asserter/bool/Bool_test.go new file mode 100644 index 0000000..c75e0c1 --- /dev/null +++ b/src/test/asserter/bool/Bool_test.go @@ -0,0 +1,57 @@ +package bool + +import ( + "github.com/sku0x20/assertG/src/main/assert_type" + "github.com/sku0x20/assertG/src/main/asserter" + "github.com/sku0x20/gRunner/src/pkg/runner" + "testing" +) + +func init_B(t *testing.T) *assert_type.SoftAssert { + return assert_type.NewSoftAssert(t) +} + +func Test_Bool(t *testing.T) { + r := runner.NewTestsRunner(t, init_B) + r.Add(truePass) + r.Add(trueFail) + r.Add(falsePass) + r.Add(falseFail) + r.Run() +} + +//goland:noinspection GoBoolExpressions +func truePass(t *testing.T, s *assert_type.SoftAssert) { + a := asserter.NewBool(s, 1 == 1) + a = a.IsTrue() + if s.Failed() { + t.Fatalf("should not have failed") + } +} + +//goland:noinspection GoBoolExpressions +func trueFail(t *testing.T, s *assert_type.SoftAssert) { + a := asserter.NewBool(s, 2 == 1) + a = a.IsTrue() + if !s.Failed() { + t.Fatalf("should have failed") + } +} + +//goland:noinspection GoBoolExpressions +func falsePass(t *testing.T, s *assert_type.SoftAssert) { + a := asserter.NewBool(s, 2 == 1) + a = a.IsFalse() + if s.Failed() { + t.Fatalf("should not have failed") + } +} + +//goland:noinspection GoBoolExpressions +func falseFail(t *testing.T, s *assert_type.SoftAssert) { + a := asserter.NewBool(s, 1 == 1) + a = a.IsFalse() + if !s.Failed() { + t.Fatalf("should have failed") + } +} diff --git a/src/test/asserter/generic/Generic_test.go b/src/test/asserter/generic/Generic_test.go new file mode 100644 index 0000000..ccc0b31 --- /dev/null +++ b/src/test/asserter/generic/Generic_test.go @@ -0,0 +1,93 @@ +package generic + +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/gRunner/src/pkg/runner" + "testing" +) + +func init_G(t *testing.T) *assert_type.SoftAssert { + return assert_type.NewSoftAssert(t) +} + +func Test_Generic(t *testing.T) { + r := runner.NewTestsRunner[*assert_type.SoftAssert](t, init_G) + r.Add(equalFail) + r.Add(equalPass) + r.Add(customEquator) + r.Add(nilPass) + r.Add(nilFail) + r.Add(notNilPass) + r.Add(notNilFail) + r.Run() +} + +func equalFail(t *testing.T, s *assert_type.SoftAssert) { + a := asserter.NewGeneric(s, equator.NewReflectDeepEquator[int](), 30) + a = a.IsEqualTo("something") + if !s.Failed() { + t.Fatalf("should have failed") + } +} + +func equalPass(t *testing.T, s *assert_type.SoftAssert) { + type st struct { + s *string + } + s1 := "something" + s2 := "something" + a := asserter.NewGeneric(s, equator.NewReflectDeepEquator[*st](), &st{&s1}) + a = a.IsEqualTo(&st{&s2}) + if s.Failed() { + t.Fatalf("should not have failed") + } +} + +type FakeEquator struct { +} + +func (f *FakeEquator) AreEqual(a int, b any) bool { + return true +} + +func customEquator(t *testing.T, s *assert_type.SoftAssert) { + a := asserter.NewGeneric(s, &FakeEquator{}, 10) + a = a.IsEqualTo(20) + if s.Failed() { + t.Fatalf("should have passed") + } +} + +func nilPass(t *testing.T, s *assert_type.SoftAssert) { + a := asserter.NewGeneric(s, equator.NewReflectDeepEquator[any](), nil) + a = a.IsNil() + if s.Failed() { + t.Fatalf("should not have failed") + } +} + +func nilFail(t *testing.T, s *assert_type.SoftAssert) { + a := asserter.NewGeneric(s, equator.NewReflectDeepEquator[int](), 10) + a = a.IsNil() + if !s.Failed() { + t.Fatalf("should have failed") + } +} + +func notNilPass(t *testing.T, s *assert_type.SoftAssert) { + a := asserter.NewGeneric(s, equator.NewReflectDeepEquator[int](), 10) + a = a.IsNotNil() + if s.Failed() { + t.Fatalf("should not have failed") + } +} + +func notNilFail(t *testing.T, s *assert_type.SoftAssert) { + a := asserter.NewGeneric(s, equator.NewReflectDeepEquator[any](), nil) + a = a.IsNotNil() + if !s.Failed() { + t.Fatalf("should have failed") + } +} diff --git a/src/test/asserter/slice/Slice_test.go b/src/test/asserter/slice/Slice_test.go new file mode 100644 index 0000000..f8fc5d9 --- /dev/null +++ b/src/test/asserter/slice/Slice_test.go @@ -0,0 +1,127 @@ +package slice + +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/gRunner/src/pkg/runner" + "testing" +) + +func Test_Slice(t *testing.T) { + r := runner.NewTestsRunnerEmptyInit[any](t) + r.Add(hasLength) + r.Add(isEqualTo) + r.Add(isEqualToIgnoringOrder) + r.Add(contains) + r.Add(notContains) + r.Run() +} + +func hasLength(t *testing.T, _ any) { + intS := []int{10} + sa := assert_type.NewSoftAssert(t) + a := asserter.NewSlice(sa, equator.NewComparableEquator[int](), intS) + a = a.HasLength(1) + if sa.Failed() { + t.Fatalf("should not have failed") + } + sa = assert_type.NewSoftAssert(t) + a = asserter.NewSlice(sa, equator.NewComparableEquator[int](), intS) + a = a.HasLength(2) + if !sa.Failed() { + t.Fatalf("should have failed") + } +} + +func contains(t *testing.T, _ any) { + intS := []int{10, 20, 30} + sa := assert_type.NewSoftAssert(t) + a := asserter.NewSlice(sa, equator.NewComparableEquator[int](), intS) + a = a.Contains(10) + if sa.Failed() { + t.Fatalf("should not have failed") + } + sa = assert_type.NewSoftAssert(t) + a = asserter.NewSlice(sa, equator.NewComparableEquator[int](), intS) + a = a.Contains(50) + if !sa.Failed() { + t.Fatalf("should have failed") + } +} + +func notContains(t *testing.T, _ any) { + intS := []int{10, 20, 30} + sa := assert_type.NewSoftAssert(t) + a := asserter.NewSlice(sa, equator.NewComparableEquator[int](), intS) + a = a.NotContains(50) + if sa.Failed() { + t.Fatalf("should not have failed") + } + sa = assert_type.NewSoftAssert(t) + a = asserter.NewSlice(sa, equator.NewComparableEquator[int](), intS) + a = a.NotContains(20) + if !sa.Failed() { + t.Fatalf("should have failed") + } +} + +type test struct { + actual []int + expected []int + shouldFail bool +} + +func isEqualTo(t *testing.T, _ any) { + tests := []test{ + {[]int{10, 20, 30}, []int{10}, true}, + {[]int{10, 20, 30}, []int{10, 20, 30, 40}, true}, + {[]int{10, 20, 30}, []int{30, 10, 20}, true}, + {[]int{10, 20, 30}, []int{10, 20, 30}, false}, + } + runTests(t, tests, func(a *asserter.Slice[int], expected []int) *asserter.Slice[int] { + defer func() { + if r := recover(); r != nil { + // panic is valid in the 1st and 2nd case + t.Logf("recovered from panic: %v", r) + } + }() + return a.IsEqualTo(expected) + }) +} + +func isEqualToIgnoringOrder(t *testing.T, _ any) { + tests := []test{ + {[]int{10, 20, 30}, []int{10}, true}, + {[]int{10, 20, 30}, []int{10, 20, 30, 40}, true}, + {[]int{10, 20, 30}, []int{0, 20, 30}, true}, + {[]int{10, 20, 30}, []int{30, 10, 20}, false}, + {[]int{10, 20, 30}, []int{10, 20, 30}, false}, + } + runTests(t, tests, func(a *asserter.Slice[int], expected []int) *asserter.Slice[int] { + defer func() { + if r := recover(); r != nil { + // panic is valid in the 1st and 2nd case + t.Logf("recovered from panic: %v", r) + } + }() + return a.IsEqualToIgnoringOrder(expected) + }) +} + +func runTests( + t *testing.T, + tests []test, + fnAssertion func(a *asserter.Slice[int], elem []int) *asserter.Slice[int], +) { + for _, ct := range tests { + t.Run("", func(t *testing.T) { + sa := assert_type.NewSoftAssert(t) + a := asserter.NewSlice(sa, equator.NewComparableEquator[int](), ct.actual) + a = fnAssertion(a, ct.expected) + if sa.Failed() != ct.shouldFail { + t.Fatalf("should have failed = %t", ct.shouldFail) + } + }) + } +} diff --git a/src/test/asserter/String_test.go b/src/test/asserter/string/String_test.go similarity index 54% rename from src/test/asserter/String_test.go rename to src/test/asserter/string/String_test.go index 34f958d..9d70cee 100644 --- a/src/test/asserter/String_test.go +++ b/src/test/asserter/string/String_test.go @@ -1,30 +1,30 @@ -package asserter +package string import ( - "github.com/sku0x20/assertG/src/pkg/asserter" - "github.com/sku0x20/assertG/src/pkg/assertion" + "github.com/sku0x20/assertG/src/main/assert_type" + "github.com/sku0x20/assertG/src/main/asserter" "github.com/sku0x20/gRunner/src/pkg/runner" "testing" ) -func init_String(t *testing.T) *assertion.Soft { - return assertion.NewSoft(t) +func init_S(t *testing.T) *assert_type.SoftAssert { + return assert_type.NewSoftAssert(t) } func Test_String(t *testing.T) { - r := runner.NewTestsRunner(t, init_String) - r.Add(equalPass_String) - r.Add(equalFail_String) - r.Add(containsPass_String) - r.Add(containsFail_String) - r.Add(notContainsPass_String) - r.Add(notContainsFail_String) - r.Add(hasLengthPass_String) - r.Add(hasLengthFail_String) + r := runner.NewTestsRunner(t, init_S) + r.Add(equalPass) + r.Add(equalFail) + r.Add(containsPass) + r.Add(containsFail) + r.Add(notContainsPass) + r.Add(notContainsFail) + r.Add(hasLengthPass) + r.Add(hasLengthFail) r.Run() } -func equalPass_String(t *testing.T, s *assertion.Soft) { +func equalPass(t *testing.T, s *assert_type.SoftAssert) { a := asserter.NewString(s, "some val") a = a.IsEqualTo("some val") if s.Failed() { @@ -32,7 +32,7 @@ func equalPass_String(t *testing.T, s *assertion.Soft) { } } -func equalFail_String(t *testing.T, s *assertion.Soft) { +func equalFail(t *testing.T, s *assert_type.SoftAssert) { a := asserter.NewString(s, "some val") a = a.IsEqualTo("other val") if !s.Failed() { @@ -40,7 +40,7 @@ func equalFail_String(t *testing.T, s *assertion.Soft) { } } -func containsPass_String(t *testing.T, s *assertion.Soft) { +func containsPass(t *testing.T, s *assert_type.SoftAssert) { a := asserter.NewString(s, "some val") a = a.Contains("val") if s.Failed() { @@ -48,7 +48,7 @@ func containsPass_String(t *testing.T, s *assertion.Soft) { } } -func containsFail_String(t *testing.T, s *assertion.Soft) { +func containsFail(t *testing.T, s *assert_type.SoftAssert) { a := asserter.NewString(s, "some val") a = a.Contains("other") if !s.Failed() { @@ -56,7 +56,7 @@ func containsFail_String(t *testing.T, s *assertion.Soft) { } } -func notContainsPass_String(t *testing.T, s *assertion.Soft) { +func notContainsPass(t *testing.T, s *assert_type.SoftAssert) { a := asserter.NewString(s, "some val") a = a.NotContains("other") if s.Failed() { @@ -64,7 +64,7 @@ func notContainsPass_String(t *testing.T, s *assertion.Soft) { } } -func notContainsFail_String(t *testing.T, s *assertion.Soft) { +func notContainsFail(t *testing.T, s *assert_type.SoftAssert) { a := asserter.NewString(s, "some val") a = a.NotContains("some") if !s.Failed() { @@ -72,7 +72,7 @@ func notContainsFail_String(t *testing.T, s *assertion.Soft) { } } -func hasLengthPass_String(t *testing.T, s *assertion.Soft) { +func hasLengthPass(t *testing.T, s *assert_type.SoftAssert) { a := asserter.NewString(s, "some val") a = a.HasLength(8) if s.Failed() { @@ -80,7 +80,7 @@ func hasLengthPass_String(t *testing.T, s *assertion.Soft) { } } -func hasLengthFail_String(t *testing.T, s *assertion.Soft) { +func hasLengthFail(t *testing.T, s *assert_type.SoftAssert) { a := asserter.NewString(s, "some val") a = a.HasLength(10) if !s.Failed() { diff --git a/src/test/e2e_test.go b/src/test/e2e_test.go index e77a3be..e70bcc6 100644 --- a/src/test/e2e_test.go +++ b/src/test/e2e_test.go @@ -1,31 +1,38 @@ package test import ( - assertP "github.com/sku0x20/assertG/src/pkg/assert" - "github.com/sku0x20/assertG/src/pkg/assertion" + "github.com/sku0x20/assertG/src/main/assert" + "github.com/sku0x20/assertG/src/main/assert_type" + "github.com/sku0x20/assertG/src/main/registry" "github.com/sku0x20/gRunner/src/pkg/runner" "testing" ) func Test_WithoutRunner(t *testing.T) { - assert := assertP.NewAssert(assertion.NewHard(t)) - assert.ThatAny(10). + registry.GlobalRegistrySetAssertType(assert_type.NewHardAssert(t)) + assert.That(10). IsNotNil(). IsEqualTo(10) } -func initE(t *testing.T) *assertP.Assert { - return assertP.NewAssert(assertion.NewHard(t)) +func initE(t *testing.T) any { + registry.GlobalRegistrySetAssertType(assert_type.NewSoftAssert(t)) + return nil } func Test_WithRunner(t *testing.T) { - r := runner.NewTestsRunner[*assertP.Assert](t, initE) - r.Add(makeAssert) + r := runner.NewTestsRunner[any](t, initE) + r.Add(makeAndValidateAssert) r.Run() } -func makeAssert(_ *testing.T, assert *assertP.Assert) { - assert.ThatAny(10). +func makeAndValidateAssert(t *testing.T, _ any) { + assert.That(10). IsNotNil(). - IsEqualTo(10) + IsEqualTo(20) + + sa := registry.GlobalRegistryGetAssertType().(*assert_type.SoftAssert) + if !sa.Failed() { + t.Fatalf("should have failed") + } } diff --git a/src/test/equator/ComparableEquator_test.go b/src/test/equator/ComparableEquator_test.go new file mode 100644 index 0000000..1f5b60e --- /dev/null +++ b/src/test/equator/ComparableEquator_test.go @@ -0,0 +1,25 @@ +package equator + +import ( + "github.com/sku0x20/assertG/src/main/equator" + "testing" +) + +func Test_ComparableEquator(t *testing.T) { + a := 10 + a2 := 10 + + b := struct { + a int + b string + c []string + }{10, "10", []string{"20"}} + + rde := equator.NewComparableEquator[int]() + if !rde.AreEqual(a, a2) { + t.Fatalf("should be equal") + } + if rde.AreEqual(a, b) { + t.Fatalf("should not be equal") + } +} diff --git a/src/test/equator/ReflectDeepEquator_test.go b/src/test/equator/ReflectDeepEquator_test.go new file mode 100644 index 0000000..9a24425 --- /dev/null +++ b/src/test/equator/ReflectDeepEquator_test.go @@ -0,0 +1,42 @@ +package equator + +import ( + "github.com/sku0x20/assertG/src/main/equator" + "testing" +) + +func Test_ReflectDeepEquator(t *testing.T) { + type sa struct { + a int + b string + c []string + } + a := sa{10, "10", []string{"10"}} + a2 := sa{10, "10", []string{"10"}} + + b := struct { + a int + b string + c []string + }{10, "10", []string{"20"}} + + c := struct { + a int + b int + c []string + }{10, 10, []string{"10"}} + + rde := equator.NewReflectDeepEquator[sa]() + if !rde.AreEqual(a, a2) { + t.Fatalf("should be equal") + } + if rde.AreEqual(a, b) { + t.Fatalf("should not be equal") + } + if rde.AreEqual(a, c) { + t.Fatalf("should not be equal") + } + if rde.AreEqual(b, c) { + t.Fatalf("should not be equal") + } +} diff --git a/src/test/message/Message_test.go b/src/test/message/Message_test.go index 1d3ed41..bb12a45 100644 --- a/src/test/message/Message_test.go +++ b/src/test/message/Message_test.go @@ -1,7 +1,7 @@ package message import ( - "github.com/sku0x20/assertG/src/pkg/message" + "github.com/sku0x20/assertG/src/main/message" "github.com/sku0x20/gRunner/src/pkg/runner" "testing" ) diff --git a/src/test/message/defined_test.go b/src/test/message/defined_test.go index 996789d..2c8cf03 100644 --- a/src/test/message/defined_test.go +++ b/src/test/message/defined_test.go @@ -1,8 +1,8 @@ package message import ( - "github.com/sku0x20/assertG/src/pkg/message" - "github.com/sku0x20/assertG/src/pkg/message/verbs" + "github.com/sku0x20/assertG/src/main/message" + "github.com/sku0x20/assertG/src/main/message/verbs" "github.com/sku0x20/gRunner/src/pkg/runner" "testing" ) diff --git a/src/test/registry/GlobalRegistry_test.go b/src/test/registry/GlobalRegistry_test.go new file mode 100644 index 0000000..af76c92 --- /dev/null +++ b/src/test/registry/GlobalRegistry_test.go @@ -0,0 +1,22 @@ +package registry + +import ( + "github.com/sku0x20/assertG/src/main/assert_type" + "github.com/sku0x20/assertG/src/main/registry" + "github.com/sku0x20/gRunner/src/pkg/runner" + "testing" +) + +func Test_GlobalRegistry(t *testing.T) { + r := runner.NewTestsRunnerEmptyInit[any](t) + r.Add(setAssertType) + r.Run() +} + +func setAssertType(t *testing.T, _ any) { + sa := assert_type.NewSoftAssert(t) + registry.GlobalRegistrySetAssertType(sa) + if registry.GlobalRegistryGetAssertType() != sa { + t.Fatalf("different AssertType") + } +}