From 2550691e2e022f7693a932385fb8ac504fbb81cf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mike=20Schw=C3=B6rer?= Date: Fri, 31 Mar 2023 13:33:06 +0200 Subject: [PATCH] v0.0.99 --- confext/confParser_test.go | 93 +++++++++++++++++++------------------ cryptext/aes_test.go | 5 +- cryptext/hash_test.go | 29 ++++-------- dataext/merge_test.go | 9 ++-- dataext/structHash_test.go | 41 +++++++--------- langext/base58_test.go | 34 +++++++------- rext/wrapper.go | 2 +- rext/wrapper_test.go | 47 +++++++++++++++++++ rfctime/interface_test.go | 22 ++++----- rfctime/rfc3339Nano_test.go | 9 +--- termext/termcolor_test.go | 34 +++++++------- timeext/parser_test.go | 84 ++++++++++++++++----------------- tst/assertions.go | 65 ++++++++++++++++++++++++++ tst/identAssertions.go | 48 +++++++++++++++++++ 14 files changed, 331 insertions(+), 191 deletions(-) create mode 100644 rext/wrapper_test.go create mode 100644 tst/assertions.go create mode 100644 tst/identAssertions.go diff --git a/confext/confParser_test.go b/confext/confParser_test.go index 967c6ad..c2fdbd8 100644 --- a/confext/confParser_test.go +++ b/confext/confParser_test.go @@ -2,6 +2,7 @@ package confext import ( "gogs.mikescher.com/BlackForestBytes/goext/timeext" + "gogs.mikescher.com/BlackForestBytes/goext/tst" "testing" "time" ) @@ -41,13 +42,13 @@ func TestApplyEnvOverridesNoop(t *testing.T) { output := input - err := ApplyEnvOverrides(&output, ".") + err := ApplyEnvOverrides("", &output, ".") if err != nil { t.Errorf("%v", err) t.FailNow() } - assertEqual(t, input, output) + tst.AssertEqual(t, input, output) } func TestApplyEnvOverridesSimple(t *testing.T) { @@ -93,21 +94,21 @@ func TestApplyEnvOverridesSimple(t *testing.T) { t.Setenv("TEST_V8", "1min4s") t.Setenv("TEST_V9", "2009-11-10T23:00:00Z") - err := ApplyEnvOverrides(&data, ".") + err := ApplyEnvOverrides("", &data, ".") if err != nil { t.Errorf("%v", err) t.FailNow() } - assertEqual(t, data.V1, 846) - assertEqual(t, data.V2, "hello_world") - assertEqual(t, data.V3, 6) - assertEqual(t, data.V4, 333) - assertEqual(t, data.V5, -937) - assertEqual(t, data.V6, 70) - assertEqual(t, data.V7, "AAAAAA") - assertEqual(t, data.V8, time.Second*64) - assertEqual(t, data.V9, time.Unix(1257894000, 0).UTC()) + tst.AssertEqual(t, data.V1, 846) + tst.AssertEqual(t, data.V2, "hello_world") + tst.AssertEqual(t, data.V3, 6) + tst.AssertEqual(t, data.V4, 333) + tst.AssertEqual(t, data.V5, -937) + tst.AssertEqual(t, data.V6, 70) + tst.AssertEqual(t, data.V7, "AAAAAA") + tst.AssertEqual(t, data.V8, time.Second*64) + tst.AssertEqual(t, data.V9, time.Unix(1257894000, 0).UTC()) } func TestApplyEnvOverridesRecursive(t *testing.T) { @@ -182,35 +183,35 @@ func TestApplyEnvOverridesRecursive(t *testing.T) { t.Setenv("SUB_V3", "33min") t.Setenv("SUB_V4", "2044-01-01T00:00:00Z") - err := ApplyEnvOverrides(&data, "_") + err := ApplyEnvOverrides("", &data, "_") if err != nil { t.Errorf("%v", err) t.FailNow() } - assertEqual(t, data.V1, 999) - assertEqual(t, data.VX, "2") - assertEqual(t, data.V5, "no") - assertEqual(t, data.Sub1.V1, 3) - assertEqual(t, data.Sub1.VX, "4") - assertEqual(t, data.Sub1.V2, "5") - assertEqual(t, data.Sub1.V8, time.Second*6) - assertEqual(t, data.Sub1.V9, time.Unix(947206861, 0).UTC()) - assertEqual(t, data.Sub2.V1, 846) - assertEqual(t, data.Sub2.VX, "9") - assertEqual(t, data.Sub2.V2, "222_hello_world") - assertEqual(t, data.Sub2.V8, time.Second*64) - assertEqual(t, data.Sub2.V9, time.Unix(1257894000, 0).UTC()) - assertEqual(t, data.Sub3.V1, 33846) - assertEqual(t, data.Sub3.VX, "14") - assertEqual(t, data.Sub3.V2, "33_hello_world") - assertEqual(t, data.Sub3.V8, time.Second*1984) - assertEqual(t, data.Sub3.V9, time.Unix(2015276400, 0).UTC()) - assertEqual(t, data.Sub4.V1, 11) - assertEqual(t, data.Sub4.VX, "19") - assertEqual(t, data.Sub4.V2, "22") - assertEqual(t, data.Sub4.V8, time.Second*1980) - assertEqual(t, data.Sub4.V9, time.Unix(2335219200, 0).UTC()) + tst.AssertEqual(t, data.V1, 999) + tst.AssertEqual(t, data.VX, "2") + tst.AssertEqual(t, data.V5, "no") + tst.AssertEqual(t, data.Sub1.V1, 3) + tst.AssertEqual(t, data.Sub1.VX, "4") + tst.AssertEqual(t, data.Sub1.V2, "5") + tst.AssertEqual(t, data.Sub1.V8, time.Second*6) + tst.AssertEqual(t, data.Sub1.V9, time.Unix(947206861, 0).UTC()) + tst.AssertEqual(t, data.Sub2.V1, 846) + tst.AssertEqual(t, data.Sub2.VX, "9") + tst.AssertEqual(t, data.Sub2.V2, "222_hello_world") + tst.AssertEqual(t, data.Sub2.V8, time.Second*64) + tst.AssertEqual(t, data.Sub2.V9, time.Unix(1257894000, 0).UTC()) + tst.AssertEqual(t, data.Sub3.V1, 33846) + tst.AssertEqual(t, data.Sub3.VX, "14") + tst.AssertEqual(t, data.Sub3.V2, "33_hello_world") + tst.AssertEqual(t, data.Sub3.V8, time.Second*1984) + tst.AssertEqual(t, data.Sub3.V9, time.Unix(2015276400, 0).UTC()) + tst.AssertEqual(t, data.Sub4.V1, 11) + tst.AssertEqual(t, data.Sub4.VX, "19") + tst.AssertEqual(t, data.Sub4.V2, "22") + tst.AssertEqual(t, data.Sub4.V8, time.Second*1980) + tst.AssertEqual(t, data.Sub4.V9, time.Unix(2335219200, 0).UTC()) } func TestApplyEnvOverridesPointer(t *testing.T) { @@ -244,21 +245,21 @@ func TestApplyEnvOverridesPointer(t *testing.T) { t.Setenv("TEST_V8", "1min4s") t.Setenv("TEST_V9", "2009-11-10T23:00:00Z") - err := ApplyEnvOverrides(&data, ".") + err := ApplyEnvOverrides("", &data, ".") if err != nil { t.Errorf("%v", err) t.FailNow() } - assertPtrEqual(t, data.V1, 846) - assertPtrEqual(t, data.V2, "hello_world") - assertPtrEqual(t, data.V3, 6) - assertPtrEqual(t, data.V4, 333) - assertPtrEqual(t, data.V5, -937) - assertPtrEqual(t, data.V6, 70) - assertPtrEqual(t, data.V7, "AAAAAA") - assertPtrEqual(t, data.V8, time.Second*64) - assertPtrEqual(t, data.V9, time.Unix(1257894000, 0).UTC()) + tst.AssertDeRefEqual(t, data.V1, 846) + tst.AssertDeRefEqual(t, data.V2, "hello_world") + tst.AssertDeRefEqual(t, data.V3, 6) + tst.AssertDeRefEqual(t, data.V4, 333) + tst.AssertDeRefEqual(t, data.V5, -937) + tst.AssertDeRefEqual(t, data.V6, 70) + tst.AssertDeRefEqual(t, data.V7, "AAAAAA") + tst.AssertDeRefEqual(t, data.V8, time.Second*64) + tst.AssertDeRefEqual(t, data.V9, time.Unix(1257894000, 0).UTC()) } func assertEqual[T comparable](t *testing.T, actual T, expected T) { diff --git a/cryptext/aes_test.go b/cryptext/aes_test.go index 3954537..7bd2d90 100644 --- a/cryptext/aes_test.go +++ b/cryptext/aes_test.go @@ -2,6 +2,7 @@ package cryptext import ( "fmt" + "gogs.mikescher.com/BlackForestBytes/goext/tst" "testing" ) @@ -23,13 +24,13 @@ func TestEncryptAESSimple(t *testing.T) { panic(err) } - assertEqual(t, string(str1), string(str3)) + tst.AssertEqual(t, string(str1), string(str3)) str4, err := EncryptAESSimple(pw, str3, 512) if err != nil { panic(err) } - assertNotEqual(t, string(str2), string(str4)) + tst.AssertNotEqual(t, string(str2), string(str4)) } diff --git a/cryptext/hash_test.go b/cryptext/hash_test.go index 421b2ed..14bcd72 100644 --- a/cryptext/hash_test.go +++ b/cryptext/hash_test.go @@ -1,31 +1,20 @@ package cryptext import ( + "gogs.mikescher.com/BlackForestBytes/goext/tst" "testing" ) func TestStrSha256(t *testing.T) { - assertEqual(t, StrSha256(""), "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855") - assertEqual(t, StrSha256("0"), "5feceb66ffc86f38d952786c6d696c79c2dbc239dd4e91b46729d73a27fb57e9") - assertEqual(t, StrSha256("80085"), "b3786e141d65638ad8a98173e26b5f6a53c927737b23ff31fb1843937250f44b") - assertEqual(t, StrSha256("Hello World"), "a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146e") + tst.AssertEqual(t, StrSha256(""), "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855") + tst.AssertEqual(t, StrSha256("0"), "5feceb66ffc86f38d952786c6d696c79c2dbc239dd4e91b46729d73a27fb57e9") + tst.AssertEqual(t, StrSha256("80085"), "b3786e141d65638ad8a98173e26b5f6a53c927737b23ff31fb1843937250f44b") + tst.AssertEqual(t, StrSha256("Hello World"), "a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146e") } func TestBytesSha256(t *testing.T) { - assertEqual(t, BytesSha256([]byte{}), "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855") - assertEqual(t, BytesSha256([]byte{0}), "6e340b9cffb37a989ca544e6bb780a2c78901d3fb33738768511a30617afa01d") - assertEqual(t, BytesSha256([]byte{128}), "76be8b528d0075f7aae98d6fa57a6d3c83ae480a8469e668d7b0af968995ac71") - assertEqual(t, BytesSha256([]byte{0, 1, 2, 4, 8, 16, 32, 64, 128, 255}), "55016a318ba538e00123c736b2a8b6db368d00e7e25727547655b653e5853603") -} - -func assertEqual(t *testing.T, actual string, expected string) { - if actual != expected { - t.Errorf("values differ: Actual: '%v', Expected: '%v'", actual, expected) - } -} - -func assertNotEqual(t *testing.T, actual string, expected string) { - if actual == expected { - t.Errorf("values do not differ: Actual: '%v', Expected: '%v'", actual, expected) - } + tst.AssertEqual(t, BytesSha256([]byte{}), "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855") + tst.AssertEqual(t, BytesSha256([]byte{0}), "6e340b9cffb37a989ca544e6bb780a2c78901d3fb33738768511a30617afa01d") + tst.AssertEqual(t, BytesSha256([]byte{128}), "76be8b528d0075f7aae98d6fa57a6d3c83ae480a8469e668d7b0af968995ac71") + tst.AssertEqual(t, BytesSha256([]byte{0, 1, 2, 4, 8, 16, 32, 64, 128, 255}), "55016a318ba538e00123c736b2a8b6db368d00e7e25727547655b653e5853603") } diff --git a/dataext/merge_test.go b/dataext/merge_test.go index f5b1031..76a58c5 100644 --- a/dataext/merge_test.go +++ b/dataext/merge_test.go @@ -2,6 +2,7 @@ package dataext import ( "gogs.mikescher.com/BlackForestBytes/goext/langext" + "gogs.mikescher.com/BlackForestBytes/goext/tst" "testing" ) @@ -43,10 +44,10 @@ func TestObjectMerge(t *testing.T) { valueMerge := ObjectMerge(valueA, valueB) - assertPtrEqual(t, "Field1", valueMerge.Field1, valueB.Field1) - assertPtrEqual(t, "Field2", valueMerge.Field2, valueA.Field2) - assertPtrEqual(t, "Field3", valueMerge.Field3, valueB.Field3) - assertPtrEqual(t, "Field4", valueMerge.Field4, nil) + tst.AssertIdentPtrEqual(t, "Field1", valueMerge.Field1, valueB.Field1) + tst.AssertIdentPtrEqual(t, "Field2", valueMerge.Field2, valueA.Field2) + tst.AssertIdentPtrEqual(t, "Field3", valueMerge.Field3, valueB.Field3) + tst.AssertIdentPtrEqual(t, "Field4", valueMerge.Field4, nil) } diff --git a/dataext/structHash_test.go b/dataext/structHash_test.go index 7d0f489..17bf94e 100644 --- a/dataext/structHash_test.go +++ b/dataext/structHash_test.go @@ -1,8 +1,8 @@ package dataext import ( - "encoding/hex" "gogs.mikescher.com/BlackForestBytes/goext/langext" + "gogs.mikescher.com/BlackForestBytes/goext/tst" "testing" ) @@ -18,14 +18,14 @@ func noErrStructHash(t *testing.T, dat any, opt ...StructHashOptions) []byte { func TestStructHashSimple(t *testing.T) { - assertEqual(t, "209bf774af36cc3a045c152d9f1269ef3684ad819c1359ee73ff0283a308fefa", noErrStructHash(t, "Hello")) - assertEqual(t, "c32f3626b981ae2997db656f3acad3f1dc9d30ef6b6d14296c023e391b25f71a", noErrStructHash(t, 0)) - assertEqual(t, "01b781b03e9586b257d387057dfc70d9f06051e7d3c1e709a57e13cc8daf3e35", noErrStructHash(t, []byte{})) - assertEqual(t, "93e1dcd45c732fe0079b0fb3204c7c803f0921835f6bfee2e6ff263e73eed53c", noErrStructHash(t, []int{})) - assertEqual(t, "54f637a376aad55b3160d98ebbcae8099b70d91b9400df23fb3709855d59800a", noErrStructHash(t, []int{1, 2, 3})) - assertEqual(t, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", noErrStructHash(t, nil)) - assertEqual(t, "349a7db91aa78fd30bbaa7c7f9c7bfb2fcfe72869b4861162a96713a852f60d3", noErrStructHash(t, []any{1, "", nil})) - assertEqual(t, "ca51aab87808bf0062a4a024de6aac0c2bad54275cc857a4944569f89fd245ad", noErrStructHash(t, struct{}{})) + tst.AssertHexEqual(t, "209bf774af36cc3a045c152d9f1269ef3684ad819c1359ee73ff0283a308fefa", noErrStructHash(t, "Hello")) + tst.AssertHexEqual(t, "c32f3626b981ae2997db656f3acad3f1dc9d30ef6b6d14296c023e391b25f71a", noErrStructHash(t, 0)) + tst.AssertHexEqual(t, "01b781b03e9586b257d387057dfc70d9f06051e7d3c1e709a57e13cc8daf3e35", noErrStructHash(t, []byte{})) + tst.AssertHexEqual(t, "93e1dcd45c732fe0079b0fb3204c7c803f0921835f6bfee2e6ff263e73eed53c", noErrStructHash(t, []int{})) + tst.AssertHexEqual(t, "54f637a376aad55b3160d98ebbcae8099b70d91b9400df23fb3709855d59800a", noErrStructHash(t, []int{1, 2, 3})) + tst.AssertHexEqual(t, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", noErrStructHash(t, nil)) + tst.AssertHexEqual(t, "349a7db91aa78fd30bbaa7c7f9c7bfb2fcfe72869b4861162a96713a852f60d3", noErrStructHash(t, []any{1, "", nil})) + tst.AssertHexEqual(t, "ca51aab87808bf0062a4a024de6aac0c2bad54275cc857a4944569f89fd245ad", noErrStructHash(t, struct{}{})) } @@ -37,13 +37,13 @@ func TestStructHashSimpleStruct(t *testing.T) { F3 *int } - assertEqual(t, "a90bff751c70c738bb5cfc9b108e783fa9c19c0bc9273458e0aaee6e74aa1b92", noErrStructHash(t, t0{ + tst.AssertHexEqual(t, "a90bff751c70c738bb5cfc9b108e783fa9c19c0bc9273458e0aaee6e74aa1b92", noErrStructHash(t, t0{ F1: 10, F2: []string{"1", "2", "3"}, F3: nil, })) - assertEqual(t, "5d09090dc34ac59dd645f197a255f653387723de3afa1b614721ea5a081c675f", noErrStructHash(t, t0{ + tst.AssertHexEqual(t, "5d09090dc34ac59dd645f197a255f653387723de3afa1b614721ea5a081c675f", noErrStructHash(t, t0{ F1: 10, F2: []string{"1", "2", "3"}, F3: langext.Ptr(99), @@ -64,7 +64,7 @@ func TestStructHashLayeredStruct(t *testing.T) { SV3 t1_1 } - assertEqual(t, "fd4ca071fb40a288fee4b7a3dfdaab577b30cb8f80f81ec511e7afd72dc3b469", noErrStructHash(t, t1_2{ + tst.AssertHexEqual(t, "fd4ca071fb40a288fee4b7a3dfdaab577b30cb8f80f81ec511e7afd72dc3b469", noErrStructHash(t, t1_2{ SV1: nil, SV2: nil, SV3: t1_1{ @@ -73,7 +73,7 @@ func TestStructHashLayeredStruct(t *testing.T) { F15: false, }, })) - assertEqual(t, "3fbf7c67d8121deda075cc86319a4e32d71744feb2cebf89b43bc682f072a029", noErrStructHash(t, t1_2{ + tst.AssertHexEqual(t, "3fbf7c67d8121deda075cc86319a4e32d71744feb2cebf89b43bc682f072a029", noErrStructHash(t, t1_2{ SV1: nil, SV2: &t1_1{}, SV3: t1_1{ @@ -82,7 +82,7 @@ func TestStructHashLayeredStruct(t *testing.T) { F15: true, }, })) - assertEqual(t, "b1791ccd1b346c3ede5bbffda85555adcd8216b93ffca23f14fe175ec47c5104", noErrStructHash(t, t1_2{ + tst.AssertHexEqual(t, "b1791ccd1b346c3ede5bbffda85555adcd8216b93ffca23f14fe175ec47c5104", noErrStructHash(t, t1_2{ SV1: &t1_1{}, SV2: &t1_1{}, SV3: t1_1{ @@ -101,7 +101,7 @@ func TestStructHashMap(t *testing.T) { F2 map[string]int } - assertEqual(t, "d50c53ad1fafb448c33fddd5aca01a86a2edf669ce2ecab07ba6fe877951d824", noErrStructHash(t, t0{ + tst.AssertHexEqual(t, "d50c53ad1fafb448c33fddd5aca01a86a2edf669ce2ecab07ba6fe877951d824", noErrStructHash(t, t0{ F1: 10, F2: map[string]int{ "x": 1, @@ -110,7 +110,7 @@ func TestStructHashMap(t *testing.T) { }, })) - assertEqual(t, "d50c53ad1fafb448c33fddd5aca01a86a2edf669ce2ecab07ba6fe877951d824", noErrStructHash(t, t0{ + tst.AssertHexEqual(t, "d50c53ad1fafb448c33fddd5aca01a86a2edf669ce2ecab07ba6fe877951d824", noErrStructHash(t, t0{ F1: 10, F2: map[string]int{ "a": 99, @@ -128,16 +128,9 @@ func TestStructHashMap(t *testing.T) { m3["x"] = 1 m3["a"] = 2 - assertEqual(t, "d50c53ad1fafb448c33fddd5aca01a86a2edf669ce2ecab07ba6fe877951d824", noErrStructHash(t, t0{ + tst.AssertHexEqual(t, "d50c53ad1fafb448c33fddd5aca01a86a2edf669ce2ecab07ba6fe877951d824", noErrStructHash(t, t0{ F1: 10, F2: m3, })) } - -func assertEqual(t *testing.T, expected string, actual []byte) { - actualStr := hex.EncodeToString(actual) - if actualStr != expected { - t.Errorf("values differ: Actual: '%v', Expected: '%v'", actualStr, expected) - } -} diff --git a/langext/base58_test.go b/langext/base58_test.go index 2f5319b..11b1b86 100644 --- a/langext/base58_test.go +++ b/langext/base58_test.go @@ -21,46 +21,46 @@ func _decStr(t *testing.T, enc *B58Encoding, v string) string { } func TestBase58DefaultEncoding(t *testing.T) { - assertEqual(t, _encStr(t, Base58DefaultEncoding, "Hello"), "9Ajdvzr") - assertEqual(t, _encStr(t, Base58DefaultEncoding, "If debugging is the process of removing software bugs, then programming must be the process of putting them in."), "48638SMcJuah5okqPx4kCVf5d8QAdgbdNf28g7ReY13prUENNbMyssjq5GjsrJHF5zeZfqs4uJMUJHr7VbrU4XBUZ2Fw9DVtqtn9N1eXucEWSEZahXV6w4ysGSWqGdpeYTJf1MdDzTg8vfcQViifJjZX") + tst.AssertEqual(t, _encStr(t, Base58DefaultEncoding, "Hello"), "9Ajdvzr") + tst.AssertEqual(t, _encStr(t, Base58DefaultEncoding, "If debugging is the process of removing software bugs, then programming must be the process of putting them in."), "48638SMcJuah5okqPx4kCVf5d8QAdgbdNf28g7ReY13prUENNbMyssjq5GjsrJHF5zeZfqs4uJMUJHr7VbrU4XBUZ2Fw9DVtqtn9N1eXucEWSEZahXV6w4ysGSWqGdpeYTJf1MdDzTg8vfcQViifJjZX") } func TestBase58DefaultDecoding(t *testing.T) { - assertEqual(t, _decStr(t, Base58DefaultEncoding, "9Ajdvzr"), "Hello") - assertEqual(t, _decStr(t, Base58DefaultEncoding, "48638SMcJuah5okqPx4kCVf5d8QAdgbdNf28g7ReY13prUENNbMyssjq5GjsrJHF5zeZfqs4uJMUJHr7VbrU4XBUZ2Fw9DVtqtn9N1eXucEWSEZahXV6w4ysGSWqGdpeYTJf1MdDzTg8vfcQViifJjZX"), "If debugging is the process of removing software bugs, then programming must be the process of putting them in.") + tst.AssertEqual(t, _decStr(t, Base58DefaultEncoding, "9Ajdvzr"), "Hello") + tst.AssertEqual(t, _decStr(t, Base58DefaultEncoding, "48638SMcJuah5okqPx4kCVf5d8QAdgbdNf28g7ReY13prUENNbMyssjq5GjsrJHF5zeZfqs4uJMUJHr7VbrU4XBUZ2Fw9DVtqtn9N1eXucEWSEZahXV6w4ysGSWqGdpeYTJf1MdDzTg8vfcQViifJjZX"), "If debugging is the process of removing software bugs, then programming must be the process of putting them in.") } func TestBase58RippleEncoding(t *testing.T) { - assertEqual(t, _encStr(t, Base58RippleEncoding, "Hello"), "9wjdvzi") - assertEqual(t, _encStr(t, Base58RippleEncoding, "If debugging is the process of removing software bugs, then programming must be the process of putting them in."), "h3as3SMcJu26nokqPxhkUVCnd3Qwdgbd4Cp3gfReYrsFi7N44bMy11jqnGj1iJHEnzeZCq1huJM7JHifVbi7hXB7ZpEA9DVtqt894reXucNWSNZ26XVaAhy1GSWqGdFeYTJCrMdDzTg3vCcQV55CJjZX") + tst.AssertEqual(t, _encStr(t, Base58RippleEncoding, "Hello"), "9wjdvzi") + tst.AssertEqual(t, _encStr(t, Base58RippleEncoding, "If debugging is the process of removing software bugs, then programming must be the process of putting them in."), "h3as3SMcJu26nokqPxhkUVCnd3Qwdgbd4Cp3gfReYrsFi7N44bMy11jqnGj1iJHEnzeZCq1huJM7JHifVbi7hXB7ZpEA9DVtqt894reXucNWSNZ26XVaAhy1GSWqGdFeYTJCrMdDzTg3vCcQV55CJjZX") } func TestBase58RippleDecoding(t *testing.T) { - assertEqual(t, _decStr(t, Base58RippleEncoding, "9wjdvzi"), "Hello") - assertEqual(t, _decStr(t, Base58RippleEncoding, "h3as3SMcJu26nokqPxhkUVCnd3Qwdgbd4Cp3gfReYrsFi7N44bMy11jqnGj1iJHEnzeZCq1huJM7JHifVbi7hXB7ZpEA9DVtqt894reXucNWSNZ26XVaAhy1GSWqGdFeYTJCrMdDzTg3vCcQV55CJjZX"), "If debugging is the process of removing software bugs, then programming must be the process of putting them in.") + tst.AssertEqual(t, _decStr(t, Base58RippleEncoding, "9wjdvzi"), "Hello") + tst.AssertEqual(t, _decStr(t, Base58RippleEncoding, "h3as3SMcJu26nokqPxhkUVCnd3Qwdgbd4Cp3gfReYrsFi7N44bMy11jqnGj1iJHEnzeZCq1huJM7JHifVbi7hXB7ZpEA9DVtqt894reXucNWSNZ26XVaAhy1GSWqGdFeYTJCrMdDzTg3vCcQV55CJjZX"), "If debugging is the process of removing software bugs, then programming must be the process of putting them in.") } func TestBase58BitcoinEncoding(t *testing.T) { - assertEqual(t, _encStr(t, Base58BitcoinEncoding, "Hello"), "9Ajdvzr") - assertEqual(t, _encStr(t, Base58BitcoinEncoding, "If debugging is the process of removing software bugs, then programming must be the process of putting them in."), "48638SMcJuah5okqPx4kCVf5d8QAdgbdNf28g7ReY13prUENNbMyssjq5GjsrJHF5zeZfqs4uJMUJHr7VbrU4XBUZ2Fw9DVtqtn9N1eXucEWSEZahXV6w4ysGSWqGdpeYTJf1MdDzTg8vfcQViifJjZX") + tst.AssertEqual(t, _encStr(t, Base58BitcoinEncoding, "Hello"), "9Ajdvzr") + tst.AssertEqual(t, _encStr(t, Base58BitcoinEncoding, "If debugging is the process of removing software bugs, then programming must be the process of putting them in."), "48638SMcJuah5okqPx4kCVf5d8QAdgbdNf28g7ReY13prUENNbMyssjq5GjsrJHF5zeZfqs4uJMUJHr7VbrU4XBUZ2Fw9DVtqtn9N1eXucEWSEZahXV6w4ysGSWqGdpeYTJf1MdDzTg8vfcQViifJjZX") } func TestBase58BitcoinDecoding(t *testing.T) { - assertEqual(t, _decStr(t, Base58BitcoinEncoding, "9Ajdvzr"), "Hello") - assertEqual(t, _decStr(t, Base58BitcoinEncoding, "48638SMcJuah5okqPx4kCVf5d8QAdgbdNf28g7ReY13prUENNbMyssjq5GjsrJHF5zeZfqs4uJMUJHr7VbrU4XBUZ2Fw9DVtqtn9N1eXucEWSEZahXV6w4ysGSWqGdpeYTJf1MdDzTg8vfcQViifJjZX"), "If debugging is the process of removing software bugs, then programming must be the process of putting them in.") + tst.AssertEqual(t, _decStr(t, Base58BitcoinEncoding, "9Ajdvzr"), "Hello") + tst.AssertEqual(t, _decStr(t, Base58BitcoinEncoding, "48638SMcJuah5okqPx4kCVf5d8QAdgbdNf28g7ReY13prUENNbMyssjq5GjsrJHF5zeZfqs4uJMUJHr7VbrU4XBUZ2Fw9DVtqtn9N1eXucEWSEZahXV6w4ysGSWqGdpeYTJf1MdDzTg8vfcQViifJjZX"), "If debugging is the process of removing software bugs, then programming must be the process of putting them in.") } func TestBase58FlickrEncoding(t *testing.T) { - assertEqual(t, _encStr(t, Base58FlickrEncoding, "Hello"), "9aJCVZR") - assertEqual(t, _encStr(t, Base58FlickrEncoding, "If debugging is the process of removing software bugs, then programming must be the process of putting them in."), "48638rmBiUzG5NKQoX4KcuE5C8paCFACnE28F7qDx13PRtennAmYSSJQ5gJSRihf5ZDyEQS4UimtihR7uARt4wbty2fW9duTQTM9n1DwUBevreyzGwu6W4YSgrvQgCPDxsiE1mCdZsF8VEBpuHHEiJyw") + tst.AssertEqual(t, _encStr(t, Base58FlickrEncoding, "Hello"), "9aJCVZR") + tst.AssertEqual(t, _encStr(t, Base58FlickrEncoding, "If debugging is the process of removing software bugs, then programming must be the process of putting them in."), "48638rmBiUzG5NKQoX4KcuE5C8paCFACnE28F7qDx13PRtennAmYSSJQ5gJSRihf5ZDyEQS4UimtihR7uARt4wbty2fW9duTQTM9n1DwUBevreyzGwu6W4YSgrvQgCPDxsiE1mCdZsF8VEBpuHHEiJyw") } func TestBase58FlickrDecoding(t *testing.T) { - assertEqual(t, _decStr(t, Base58FlickrEncoding, "9aJCVZR"), "Hello") - assertEqual(t, _decStr(t, Base58FlickrEncoding, "48638rmBiUzG5NKQoX4KcuE5C8paCFACnE28F7qDx13PRtennAmYSSJQ5gJSRihf5ZDyEQS4UimtihR7uARt4wbty2fW9duTQTM9n1DwUBevreyzGwu6W4YSgrvQgCPDxsiE1mCdZsF8VEBpuHHEiJyw"), "If debugging is the process of removing software bugs, then programming must be the process of putting them in.") + tst.AssertEqual(t, _decStr(t, Base58FlickrEncoding, "9aJCVZR"), "Hello") + tst.AssertEqual(t, _decStr(t, Base58FlickrEncoding, "48638rmBiUzG5NKQoX4KcuE5C8paCFACnE28F7qDx13PRtennAmYSSJQ5gJSRihf5ZDyEQS4UimtihR7uARt4wbty2fW9duTQTM9n1DwUBevreyzGwu6W4YSgrvQgCPDxsiE1mCdZsF8VEBpuHHEiJyw"), "If debugging is the process of removing software bugs, then programming must be the process of putting them in.") } -func assertEqual(t *testing.T, actual string, expected string) { +func tst.AssertEqual(t *testing.T, actual string, expected string) { if actual != expected { t.Errorf("values differ: Actual: '%v', Expected: '%v'", actual, expected) } diff --git a/rext/wrapper.go b/rext/wrapper.go index f17e6ee..2c17601 100644 --- a/rext/wrapper.go +++ b/rext/wrapper.go @@ -117,7 +117,7 @@ func (m RegexMatch) GroupByName(name string) RegexMatchGroup { // GroupByName returns the value of a matched group (returns empty OptRegexMatchGroup if not found) func (m RegexMatch) GroupByNameOrEmpty(name string) OptRegexMatchGroup { for idx, subname := range m.subnames { - if subname == name { + if subname == name && (m.submatchesIndex[idx*2] != -1 || m.submatchesIndex[idx*2+1] != -1) { return OptRegexMatchGroup{&RegexMatchGroup{haystack: m.haystack, start: m.submatchesIndex[idx*2], end: m.submatchesIndex[idx*2+1]}} } } diff --git a/rext/wrapper_test.go b/rext/wrapper_test.go new file mode 100644 index 0000000..71bbc75 --- /dev/null +++ b/rext/wrapper_test.go @@ -0,0 +1,47 @@ +package rext + +import ( + "gogs.mikescher.com/BlackForestBytes/goext/tst" + "regexp" + "testing" +) + +func TestGroupByNameOrEmpty1(t *testing.T) { + + regex1 := W(regexp.MustCompile("0(?PA+)B(?PC+)0")) + + match1, ok1 := regex1.MatchFirst("Hello 0AAAABCCC0 Bye.") + + tst.AssertTrue(t, ok1) + + tst.AssertFalse(t, match1.GroupByNameOrEmpty("group1").IsEmpty()) + tst.AssertEqual(t, match1.GroupByNameOrEmpty("group1").ValueOrEmpty(), "AAAA") + tst.AssertEqual(t, *match1.GroupByNameOrEmpty("group1").ValueOrNil(), "AAAA") + + tst.AssertFalse(t, match1.GroupByNameOrEmpty("group2").IsEmpty()) + tst.AssertEqual(t, match1.GroupByNameOrEmpty("group2").ValueOrEmpty(), "CCC") + tst.AssertEqual(t, *match1.GroupByNameOrEmpty("group2").ValueOrNil(), "CCC") + +} + +func TestGroupByNameOrEmpty2(t *testing.T) { + + regex1 := W(regexp.MustCompile("0(?PA+)B(?PC+)(?PC+)?0")) + + match1, ok1 := regex1.MatchFirst("Hello 0AAAABCCC0 Bye.") + + tst.AssertTrue(t, ok1) + + tst.AssertFalse(t, match1.GroupByNameOrEmpty("group1").IsEmpty()) + tst.AssertEqual(t, match1.GroupByNameOrEmpty("group1").ValueOrEmpty(), "AAAA") + tst.AssertEqual(t, *match1.GroupByNameOrEmpty("group1").ValueOrNil(), "AAAA") + + tst.AssertFalse(t, match1.GroupByNameOrEmpty("group2").IsEmpty()) + tst.AssertEqual(t, match1.GroupByNameOrEmpty("group2").ValueOrEmpty(), "CCC") + tst.AssertEqual(t, *match1.GroupByNameOrEmpty("group2").ValueOrNil(), "CCC") + + tst.AssertTrue(t, match1.GroupByNameOrEmpty("group3").IsEmpty()) + tst.AssertEqual(t, match1.GroupByNameOrEmpty("group3").ValueOrEmpty(), "") + tst.AssertPtrEqual(t, match1.GroupByNameOrEmpty("group3").ValueOrNil(), nil) + +} diff --git a/rfctime/interface_test.go b/rfctime/interface_test.go index 5fa79ce..b89d588 100644 --- a/rfctime/interface_test.go +++ b/rfctime/interface_test.go @@ -10,22 +10,22 @@ func TestAnyTimeInterface(t *testing.T) { var v AnyTime v = NowRFC3339Nano() - assertEqual(t, v.String(), v.String()) + tst.AssertEqual(t, v.String(), v.String()) v = NowRFC3339() - assertEqual(t, v.String(), v.String()) + tst.AssertEqual(t, v.String(), v.String()) v = NowUnix() - assertEqual(t, v.String(), v.String()) + tst.AssertEqual(t, v.String(), v.String()) v = NowUnixMilli() - assertEqual(t, v.String(), v.String()) + tst.AssertEqual(t, v.String(), v.String()) v = NowUnixNano() - assertEqual(t, v.String(), v.String()) + tst.AssertEqual(t, v.String(), v.String()) v = time.Now() - assertEqual(t, v.String(), v.String()) + tst.AssertEqual(t, v.String(), v.String()) } @@ -33,18 +33,18 @@ func TestRFCTimeInterface(t *testing.T) { var v RFCTime v = NowRFC3339Nano() - assertEqual(t, v.String(), v.String()) + tst.AssertEqual(t, v.String(), v.String()) v = NowRFC3339() - assertEqual(t, v.String(), v.String()) + tst.AssertEqual(t, v.String(), v.String()) v = NowUnix() - assertEqual(t, v.String(), v.String()) + tst.AssertEqual(t, v.String(), v.String()) v = NowUnixMilli() - assertEqual(t, v.String(), v.String()) + tst.AssertEqual(t, v.String(), v.String()) v = NowUnixNano() - assertEqual(t, v.String(), v.String()) + tst.AssertEqual(t, v.String(), v.String()) } diff --git a/rfctime/rfc3339Nano_test.go b/rfctime/rfc3339Nano_test.go index 4757366..19cd474 100644 --- a/rfctime/rfc3339Nano_test.go +++ b/rfctime/rfc3339Nano_test.go @@ -2,6 +2,7 @@ package rfctime import ( "encoding/json" + "gogs.mikescher.com/BlackForestBytes/goext/tst" "testing" "time" ) @@ -37,16 +38,10 @@ func TestRoundtrip(t *testing.T) { panic(err) } - assertEqual(t, string(jstr1), string(jstr2)) + tst.AssertEqual(t, string(jstr1), string(jstr2)) if !w1.Value.Equal(&w2.Value) { t.Errorf("time differs") } } - -func assertEqual(t *testing.T, actual string, expected string) { - if actual != expected { - t.Errorf("values differ: Actual: '%v', Expected: '%v'", actual, expected) - } -} diff --git a/termext/termcolor_test.go b/termext/termcolor_test.go index 35c0ad8..cf7d229 100644 --- a/termext/termcolor_test.go +++ b/termext/termcolor_test.go @@ -14,26 +14,26 @@ func TestSupportsColors(t *testing.T) { } func TestColor(t *testing.T) { - assertEqual(t, Red("test"), "\033[31mtest\u001B[0m") - assertEqual(t, Green("test"), "\033[32mtest\u001B[0m") - assertEqual(t, Yellow("test"), "\033[33mtest\u001B[0m") - assertEqual(t, Blue("test"), "\033[34mtest\u001B[0m") - assertEqual(t, Purple("test"), "\033[35mtest\u001B[0m") - assertEqual(t, Cyan("test"), "\033[36mtest\u001B[0m") - assertEqual(t, Gray("test"), "\033[37mtest\u001B[0m") - assertEqual(t, White("test"), "\033[97mtest\u001B[0m") + tst.AssertEqual(t, Red("test"), "\033[31mtest\u001B[0m") + tst.AssertEqual(t, Green("test"), "\033[32mtest\u001B[0m") + tst.AssertEqual(t, Yellow("test"), "\033[33mtest\u001B[0m") + tst.AssertEqual(t, Blue("test"), "\033[34mtest\u001B[0m") + tst.AssertEqual(t, Purple("test"), "\033[35mtest\u001B[0m") + tst.AssertEqual(t, Cyan("test"), "\033[36mtest\u001B[0m") + tst.AssertEqual(t, Gray("test"), "\033[37mtest\u001B[0m") + tst.AssertEqual(t, White("test"), "\033[97mtest\u001B[0m") - assertEqual(t, CleanString(Red("test")), "test") - assertEqual(t, CleanString(Green("test")), "test") - assertEqual(t, CleanString(Yellow("test")), "test") - assertEqual(t, CleanString(Blue("test")), "test") - assertEqual(t, CleanString(Purple("test")), "test") - assertEqual(t, CleanString(Cyan("test")), "test") - assertEqual(t, CleanString(Gray("test")), "test") - assertEqual(t, CleanString(White("test")), "test") + tst.AssertEqual(t, CleanString(Red("test")), "test") + tst.AssertEqual(t, CleanString(Green("test")), "test") + tst.AssertEqual(t, CleanString(Yellow("test")), "test") + tst.AssertEqual(t, CleanString(Blue("test")), "test") + tst.AssertEqual(t, CleanString(Purple("test")), "test") + tst.AssertEqual(t, CleanString(Cyan("test")), "test") + tst.AssertEqual(t, CleanString(Gray("test")), "test") + tst.AssertEqual(t, CleanString(White("test")), "test") } -func assertEqual(t *testing.T, actual string, expected string) { +func tst.AssertEqual(t *testing.T, actual string, expected string) { if actual != expected { t.Errorf("values differ: Actual: '%v', Expected: '%v'", actual, expected) } diff --git a/timeext/parser_test.go b/timeext/parser_test.go index 96b300e..a8064e0 100644 --- a/timeext/parser_test.go +++ b/timeext/parser_test.go @@ -7,56 +7,56 @@ import ( func TestParseDurationShortString(t *testing.T) { - assertPDSSEqual(t, FromSeconds(1), "1s") - assertPDSSEqual(t, FromSeconds(1), "1sec") - assertPDSSEqual(t, FromSeconds(1), "1second") - assertPDSSEqual(t, FromSeconds(1), "1seconds") - assertPDSSEqual(t, FromSeconds(100), "100second") - assertPDSSEqual(t, FromSeconds(100), "100seconds") - assertPDSSEqual(t, FromSeconds(1883639.77), "1883639.77second") - assertPDSSEqual(t, FromSeconds(1883639.77), "1883639.77seconds") - assertPDSSEqual(t, FromSeconds(50), "50s") - assertPDSSEqual(t, FromSeconds(50), "50sec") - assertPDSSEqual(t, FromSeconds(1), "1second") - assertPDSSEqual(t, FromSeconds(50), "50seconds") + tst.AssertPDSSEqual(t, FromSeconds(1), "1s") + tst.AssertPDSSEqual(t, FromSeconds(1), "1sec") + tst.AssertPDSSEqual(t, FromSeconds(1), "1second") + tst.AssertPDSSEqual(t, FromSeconds(1), "1seconds") + tst.AssertPDSSEqual(t, FromSeconds(100), "100second") + tst.AssertPDSSEqual(t, FromSeconds(100), "100seconds") + tst.AssertPDSSEqual(t, FromSeconds(1883639.77), "1883639.77second") + tst.AssertPDSSEqual(t, FromSeconds(1883639.77), "1883639.77seconds") + tst.AssertPDSSEqual(t, FromSeconds(50), "50s") + tst.AssertPDSSEqual(t, FromSeconds(50), "50sec") + tst.AssertPDSSEqual(t, FromSeconds(1), "1second") + tst.AssertPDSSEqual(t, FromSeconds(50), "50seconds") - assertPDSSEqual(t, FromMinutes(10), "10m") - assertPDSSEqual(t, FromMinutes(10), "10min") - assertPDSSEqual(t, FromMinutes(1), "1minute") - assertPDSSEqual(t, FromMinutes(10), "10minutes") - assertPDSSEqual(t, FromMinutes(10.5), "10.5minutes") + tst.AssertPDSSEqual(t, FromMinutes(10), "10m") + tst.AssertPDSSEqual(t, FromMinutes(10), "10min") + tst.AssertPDSSEqual(t, FromMinutes(1), "1minute") + tst.AssertPDSSEqual(t, FromMinutes(10), "10minutes") + tst.AssertPDSSEqual(t, FromMinutes(10.5), "10.5minutes") - assertPDSSEqual(t, FromMilliseconds(100), "100ms") - assertPDSSEqual(t, FromMilliseconds(100), "100milliseconds") - assertPDSSEqual(t, FromMilliseconds(100), "100millisecond") + tst.AssertPDSSEqual(t, FromMilliseconds(100), "100ms") + tst.AssertPDSSEqual(t, FromMilliseconds(100), "100milliseconds") + tst.AssertPDSSEqual(t, FromMilliseconds(100), "100millisecond") - assertPDSSEqual(t, FromNanoseconds(99235), "99235ns") - assertPDSSEqual(t, FromNanoseconds(99235), "99235nanoseconds") - assertPDSSEqual(t, FromNanoseconds(99235), "99235nanosecond") + tst.AssertPDSSEqual(t, FromNanoseconds(99235), "99235ns") + tst.AssertPDSSEqual(t, FromNanoseconds(99235), "99235nanoseconds") + tst.AssertPDSSEqual(t, FromNanoseconds(99235), "99235nanosecond") - assertPDSSEqual(t, FromMicroseconds(99235), "99235us") - assertPDSSEqual(t, FromMicroseconds(99235), "99235microseconds") - assertPDSSEqual(t, FromMicroseconds(99235), "99235microsecond") + tst.AssertPDSSEqual(t, FromMicroseconds(99235), "99235us") + tst.AssertPDSSEqual(t, FromMicroseconds(99235), "99235microseconds") + tst.AssertPDSSEqual(t, FromMicroseconds(99235), "99235microsecond") - assertPDSSEqual(t, FromHours(1), "1h") - assertPDSSEqual(t, FromHours(1), "1hour") - assertPDSSEqual(t, FromHours(2), "2hours") + tst.AssertPDSSEqual(t, FromHours(1), "1h") + tst.AssertPDSSEqual(t, FromHours(1), "1hour") + tst.AssertPDSSEqual(t, FromHours(2), "2hours") - assertPDSSEqual(t, FromDays(1), "1d") - assertPDSSEqual(t, FromDays(1), "1day") - assertPDSSEqual(t, FromDays(10), "10days") - assertPDSSEqual(t, FromDays(1), "1days") - assertPDSSEqual(t, FromDays(10), "10day") + tst.AssertPDSSEqual(t, FromDays(1), "1d") + tst.AssertPDSSEqual(t, FromDays(1), "1day") + tst.AssertPDSSEqual(t, FromDays(10), "10days") + tst.AssertPDSSEqual(t, FromDays(1), "1days") + tst.AssertPDSSEqual(t, FromDays(10), "10day") - assertPDSSEqual(t, FromDays(1)+FromMinutes(10), "1d10m") - assertPDSSEqual(t, FromDays(1)+FromMinutes(10)+FromSeconds(200), "1d10m200sec") - assertPDSSEqual(t, FromDays(1)+FromMinutes(10), "1d:10m") - assertPDSSEqual(t, FromDays(1)+FromMinutes(10), "1d 10m") - assertPDSSEqual(t, FromDays(1)+FromMinutes(10), "1d,10m") - assertPDSSEqual(t, FromDays(1)+FromMinutes(10), "1d, 10m") - assertPDSSEqual(t, FromDays(1)+FromSeconds(1000), "1d 1000seconds") + tst.AssertPDSSEqual(t, FromDays(1)+FromMinutes(10), "1d10m") + tst.AssertPDSSEqual(t, FromDays(1)+FromMinutes(10)+FromSeconds(200), "1d10m200sec") + tst.AssertPDSSEqual(t, FromDays(1)+FromMinutes(10), "1d:10m") + tst.AssertPDSSEqual(t, FromDays(1)+FromMinutes(10), "1d 10m") + tst.AssertPDSSEqual(t, FromDays(1)+FromMinutes(10), "1d,10m") + tst.AssertPDSSEqual(t, FromDays(1)+FromMinutes(10), "1d, 10m") + tst.AssertPDSSEqual(t, FromDays(1)+FromSeconds(1000), "1d 1000seconds") - assertPDSSEqual(t, FromDays(1), "86400s") + tst.AssertPDSSEqual(t, FromDays(1), "86400s") } func assertPDSSEqual(t *testing.T, expected time.Duration, fmt string) { diff --git a/tst/assertions.go b/tst/assertions.go new file mode 100644 index 0000000..ef814bb --- /dev/null +++ b/tst/assertions.go @@ -0,0 +1,65 @@ +package tst + +import ( + "encoding/hex" + "testing" +) + +func AssertEqual[T comparable](t *testing.T, actual T, expected T) { + if actual != expected { + t.Errorf("values differ: Actual: '%v', Expected: '%v'", actual, expected) + } +} + +func AssertNotEqual[T comparable](t *testing.T, actual T, expected T) { + if actual == expected { + t.Errorf("values do not differ: Actual: '%v', Expected: '%v'", actual, expected) + } +} + +func AssertDeRefEqual[T comparable](t *testing.T, actual *T, expected T) { + if actual == nil { + t.Errorf("values differ: Actual: NIL, Expected: '%v'", expected) + } + if *actual != expected { + t.Errorf("values differ: Actual: '%v', Expected: '%v'", actual, expected) + } +} + +func AssertPtrEqual[T comparable](t *testing.T, actual *T, expected *T) { + if actual == nil && expected == nil { + return + } + if actual != nil && expected != nil { + if *actual != *expected { + t.Errorf("values differ: Actual: '%v', Expected: '%v'", *actual, *expected) + } else { + return + } + } + if actual == nil && expected != nil { + t.Errorf("values differ: Actual: nil, Expected: not-nil") + } + if actual != nil && expected == nil { + t.Errorf("values differ: Actual: not-nil, Expected: nil") + } +} + +func AssertHexEqual(t *testing.T, expected string, actual []byte) { + actualStr := hex.EncodeToString(actual) + if actualStr != expected { + t.Errorf("values differ: Actual: '%v', Expected: '%v'", actualStr, expected) + } +} + +func AssertTrue(t *testing.T, value bool) { + if !value { + t.Error("value should be true") + } +} + +func AssertFalse(t *testing.T, value bool) { + if value { + t.Error("value should be false") + } +} diff --git a/tst/identAssertions.go b/tst/identAssertions.go new file mode 100644 index 0000000..d88573d --- /dev/null +++ b/tst/identAssertions.go @@ -0,0 +1,48 @@ +package tst + +import ( + "testing" +) + +func AssertIdentEqual[T comparable](t *testing.T, ident string, actual T, expected T) { + if actual != expected { + t.Errorf("[%s] values differ: Actual: '%v', Expected: '%v'", ident, actual, expected) + } +} + +func AssertIdentNotEqual[T comparable](t *testing.T, ident string, actual T, expected T) { + if actual == expected { + t.Errorf("[%s] values do not differ: Actual: '%v', Expected: '%v'", ident, actual, expected) + } +} + +func AssertIdentPtrEqual[T comparable](t *testing.T, ident string, actual *T, expected *T) { + if actual == nil && expected == nil { + return + } + if actual != nil && expected != nil { + if *actual != *expected { + t.Errorf("[%s] values differ: Actual: '%v', Expected: '%v'", ident, *actual, *expected) + } else { + return + } + } + if actual == nil && expected != nil { + t.Errorf("[%s] values differ: Actual: nil, Expected: not-nil", ident) + } + if actual != nil && expected == nil { + t.Errorf("[%s] values differ: Actual: not-nil, Expected: nil", ident) + } +} + +func AssertIdentTrue(t *testing.T, ident string, value bool) { + if !value { + t.Errorf("[%s] value should be true", ident) + } +} + +func AssertIdentFalse(t *testing.T, ident string, value bool) { + if !value { + t.Errorf("[%s] value should be false", ident) + } +}