v0.0.100

_data/version.sh

@@ -21,6 +21,8 @@ if [ "$( git rev-parse --abbrev-ref HEAD )" != "master" ]; then
   exit 1
 fi
 
+git pull --ff
+
 curr_vers=$(git describe --tags --abbrev=0 | sed 's/v//g')
 
 next_ver=$(echo "$curr_vers" | awk -F. -v OFS=. 'NF==1{print ++$NF}; NF>1{if(length($NF+1)>length($NF))$(NF-1)++; $NF=sprintf("%0*d", length($NF), ($NF+1)%(10^length($NF))); print}')
@@ -32,7 +34,13 @@ echo ""
 
 git add --verbose .
 
-git commit -a -m "v${next_ver}"
+msg="v${next_ver}"
+
+if [ $# -gt 0 ]; then
+  msg="$1"
+fi
+
+git commit -a -m "${msg}"
 
 git tag "v${next_ver}"
 

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)
+	tst.AssertEqual(t, data.V1, 846)
-	assertEqual(t, data.V2, "hello_world")
+	tst.AssertEqual(t, data.V2, "hello_world")
-	assertEqual(t, data.V3, 6)
+	tst.AssertEqual(t, data.V3, 6)
-	assertEqual(t, data.V4, 333)
+	tst.AssertEqual(t, data.V4, 333)
-	assertEqual(t, data.V5, -937)
+	tst.AssertEqual(t, data.V5, -937)
-	assertEqual(t, data.V6, 70)
+	tst.AssertEqual(t, data.V6, 70)
-	assertEqual(t, data.V7, "AAAAAA")
+	tst.AssertEqual(t, data.V7, "AAAAAA")
-	assertEqual(t, data.V8, time.Second*64)
+	tst.AssertEqual(t, data.V8, time.Second*64)
-	assertEqual(t, data.V9, time.Unix(1257894000, 0).UTC())
+	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)
+	tst.AssertEqual(t, data.V1, 999)
-	assertEqual(t, data.VX, "2")
+	tst.AssertEqual(t, data.VX, "2")
-	assertEqual(t, data.V5, "no")
+	tst.AssertEqual(t, data.V5, "no")
-	assertEqual(t, data.Sub1.V1, 3)
+	tst.AssertEqual(t, data.Sub1.V1, 3)
-	assertEqual(t, data.Sub1.VX, "4")
+	tst.AssertEqual(t, data.Sub1.VX, "4")
-	assertEqual(t, data.Sub1.V2, "5")
+	tst.AssertEqual(t, data.Sub1.V2, "5")
-	assertEqual(t, data.Sub1.V8, time.Second*6)
+	tst.AssertEqual(t, data.Sub1.V8, time.Second*6)
-	assertEqual(t, data.Sub1.V9, time.Unix(947206861, 0).UTC())
+	tst.AssertEqual(t, data.Sub1.V9, time.Unix(947206861, 0).UTC())
-	assertEqual(t, data.Sub2.V1, 846)
+	tst.AssertEqual(t, data.Sub2.V1, 846)
-	assertEqual(t, data.Sub2.VX, "9")
+	tst.AssertEqual(t, data.Sub2.VX, "9")
-	assertEqual(t, data.Sub2.V2, "222_hello_world")
+	tst.AssertEqual(t, data.Sub2.V2, "222_hello_world")
-	assertEqual(t, data.Sub2.V8, time.Second*64)
+	tst.AssertEqual(t, data.Sub2.V8, time.Second*64)
-	assertEqual(t, data.Sub2.V9, time.Unix(1257894000, 0).UTC())
+	tst.AssertEqual(t, data.Sub2.V9, time.Unix(1257894000, 0).UTC())
-	assertEqual(t, data.Sub3.V1, 33846)
+	tst.AssertEqual(t, data.Sub3.V1, 33846)
-	assertEqual(t, data.Sub3.VX, "14")
+	tst.AssertEqual(t, data.Sub3.VX, "14")
-	assertEqual(t, data.Sub3.V2, "33_hello_world")
+	tst.AssertEqual(t, data.Sub3.V2, "33_hello_world")
-	assertEqual(t, data.Sub3.V8, time.Second*1984)
+	tst.AssertEqual(t, data.Sub3.V8, time.Second*1984)
-	assertEqual(t, data.Sub3.V9, time.Unix(2015276400, 0).UTC())
+	tst.AssertEqual(t, data.Sub3.V9, time.Unix(2015276400, 0).UTC())
-	assertEqual(t, data.Sub4.V1, 11)
+	tst.AssertEqual(t, data.Sub4.V1, 11)
-	assertEqual(t, data.Sub4.VX, "19")
+	tst.AssertEqual(t, data.Sub4.VX, "19")
-	assertEqual(t, data.Sub4.V2, "22")
+	tst.AssertEqual(t, data.Sub4.V2, "22")
-	assertEqual(t, data.Sub4.V8, time.Second*1980)
+	tst.AssertEqual(t, data.Sub4.V8, time.Second*1980)
-	assertEqual(t, data.Sub4.V9, time.Unix(2335219200, 0).UTC())
+	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)
+	tst.AssertDeRefEqual(t, data.V1, 846)
-	assertPtrEqual(t, data.V2, "hello_world")
+	tst.AssertDeRefEqual(t, data.V2, "hello_world")
-	assertPtrEqual(t, data.V3, 6)
+	tst.AssertDeRefEqual(t, data.V3, 6)
-	assertPtrEqual(t, data.V4, 333)
+	tst.AssertDeRefEqual(t, data.V4, 333)
-	assertPtrEqual(t, data.V5, -937)
+	tst.AssertDeRefEqual(t, data.V5, -937)
-	assertPtrEqual(t, data.V6, 70)
+	tst.AssertDeRefEqual(t, data.V6, 70)
-	assertPtrEqual(t, data.V7, "AAAAAA")
+	tst.AssertDeRefEqual(t, data.V7, "AAAAAA")
-	assertPtrEqual(t, data.V8, time.Second*64)
+	tst.AssertDeRefEqual(t, data.V8, time.Second*64)
-	assertPtrEqual(t, data.V9, time.Unix(1257894000, 0).UTC())
+	tst.AssertDeRefEqual(t, data.V9, time.Unix(1257894000, 0).UTC())
 }
 
 func assertEqual[T comparable](t *testing.T, actual T, expected T) {

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))
 
 }

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")
+	tst.AssertEqual(t, StrSha256(""), "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")
-	assertEqual(t, StrSha256("0"), "5feceb66ffc86f38d952786c6d696c79c2dbc239dd4e91b46729d73a27fb57e9")
+	tst.AssertEqual(t, StrSha256("0"), "5feceb66ffc86f38d952786c6d696c79c2dbc239dd4e91b46729d73a27fb57e9")
-	assertEqual(t, StrSha256("80085"), "b3786e141d65638ad8a98173e26b5f6a53c927737b23ff31fb1843937250f44b")
+	tst.AssertEqual(t, StrSha256("80085"), "b3786e141d65638ad8a98173e26b5f6a53c927737b23ff31fb1843937250f44b")
-	assertEqual(t, StrSha256("Hello World"), "a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146e")
+	tst.AssertEqual(t, StrSha256("Hello World"), "a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146e")
 }
 
 func TestBytesSha256(t *testing.T) {
-	assertEqual(t, BytesSha256([]byte{}), "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")
+	tst.AssertEqual(t, BytesSha256([]byte{}), "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")
-	assertEqual(t, BytesSha256([]byte{0}), "6e340b9cffb37a989ca544e6bb780a2c78901d3fb33738768511a30617afa01d")
+	tst.AssertEqual(t, BytesSha256([]byte{0}), "6e340b9cffb37a989ca544e6bb780a2c78901d3fb33738768511a30617afa01d")
-	assertEqual(t, BytesSha256([]byte{128}), "76be8b528d0075f7aae98d6fa57a6d3c83ae480a8469e668d7b0af968995ac71")
+	tst.AssertEqual(t, BytesSha256([]byte{128}), "76be8b528d0075f7aae98d6fa57a6d3c83ae480a8469e668d7b0af968995ac71")
-	assertEqual(t, BytesSha256([]byte{0, 1, 2, 4, 8, 16, 32, 64, 128, 255}), "55016a318ba538e00123c736b2a8b6db368d00e7e25727547655b653e5853603")
+	tst.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)
-	}
 }

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)
+	tst.AssertIdentPtrEqual(t, "Field1", valueMerge.Field1, valueB.Field1)
-	assertPtrEqual(t, "Field2", valueMerge.Field2, valueA.Field2)
+	tst.AssertIdentPtrEqual(t, "Field2", valueMerge.Field2, valueA.Field2)
-	assertPtrEqual(t, "Field3", valueMerge.Field3, valueB.Field3)
+	tst.AssertIdentPtrEqual(t, "Field3", valueMerge.Field3, valueB.Field3)
-	assertPtrEqual(t, "Field4", valueMerge.Field4, nil)
+	tst.AssertIdentPtrEqual(t, "Field4", valueMerge.Field4, nil)
 
 }
 

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"))
+	tst.AssertHexEqual(t, "209bf774af36cc3a045c152d9f1269ef3684ad819c1359ee73ff0283a308fefa", noErrStructHash(t, "Hello"))
-	assertEqual(t, "c32f3626b981ae2997db656f3acad3f1dc9d30ef6b6d14296c023e391b25f71a", noErrStructHash(t, 0))
+	tst.AssertHexEqual(t, "c32f3626b981ae2997db656f3acad3f1dc9d30ef6b6d14296c023e391b25f71a", noErrStructHash(t, 0))
-	assertEqual(t, "01b781b03e9586b257d387057dfc70d9f06051e7d3c1e709a57e13cc8daf3e35", noErrStructHash(t, []byte{}))
+	tst.AssertHexEqual(t, "01b781b03e9586b257d387057dfc70d9f06051e7d3c1e709a57e13cc8daf3e35", noErrStructHash(t, []byte{}))
-	assertEqual(t, "93e1dcd45c732fe0079b0fb3204c7c803f0921835f6bfee2e6ff263e73eed53c", noErrStructHash(t, []int{}))
+	tst.AssertHexEqual(t, "93e1dcd45c732fe0079b0fb3204c7c803f0921835f6bfee2e6ff263e73eed53c", noErrStructHash(t, []int{}))
-	assertEqual(t, "54f637a376aad55b3160d98ebbcae8099b70d91b9400df23fb3709855d59800a", noErrStructHash(t, []int{1, 2, 3}))
+	tst.AssertHexEqual(t, "54f637a376aad55b3160d98ebbcae8099b70d91b9400df23fb3709855d59800a", noErrStructHash(t, []int{1, 2, 3}))
-	assertEqual(t, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", noErrStructHash(t, nil))
+	tst.AssertHexEqual(t, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", noErrStructHash(t, nil))
-	assertEqual(t, "349a7db91aa78fd30bbaa7c7f9c7bfb2fcfe72869b4861162a96713a852f60d3", noErrStructHash(t, []any{1, "", nil}))
+	tst.AssertHexEqual(t, "349a7db91aa78fd30bbaa7c7f9c7bfb2fcfe72869b4861162a96713a852f60d3", noErrStructHash(t, []any{1, "", nil}))
-	assertEqual(t, "ca51aab87808bf0062a4a024de6aac0c2bad54275cc857a4944569f89fd245ad", noErrStructHash(t, struct{}{}))
+	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)
-	}
-}

langext/array.go

@@ -217,6 +217,15 @@ func ArrFirst[T any](arr []T, comp func(v T) bool) (T, bool) {
 	return *new(T), false
 }
 
+func ArrFirstOrNil[T any](arr []T, comp func(v T) bool) *T {
+	for _, v := range arr {
+		if comp(v) {
+			return Ptr(v)
+		}
+	}
+	return nil
+}
+
 func ArrLast[T any](arr []T, comp func(v T) bool) (T, bool) {
 	found := false
 	result := *new(T)
@@ -229,6 +238,22 @@ func ArrLast[T any](arr []T, comp func(v T) bool) (T, bool) {
 	return result, found
 }
 
+func ArrLastOrNil[T any](arr []T, comp func(v T) bool) *T {
+	found := false
+	result := *new(T)
+	for _, v := range arr {
+		if comp(v) {
+			found = true
+			result = v
+		}
+	}
+	if found {
+		return Ptr(result)
+	} else {
+		return nil
+	}
+}
+
 func ArrFirstIndex[T comparable](arr []T, needle T) int {
 	for i, v := range arr {
 		if v == needle {
@@ -265,6 +290,26 @@ func ArrMap[T1 any, T2 any](arr []T1, conv func(v T1) T2) []T2 {
 	return r
 }
 
+func MapMap[TK comparable, TV any, TR any](inmap map[TK]TV, conv func(k TK, v TV) TR) []TR {
+	r := make([]TR, 0, len(inmap))
+	for k, v := range inmap {
+		r = append(r, conv(k, v))
+	}
+	return r
+}
+
+func MapMapErr[TK comparable, TV any, TR any](inmap map[TK]TV, conv func(k TK, v TV) (TR, error)) ([]TR, error) {
+	r := make([]TR, 0, len(inmap))
+	for k, v := range inmap {
+		elem, err := conv(k, v)
+		if err != nil {
+			return nil, err
+		}
+		r = append(r, elem)
+	}
+	return r, nil
+}
+
 func ArrMapExt[T1 any, T2 any](arr []T1, conv func(idx int, v T1) T2) []T2 {
 	r := make([]T2, len(arr))
 	for i, v := range arr {
@@ -328,3 +373,11 @@ func ArrFlattenDirect[T1 any](arr [][]T1) []T1 {
 	}
 	return r
 }
+
+func ArrCastToAny[T1 any](arr []T1) []any {
+	r := make([]any, len(arr))
+	for i, v := range arr {
+		r[i] = any(v)
+	}
+	return r
+}

langext/base58.go

@@ -0,0 +1,178 @@
+package langext
+
+import (
+	"bytes"
+	"errors"
+	"math/big"
+)
+
+// shamelessly stolen from https://github.com/btcsuite/
+
+type B58Encoding struct {
+	bigRadix     [11]*big.Int
+	bigRadix10   *big.Int
+	alphabet     string
+	alphabetIdx0 byte
+	b58          [256]byte
+}
+
+var Base58DefaultEncoding = newBase58Encoding("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
+var Base58FlickrEncoding = newBase58Encoding("123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ")
+var Base58RippleEncoding = newBase58Encoding("rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz")
+var Base58BitcoinEncoding = newBase58Encoding("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
+
+func newBase58Encoding(alphabet string) *B58Encoding {
+	bigRadix10 := big.NewInt(58 * 58 * 58 * 58 * 58 * 58 * 58 * 58 * 58 * 58)
+	enc := &B58Encoding{
+		alphabet:     alphabet,
+		alphabetIdx0: '1',
+		bigRadix: [...]*big.Int{
+			big.NewInt(0),
+			big.NewInt(58),
+			big.NewInt(58 * 58),
+			big.NewInt(58 * 58 * 58),
+			big.NewInt(58 * 58 * 58 * 58),
+			big.NewInt(58 * 58 * 58 * 58 * 58),
+			big.NewInt(58 * 58 * 58 * 58 * 58 * 58),
+			big.NewInt(58 * 58 * 58 * 58 * 58 * 58 * 58),
+			big.NewInt(58 * 58 * 58 * 58 * 58 * 58 * 58 * 58),
+			big.NewInt(58 * 58 * 58 * 58 * 58 * 58 * 58 * 58 * 58),
+			bigRadix10,
+		},
+		bigRadix10: bigRadix10,
+	}
+
+	b58 := make([]byte, 0, 256)
+
+	for i := byte(0); i < 32; i++ {
+		for j := byte(0); j < 8; j++ {
+
+			b := i*8 + j
+
+			idx := bytes.IndexByte([]byte(alphabet), b)
+			if idx == -1 {
+				b58 = append(b58, 255)
+			} else {
+				b58 = append(b58, byte(idx))
+			}
+
+		}
+	}
+
+	enc.b58 = *((*[256]byte)(b58))
+
+	return enc
+}
+
+func (enc *B58Encoding) EncodeString(src string) (string, error) {
+	v, err := enc.Encode([]byte(src))
+	if err != nil {
+		return "", err
+	}
+	return string(v), nil
+}
+
+func (enc *B58Encoding) Encode(src []byte) ([]byte, error) {
+	x := new(big.Int)
+	x.SetBytes(src)
+
+	// maximum length of output is log58(2^(8*len(b))) == len(b) * 8 / log(58)
+	maxlen := int(float64(len(src))*1.365658237309761) + 1
+	answer := make([]byte, 0, maxlen)
+	mod := new(big.Int)
+	for x.Sign() > 0 {
+		// Calculating with big.Int is slow for each iteration.
+		//    x, mod = x / 58, x % 58
+		//
+		// Instead we can try to do as much calculations on int64.
+		//    x, mod = x / 58^10, x % 58^10
+		//
+		// Which will give us mod, which is 10 digit base58 number.
+		// We'll loop that 10 times to convert to the answer.
+
+		x.DivMod(x, enc.bigRadix10, mod)
+		if x.Sign() == 0 {
+			// When x = 0, we need to ensure we don't add any extra zeros.
+			m := mod.Int64()
+			for m > 0 {
+				answer = append(answer, enc.alphabet[m%58])
+				m /= 58
+			}
+		} else {
+			m := mod.Int64()
+			for i := 0; i < 10; i++ {
+				answer = append(answer, enc.alphabet[m%58])
+				m /= 58
+			}
+		}
+	}
+
+	// leading zero bytes
+	for _, i := range src {
+		if i != 0 {
+			break
+		}
+		answer = append(answer, enc.alphabetIdx0)
+	}
+
+	// reverse
+	alen := len(answer)
+	for i := 0; i < alen/2; i++ {
+		answer[i], answer[alen-1-i] = answer[alen-1-i], answer[i]
+	}
+
+	return answer, nil
+}
+
+func (enc *B58Encoding) DecodeString(src string) (string, error) {
+	v, err := enc.Decode([]byte(src))
+	if err != nil {
+		return "", err
+	}
+	return string(v), nil
+}
+
+func (enc *B58Encoding) Decode(src []byte) ([]byte, error) {
+	answer := big.NewInt(0)
+	scratch := new(big.Int)
+
+	for t := src; len(t) > 0; {
+		n := len(t)
+		if n > 10 {
+			n = 10
+		}
+
+		total := uint64(0)
+		for _, v := range t[:n] {
+			if v > 255 {
+				return []byte{}, errors.New("invalid char in input")
+			}
+
+			tmp := enc.b58[v]
+			if tmp == 255 {
+				return []byte{}, errors.New("invalid char in input")
+			}
+			total = total*58 + uint64(tmp)
+		}
+
+		answer.Mul(answer, enc.bigRadix[n])
+		scratch.SetUint64(total)
+		answer.Add(answer, scratch)
+
+		t = t[n:]
+	}
+
+	tmpval := answer.Bytes()
+
+	var numZeros int
+	for numZeros = 0; numZeros < len(src); numZeros++ {
+		if src[numZeros] != enc.alphabetIdx0 {
+			break
+		}
+	}
+	flen := numZeros + len(tmpval)
+	val := make([]byte, flen)
+	copy(val[numZeros:], tmpval)
+
+	return val, nil
+}

langext/base58_test.go

@@ -0,0 +1,67 @@
+package langext
+
+import (
+	"testing"
+)
+
+func _encStr(t *testing.T, enc *B58Encoding, v string) string {
+	v, err := enc.EncodeString(v)
+	if err != nil {
+		t.Error(err)
+	}
+	return v
+}
+
+func _decStr(t *testing.T, enc *B58Encoding, v string) string {
+	v, err := enc.DecodeString(v)
+	if err != nil {
+		t.Error(err)
+	}
+	return v
+}
+
+func TestBase58DefaultEncoding(t *testing.T) {
+	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) {
+	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) {
+	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) {
+	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) {
+	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) {
+	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) {
+	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) {
+	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 tst.AssertEqual(t *testing.T, actual string, expected string) {
+	if actual != expected {
+		t.Errorf("values differ: Actual: '%v', Expected: '%v'", actual, expected)
+	}
+}

langext/coalesce.go

@@ -60,3 +60,12 @@ func CoalesceStringer(s fmt.Stringer, def string) string {
 		return s.String()
 	}
 }
+
+func SafeCast[T any](v any, def T) T {
+	switch r := v.(type) {
+	case T:
+		return r
+	default:
+		return def
+	}
+}

rext/wrapper.go

@@ -1,6 +1,9 @@
 package rext
 
-import "regexp"
+import (
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"regexp"
+)
 
 type Regex interface {
 	IsMatch(haystack string) bool
@@ -29,6 +32,10 @@ type RegexMatchGroup struct {
 	end      int
 }
 
+type OptRegexMatchGroup struct {
+	v *RegexMatchGroup
+}
+
 func W(rex *regexp.Regexp) Regex {
 	return &regexWrapper{rex: rex, subnames: rex.SubexpNames()}
 }
@@ -97,7 +104,7 @@ func (m RegexMatch) GroupByIndex(idx int) RegexMatchGroup {
 	return RegexMatchGroup{haystack: m.haystack, start: m.submatchesIndex[idx*2], end: m.submatchesIndex[idx*2+1]}
 }
 
-// GroupByName returns the value of a matched group (group 0 == whole match)
+// GroupByName returns the value of a matched group (panics if not found!)
 func (m RegexMatch) GroupByName(name string) RegexMatchGroup {
 	for idx, subname := range m.subnames {
 		if subname == name {
@@ -107,6 +114,16 @@ func (m RegexMatch) GroupByName(name string) RegexMatchGroup {
 	panic("failed to find regex-group by name")
 }
 
+// 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 && (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]}}
+		}
+	}
+	return OptRegexMatchGroup{}
+}
+
 // ---------------------------------------------------------------------------------------------------------------------
 
 func (g RegexMatchGroup) Value() string {
@@ -128,3 +145,47 @@ func (g RegexMatchGroup) Range() (int, int) {
 func (g RegexMatchGroup) Length() int {
 	return g.end - g.start
 }
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+func (g OptRegexMatchGroup) Value() string {
+	return g.v.Value()
+}
+
+func (g OptRegexMatchGroup) ValueOrEmpty() string {
+	if g.v == nil {
+		return ""
+	}
+	return g.v.Value()
+}
+
+func (g OptRegexMatchGroup) ValueOrNil() *string {
+	if g.v == nil {
+		return nil
+	}
+	return langext.Ptr(g.v.Value())
+}
+
+func (g OptRegexMatchGroup) IsEmpty() bool {
+	return g.v == nil
+}
+
+func (g OptRegexMatchGroup) Exists() bool {
+	return g.v != nil
+}
+
+func (g OptRegexMatchGroup) Start() int {
+	return g.v.Start()
+}
+
+func (g OptRegexMatchGroup) End() int {
+	return g.v.End()
+}
+
+func (g OptRegexMatchGroup) Range() (int, int) {
+	return g.v.Range()
+}
+
+func (g OptRegexMatchGroup) Length() int {
+	return g.v.Length()
+}

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(?P<group1>A+)B(?P<group2>C+)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(?P<group1>A+)B(?P<group2>C+)(?P<group3>C+)?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)
+
+}

rfctime/interface.go

@@ -3,24 +3,27 @@ package rfctime
 import "time"
 
 type RFCTime interface {
+	AnyTime
+
 	Time() time.Time
 	Serialize() string
 
-	UnmarshalJSON(bytes []byte) error
+	After(u AnyTime) bool
+	Before(u AnyTime) bool
+	Equal(u AnyTime) bool
+
+	Sub(u AnyTime) time.Duration
+}
+
+type AnyTime interface {
 	MarshalJSON() ([]byte, error)
 
 	MarshalBinary() ([]byte, error)
-	UnmarshalBinary(data []byte) error
 
 	GobEncode() ([]byte, error)
-	GobDecode(data []byte) error
 
 	MarshalText() ([]byte, error)
-	UnmarshalText(data []byte) error
 
-	After(u RFCTime) bool
-	Before(u RFCTime) bool
-	Equal(u RFCTime) bool
 	IsZero() bool
 	Date() (year int, month time.Month, day int)
 	Year() int
@@ -34,7 +37,6 @@ type RFCTime interface {
 	Second() int
 	Nanosecond() int
 	YearDay() int
-	Sub(u RFCTime) time.Duration
 	Unix() int64
 	UnixMilli() int64
 	UnixMicro() int64
@@ -42,6 +44,8 @@ type RFCTime interface {
 	Format(layout string) string
 	GoString() string
 	String() string
+
+	Location() *time.Location
 }
 
 type RFCDuration interface {
@@ -60,9 +64,9 @@ type RFCDuration interface {
 	MarshalText() ([]byte, error)
 	UnmarshalText(data []byte) error
 
-	After(u RFCTime) bool
+	After(u AnyTime) bool
-	Before(u RFCTime) bool
+	Before(u AnyTime) bool
-	Equal(u RFCTime) bool
+	Equal(u AnyTime) bool
 	IsZero() bool
 	Date() (year int, month time.Month, day int)
 	Year() int
@@ -76,7 +80,7 @@ type RFCDuration interface {
 	Second() int
 	Nanosecond() int
 	YearDay() int
-	Sub(u RFCTime) time.Duration
+	Sub(u AnyTime) time.Duration
 	Unix() int64
 	UnixMilli() int64
 	UnixMicro() int64
@@ -85,3 +89,13 @@ type RFCDuration interface {
 	GoString() string
 	String() string
 }
+
+func tt(v AnyTime) time.Time {
+	if r, ok := v.(time.Time); ok {
+		return r
+	}
+	if r, ok := v.(RFCTime); ok {
+		return r.Time()
+	}
+	return time.Unix(0, v.UnixNano()).In(v.Location())
+}

rfctime/interface_test.go

@@ -0,0 +1,50 @@
+package rfctime
+
+import (
+	"testing"
+	"time"
+)
+
+func TestAnyTimeInterface(t *testing.T) {
+
+	var v AnyTime
+
+	v = NowRFC3339Nano()
+	tst.AssertEqual(t, v.String(), v.String())
+
+	v = NowRFC3339()
+	tst.AssertEqual(t, v.String(), v.String())
+
+	v = NowUnix()
+	tst.AssertEqual(t, v.String(), v.String())
+
+	v = NowUnixMilli()
+	tst.AssertEqual(t, v.String(), v.String())
+
+	v = NowUnixNano()
+	tst.AssertEqual(t, v.String(), v.String())
+
+	v = time.Now()
+	tst.AssertEqual(t, v.String(), v.String())
+
+}
+
+func TestRFCTimeInterface(t *testing.T) {
+	var v RFCTime
+
+	v = NowRFC3339Nano()
+	tst.AssertEqual(t, v.String(), v.String())
+
+	v = NowRFC3339()
+	tst.AssertEqual(t, v.String(), v.String())
+
+	v = NowUnix()
+	tst.AssertEqual(t, v.String(), v.String())
+
+	v = NowUnixMilli()
+	tst.AssertEqual(t, v.String(), v.String())
+
+	v = NowUnixNano()
+	tst.AssertEqual(t, v.String(), v.String())
+
+}

rfctime/rfc3339.go

@@ -90,16 +90,16 @@ func (t RFC3339Time) FormatStr() string {
 	return time.RFC3339
 }
 
-func (t RFC3339Time) After(u RFCTime) bool {
+func (t RFC3339Time) After(u AnyTime) bool {
-	return t.Time().After(u.Time())
+	return t.Time().After(tt(u))
 }
 
-func (t RFC3339Time) Before(u RFCTime) bool {
+func (t RFC3339Time) Before(u AnyTime) bool {
-	return t.Time().Before(u.Time())
+	return t.Time().Before(tt(u))
 }
 
-func (t RFC3339Time) Equal(u RFCTime) bool {
+func (t RFC3339Time) Equal(u AnyTime) bool {
-	return t.Time().Equal(u.Time())
+	return t.Time().Equal(tt(u))
 }
 
 func (t RFC3339Time) IsZero() bool {
@@ -158,8 +158,8 @@ func (t RFC3339Time) Add(d time.Duration) RFC3339Time {
 	return RFC3339Time(t.Time().Add(d))
 }
 
-func (t RFC3339Time) Sub(u RFCTime) time.Duration {
+func (t RFC3339Time) Sub(u AnyTime) time.Duration {
-	return t.Time().Sub(u.Time())
+	return t.Time().Sub(tt(u))
 }
 
 func (t RFC3339Time) AddDate(years int, months int, days int) RFC3339Time {
@@ -194,6 +194,10 @@ func (t RFC3339Time) String() string {
 	return t.Time().String()
 }
 
+func (t RFC3339Time) Location() *time.Location {
+	return t.Time().Location()
+}
+
 func NewRFC3339(t time.Time) RFC3339Time {
 	return RFC3339Time(t)
 }

rfctime/rfc3339Nano.go

@@ -90,16 +90,16 @@ func (t RFC3339NanoTime) FormatStr() string {
 	return time.RFC3339Nano
 }
 
-func (t RFC3339NanoTime) After(u RFCTime) bool {
+func (t RFC3339NanoTime) After(u AnyTime) bool {
-	return t.Time().After(u.Time())
+	return t.Time().After(tt(u))
 }
 
-func (t RFC3339NanoTime) Before(u RFCTime) bool {
+func (t RFC3339NanoTime) Before(u AnyTime) bool {
-	return t.Time().Before(u.Time())
+	return t.Time().Before(tt(u))
 }
 
-func (t RFC3339NanoTime) Equal(u RFCTime) bool {
+func (t RFC3339NanoTime) Equal(u AnyTime) bool {
-	return t.Time().Equal(u.Time())
+	return t.Time().Equal(tt(u))
 }
 
 func (t RFC3339NanoTime) IsZero() bool {
@@ -158,8 +158,8 @@ func (t RFC3339NanoTime) Add(d time.Duration) RFC3339NanoTime {
 	return RFC3339NanoTime(t.Time().Add(d))
 }
 
-func (t RFC3339NanoTime) Sub(u RFCTime) time.Duration {
+func (t RFC3339NanoTime) Sub(u AnyTime) time.Duration {
-	return t.Time().Sub(u.Time())
+	return t.Time().Sub(tt(u))
 }
 
 func (t RFC3339NanoTime) AddDate(years int, months int, days int) RFC3339NanoTime {
@@ -194,6 +194,10 @@ func (t RFC3339NanoTime) String() string {
 	return t.Time().String()
 }
 
+func (t RFC3339NanoTime) Location() *time.Location {
+	return t.Time().Location()
+}
+
 func NewRFC3339Nano(t time.Time) RFC3339NanoTime {
 	return RFC3339NanoTime(t)
 }

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)
-	}
-}

rfctime/unix.go

@@ -63,16 +63,16 @@ func (t UnixTime) Serialize() string {
 	return strconv.FormatInt(t.Time().Unix(), 10)
 }
 
-func (t UnixTime) After(u RFCTime) bool {
+func (t UnixTime) After(u AnyTime) bool {
-	return t.Time().After(u.Time())
+	return t.Time().After(tt(u))
 }
 
-func (t UnixTime) Before(u RFCTime) bool {
+func (t UnixTime) Before(u AnyTime) bool {
-	return t.Time().Before(u.Time())
+	return t.Time().Before(tt(u))
 }
 
-func (t UnixTime) Equal(u RFCTime) bool {
+func (t UnixTime) Equal(u AnyTime) bool {
-	return t.Time().Equal(u.Time())
+	return t.Time().Equal(tt(u))
 }
 
 func (t UnixTime) IsZero() bool {
@@ -131,8 +131,8 @@ func (t UnixTime) Add(d time.Duration) UnixTime {
 	return UnixTime(t.Time().Add(d))
 }
 
-func (t UnixTime) Sub(u RFCTime) time.Duration {
+func (t UnixTime) Sub(u AnyTime) time.Duration {
-	return t.Time().Sub(u.Time())
+	return t.Time().Sub(tt(u))
 }
 
 func (t UnixTime) AddDate(years int, months int, days int) UnixTime {
@@ -167,6 +167,10 @@ func (t UnixTime) String() string {
 	return t.Time().String()
 }
 
+func (t UnixTime) Location() *time.Location {
+	return t.Time().Location()
+}
+
 func NewUnix(t time.Time) UnixTime {
 	return UnixTime(t)
 }

rfctime/unixMilli.go

@@ -63,16 +63,16 @@ func (t UnixMilliTime) Serialize() string {
 	return strconv.FormatInt(t.Time().UnixMilli(), 10)
 }
 
-func (t UnixMilliTime) After(u RFCTime) bool {
+func (t UnixMilliTime) After(u AnyTime) bool {
-	return t.Time().After(u.Time())
+	return t.Time().After(tt(u))
 }
 
-func (t UnixMilliTime) Before(u RFCTime) bool {
+func (t UnixMilliTime) Before(u AnyTime) bool {
-	return t.Time().Before(u.Time())
+	return t.Time().Before(tt(u))
 }
 
-func (t UnixMilliTime) Equal(u RFCTime) bool {
+func (t UnixMilliTime) Equal(u AnyTime) bool {
-	return t.Time().Equal(u.Time())
+	return t.Time().Equal(tt(u))
 }
 
 func (t UnixMilliTime) IsZero() bool {
@@ -131,8 +131,8 @@ func (t UnixMilliTime) Add(d time.Duration) UnixMilliTime {
 	return UnixMilliTime(t.Time().Add(d))
 }
 
-func (t UnixMilliTime) Sub(u RFCTime) time.Duration {
+func (t UnixMilliTime) Sub(u AnyTime) time.Duration {
-	return t.Time().Sub(u.Time())
+	return t.Time().Sub(tt(u))
 }
 
 func (t UnixMilliTime) AddDate(years int, months int, days int) UnixMilliTime {
@@ -167,6 +167,10 @@ func (t UnixMilliTime) String() string {
 	return t.Time().String()
 }
 
+func (t UnixMilliTime) Location() *time.Location {
+	return t.Time().Location()
+}
+
 func NewUnixMilli(t time.Time) UnixMilliTime {
 	return UnixMilliTime(t)
 }

rfctime/unixNano.go

@@ -63,16 +63,16 @@ func (t UnixNanoTime) Serialize() string {
 	return strconv.FormatInt(t.Time().UnixNano(), 10)
 }
 
-func (t UnixNanoTime) After(u RFCTime) bool {
+func (t UnixNanoTime) After(u AnyTime) bool {
-	return t.Time().After(u.Time())
+	return t.Time().After(tt(u))
 }
 
-func (t UnixNanoTime) Before(u RFCTime) bool {
+func (t UnixNanoTime) Before(u AnyTime) bool {
-	return t.Time().Before(u.Time())
+	return t.Time().Before(tt(u))
 }
 
-func (t UnixNanoTime) Equal(u RFCTime) bool {
+func (t UnixNanoTime) Equal(u AnyTime) bool {
-	return t.Time().Equal(u.Time())
+	return t.Time().Equal(tt(u))
 }
 
 func (t UnixNanoTime) IsZero() bool {
@@ -131,8 +131,8 @@ func (t UnixNanoTime) Add(d time.Duration) UnixNanoTime {
 	return UnixNanoTime(t.Time().Add(d))
 }
 
-func (t UnixNanoTime) Sub(u RFCTime) time.Duration {
+func (t UnixNanoTime) Sub(u AnyTime) time.Duration {
-	return t.Time().Sub(u.Time())
+	return t.Time().Sub(tt(u))
 }
 
 func (t UnixNanoTime) AddDate(years int, months int, days int) UnixNanoTime {
@@ -167,6 +167,10 @@ func (t UnixNanoTime) String() string {
 	return t.Time().String()
 }
 
+func (t UnixNanoTime) Location() *time.Location {
+	return t.Time().Location()
+}
+
 func NewUnixNano(t time.Time) UnixNanoTime {
 	return UnixNanoTime(t)
 }

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")
+	tst.AssertEqual(t, Red("test"), "\033[31mtest\u001B[0m")
-	assertEqual(t, Green("test"), "\033[32mtest\u001B[0m")
+	tst.AssertEqual(t, Green("test"), "\033[32mtest\u001B[0m")
-	assertEqual(t, Yellow("test"), "\033[33mtest\u001B[0m")
+	tst.AssertEqual(t, Yellow("test"), "\033[33mtest\u001B[0m")
-	assertEqual(t, Blue("test"), "\033[34mtest\u001B[0m")
+	tst.AssertEqual(t, Blue("test"), "\033[34mtest\u001B[0m")
-	assertEqual(t, Purple("test"), "\033[35mtest\u001B[0m")
+	tst.AssertEqual(t, Purple("test"), "\033[35mtest\u001B[0m")
-	assertEqual(t, Cyan("test"), "\033[36mtest\u001B[0m")
+	tst.AssertEqual(t, Cyan("test"), "\033[36mtest\u001B[0m")
-	assertEqual(t, Gray("test"), "\033[37mtest\u001B[0m")
+	tst.AssertEqual(t, Gray("test"), "\033[37mtest\u001B[0m")
-	assertEqual(t, White("test"), "\033[97mtest\u001B[0m")
+	tst.AssertEqual(t, White("test"), "\033[97mtest\u001B[0m")
 
-	assertEqual(t, CleanString(Red("test")), "test")
+	tst.AssertEqual(t, CleanString(Red("test")), "test")
-	assertEqual(t, CleanString(Green("test")), "test")
+	tst.AssertEqual(t, CleanString(Green("test")), "test")
-	assertEqual(t, CleanString(Yellow("test")), "test")
+	tst.AssertEqual(t, CleanString(Yellow("test")), "test")
-	assertEqual(t, CleanString(Blue("test")), "test")
+	tst.AssertEqual(t, CleanString(Blue("test")), "test")
-	assertEqual(t, CleanString(Purple("test")), "test")
+	tst.AssertEqual(t, CleanString(Purple("test")), "test")
-	assertEqual(t, CleanString(Cyan("test")), "test")
+	tst.AssertEqual(t, CleanString(Cyan("test")), "test")
-	assertEqual(t, CleanString(Gray("test")), "test")
+	tst.AssertEqual(t, CleanString(Gray("test")), "test")
-	assertEqual(t, CleanString(White("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)
 	}

timeext/parser_test.go

@@ -7,56 +7,56 @@ import (
 
 func TestParseDurationShortString(t *testing.T) {
 
-	assertPDSSEqual(t, FromSeconds(1), "1s")
+	tst.AssertPDSSEqual(t, FromSeconds(1), "1s")
-	assertPDSSEqual(t, FromSeconds(1), "1sec")
+	tst.AssertPDSSEqual(t, FromSeconds(1), "1sec")
-	assertPDSSEqual(t, FromSeconds(1), "1second")
+	tst.AssertPDSSEqual(t, FromSeconds(1), "1second")
-	assertPDSSEqual(t, FromSeconds(1), "1seconds")
+	tst.AssertPDSSEqual(t, FromSeconds(1), "1seconds")
-	assertPDSSEqual(t, FromSeconds(100), "100second")
+	tst.AssertPDSSEqual(t, FromSeconds(100), "100second")
-	assertPDSSEqual(t, FromSeconds(100), "100seconds")
+	tst.AssertPDSSEqual(t, FromSeconds(100), "100seconds")
-	assertPDSSEqual(t, FromSeconds(1883639.77), "1883639.77second")
+	tst.AssertPDSSEqual(t, FromSeconds(1883639.77), "1883639.77second")
-	assertPDSSEqual(t, FromSeconds(1883639.77), "1883639.77seconds")
+	tst.AssertPDSSEqual(t, FromSeconds(1883639.77), "1883639.77seconds")
-	assertPDSSEqual(t, FromSeconds(50), "50s")
+	tst.AssertPDSSEqual(t, FromSeconds(50), "50s")
-	assertPDSSEqual(t, FromSeconds(50), "50sec")
+	tst.AssertPDSSEqual(t, FromSeconds(50), "50sec")
-	assertPDSSEqual(t, FromSeconds(1), "1second")
+	tst.AssertPDSSEqual(t, FromSeconds(1), "1second")
-	assertPDSSEqual(t, FromSeconds(50), "50seconds")
+	tst.AssertPDSSEqual(t, FromSeconds(50), "50seconds")
 
-	assertPDSSEqual(t, FromMinutes(10), "10m")
+	tst.AssertPDSSEqual(t, FromMinutes(10), "10m")
-	assertPDSSEqual(t, FromMinutes(10), "10min")
+	tst.AssertPDSSEqual(t, FromMinutes(10), "10min")
-	assertPDSSEqual(t, FromMinutes(1), "1minute")
+	tst.AssertPDSSEqual(t, FromMinutes(1), "1minute")
-	assertPDSSEqual(t, FromMinutes(10), "10minutes")
+	tst.AssertPDSSEqual(t, FromMinutes(10), "10minutes")
-	assertPDSSEqual(t, FromMinutes(10.5), "10.5minutes")
+	tst.AssertPDSSEqual(t, FromMinutes(10.5), "10.5minutes")
 
-	assertPDSSEqual(t, FromMilliseconds(100), "100ms")
+	tst.AssertPDSSEqual(t, FromMilliseconds(100), "100ms")
-	assertPDSSEqual(t, FromMilliseconds(100), "100milliseconds")
+	tst.AssertPDSSEqual(t, FromMilliseconds(100), "100milliseconds")
-	assertPDSSEqual(t, FromMilliseconds(100), "100millisecond")
+	tst.AssertPDSSEqual(t, FromMilliseconds(100), "100millisecond")
 
-	assertPDSSEqual(t, FromNanoseconds(99235), "99235ns")
+	tst.AssertPDSSEqual(t, FromNanoseconds(99235), "99235ns")
-	assertPDSSEqual(t, FromNanoseconds(99235), "99235nanoseconds")
+	tst.AssertPDSSEqual(t, FromNanoseconds(99235), "99235nanoseconds")
-	assertPDSSEqual(t, FromNanoseconds(99235), "99235nanosecond")
+	tst.AssertPDSSEqual(t, FromNanoseconds(99235), "99235nanosecond")
 
-	assertPDSSEqual(t, FromMicroseconds(99235), "99235us")
+	tst.AssertPDSSEqual(t, FromMicroseconds(99235), "99235us")
-	assertPDSSEqual(t, FromMicroseconds(99235), "99235microseconds")
+	tst.AssertPDSSEqual(t, FromMicroseconds(99235), "99235microseconds")
-	assertPDSSEqual(t, FromMicroseconds(99235), "99235microsecond")
+	tst.AssertPDSSEqual(t, FromMicroseconds(99235), "99235microsecond")
 
-	assertPDSSEqual(t, FromHours(1), "1h")
+	tst.AssertPDSSEqual(t, FromHours(1), "1h")
-	assertPDSSEqual(t, FromHours(1), "1hour")
+	tst.AssertPDSSEqual(t, FromHours(1), "1hour")
-	assertPDSSEqual(t, FromHours(2), "2hours")
+	tst.AssertPDSSEqual(t, FromHours(2), "2hours")
 
-	assertPDSSEqual(t, FromDays(1), "1d")
+	tst.AssertPDSSEqual(t, FromDays(1), "1d")
-	assertPDSSEqual(t, FromDays(1), "1day")
+	tst.AssertPDSSEqual(t, FromDays(1), "1day")
-	assertPDSSEqual(t, FromDays(10), "10days")
+	tst.AssertPDSSEqual(t, FromDays(10), "10days")
-	assertPDSSEqual(t, FromDays(1), "1days")
+	tst.AssertPDSSEqual(t, FromDays(1), "1days")
-	assertPDSSEqual(t, FromDays(10), "10day")
+	tst.AssertPDSSEqual(t, FromDays(10), "10day")
 
-	assertPDSSEqual(t, FromDays(1)+FromMinutes(10), "1d10m")
+	tst.AssertPDSSEqual(t, FromDays(1)+FromMinutes(10), "1d10m")
-	assertPDSSEqual(t, FromDays(1)+FromMinutes(10)+FromSeconds(200), "1d10m200sec")
+	tst.AssertPDSSEqual(t, FromDays(1)+FromMinutes(10)+FromSeconds(200), "1d10m200sec")
-	assertPDSSEqual(t, FromDays(1)+FromMinutes(10), "1d:10m")
+	tst.AssertPDSSEqual(t, FromDays(1)+FromMinutes(10), "1d:10m")
-	assertPDSSEqual(t, FromDays(1)+FromMinutes(10), "1d 10m")
+	tst.AssertPDSSEqual(t, FromDays(1)+FromMinutes(10), "1d 10m")
-	assertPDSSEqual(t, FromDays(1)+FromMinutes(10), "1d,10m")
+	tst.AssertPDSSEqual(t, FromDays(1)+FromMinutes(10), "1d,10m")
-	assertPDSSEqual(t, FromDays(1)+FromMinutes(10), "1d, 10m")
+	tst.AssertPDSSEqual(t, FromDays(1)+FromMinutes(10), "1d, 10m")
-	assertPDSSEqual(t, FromDays(1)+FromSeconds(1000), "1d   1000seconds")
+	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) {

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")
+	}
+}

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)
+	}
+}