[feature] add annotations for all assertion methods to allow users to see method documentations on hover (#7)

Author: golanglibs

README.md

@@ -45,7 +45,7 @@ func Test_1Plus1ShouldEqual2(t *testing.T) {
 * `NotNil` - asserts the value is not nil
 * `EqualSlice` - asserts two slices have the same values in the same order. The elements must be comparable
 * `NotEqualSlice` - asserts two slices do not have the same values in the same order. The elements must be comparable
-* `SimilarSlice` - asserts two slices have the same values in either different or same order. The elements must be comparable
+* `SimilarSlice` - asserts two slices have the same values in any order. The elements must be comparable
 * `NotSimilarSlice` - asserts two slices do not have the same values. The elements must be comparable
 * `EqualMap` - asserts two maps have same key-value pairs. The values must be comparable
 * `NotEqualMap` - asserts two maps do not have same key-value pairs. The values must be comparable

assert_collections.go

@@ -2,6 +2,9 @@ package goassert
 
 import "testing"
 
+/*
+Asserts that the given slice is empty. The assertion fails if the given slice is nil
+*/
 func EmptySlice[T any](t testing.TB, s []T) {
 	t.Helper()
 
@@ -16,6 +19,9 @@ func EmptySlice[T any](t testing.TB, s []T) {
 	}
 }
 
+/*
+Asserts that the given slice is not nil or empty
+*/
 func NotEmptySlice[T any](t testing.TB, s []T) {
 	t.Helper()
 
@@ -29,6 +35,9 @@ func NotEmptySlice[T any](t testing.TB, s []T) {
 	}
 }
 
+/*
+Asserts that the given slice has length equal to the specified expected length
+*/
 func SliceLength[T any](t testing.TB, s []T, expectedLength int) {
 	t.Helper()
 
@@ -38,6 +47,9 @@ func SliceLength[T any](t testing.TB, s []T, expectedLength int) {
 	}
 }
 
+/*
+Asserts that the given slice contains the given element. The element must be [comparable]
+*/
 func SliceContains[K comparable](t testing.TB, s []K, element K) {
 	t.Helper()
 
@@ -46,6 +58,9 @@ func SliceContains[K comparable](t testing.TB, s []K, element K) {
 	}
 }
 
+/*
+Asserts that the given slice does not contain the given element. The element must be [comparable]
+*/
 func SliceNotContains[K comparable](t testing.TB, s []K, element K) {
 	t.Helper()
 
@@ -64,6 +79,9 @@ func sliceContains[K comparable](s []K, element K) bool {
 	return false
 }
 
+/*
+Asserts that the given map is empty. The assertion will fail if the given map is nil
+*/
 func EmptyMap[K comparable, V any](t testing.TB, m map[K]V) {
 	t.Helper()
 
@@ -78,6 +96,9 @@ func EmptyMap[K comparable, V any](t testing.TB, m map[K]V) {
 	}
 }
 
+/*
+Asserts that the given map is not nil or empty
+*/
 func NotEmptyMap[K comparable, V any](t testing.TB, m map[K]V) {
 	t.Helper()
 
@@ -91,6 +112,9 @@ func NotEmptyMap[K comparable, V any](t testing.TB, m map[K]V) {
 	}
 }
 
+/*
+Asserts that the given map has length equal to the specified length
+*/
 func MapLength[K comparable, V any](t testing.TB, m map[K]V, expectedLength int) {
 	t.Helper()
 
@@ -100,6 +124,9 @@ func MapLength[K comparable, V any](t testing.TB, m map[K]V, expectedLength int)
 	}
 }
 
+/*
+Asserts that the given map contains the given key-value pair. The key and value must be [comparable]
+*/
 func MapContains[K, V comparable](t testing.TB, m map[K]V, k K, v V) {
 	t.Helper()
 
@@ -115,6 +142,9 @@ func MapContains[K, V comparable](t testing.TB, m map[K]V, k K, v V) {
 	}
 }
 
+/*
+Asserts that the given map does not contain the given key-value pair. The key and value must be [comparable]
+*/
 func MapNotContains[K, V comparable](t testing.TB, m map[K]V, k K, v V) {
 	t.Helper()
 

assert_equality.go

@@ -5,6 +5,9 @@ import (
 	"testing"
 )
 
+/*
+Asserts that the two given values are equal. The given values must be [comparable]
+*/
 func Equal[K comparable](t testing.TB, expected K, actual K) {
 	t.Helper()
 
@@ -13,6 +16,9 @@ func Equal[K comparable](t testing.TB, expected K, actual K) {
 	}
 }
 
+/*
+Asserts that the two given values are not equal. The given values must be [comparable]
+*/
 func NotEqual[K comparable](t testing.TB, expected K, actual K) {
 	t.Helper()
 
@@ -21,6 +27,9 @@ func NotEqual[K comparable](t testing.TB, expected K, actual K) {
 	}
 }
 
+/*
+Asserts that the given value is nil
+*/
 func Nil(t testing.TB, actual interface{}) {
 	t.Helper()
 
@@ -29,6 +38,9 @@ func Nil(t testing.TB, actual interface{}) {
 	}
 }
 
+/*
+Asserts that the given value is not nil
+*/
 func NotNil(t testing.TB, actual interface{}) {
 	t.Helper()
 
@@ -50,6 +62,9 @@ func isNil(value interface{}) bool {
 	return false
 }
 
+/*
+Asserts that the two given slices have the same elements in the same order. The elements must be [comparable]
+*/
 func EqualSlice[K comparable](t testing.TB, expected []K, actual []K) {
 	t.Helper()
 
@@ -58,6 +73,9 @@ func EqualSlice[K comparable](t testing.TB, expected []K, actual []K) {
 	}
 }
 
+/*
+Asserts that the two given slices does not have the same elements in the same order. The elements must be [comparable]
+*/
 func NotEqualSlice[K comparable](t testing.TB, expected []K, actual []K) {
 	t.Helper()
 
@@ -82,6 +100,9 @@ func areEqualSlices[K comparable](expected []K, actual []K) bool {
 	return true
 }
 
+/*
+Asserts that the two given slices have the same values in any order. The elements must be [comparable]
+*/
 func SimilarSlice[K comparable](t testing.TB, expected []K, actual []K) {
 	t.Helper()
 
@@ -90,6 +111,9 @@ func SimilarSlice[K comparable](t testing.TB, expected []K, actual []K) {
 	}
 }
 
+/*
+Asserts that the two given slices does not have the same values. The elements must be [comparable]
+*/
 func NotSimilarSlice[K comparable](t testing.TB, expected []K, actual []K) {
 	t.Helper()
 
@@ -118,6 +142,9 @@ func areSimilarSlices[K comparable](expected []K, actual []K) bool {
 	return isEqualMap(expectedElementsMap, actualElementsMap)
 }
 
+/*
+Asserts that the two given maps have the same key-value pairs. The values must be [comparable]
+*/
 func EqualMap[K, V comparable](t testing.TB, expected map[K]V, actual map[K]V) {
 	t.Helper()
 
@@ -126,6 +153,9 @@ func EqualMap[K, V comparable](t testing.TB, expected map[K]V, actual map[K]V) {
 	}
 }
 
+/*
+Asserts that the two given maps does not have the same key-value pairs. The values must be [comparable]
+*/
 func NotEqualMap[K, V comparable](t testing.TB, expected map[K]V, actual map[K]V) {
 	t.Helper()
 

assert_panic.go

@@ -4,6 +4,9 @@ import (
 	"testing"
 )
 
+/*
+Asserts that the given function panics
+*/
 func Panic(t testing.TB, underTest func()) {
 	t.Helper()
 
@@ -16,6 +19,9 @@ func Panic(t testing.TB, underTest func()) {
 	underTest()
 }
 
+/*
+Asserts that the given function does not panic
+*/
 func NotPanic(t testing.TB, underTest func()) {
 	t.Helper()
 
@@ -28,6 +34,10 @@ func NotPanic(t testing.TB, underTest func()) {
 	underTest()
 }
 
+/*
+Asserts that the given function panics with the specified error.
+The actual error must be of the same type and value as the given error
+*/
 func PanicWithError[K comparable](t testing.TB, expectedError K, underTest func()) {
 	t.Helper()
 
@@ -53,6 +63,10 @@ func PanicWithError[K comparable](t testing.TB, expectedError K, underTest func(
 	underTest()
 }
 
+/*
+Asserts that the given function does not panic with the specified error.
+The assertion succeeds if the given function does not panic or panics with a different error
+*/
 func NotPanicWithError[K comparable](t testing.TB, expectedError K, underTest func()) {
 	t.Helper()
 

assert_true.go

@@ -2,6 +2,9 @@ package goassert
 
 import "testing"
 
+/*
+Asserts that the given value is true
+*/
 func True(t testing.TB, assertion bool) {
 	t.Helper()
 
@@ -10,6 +13,9 @@ func True(t testing.TB, assertion bool) {
 	}
 }
 
+/*
+Asserts that the given value is false
+*/
 func False(t testing.TB, assertion bool) {
 	t.Helper()