From ab364744b601ca602577dda78616fe5b6dbf7684 Mon Sep 17 00:00:00 2001 From: dudaodong Date: Thu, 29 Jun 2023 14:49:28 +0800 Subject: [PATCH] test: add parallel running for all unit test functions --- algorithm/lrucache_test.go | 1 + algorithm/search_test.go | 2 + algorithm/sort_test.go | 9 +++ compare/compare_test.go | 6 ++ concurrency/channel_test.go | 9 +++ condition/condition_test.go | 17 +++++ convertor/convertor_test.go | 40 ++++++++++++ cryptor/basic_test.go | 24 +++++++ cryptor/encrypt_test.go | 22 +++++++ datastructure/hashmap/hashmap_test.go | 6 ++ datastructure/heap/maxheap_test.go | 8 +++ datastructure/link/doublylink_test.go | 21 ++++++- datastructure/link/singlylink_test.go | 22 ++++++- datastructure/list/list_test.go | 77 +++++++++++++++++++++-- datastructure/queue/arrayqueue_test.go | 17 ++++- datastructure/queue/circularqueue_test.go | 14 +++++ datastructure/queue/linkedqueue_test.go | 13 +++- datastructure/queue/priorityqueue_test.go | 4 ++ datastructure/set/set_test.go | 49 ++++++++++++--- datastructure/stack/arraystack_test.go | 17 +++-- datastructure/stack/linkedstack_test.go | 17 +++-- datastructure/tree/bstree_test.go | 23 ++++--- datetime/conversion_test.go | 10 ++- datetime/datetime_test.go | 56 ++++++++++++++++- fileutil/file_test.go | 10 +++ formatter/byte_test.go | 8 +++ formatter/formatter_test.go | 6 ++ function/function_test.go | 8 +++ function/watcher_test.go | 2 + iterator/iterator_test.go | 6 ++ iterator/operation_test.go | 10 +++ maputil/map_test.go | 40 ++++++++++++ maputil/typemap_test.go | 13 ++++ 33 files changed, 541 insertions(+), 46 deletions(-) diff --git a/algorithm/lrucache_test.go b/algorithm/lrucache_test.go index 7d62b68..0b1a582 100644 --- a/algorithm/lrucache_test.go +++ b/algorithm/lrucache_test.go @@ -7,6 +7,7 @@ import ( ) func TestLRUCache(t *testing.T) { + t.Parallel() asssert := internal.NewAssert(t, "TestLRUCache") cache := NewLRUCache[int, int](3) diff --git a/algorithm/search_test.go b/algorithm/search_test.go index 2ee1f35..d4586f4 100644 --- a/algorithm/search_test.go +++ b/algorithm/search_test.go @@ -7,6 +7,7 @@ import ( ) func TestLinearSearch(t *testing.T) { + t.Parallel() asssert := internal.NewAssert(t, "TestLinearSearch") numbers := []int{3, 4, 5, 3, 2, 1} @@ -19,6 +20,7 @@ func TestLinearSearch(t *testing.T) { } func TestBinarySearch(t *testing.T) { + t.Parallel() asssert := internal.NewAssert(t, "TestBinarySearch") sortedNumbers := []int{1, 2, 3, 4, 5, 6, 7, 8} diff --git a/algorithm/sort_test.go b/algorithm/sort_test.go index febed28..5270fbb 100644 --- a/algorithm/sort_test.go +++ b/algorithm/sort_test.go @@ -46,6 +46,7 @@ func (c *intComparator) Compare(v1 any, v2 any) int { } func TestBubbleSortForStructSlice(t *testing.T) { + t.Parallel() asssert := internal.NewAssert(t, "TestBubbleSortForStructSlice") peoples := []people{ @@ -65,6 +66,7 @@ func TestBubbleSortForStructSlice(t *testing.T) { } func TestBubbleSortForIntSlice(t *testing.T) { + t.Parallel() asssert := internal.NewAssert(t, "TestBubbleSortForIntSlice") numbers := []int{2, 1, 5, 3, 6, 4} @@ -75,6 +77,7 @@ func TestBubbleSortForIntSlice(t *testing.T) { } func TestInsertionSort(t *testing.T) { + t.Parallel() asssert := internal.NewAssert(t, "TestInsertionSort") peoples := []people{ @@ -94,6 +97,7 @@ func TestInsertionSort(t *testing.T) { } func TestSelectionSort(t *testing.T) { + t.Parallel() asssert := internal.NewAssert(t, "TestSelectionSort") peoples := []people{ @@ -113,6 +117,7 @@ func TestSelectionSort(t *testing.T) { } func TestShellSort(t *testing.T) { + t.Parallel() asssert := internal.NewAssert(t, "TestShellSort") peoples := []people{ @@ -132,6 +137,7 @@ func TestShellSort(t *testing.T) { } func TestQuickSort(t *testing.T) { + t.Parallel() asssert := internal.NewAssert(t, "TestQuickSort") peoples := []people{ @@ -151,6 +157,7 @@ func TestQuickSort(t *testing.T) { } func TestHeapSort(t *testing.T) { + t.Parallel() asssert := internal.NewAssert(t, "TestHeapSort") peoples := []people{ @@ -170,6 +177,7 @@ func TestHeapSort(t *testing.T) { } func TestMergeSort(t *testing.T) { + t.Parallel() asssert := internal.NewAssert(t, "TestMergeSort") peoples := []people{ @@ -189,6 +197,7 @@ func TestMergeSort(t *testing.T) { } func TestCountSort(t *testing.T) { + t.Parallel() asssert := internal.NewAssert(t, "TestCountSort") peoples := []people{ diff --git a/compare/compare_test.go b/compare/compare_test.go index 94f4b54..c3c1a15 100644 --- a/compare/compare_test.go +++ b/compare/compare_test.go @@ -8,6 +8,7 @@ import ( ) func TestEqual(t *testing.T) { + t.Parallel() assert := internal.NewAssert(t, "TestEqual") assert.Equal(true, Equal(1, 1)) @@ -60,6 +61,7 @@ func TestEqual(t *testing.T) { } func TestEqualValue(t *testing.T) { + t.Parallel() assert := internal.NewAssert(t, "TestEqualValue") assert.Equal(true, EqualValue(1, 1)) @@ -70,6 +72,7 @@ func TestEqualValue(t *testing.T) { } func TestLessThan(t *testing.T) { + t.Parallel() assert := internal.NewAssert(t, "TestLessThan") assert.Equal(true, LessThan(1, 2)) @@ -85,6 +88,7 @@ func TestLessThan(t *testing.T) { } func TestGreaterThan(t *testing.T) { + t.Parallel() assert := internal.NewAssert(t, "TestGreaterThan") assert.Equal(true, GreaterThan(2, 1)) @@ -101,6 +105,7 @@ func TestGreaterThan(t *testing.T) { } func TestLessOrEqual(t *testing.T) { + t.Parallel() assert := internal.NewAssert(t, "TestLessOrEqual") assert.Equal(true, LessOrEqual(1, 2)) @@ -117,6 +122,7 @@ func TestLessOrEqual(t *testing.T) { } func TestGreaterOrEqual(t *testing.T) { + t.Parallel() assert := internal.NewAssert(t, "TestGreaterThan") assert.Equal(true, GreaterOrEqual(2, 1)) diff --git a/concurrency/channel_test.go b/concurrency/channel_test.go index 83df873..e977bcf 100644 --- a/concurrency/channel_test.go +++ b/concurrency/channel_test.go @@ -9,6 +9,7 @@ import ( ) func TestGenerate(t *testing.T) { + t.Parallel() assert := internal.NewAssert(t, "TestGenerate") ctx, cancel := context.WithCancel(context.Background()) @@ -23,6 +24,7 @@ func TestGenerate(t *testing.T) { } func TestRepeat(t *testing.T) { + t.Parallel() assert := internal.NewAssert(t, "TestRepeat") ctx, cancel := context.WithCancel(context.Background()) @@ -39,6 +41,7 @@ func TestRepeat(t *testing.T) { } func TestRepeatFn(t *testing.T) { + t.Parallel() assert := internal.NewAssert(t, "TestRepeatFn") ctx, cancel := context.WithCancel(context.Background()) @@ -57,6 +60,7 @@ func TestRepeatFn(t *testing.T) { } func TestTake(t *testing.T) { + t.Parallel() assert := internal.NewAssert(t, "TestTake") ctx, cancel := context.WithCancel(context.Background()) @@ -79,6 +83,7 @@ func TestTake(t *testing.T) { } func TestFanIn(t *testing.T) { + t.Parallel() assert := internal.NewAssert(t, "TestFanIn") ctx, cancel := context.WithCancel(context.Background()) @@ -101,6 +106,7 @@ func TestFanIn(t *testing.T) { } func TestOr(t *testing.T) { + t.Parallel() assert := internal.NewAssert(t, "TestOr") sig := func(after time.Duration) <-chan any { @@ -127,6 +133,7 @@ func TestOr(t *testing.T) { } func TestOrDone(t *testing.T) { + t.Parallel() assert := internal.NewAssert(t, "TestOrDone") ctx, cancel := context.WithCancel(context.Background()) @@ -141,6 +148,7 @@ func TestOrDone(t *testing.T) { } func TestTee(t *testing.T) { + t.Parallel() assert := internal.NewAssert(t, "TestTee") ctx, cancel := context.WithCancel(context.Background()) @@ -159,6 +167,7 @@ func TestTee(t *testing.T) { } func TestBridge(t *testing.T) { + t.Parallel() assert := internal.NewAssert(t, "TestBridge") ctx, cancel := context.WithCancel(context.Background()) diff --git a/condition/condition_test.go b/condition/condition_test.go index 821b9f9..b8446bc 100644 --- a/condition/condition_test.go +++ b/condition/condition_test.go @@ -11,6 +11,8 @@ import ( type TestStruct struct{} func TestBool(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestBool") // bool @@ -63,6 +65,8 @@ func TestBool(t *testing.T) { } func TestAnd(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestAnd") assert.Equal(false, And(0, 1)) assert.Equal(false, And(0, "")) @@ -71,6 +75,8 @@ func TestAnd(t *testing.T) { } func TestOr(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestOr") assert.Equal(false, Or(0, "")) assert.Equal(true, Or(0, 1)) @@ -79,6 +85,8 @@ func TestOr(t *testing.T) { } func TestXor(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestOr") assert.Equal(false, Xor(0, 0)) assert.Equal(true, Xor(0, 1)) @@ -87,6 +95,8 @@ func TestXor(t *testing.T) { } func TestNor(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestNor") assert.Equal(true, Nor(0, 0)) assert.Equal(false, Nor(0, 1)) @@ -95,6 +105,8 @@ func TestNor(t *testing.T) { } func TestXnor(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestXnor") assert.Equal(true, Xnor(0, 0)) assert.Equal(false, Xnor(0, 1)) @@ -103,6 +115,8 @@ func TestXnor(t *testing.T) { } func TestNand(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestNand") assert.Equal(true, Nand(0, 0)) assert.Equal(true, Nand(0, 1)) @@ -111,7 +125,10 @@ func TestNand(t *testing.T) { } func TestTernaryOperator(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TernaryOperator") + trueValue := "1" falseValue := "0" diff --git a/convertor/convertor_test.go b/convertor/convertor_test.go index dada174..622225f 100644 --- a/convertor/convertor_test.go +++ b/convertor/convertor_test.go @@ -13,6 +13,8 @@ import ( ) func TestToChar(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestToChar") cases := []string{"", "abc", "1 2#3"} @@ -27,6 +29,8 @@ func TestToChar(t *testing.T) { } func TestToChannel(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestToChannel") ch := ToChannel([]int{1, 2, 3}) @@ -39,6 +43,8 @@ func TestToChannel(t *testing.T) { } func TestToBool(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestToBool") cases := []string{"1", "true", "True", "false", "False", "0", "123", "0.0", "abc"} @@ -51,6 +57,8 @@ func TestToBool(t *testing.T) { } func TestToBytes(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestToBytes") cases := []any{ @@ -77,6 +85,8 @@ func TestToBytes(t *testing.T) { } func TestToInt(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestToInt") cases := []any{"123", "-123", 123, @@ -93,6 +103,8 @@ func TestToInt(t *testing.T) { } func TestToFloat(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestToFloat") cases := []any{ @@ -111,6 +123,8 @@ func TestToFloat(t *testing.T) { } func TestToString(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestToString") aMap := make(map[string]int) @@ -146,6 +160,8 @@ func TestToString(t *testing.T) { } } func TestToJson(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestToJson") var aMap = map[string]int{"a": 1, "b": 2, "c": 3} @@ -161,6 +177,8 @@ func TestToJson(t *testing.T) { } func TestToMap(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestToMap") type Message struct { @@ -180,6 +198,8 @@ func TestToMap(t *testing.T) { } func TestStructToMap(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestStructToMap") t.Run("StructToMap", func(_ *testing.T) { @@ -215,6 +235,8 @@ func TestStructToMap(t *testing.T) { } func TestMapToSlice(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestMapToSlice") aMap := map[string]int{"a": 1, "b": 2, "c": 3} @@ -229,6 +251,8 @@ func TestMapToSlice(t *testing.T) { } func TestColorHexToRGB(t *testing.T) { + t.Parallel() + colorHex := "#003366" r, g, b := ColorHexToRGB(colorHex) colorRGB := fmt.Sprintf("%d,%d,%d", r, g, b) @@ -239,6 +263,8 @@ func TestColorHexToRGB(t *testing.T) { } func TestColorRGBToHex(t *testing.T) { + t.Parallel() + r := 0 g := 51 b := 102 @@ -250,6 +276,8 @@ func TestColorRGBToHex(t *testing.T) { } func TestToPointer(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestToPointer") result := ToPointer(123) @@ -257,6 +285,8 @@ func TestToPointer(t *testing.T) { } func TestEncodeByte(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestEncodeByte") byteData, _ := EncodeByte("abc") @@ -266,6 +296,8 @@ func TestEncodeByte(t *testing.T) { } func TestDecodeByte(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestDecodeByte") var obj string @@ -276,6 +308,8 @@ func TestDecodeByte(t *testing.T) { } func TestDeepClone(t *testing.T) { + t.Parallel() + // assert := internal.NewAssert(t, "TestDeepClone") type Struct struct { @@ -319,6 +353,8 @@ func TestDeepClone(t *testing.T) { } func TestCopyProperties(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestCopyProperties") type Disk struct { @@ -371,6 +407,8 @@ func TestCopyProperties(t *testing.T) { } func TestToInterface(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestToInterface") cases := []reflect.Value{ @@ -400,6 +438,7 @@ func TestToInterface(t *testing.T) { } func TestUtf8ToGbk(t *testing.T) { + t.Parallel() assert := internal.NewAssert(t, "TestUtf8ToGbk") utf8Data := []byte("hello") @@ -411,6 +450,7 @@ func TestUtf8ToGbk(t *testing.T) { } func TestGbkToUtf8(t *testing.T) { + t.Parallel() assert := internal.NewAssert(t, "TestGbkToUtf8") gbkData, err := Utf8ToGbk([]byte("hello")) diff --git a/cryptor/basic_test.go b/cryptor/basic_test.go index b049820..bc53c3d 100644 --- a/cryptor/basic_test.go +++ b/cryptor/basic_test.go @@ -7,27 +7,37 @@ import ( ) func TestBase64StdEncode(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestBase64StdEncode") assert.Equal("aGVsbG8gd29ybGQ=", Base64StdEncode("hello world")) } func TestBase64StdDecode(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestBase64StdDecode") assert.Equal("hello world", Base64StdDecode("aGVsbG8gd29ybGQ=")) } func TestMd5String(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestMd5String") assert.Equal("5d41402abc4b2a76b9719d911017c592", Md5String("hello")) } func TestMd5Byte(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestMd5Byte") data := []byte{'a'} assert.Equal("0cc175b9c0f1b6a831c399e269772661", Md5Byte(data)) } func TestMd5File(t *testing.T) { + t.Parallel() + fileMd5, err := Md5File("./basic.go") assert := internal.NewAssert(t, "TestMd5File") assert.IsNotNil(fileMd5) @@ -35,11 +45,15 @@ func TestMd5File(t *testing.T) { } func TestHmacMd5(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestHmacMd5") assert.Equal("5f4c9faaff0a1ad3007d9ddc06abe36d", HmacMd5("hello world", "12345")) } func TestHmacSha1(t *testing.T) { + t.Parallel() + s := "hello world" key := "12345" hmacSha1 := HmacSha1(s, key) @@ -50,6 +64,8 @@ func TestHmacSha1(t *testing.T) { } func TestHmacSha256(t *testing.T) { + t.Parallel() + s := "hello world" key := "12345" hmacSha256 := HmacSha256(s, key) @@ -60,6 +76,8 @@ func TestHmacSha256(t *testing.T) { } func TestHmacSha512(t *testing.T) { + t.Parallel() + s := "hello world" key := "12345" hmacSha512 := HmacSha512(s, key) @@ -70,6 +88,8 @@ func TestHmacSha512(t *testing.T) { } func TestSha1(t *testing.T) { + t.Parallel() + s := "hello world" sha1 := Sha1(s) expected := "2aae6c35c94fcfb415dbe95f408b9ce91ee846ed" @@ -79,6 +99,8 @@ func TestSha1(t *testing.T) { } func TestSha256(t *testing.T) { + t.Parallel() + s := "hello world" sha256 := Sha256(s) expected := "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9" @@ -88,6 +110,8 @@ func TestSha256(t *testing.T) { } func TestSha512(t *testing.T) { + t.Parallel() + s := "hello world" sha512 := Sha512(s) expected := "309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f" diff --git a/cryptor/encrypt_test.go b/cryptor/encrypt_test.go index 34efa86..98e92f4 100644 --- a/cryptor/encrypt_test.go +++ b/cryptor/encrypt_test.go @@ -7,6 +7,8 @@ import ( ) func TestAesEcbEncrypt(t *testing.T) { + t.Parallel() + data := "hello world" key := "abcdefghijklmnop" @@ -18,6 +20,8 @@ func TestAesEcbEncrypt(t *testing.T) { } func TestAesCbcEncrypt(t *testing.T) { + t.Parallel() + data := "hello world" key := "abcdefghijklmnop" @@ -29,6 +33,8 @@ func TestAesCbcEncrypt(t *testing.T) { } func TestAesCtrCrypt(t *testing.T) { + t.Parallel() + data := "hello world" key := "abcdefghijklmnop" @@ -40,6 +46,8 @@ func TestAesCtrCrypt(t *testing.T) { } func TestAesCfbEncrypt(t *testing.T) { + t.Parallel() + data := "hello world" key := "abcdefghijklmnop" @@ -51,6 +59,8 @@ func TestAesCfbEncrypt(t *testing.T) { } func TestAesOfbEncrypt(t *testing.T) { + t.Parallel() + data := "hello world" key := "abcdefghijklmnop" @@ -62,6 +72,8 @@ func TestAesOfbEncrypt(t *testing.T) { } func TestDesEcbEncrypt(t *testing.T) { + t.Parallel() + data := "hello world" key := "abcdefgh" @@ -73,6 +85,8 @@ func TestDesEcbEncrypt(t *testing.T) { } func TestDesCbcEncrypt(t *testing.T) { + t.Parallel() + data := "hello world" key := "abcdefgh" @@ -84,6 +98,8 @@ func TestDesCbcEncrypt(t *testing.T) { } func TestDesCtrCrypt(t *testing.T) { + t.Parallel() + data := "hello world" key := "abcdefgh" @@ -95,6 +111,8 @@ func TestDesCtrCrypt(t *testing.T) { } func TestDesCfbEncrypt(t *testing.T) { + t.Parallel() + data := "hello world" key := "abcdefgh" @@ -106,6 +124,8 @@ func TestDesCfbEncrypt(t *testing.T) { } func TestDesOfbEncrypt(t *testing.T) { + t.Parallel() + data := "hello world" key := "abcdefgh" @@ -117,6 +137,8 @@ func TestDesOfbEncrypt(t *testing.T) { } func TestRsaEncrypt(t *testing.T) { + t.Parallel() + err := GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem") if err != nil { t.FailNow() diff --git a/datastructure/hashmap/hashmap_test.go b/datastructure/hashmap/hashmap_test.go index 6f85a0c..9a1c29b 100644 --- a/datastructure/hashmap/hashmap_test.go +++ b/datastructure/hashmap/hashmap_test.go @@ -32,6 +32,8 @@ func TestHashMap_Resize(t *testing.T) { } func TestHashMap_Delete(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestHashMap_Delete") hm := NewHashMap() @@ -44,6 +46,8 @@ func TestHashMap_Delete(t *testing.T) { } func TestHashMap_Contains(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestHashMap_Contains") hm := NewHashMap() @@ -54,6 +58,8 @@ func TestHashMap_Contains(t *testing.T) { } func TestHashMap_KeysValues(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestHashMap_KeysValues") hm := NewHashMap() diff --git a/datastructure/heap/maxheap_test.go b/datastructure/heap/maxheap_test.go index 208ee06..8227711 100644 --- a/datastructure/heap/maxheap_test.go +++ b/datastructure/heap/maxheap_test.go @@ -21,6 +21,8 @@ func (c *intComparator) Compare(v1, v2 any) int { } func TestMaxHeap_BuildMaxHeap(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestMaxHeap_BuildMaxHeap") values := []int{6, 5, 2, 4, 7, 10, 12, 1, 3, 8, 9, 11} @@ -33,6 +35,8 @@ func TestMaxHeap_BuildMaxHeap(t *testing.T) { } func TestMaxHeap_Push(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestMaxHeap_Push") heap := NewMaxHeap[int](&intComparator{}) @@ -51,6 +55,8 @@ func TestMaxHeap_Push(t *testing.T) { } func TestMaxHeap_Pop(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestMaxHeap_Pop") heap := NewMaxHeap[int](&intComparator{}) @@ -70,6 +76,8 @@ func TestMaxHeap_Pop(t *testing.T) { } func TestMaxHeap_Peek(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestMaxHeap_Peek") heap := NewMaxHeap[int](&intComparator{}) diff --git a/datastructure/link/doublylink_test.go b/datastructure/link/doublylink_test.go index 6441ef4..e5f7219 100644 --- a/datastructure/link/doublylink_test.go +++ b/datastructure/link/doublylink_test.go @@ -7,6 +7,8 @@ import ( ) func TestDoublyLink_InsertAtFirst(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestDoublyLink_InsertAtFirst") link := NewDoublyLink[int]() @@ -22,6 +24,8 @@ func TestDoublyLink_InsertAtFirst(t *testing.T) { } func TestDoublyLink_InsertAtTail(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestDoublyLink_InsertAtTail") link := NewDoublyLink[int]() @@ -37,12 +41,12 @@ func TestDoublyLink_InsertAtTail(t *testing.T) { } func TestDoublyLink_InsertAt(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestDoublyLink_InsertAt") link := NewDoublyLink[int]() - link.InsertAt(1, 1) //do nothing - link.InsertAt(0, 1) link.InsertAt(1, 2) link.InsertAt(2, 4) @@ -55,6 +59,8 @@ func TestDoublyLink_InsertAt(t *testing.T) { } func TestDoublyLink_DeleteAtHead(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestDoublyLink_DeleteAtHead") link := NewDoublyLink[int]() @@ -74,6 +80,8 @@ func TestDoublyLink_DeleteAtHead(t *testing.T) { } func TestDoublyLink_DeleteAtTail(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestDoublyLink_DeleteAtTail") link := NewDoublyLink[int]() @@ -93,6 +101,8 @@ func TestDoublyLink_DeleteAtTail(t *testing.T) { } func TestDoublyLink_DeleteAt(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestDoublyLink_DeleteAt") link := NewDoublyLink[int]() @@ -116,6 +126,8 @@ func TestDoublyLink_DeleteAt(t *testing.T) { } func TestDoublyLink_Reverse(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestDoublyLink_Reverse") link := NewDoublyLink[int]() @@ -130,6 +142,8 @@ func TestDoublyLink_Reverse(t *testing.T) { } func TestDoublyLink_GetMiddleNode(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestDoublyLink_GetMiddleNode") link := NewDoublyLink[int]() @@ -149,10 +163,11 @@ func TestDoublyLink_GetMiddleNode(t *testing.T) { } func TestDoublyLink_Clear(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestDoublyLink_Clear") link := NewDoublyLink[int]() - assert.Equal(true, link.IsEmpty()) assert.Equal(0, link.Size()) diff --git a/datastructure/link/singlylink_test.go b/datastructure/link/singlylink_test.go index 062b6d1..d1d29f0 100644 --- a/datastructure/link/singlylink_test.go +++ b/datastructure/link/singlylink_test.go @@ -7,6 +7,8 @@ import ( ) func TestSinglyLink_InsertAtFirst(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSinglyLink_InsertAtFirst") link := NewSinglyLink[int]() @@ -22,6 +24,8 @@ func TestSinglyLink_InsertAtFirst(t *testing.T) { } func TestSinglyLink_InsertAtTail(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSinglyLink_InsertAtTail") link := NewSinglyLink[int]() @@ -37,6 +41,8 @@ func TestSinglyLink_InsertAtTail(t *testing.T) { } func TestSinglyLink_InsertAt(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSinglyLink_InsertAt") link := NewSinglyLink[int]() @@ -57,6 +63,8 @@ func TestSinglyLink_InsertAt(t *testing.T) { } func TestSinglyLink_DeleteAtHead(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSinglyLink_DeleteAtHead") link := NewSinglyLink[int]() @@ -78,10 +86,11 @@ func TestSinglyLink_DeleteAtHead(t *testing.T) { } func TestSinglyLink_DeleteAtTail(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSinglyLink_DeleteAtTail") link := NewSinglyLink[int]() - link.InsertAtTail(1) link.InsertAtTail(2) link.InsertAtTail(3) @@ -96,10 +105,11 @@ func TestSinglyLink_DeleteAtTail(t *testing.T) { } func TestSinglyLink_DeleteValue(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSinglyLink_DeleteValue") link := NewSinglyLink[int]() - link.InsertAtTail(1) link.InsertAtTail(2) link.InsertAtTail(2) @@ -114,10 +124,11 @@ func TestSinglyLink_DeleteValue(t *testing.T) { } func TestSinglyLink_DeleteAt(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSinglyLink_DeleteAt") link := NewSinglyLink[int]() - link.InsertAtTail(1) link.InsertAtTail(2) link.InsertAtTail(3) @@ -136,6 +147,8 @@ func TestSinglyLink_DeleteAt(t *testing.T) { } func TestSinglyLink_Reverse(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSinglyLink_Reverse") link := NewSinglyLink[int]() @@ -149,6 +162,8 @@ func TestSinglyLink_Reverse(t *testing.T) { } func TestSinglyLink_GetMiddleNode(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSinglyLink_GetMiddleNode") link := NewSinglyLink[int]() @@ -163,6 +178,7 @@ func TestSinglyLink_GetMiddleNode(t *testing.T) { link.InsertAtTail(5) link.InsertAtTail(6) link.InsertAtTail(7) + middle2 := link.GetMiddleNode() assert.Equal(4, middle2.Value) } diff --git a/datastructure/list/list_test.go b/datastructure/list/list_test.go index 3a355d4..d553558 100644 --- a/datastructure/list/list_test.go +++ b/datastructure/list/list_test.go @@ -7,6 +7,8 @@ import ( ) func TestListData(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestListData") list := NewList([]int{1, 2, 3}) @@ -14,6 +16,8 @@ func TestListData(t *testing.T) { } func TestValueOf(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestValueOf") list := NewList([]int{1, 2, 3}) @@ -26,6 +30,8 @@ func TestValueOf(t *testing.T) { } func TestIndexOf(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestIndexOf") list := NewList([]int{1, 2, 3}) @@ -37,6 +43,8 @@ func TestIndexOf(t *testing.T) { } func TestIndexOfFunc(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestIndexOf") list := NewList([]int{1, 2, 3}) @@ -48,6 +56,8 @@ func TestIndexOfFunc(t *testing.T) { } func TestLastIndexOf(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestIndexOf") list := NewList([]int{1, 2, 3, 3, 3, 3, 4, 5, 6, 9}) @@ -65,6 +75,8 @@ func TestLastIndexOf(t *testing.T) { } func TestLastIndexOfFunc(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestIndexOf") list := NewList([]int{1, 2, 3, 3, 3, 3, 4, 5, 6, 9}) @@ -82,6 +94,8 @@ func TestLastIndexOfFunc(t *testing.T) { } func TestContain(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestContain") list := NewList([]int{1, 2, 3}) @@ -90,6 +104,8 @@ func TestContain(t *testing.T) { } func TestPush(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestPush") list := NewList([]int{1, 2, 3}) @@ -99,6 +115,8 @@ func TestPush(t *testing.T) { } func TestInsertAtFirst(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestInsertAtFirst") list := NewList([]int{1, 2, 3}) @@ -108,6 +126,8 @@ func TestInsertAtFirst(t *testing.T) { } func TestInsertAtLast(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestInsertAtLast") list := NewList([]int{1, 2, 3}) @@ -117,6 +137,8 @@ func TestInsertAtLast(t *testing.T) { } func TestInsertAt(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestInsertAt") list := NewList([]int{1, 2, 3}) @@ -135,6 +157,8 @@ func TestInsertAt(t *testing.T) { } func TestPopFirst(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestPopFirst") list := NewList([]int{1, 2, 3}) @@ -150,6 +174,8 @@ func TestPopFirst(t *testing.T) { } func TestPopLast(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestPopLast") list := NewList([]int{1, 2, 3}) @@ -165,6 +191,8 @@ func TestPopLast(t *testing.T) { } func TestDeleteAt(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestDeleteAt") list := NewList([]int{1, 2, 3, 4}) @@ -183,6 +211,8 @@ func TestDeleteAt(t *testing.T) { } func TestUpdateAt(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestUpdateAt") list := NewList([]int{1, 2, 3, 4}) @@ -201,6 +231,8 @@ func TestUpdateAt(t *testing.T) { } func TestEqual(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestEqual") list1 := NewList([]int{1, 2, 3, 4}) @@ -212,6 +244,8 @@ func TestEqual(t *testing.T) { } func TestIsEmpty(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestIsEmpty") list1 := NewList([]int{1, 2, 3, 4}) @@ -222,6 +256,8 @@ func TestIsEmpty(t *testing.T) { } func TestIsClear(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestIsClear") list1 := NewList([]int{1, 2, 3, 4}) @@ -232,6 +268,8 @@ func TestIsClear(t *testing.T) { } func TestClone(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestClone") list1 := NewList([]int{1, 2, 3, 4}) @@ -241,6 +279,8 @@ func TestClone(t *testing.T) { } func TestMerge(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestMerge") list1 := NewList([]int{1, 2, 3, 4}) @@ -252,6 +292,8 @@ func TestMerge(t *testing.T) { } func TestSize(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSize") list := NewList([]int{1, 2, 3, 4}) @@ -262,6 +304,8 @@ func TestSize(t *testing.T) { } func TestCap(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestCap") data := make([]int, 0, 100) @@ -274,6 +318,8 @@ func TestCap(t *testing.T) { } func TestSwap(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSwap") list := NewList([]int{1, 2, 3, 4}) @@ -285,6 +331,8 @@ func TestSwap(t *testing.T) { } func TestReverse(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestReverse") list := NewList([]int{1, 2, 3, 4}) @@ -296,6 +344,8 @@ func TestReverse(t *testing.T) { } func TestUnique(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestUnique") list := NewList([]int{1, 2, 2, 3, 4}) @@ -307,6 +357,8 @@ func TestUnique(t *testing.T) { } func TestUnion(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestUnion") list1 := NewList([]int{1, 2, 3, 4}) @@ -318,6 +370,8 @@ func TestUnion(t *testing.T) { } func TestIntersection(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestIntersection") list1 := NewList([]int{1, 2, 3, 4}) @@ -329,6 +383,8 @@ func TestIntersection(t *testing.T) { } func TestDifference(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestDifference") list1 := NewList([]int{1, 2, 3}) @@ -340,6 +396,8 @@ func TestDifference(t *testing.T) { } func TestSymmetricDifference(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSymmetricDifference") list1 := NewList([]int{1, 2, 3}) @@ -351,6 +409,8 @@ func TestSymmetricDifference(t *testing.T) { } func TestSubSlice(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSubSlice") list := NewList([]int{1, 2, 3, 4, 5, 8}) @@ -367,6 +427,8 @@ func BenchmarkSubSlice(b *testing.B) { } func TestDeleteIf(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestDeleteIf") list := NewList([]int{1, 1, 1, 1, 2, 3, 1, 1, 4, 1, 1, 1, 1, 1, 1}) @@ -381,10 +443,11 @@ func TestDeleteIf(t *testing.T) { } func TestForEach(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestForEach") list := NewList([]int{1, 2, 3, 4}) - rs := make([]int, 0) list.ForEach(func(i int) { rs = append(rs, i) @@ -394,6 +457,8 @@ func TestForEach(t *testing.T) { } func TestRetainAll(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestRetainAll") list := NewList([]int{1, 2, 3, 4}) @@ -414,6 +479,8 @@ func TestRetainAll(t *testing.T) { } func TestDeleteAll(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestDeleteAll") list := NewList([]int{1, 2, 3, 4}) @@ -433,10 +500,11 @@ func TestDeleteAll(t *testing.T) { } func TestIterator(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestIterator") list := NewList([]int{1, 2, 3, 4}) - iterator := list.Iterator() rs := make([]int, 0) @@ -449,14 +517,15 @@ func TestIterator(t *testing.T) { } func TestListToMap(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "ListToMap") list := NewList([]int{1, 2, 3, 4}) - result := ListToMap(list, func(n int) (int, bool) { return n, n > 1 }) - expected := map[int]bool{1: false, 2: true, 3: true, 4: true} + expected := map[int]bool{1: false, 2: true, 3: true, 4: true} assert.Equal(expected, result) } diff --git a/datastructure/queue/arrayqueue_test.go b/datastructure/queue/arrayqueue_test.go index 97d80d3..91a5ac7 100644 --- a/datastructure/queue/arrayqueue_test.go +++ b/datastructure/queue/arrayqueue_test.go @@ -7,6 +7,8 @@ import ( ) func TestArrayQueue_Enqueue(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestArrayQueue_Enqueue") queue := NewArrayQueue[int](5) @@ -14,15 +16,16 @@ func TestArrayQueue_Enqueue(t *testing.T) { queue.Enqueue(2) queue.Enqueue(3) - expected := []int{1, 2, 3} data := queue.Data() size := queue.Size() - assert.Equal(expected, data) + assert.Equal([]int{1, 2, 3}, data) assert.Equal(3, size) } func TestArrayQueue_Dequeue(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestArrayQueue_Dequeue") queue := NewArrayQueue[int](4) @@ -38,6 +41,8 @@ func TestArrayQueue_Dequeue(t *testing.T) { } func TestArrayQueue_Front(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestArrayQueue_Front") queue := NewArrayQueue[int](4) @@ -52,6 +57,8 @@ func TestArrayQueue_Front(t *testing.T) { } func TestArrayQueue_Back(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestArrayQueue_Back") queue := NewArrayQueue[int](4) @@ -66,6 +73,8 @@ func TestArrayQueue_Back(t *testing.T) { } func TestArrayQueue_Contain(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestArrayQueue_Contain") queue := NewArrayQueue[int](4) @@ -78,6 +87,8 @@ func TestArrayQueue_Contain(t *testing.T) { } func TestArrayQueue_Clear(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestArrayQueue_Clear") queue := NewArrayQueue[int](4) @@ -95,6 +106,8 @@ func TestArrayQueue_Clear(t *testing.T) { } func TestArrayQueue_IsFull(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestArrayQueue_IsFull") queue := NewArrayQueue[int](3) diff --git a/datastructure/queue/circularqueue_test.go b/datastructure/queue/circularqueue_test.go index b12c9cd..e1d386a 100644 --- a/datastructure/queue/circularqueue_test.go +++ b/datastructure/queue/circularqueue_test.go @@ -7,6 +7,8 @@ import ( ) func TestCircularQueue_Enqueue(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestCircularQueue_Enqueue") queue := NewCircularQueue[int](6) @@ -34,6 +36,8 @@ func TestCircularQueue_Enqueue(t *testing.T) { } func TestCircularQueue_Dequeue(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestCircularQueue_DeQueue") queue := NewCircularQueue[int](4) @@ -60,6 +64,8 @@ func TestCircularQueue_Dequeue(t *testing.T) { } func TestCircularQueue_Front(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestCircularQueue_Front") queue := NewCircularQueue[int](6) @@ -80,6 +86,8 @@ func TestCircularQueue_Front(t *testing.T) { } func TestCircularQueue_Back(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestCircularQueue_Back") queue := NewCircularQueue[int](3) @@ -103,6 +111,8 @@ func TestCircularQueue_Back(t *testing.T) { } func TestCircularQueue_Contain(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestCircularQueue_Contain") queue := NewCircularQueue[int](2) @@ -114,6 +124,8 @@ func TestCircularQueue_Contain(t *testing.T) { } func TestCircularQueue_Clear(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestCircularQueue_Clear") queue := NewCircularQueue[int](3) @@ -132,6 +144,8 @@ func TestCircularQueue_Clear(t *testing.T) { } func TestCircularQueue_Data(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestCircularQueue_Data") queue := NewCircularQueue[int](3) diff --git a/datastructure/queue/linkedqueue_test.go b/datastructure/queue/linkedqueue_test.go index cf7a17e..82136dc 100644 --- a/datastructure/queue/linkedqueue_test.go +++ b/datastructure/queue/linkedqueue_test.go @@ -7,6 +7,8 @@ import ( ) func TestLinkedQueue_Enqueue(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestLinkedQueue_Enqueue") queue := NewLinkedQueue[int]() @@ -19,6 +21,8 @@ func TestLinkedQueue_Enqueue(t *testing.T) { } func TestLinkedQueue_Dequeue(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestLinkedQueue_DeQueue") queue := NewLinkedQueue[int]() @@ -35,6 +39,8 @@ func TestLinkedQueue_Dequeue(t *testing.T) { } func TestLinkedQueue_Front(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestLinkedQueue_Front") queue := NewLinkedQueue[int]() @@ -51,6 +57,8 @@ func TestLinkedQueue_Front(t *testing.T) { } func TestLinkedQueue_Back(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestLinkedQueue_Back") queue := NewLinkedQueue[int]() @@ -67,6 +75,8 @@ func TestLinkedQueue_Back(t *testing.T) { } func TestLinkedQueue_Clear(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestLinkedQueue_Back") queue := NewLinkedQueue[int]() @@ -82,10 +92,11 @@ func TestLinkedQueue_Clear(t *testing.T) { } func TestLinkedQueue_Contain(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestLinkedQueue_Contain") queue := NewLinkedQueue[int]() - queue.Enqueue(1) queue.Enqueue(2) queue.Enqueue(3) diff --git a/datastructure/queue/priorityqueue_test.go b/datastructure/queue/priorityqueue_test.go index 92c867d..43b8815 100644 --- a/datastructure/queue/priorityqueue_test.go +++ b/datastructure/queue/priorityqueue_test.go @@ -20,6 +20,8 @@ func (c *intComparator) Compare(v1, v2 any) int { return 0 } func TestPriorityQueue_Enqueue(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestPriorityQueue_Enqueue") comparator := &intComparator{} @@ -45,6 +47,8 @@ func TestPriorityQueue_Enqueue(t *testing.T) { } func TestPriorityQueue_Dequeue(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestPriorityQueue_Dequeue") comparator := &intComparator{} diff --git a/datastructure/set/set_test.go b/datastructure/set/set_test.go index 66c590c..6556ad8 100644 --- a/datastructure/set/set_test.go +++ b/datastructure/set/set_test.go @@ -7,6 +7,8 @@ import ( ) func TestSet_NewSetFromSlice(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSet_NewSetFromSlice") s1 := NewSetFromSlice([]int{1, 2, 2, 3}) @@ -20,17 +22,21 @@ func TestSet_NewSetFromSlice(t *testing.T) { } func TestSet_Add(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSet_Add") set := NewSet[int]() set.Add(1, 2, 3) - expected := NewSet(1, 2, 3) + cmpSet := NewSet(1, 2, 3) - assert.Equal(true, set.Equal(expected)) + assert.Equal(true, set.Equal(cmpSet)) } func TestSet_AddIfNotExist(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSet_AddIfNotExist") set := NewSet[int]() @@ -42,6 +48,8 @@ func TestSet_AddIfNotExist(t *testing.T) { } func TestSet_AddIfNotExistBy(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSet_AddIfNotExistBy") set := NewSet[int]() @@ -63,6 +71,8 @@ func TestSet_AddIfNotExistBy(t *testing.T) { } func TestSet_Contain(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSet_Contain") set := NewSet[int]() @@ -73,6 +83,8 @@ func TestSet_Contain(t *testing.T) { } func TestSet_ContainAll(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSet_ContainAll") set1 := NewSet(1, 2, 3) @@ -84,6 +96,8 @@ func TestSet_ContainAll(t *testing.T) { } func TestSet_Clone(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSet_Clone") set1 := NewSet(1, 2, 3) @@ -94,18 +108,20 @@ func TestSet_Clone(t *testing.T) { } func TestSet_Delete(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSet_Delete") set := NewSet[int]() set.Add(1, 2, 3) set.Delete(3) - expected := NewSet(1, 2) - - assert.Equal(true, set.Equal(expected)) + assert.Equal(true, set.Equal(NewSet(1, 2))) } func TestSet_Equal(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSet_Equal") set1 := NewSet(1, 2, 3) @@ -117,6 +133,8 @@ func TestSet_Equal(t *testing.T) { } func TestSet_Iterate(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSet_Iterate") set := NewSet(1, 2, 3) @@ -129,6 +147,8 @@ func TestSet_Iterate(t *testing.T) { } func TestSet_IsEmpty(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSet_IsEmpty") set := NewSet[int]() @@ -136,6 +156,8 @@ func TestSet_IsEmpty(t *testing.T) { } func TestSet_Size(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSet_Size") set := NewSet(1, 2, 3) @@ -143,6 +165,8 @@ func TestSet_Size(t *testing.T) { } func TestSet_Values(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSet_Values") set := NewSet(1, 2, 3) @@ -152,28 +176,33 @@ func TestSet_Values(t *testing.T) { } func TestSet_Union(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSet_Union") set1 := NewSet(1, 2, 3) set2 := NewSet(2, 3, 4, 5) - expected := NewSet(1, 2, 3, 4, 5) + unionSet := set1.Union(set2) - assert.Equal(expected, unionSet) + assert.Equal(NewSet(1, 2, 3, 4, 5), unionSet) } func TestSet_Intersection(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSet_Intersection") set1 := NewSet(1, 2, 3) set2 := NewSet(2, 3, 4, 5) - expected := NewSet(2, 3) intersectionSet := set1.Intersection(set2) - assert.Equal(expected, intersectionSet) + assert.Equal(NewSet(2, 3), intersectionSet) } func TestSet_SymmetricDifference(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSet_SymmetricDifference") set1 := NewSet(1, 2, 3) @@ -183,6 +212,8 @@ func TestSet_SymmetricDifference(t *testing.T) { } func TestSet_Minus(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSet_Minus") set1 := NewSet(1, 2, 3) diff --git a/datastructure/stack/arraystack_test.go b/datastructure/stack/arraystack_test.go index 7fca175..4bf6543 100644 --- a/datastructure/stack/arraystack_test.go +++ b/datastructure/stack/arraystack_test.go @@ -7,6 +7,8 @@ import ( ) func TestArrayStack_Push(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestArrayStack_Push") stack := NewArrayStack[int]() @@ -14,15 +16,16 @@ func TestArrayStack_Push(t *testing.T) { stack.Push(2) stack.Push(3) - expected := []int{3, 2, 1} values := stack.Data() length := stack.Size() - assert.Equal(expected, values) + assert.Equal([]int{3, 2, 1}, values) assert.Equal(3, length) } func TestArrayStack_Pop(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestArrayStack_Pop") stack := NewArrayStack[int]() @@ -37,11 +40,12 @@ func TestArrayStack_Pop(t *testing.T) { assert.IsNil(err) assert.Equal(3, *topItem) - expected := []int{2, 1} - assert.Equal(expected, stack.Data()) + assert.Equal([]int{2, 1}, stack.Data()) } func TestArrayStack_Peak(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestArrayStack_Peak") stack := NewArrayStack[int]() @@ -56,11 +60,12 @@ func TestArrayStack_Peak(t *testing.T) { assert.IsNil(err) assert.Equal(3, *topItem) - expected := []int{3, 2, 1} - assert.Equal(expected, stack.Data()) + assert.Equal([]int{3, 2, 1}, stack.Data()) } func TestArrayStack_Clear(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestArrayStack_Clear") stack := NewArrayStack[int]() diff --git a/datastructure/stack/linkedstack_test.go b/datastructure/stack/linkedstack_test.go index 6a70603..c80b3c9 100644 --- a/datastructure/stack/linkedstack_test.go +++ b/datastructure/stack/linkedstack_test.go @@ -7,6 +7,8 @@ import ( ) func TestLinkedStack_Push(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestLinkedStack_Push") stack := NewLinkedStack[int]() @@ -14,15 +16,16 @@ func TestLinkedStack_Push(t *testing.T) { stack.Push(2) stack.Push(3) - expected := []int{3, 2, 1} values := stack.Data() size := stack.Size() - assert.Equal(expected, values) + assert.Equal([]int{3, 2, 1}, values) assert.Equal(3, size) } func TestLinkedStack_Pop(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestLinkedStack_Pop") stack := NewLinkedStack[int]() @@ -37,12 +40,13 @@ func TestLinkedStack_Pop(t *testing.T) { assert.IsNil(err) assert.Equal(3, *topItem) - expected := []int{2, 1} stack.Print() - assert.Equal(expected, stack.Data()) + assert.Equal([]int{2, 1}, stack.Data()) } func TestLinkedStack_Peak(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestLinkedStack_Peak") stack := NewLinkedStack[int]() @@ -57,11 +61,12 @@ func TestLinkedStack_Peak(t *testing.T) { assert.IsNil(err) assert.Equal(3, *topItem) - expected := []int{3, 2, 1} - assert.Equal(expected, stack.Data()) + assert.Equal([]int{3, 2, 1}, stack.Data()) } func TestLinkedStack_Empty(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestLinkedStack_Empty") stack := NewLinkedStack[int]() diff --git a/datastructure/tree/bstree_test.go b/datastructure/tree/bstree_test.go index 4711e04..6d22890 100644 --- a/datastructure/tree/bstree_test.go +++ b/datastructure/tree/bstree_test.go @@ -20,16 +20,9 @@ func (c *intComparator) Compare(v1, v2 any) int { return 0 } -func TestBSTree_Insert(t *testing.T) { - bstree := NewBSTree(6, &intComparator{}) - - bstree.Insert(7) - bstree.Insert(5) - bstree.Insert(2) - bstree.Insert(4) -} - func TestBSTree_PreOrderTraverse(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestBSTree_PreOrderTraverse") bstree := NewBSTree(6, &intComparator{}) @@ -44,6 +37,8 @@ func TestBSTree_PreOrderTraverse(t *testing.T) { } func TestBSTree_PostOrderTraverse(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestBSTree_PostOrderTraverse") bstree := NewBSTree(6, &intComparator{}) @@ -58,6 +53,8 @@ func TestBSTree_PostOrderTraverse(t *testing.T) { } func TestBSTree_InOrderTraverse(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestBSTree_InOrderTraverse") bstree := NewBSTree(6, &intComparator{}) @@ -72,6 +69,8 @@ func TestBSTree_InOrderTraverse(t *testing.T) { } func TestBSTree_LevelOrderTraverse(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestBSTree_LevelOrderTraverse") bstree := NewBSTree(6, &intComparator{}) @@ -86,6 +85,8 @@ func TestBSTree_LevelOrderTraverse(t *testing.T) { } func TestBSTree_Delete(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestBSTree_Delete") bstree := NewBSTree(6, &intComparator{}) @@ -108,6 +109,8 @@ func TestBSTree_Delete(t *testing.T) { } func TestBSTree_Depth(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestBSTree_Depth") bstree := NewBSTree(6, &intComparator{}) @@ -121,6 +124,8 @@ func TestBSTree_Depth(t *testing.T) { } func TestBSTree_IsSubTree(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestBSTree_IsSubTree") superTree := NewBSTree(8, &intComparator{}) diff --git a/datetime/conversion_test.go b/datetime/conversion_test.go index 5a09ff4..b1d0537 100644 --- a/datetime/conversion_test.go +++ b/datetime/conversion_test.go @@ -7,6 +7,8 @@ import ( ) func TestToUnix(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestToUnix") tm1 := NewUnixNow() @@ -17,6 +19,8 @@ func TestToUnix(t *testing.T) { } func TestToFormat(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestToFormat") tm, err := NewFormat("2022-03-18 17:04:05") @@ -25,18 +29,21 @@ func TestToFormat(t *testing.T) { } func TestToFormatForTpl(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestToFormatForTpl") _, err := NewFormat("2022/03/18 17:04:05") assert.IsNotNil(err) tm, err := NewFormat("2022-03-18 17:04:05") - // assert.Equal("2022/03/18 17:04:05", tm.ToFormatForTpl("2006/01/02 15:04:05")) t.Log("TestToFormatForTpl", tm.ToFormatForTpl("2006/01/02 15:04:05")) assert.IsNil(err) } func TestToIso8601(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestToIso8601") _, err := NewISO8601("2022-03-18 17:04:05") @@ -44,6 +51,5 @@ func TestToIso8601(t *testing.T) { tm, err := NewISO8601("2006-01-02T15:04:05.999Z") t.Log("TestToIso8601", tm.ToIso8601()) - // assert.Equal("2006-01-02T23:04:05+08:00", tm.ToIso8601()) assert.IsNil(err) } diff --git a/datetime/datetime_test.go b/datetime/datetime_test.go index 61232d0..803c177 100644 --- a/datetime/datetime_test.go +++ b/datetime/datetime_test.go @@ -8,6 +8,8 @@ import ( ) func TestAddYear(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestAddDay") now := time.Now() @@ -21,6 +23,8 @@ func TestAddYear(t *testing.T) { } func TestBetweenSeconds(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestBetweenSeconds") today := time.Now() @@ -35,6 +39,8 @@ func TestBetweenSeconds(t *testing.T) { } func TestAddDay(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestAddDay") now := time.Now() @@ -48,6 +54,8 @@ func TestAddDay(t *testing.T) { } func TestAddHour(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestAddHour") now := time.Now() @@ -61,6 +69,8 @@ func TestAddHour(t *testing.T) { } func TestAddMinute(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestAddMinute") now := time.Now() @@ -74,36 +84,48 @@ func TestAddMinute(t *testing.T) { } func TestGetNowDate(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestGetNowDate") expected := time.Now().Format("2006-01-02") assert.Equal(expected, GetNowDate()) } func TestGetNowTime(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestGetNowTime") expected := time.Now().Format("15:04:05") assert.Equal(expected, GetNowTime()) } func TestGetNowDateTime(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestGetNowDateTime") expected := time.Now().Format("2006-01-02 15:04:05") assert.Equal(expected, GetNowDateTime()) } func TestGetTodayStartTime(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestGetTodayStartTime") expected := time.Now().Format("2006-01-02") + " 00:00:00" assert.Equal(expected, GetTodayStartTime()) } func TestGetTodayEndTime(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestGetTodayEndTime") expected := time.Now().Format("2006-01-02") + " 23:59:59" assert.Equal(expected, GetTodayEndTime()) } func TestFormatTimeToStr(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestFormatTimeToStr") datetime, _ := time.Parse("2006-01-02 15:04:05", "2021-01-02 16:04:08") @@ -128,6 +150,8 @@ func TestFormatTimeToStr(t *testing.T) { } func TestFormatStrToTime(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestFormatStrToTime") formats := []string{ @@ -155,6 +179,8 @@ func TestFormatStrToTime(t *testing.T) { } func TestBeginOfMinute(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestBeginOfMinute") expected := time.Date(2022, 2, 15, 15, 48, 0, 0, time.Local) @@ -165,6 +191,8 @@ func TestBeginOfMinute(t *testing.T) { } func TestEndOfMinute(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestEndOfMinute") expected := time.Date(2022, 2, 15, 15, 48, 59, 999999999, time.Local) @@ -175,6 +203,8 @@ func TestEndOfMinute(t *testing.T) { } func TestBeginOfHour(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestBeginOfHour") expected := time.Date(2022, 2, 15, 15, 0, 0, 0, time.Local) @@ -185,6 +215,8 @@ func TestBeginOfHour(t *testing.T) { } func TestEndOfHour(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestEndOfHour") expected := time.Date(2022, 2, 15, 15, 59, 59, 999999999, time.Local) @@ -195,6 +227,8 @@ func TestEndOfHour(t *testing.T) { } func TestBeginOfDay(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestBeginOfDay") expected := time.Date(2022, 2, 15, 0, 0, 0, 0, time.Local) @@ -205,6 +239,8 @@ func TestBeginOfDay(t *testing.T) { } func TestEndOfDay(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestEndOfDay") expected := time.Date(2022, 2, 15, 23, 59, 59, 999999999, time.Local) @@ -215,6 +251,8 @@ func TestEndOfDay(t *testing.T) { } func TestBeginOfWeek(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestBeginOfWeek") expected := time.Date(2022, 2, 13, 0, 0, 0, 0, time.Local) @@ -225,6 +263,8 @@ func TestBeginOfWeek(t *testing.T) { } func TestEndOfWeek(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestEndOfWeek") expected := time.Date(2022, 2, 19, 23, 59, 59, 999999999, time.Local) @@ -235,6 +275,8 @@ func TestEndOfWeek(t *testing.T) { } func TestBeginOfMonth(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestBeginOfMonth") expected := time.Date(2022, 2, 1, 0, 0, 0, 0, time.Local) @@ -245,6 +287,8 @@ func TestBeginOfMonth(t *testing.T) { } func TestEndOfMonth(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestEndOfMonth") expected := time.Date(2022, 2, 28, 23, 59, 59, 999999999, time.Local) @@ -255,6 +299,8 @@ func TestEndOfMonth(t *testing.T) { } func TestBeginOfYear(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestBeginOfYear") expected := time.Date(2022, 1, 1, 0, 0, 0, 0, time.Local) @@ -265,6 +311,8 @@ func TestBeginOfYear(t *testing.T) { } func TestEndOfYear(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestEndOfYear") expected := time.Date(2022, 12, 31, 23, 59, 59, 999999999, time.Local) @@ -275,6 +323,8 @@ func TestEndOfYear(t *testing.T) { } func TestIsLeapYear(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestEndOfYear") result1 := IsLeapYear(2000) @@ -285,6 +335,8 @@ func TestIsLeapYear(t *testing.T) { } func TestDayOfYear(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestDayOfYear") date1 := time.Date(2023, 02, 01, 1, 1, 1, 0, time.Local) result1 := DayOfYear(date1) @@ -300,7 +352,10 @@ func TestDayOfYear(t *testing.T) { } func TestIsWeekend(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestIsWeekend") + date := time.Date(2023, 06, 03, 0, 0, 0, 0, time.Local) result := IsWeekend(date) assert.Equal(true, result) @@ -312,5 +367,4 @@ func TestIsWeekend(t *testing.T) { date2 := time.Date(2023, 06, 02, 0, 0, 0, 0, time.Local) result2 := IsWeekend(date2) assert.Equal(false, result2) - } diff --git a/fileutil/file_test.go b/fileutil/file_test.go index 845a590..70f907d 100644 --- a/fileutil/file_test.go +++ b/fileutil/file_test.go @@ -8,6 +8,8 @@ import ( ) func TestIsExist(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestIsExist") cases := []string{"./", "./file.go", "./a.txt"} @@ -20,6 +22,8 @@ func TestIsExist(t *testing.T) { } func TestCreateFile(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestCreateFile") f := "./text.txt" @@ -36,6 +40,8 @@ func TestCreateFile(t *testing.T) { } func TestCreateDir(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestCreateDir") pwd, err := os.Getwd() @@ -57,6 +63,8 @@ func TestCreateDir(t *testing.T) { } func TestIsDir(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestIsDir") cases := []string{"./", "./a.txt"} @@ -69,6 +77,8 @@ func TestIsDir(t *testing.T) { } func TestRemoveFile(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestRemoveFile") f := "./text.txt" if !IsExist(f) { diff --git a/formatter/byte_test.go b/formatter/byte_test.go index b4eac59..fb9a618 100644 --- a/formatter/byte_test.go +++ b/formatter/byte_test.go @@ -7,6 +7,8 @@ import ( ) func TestDecimalBytes(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestDecimalBytes") assert.Equal("1KB", DecimalBytes(1000)) @@ -21,6 +23,8 @@ func TestDecimalBytes(t *testing.T) { } func TestBinaryBytes(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestBinaryBytes") assert.Equal("1KiB", BinaryBytes(1024)) @@ -30,6 +34,8 @@ func TestBinaryBytes(t *testing.T) { } func TestParseDecimalBytes(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestParseDecimalBytes") cases := map[string]uint64{ @@ -58,6 +64,8 @@ func TestParseDecimalBytes(t *testing.T) { } func TestParseBinaryBytes(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestParseBinaryBytes") cases := map[string]uint64{ diff --git a/formatter/formatter_test.go b/formatter/formatter_test.go index a92a72d..fd3ce9a 100644 --- a/formatter/formatter_test.go +++ b/formatter/formatter_test.go @@ -8,6 +8,8 @@ import ( ) func TestComma(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestComma") assert.Equal("", Comma("", "")) @@ -29,6 +31,8 @@ func TestComma(t *testing.T) { } func TestPretty(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestPretty") cases := []any{ @@ -60,6 +64,8 @@ func TestPretty(t *testing.T) { } func TestPrettyToWriter(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestPrettyToWriter") type User struct { diff --git a/function/function_test.go b/function/function_test.go index a58edd2..4b62947 100644 --- a/function/function_test.go +++ b/function/function_test.go @@ -11,6 +11,8 @@ import ( ) func TestAfter(t *testing.T) { + t.Parallel() + arr := []string{"a", "b"} f := After(len(arr), func(i int) int { fmt.Println("print done") @@ -34,6 +36,8 @@ func TestAfter(t *testing.T) { } func TestBefore(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestBefore") arr := []string{"a", "b", "c", "d", "e"} @@ -57,6 +61,8 @@ func TestBefore(t *testing.T) { } func TestCurry(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestCurry") add := func(a, b int) int { @@ -71,6 +77,8 @@ func TestCurry(t *testing.T) { } func TestCompose(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestCompose") toUpper := func(strs ...string) string { diff --git a/function/watcher_test.go b/function/watcher_test.go index d278bd2..3bc4407 100644 --- a/function/watcher_test.go +++ b/function/watcher_test.go @@ -7,6 +7,8 @@ import ( ) func TestWatcher(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestWatcher") w := NewWatcher() diff --git a/iterator/iterator_test.go b/iterator/iterator_test.go index b29cae9..726175b 100644 --- a/iterator/iterator_test.go +++ b/iterator/iterator_test.go @@ -12,6 +12,8 @@ import ( ) func TestSliceIterator(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestSliceIterator") // HashNext @@ -60,6 +62,8 @@ func TestSliceIterator(t *testing.T) { } func TestRangeIterator(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestRangeIterator") t.Run("range iterator: ", func(t *testing.T) { @@ -85,6 +89,8 @@ func TestRangeIterator(t *testing.T) { } func TestChannelIterator(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestRangeIterator") iter := FromSlice([]int{1, 2, 3, 4}) diff --git a/iterator/operation_test.go b/iterator/operation_test.go index b9052aa..4c2517e 100644 --- a/iterator/operation_test.go +++ b/iterator/operation_test.go @@ -17,6 +17,8 @@ import ( ) func TestMapIterator(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestMapIterator") iter := FromSlice([]int{1, 2, 3, 4}) @@ -28,6 +30,8 @@ func TestMapIterator(t *testing.T) { } func TestFilterIterator(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestFilterIterator") iter := FromSlice([]int{1, 2, 3, 4}) @@ -39,6 +43,8 @@ func TestFilterIterator(t *testing.T) { } func TestJoinIterator(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestJoinIterator") iter1 := FromSlice([]int{1, 2}) @@ -54,6 +60,8 @@ func TestJoinIterator(t *testing.T) { } func TestReduce(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestReduce") iter := FromSlice([]int{1, 2, 3, 4}) @@ -62,6 +70,8 @@ func TestReduce(t *testing.T) { } func TestTakeIterator(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestTakeIterator") iter := FromSlice([]int{1, 2, 3, 4, 5}) diff --git a/maputil/map_test.go b/maputil/map_test.go index 13f62d4..c1718e1 100644 --- a/maputil/map_test.go +++ b/maputil/map_test.go @@ -9,6 +9,8 @@ import ( ) func TestKeys(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestKeys") m := map[int]string{ @@ -26,6 +28,8 @@ func TestKeys(t *testing.T) { } func TestValues(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestValues") m := map[int]string{ @@ -43,6 +47,8 @@ func TestValues(t *testing.T) { } func TestKeysBy(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestKeysBy") m := map[int]string{ @@ -61,6 +67,8 @@ func TestKeysBy(t *testing.T) { } func TestValuesBy(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestValuesBy") m := map[int]string{ @@ -88,6 +96,8 @@ func TestValuesBy(t *testing.T) { } func TestMerge(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestMerge") m1 := map[int]string{ @@ -110,6 +120,8 @@ func TestMerge(t *testing.T) { } func TestForEach(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestForEach") m := map[string]int{ @@ -129,6 +141,8 @@ func TestForEach(t *testing.T) { } func TestFilter(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestFilter") m := map[string]int{ @@ -151,6 +165,8 @@ func TestFilter(t *testing.T) { } func TestFilterByKeys(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestFilterByKeys") m := map[string]int{ @@ -170,6 +186,8 @@ func TestFilterByKeys(t *testing.T) { } func TestFilterByValues(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestFilterByValues") m := map[string]int{ @@ -189,6 +207,8 @@ func TestFilterByValues(t *testing.T) { } func TestOmitBy(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestOmitBy") m := map[string]int{ @@ -212,6 +232,8 @@ func TestOmitBy(t *testing.T) { } func TestOmitByKeys(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestOmitByKeys") m := map[string]int{ @@ -232,6 +254,8 @@ func TestOmitByKeys(t *testing.T) { } func TestOmitByValues(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestOmitByValues") m := map[string]int{ @@ -252,6 +276,8 @@ func TestOmitByValues(t *testing.T) { } func TestIntersect(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestIntersect") m1 := map[string]int{ @@ -279,6 +305,8 @@ func TestIntersect(t *testing.T) { } func TestMinus(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestMinus") m1 := map[string]int{ @@ -297,6 +325,8 @@ func TestMinus(t *testing.T) { } func TestIsDisjoint(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestMinus") m1 := map[string]int{ @@ -319,6 +349,8 @@ func TestIsDisjoint(t *testing.T) { } func TestEntries(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestEntries") m := map[string]int{ @@ -339,6 +371,8 @@ func TestEntries(t *testing.T) { } func TestFromEntries(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestFromEntries") result := FromEntries([]Entry[string, int]{ @@ -354,6 +388,8 @@ func TestFromEntries(t *testing.T) { } func TestTransform(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestTransform") m := map[string]int{ @@ -376,6 +412,8 @@ func TestTransform(t *testing.T) { } func TestMapKeys(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestMapKeys") m := map[int]string{ @@ -398,6 +436,8 @@ func TestMapKeys(t *testing.T) { } func TestMapValues(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestMapKeys") m := map[int]string{ diff --git a/maputil/typemap_test.go b/maputil/typemap_test.go index 356453a..5c42fbf 100644 --- a/maputil/typemap_test.go +++ b/maputil/typemap_test.go @@ -21,6 +21,8 @@ type ( ) func TestStructType(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestStructType") src := map[string]interface{}{ @@ -44,6 +46,8 @@ func TestStructType(t *testing.T) { } func TestBaseType(t *testing.T) { + t.Parallel() + assert := internal.NewAssert(t, "TestBaseType") tc := map[string]interface{}{ @@ -90,22 +94,31 @@ func TestBaseType(t *testing.T) { MapTo(tc["i"], &number) assert.EqualValues(-1, number) + MapTo(tc["i8"], &number) assert.EqualValues(-8, number) + MapTo(tc["i16"], &number) assert.EqualValues(-16, number) + MapTo(tc["i32"], &number) assert.EqualValues(-32, number) + MapTo(tc["i64"], &number) assert.EqualValues(-64, number) + MapTo(tc["u"], &number) assert.EqualValues(1, number) + MapTo(tc["u8"], &number) assert.EqualValues(8, number) + MapTo(tc["u16"], &number) assert.EqualValues(16, number) + MapTo(tc["u32"], &number) assert.EqualValues(32, number) + MapTo(tc["u64"], &number) assert.EqualValues(64, number) }