interface{} -> any

Author: mdwhatcott

LICENSE.md

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 Smarty
+Copyright (c) 2023 Smarty
 
 Permission is hereby granted, free of charge, to any person obtaining a copy 
 of this software and associated documentation files (the "Software"), to deal 

assert/assert.go

@@ -36,7 +36,7 @@ type Result struct {
 //	if err := assert.So(1, should.Equal, 1).Error(); err != nil {
 //	    // Allows custom handling of the error, which will include the failure message and file:line header.
 //	}
-func So(actual interface{}, assert assertion, expected ...interface{}) *Result {
+func So(actual any, assert assertion, expected ...any) *Result {
 	result := new(Result)
 	result.stdout = os.Stdout
 	result.invocation = fmt.Sprintf("So(actual: %v, %v, expected: %v)", actual, assertionName(assert), expected)
@@ -46,7 +46,7 @@ func So(actual interface{}, assert assertion, expected ...interface{}) *Result {
 	}
 	return result
 }
-func assertionName(i interface{}) string {
+func assertionName(i any) string {
 	functionAddress := runtime.FuncForPC(reflect.ValueOf(i).Pointer())
 	fullNameStartingWithPackage := functionAddress.Name()
 	parts := strings.Split(fullNameStartingWithPackage, "/")
@@ -114,4 +114,4 @@ func (this *Result) Fatal() *Result {
 }
 
 // assertion is a copy of github.com/smartystreets/assertions.assertion.
-type assertion func(actual interface{}, expected ...interface{}) string
+type assertion func(actual any, expected ...any) string

assert/logger.go

@@ -34,7 +34,7 @@ func capture() *logger {
 }
 
 // Fatal -> log.Fatal (except in testing it uses log.Print)
-func (this *logger) Fatal(v ...interface{}) {
+func (this *logger) Fatal(v ...any) {
 	if this == nil {
 		this.Output(3, fmt.Sprint(v...))
 		os.Exit(1)
@@ -45,7 +45,7 @@ func (this *logger) Fatal(v ...interface{}) {
 }
 
 // Panic -> log.Panic
-func (this *logger) Panic(v ...interface{}) {
+func (this *logger) Panic(v ...any) {
 	if this == nil {
 		s := fmt.Sprint(v...)
 		this.Output(3, s)
@@ -57,7 +57,7 @@ func (this *logger) Panic(v ...interface{}) {
 }
 
 // Print -> log.Print
-func (this *logger) Print(v ...interface{}) {
+func (this *logger) Print(v ...any) {
 	if this == nil {
 		this.Output(3, fmt.Sprint(v...))
 	} else {

collections.go

@@ -9,7 +9,7 @@ import (
 
 // ShouldContain receives exactly two parameters. The first is a slice and the
 // second is a proposed member. Membership is determined using ShouldEqual.
-func ShouldContain(actual interface{}, expected ...interface{}) string {
+func ShouldContain(actual any, expected ...any) string {
 	if fail := need(1, expected); fail != success {
 		return fail
 	}
@@ -27,7 +27,7 @@ func ShouldContain(actual interface{}, expected ...interface{}) string {
 
 // ShouldNotContain receives exactly two parameters. The first is a slice and the
 // second is a proposed member. Membership is determined using ShouldEqual.
-func ShouldNotContain(actual interface{}, expected ...interface{}) string {
+func ShouldNotContain(actual any, expected ...any) string {
 	if fail := need(1, expected); fail != success {
 		return fail
 	}
@@ -44,7 +44,7 @@ func ShouldNotContain(actual interface{}, expected ...interface{}) string {
 
 // ShouldContainKey receives exactly two parameters. The first is a map and the
 // second is a proposed key. Keys are compared with a simple '=='.
-func ShouldContainKey(actual interface{}, expected ...interface{}) string {
+func ShouldContainKey(actual any, expected ...any) string {
 	if fail := need(1, expected); fail != success {
 		return fail
 	}
@@ -63,7 +63,7 @@ func ShouldContainKey(actual interface{}, expected ...interface{}) string {
 
 // ShouldNotContainKey receives exactly two parameters. The first is a map and the
 // second is a proposed absent key. Keys are compared with a simple '=='.
-func ShouldNotContainKey(actual interface{}, expected ...interface{}) string {
+func ShouldNotContainKey(actual any, expected ...any) string {
 	if fail := need(1, expected); fail != success {
 		return fail
 	}
@@ -80,14 +80,14 @@ func ShouldNotContainKey(actual interface{}, expected ...interface{}) string {
 	return ""
 }
 
-func mapKeys(m interface{}) ([]reflect.Value, bool) {
+func mapKeys(m any) ([]reflect.Value, bool) {
 	value := reflect.ValueOf(m)
 	if value.Kind() != reflect.Map {
 		return nil, false
 	}
 	return value.MapKeys(), true
 }
-func keyFound(keys []reflect.Value, expectedKey interface{}) bool {
+func keyFound(keys []reflect.Value, expectedKey any) bool {
 	found := false
 	for _, key := range keys {
 		if key.Interface() == expectedKey {
@@ -101,7 +101,7 @@ func keyFound(keys []reflect.Value, expectedKey interface{}) bool {
 // that is passed in either as the second parameter, or of the collection that consists
 // of all the remaining parameters. This assertion ensures that the proposed member is in
 // the collection (using ShouldEqual).
-func ShouldBeIn(actual interface{}, expected ...interface{}) string {
+func ShouldBeIn(actual any, expected ...any) string {
 	if fail := atLeast(1, expected); fail != success {
 		return fail
 	}
@@ -111,7 +111,7 @@ func ShouldBeIn(actual interface{}, expected ...interface{}) string {
 	}
 	return shouldBeIn(actual, expected)
 }
-func shouldBeIn(actual interface{}, expected interface{}) string {
+func shouldBeIn(actual any, expected any) string {
 	if matchError := oglematchers.Contains(actual).Matches(expected); matchError != nil {
 		return fmt.Sprintf(shouldHaveBeenIn, actual, reflect.TypeOf(expected))
 	}
@@ -122,7 +122,7 @@ func shouldBeIn(actual interface{}, expected interface{}) string {
 // that is passed in either as the second parameter, or of the collection that consists
 // of all the remaining parameters. This assertion ensures that the proposed member is NOT in
 // the collection (using ShouldEqual).
-func ShouldNotBeIn(actual interface{}, expected ...interface{}) string {
+func ShouldNotBeIn(actual any, expected ...any) string {
 	if fail := atLeast(1, expected); fail != success {
 		return fail
 	}
@@ -132,7 +132,7 @@ func ShouldNotBeIn(actual interface{}, expected ...interface{}) string {
 	}
 	return shouldNotBeIn(actual, expected)
 }
-func shouldNotBeIn(actual interface{}, expected interface{}) string {
+func shouldNotBeIn(actual any, expected any) string {
 	if matchError := oglematchers.Contains(actual).Matches(expected); matchError == nil {
 		return fmt.Sprintf(shouldNotHaveBeenIn, actual, reflect.TypeOf(expected))
 	}
@@ -142,7 +142,7 @@ func shouldNotBeIn(actual interface{}, expected interface{}) string {
 // ShouldBeEmpty receives a single parameter (actual) and determines whether
 // calling len(actual) would return `0`. It obeys the rules specified by the len
 // function for determining length: http://golang.org/pkg/builtin/#len
-func ShouldBeEmpty(actual interface{}, expected ...interface{}) string {
+func ShouldBeEmpty(actual any, expected ...any) string {
 	if fail := need(0, expected); fail != success {
 		return fail
 	}
@@ -183,7 +183,7 @@ func ShouldBeEmpty(actual interface{}, expected ...interface{}) string {
 // ShouldNotBeEmpty receives a single parameter (actual) and determines whether
 // calling len(actual) would return a value greater than zero. It obeys the rules
 // specified by the `len` function for determining length: http://golang.org/pkg/builtin/#len
-func ShouldNotBeEmpty(actual interface{}, expected ...interface{}) string {
+func ShouldNotBeEmpty(actual any, expected ...any) string {
 	if fail := need(0, expected); fail != success {
 		return fail
 	}
@@ -198,7 +198,7 @@ func ShouldNotBeEmpty(actual interface{}, expected ...interface{}) string {
 // the length of, the second being the expected length. It obeys the rules
 // specified by the len function for determining length:
 // http://golang.org/pkg/builtin/#len
-func ShouldHaveLength(actual interface{}, expected ...interface{}) string {
+func ShouldHaveLength(actual any, expected ...any) string {
 	if fail := need(1, expected); fail != success {
 		return fail
 	}

collections_test.go

@@ -91,7 +91,7 @@ func (this *AssertionsFixture) TestShouldBeEmpty() {
 
 	this.pass(so([]int{}, ShouldBeEmpty))           // empty slice
 	this.pass(so([][]int{}, ShouldBeEmpty))         // empty slice
-	this.pass(so([]interface{}{}, ShouldBeEmpty))   // empty slice
+	this.pass(so([]any{}, ShouldBeEmpty))           // empty slice
 	this.pass(so(map[string]int{}, ShouldBeEmpty))  // empty map
 	this.pass(so("", ShouldBeEmpty))                // empty string
 	this.pass(so(&[]int{}, ShouldBeEmpty))          // pointer to empty slice
@@ -101,7 +101,7 @@ func (this *AssertionsFixture) TestShouldBeEmpty() {
 
 	this.fail(so([]int{1}, ShouldBeEmpty), "Expected [1] to be empty (but it wasn't)!")                      // non-empty slice
 	this.fail(so([][]int{{1}}, ShouldBeEmpty), "Expected [[1]] to be empty (but it wasn't)!")                // non-empty slice
-	this.fail(so([]interface{}{1}, ShouldBeEmpty), "Expected [1] to be empty (but it wasn't)!")              // non-empty slice
+	this.fail(so([]any{1}, ShouldBeEmpty), "Expected [1] to be empty (but it wasn't)!")                      // non-empty slice
 	this.fail(so(map[string]int{"hi": 0}, ShouldBeEmpty), "Expected map[hi:0] to be empty (but it wasn't)!") // non-empty map
 	this.fail(so("hi", ShouldBeEmpty), "Expected hi to be empty (but it wasn't)!")                           // non-empty string
 	this.fail(so(&[]int{1}, ShouldBeEmpty), "Expected &[1] to be empty (but it wasn't)!")                    // pointer to non-empty slice
@@ -116,7 +116,7 @@ func (this *AssertionsFixture) TestShouldNotBeEmpty() {
 	this.fail(so(1, ShouldNotBeEmpty, 2, 3), "This assertion requires exactly 0 comparison values (you provided 2).")
 
 	this.fail(so([]int{}, ShouldNotBeEmpty), "Expected [] to NOT be empty (but it was)!")             // empty slice
-	this.fail(so([]interface{}{}, ShouldNotBeEmpty), "Expected [] to NOT be empty (but it was)!")     // empty slice
+	this.fail(so([]any{}, ShouldNotBeEmpty), "Expected [] to NOT be empty (but it was)!")             // empty slice
 	this.fail(so(map[string]int{}, ShouldNotBeEmpty), "Expected map[] to NOT be empty (but it was)!") // empty map
 	this.fail(so("", ShouldNotBeEmpty), "Expected  to NOT be empty (but it was)!")                    // empty string
 	this.fail(so(&[]int{}, ShouldNotBeEmpty), "Expected &[] to NOT be empty (but it was)!")           // pointer to empty slice
@@ -126,7 +126,7 @@ func (this *AssertionsFixture) TestShouldNotBeEmpty() {
 	this.fail(so(c, ShouldNotBeEmpty), fmt.Sprintf("Expected %+v to NOT be empty (but it was)!", c))  // empty channel
 
 	this.pass(so([]int{1}, ShouldNotBeEmpty))                // non-empty slice
-	this.pass(so([]interface{}{1}, ShouldNotBeEmpty))        // non-empty slice
+	this.pass(so([]any{1}, ShouldNotBeEmpty))                // non-empty slice
 	this.pass(so(map[string]int{"hi": 0}, ShouldNotBeEmpty)) // non-empty map
 	this.pass(so("hi", ShouldNotBeEmpty))                    // non-empty string
 	this.pass(so(&[]int{1}, ShouldNotBeEmpty))               // pointer to non-empty slice
@@ -148,7 +148,7 @@ func (this *AssertionsFixture) TestShouldHaveLength() {
 	this.fail(so([]int{}, ShouldHaveLength, 1), // empty slice
 		"Expected collection to have length equal to [1], but its length was [0] instead! contents: []")
 
-	this.fail(so([]interface{}{}, ShouldHaveLength, 1), // empty slice
+	this.fail(so([]any{}, ShouldHaveLength, 1), // empty slice
 		"Expected collection to have length equal to [1], but its length was [0] instead! contents: []")
 
 	this.fail(so(map[string]int{}, ShouldHaveLength, 1), // empty map
@@ -172,7 +172,7 @@ func (this *AssertionsFixture) TestShouldHaveLength() {
 		"Expected collection to have length equal to [1], but its length was [0] instead! contents: %+v", c))
 
 	this.pass(so([]int{1}, ShouldHaveLength, 1))                // non-empty slice
-	this.pass(so([]interface{}{1}, ShouldHaveLength, 1))        // non-empty slice
+	this.pass(so([]any{1}, ShouldHaveLength, 1))                // non-empty slice
 	this.pass(so(map[string]int{"hi": 0}, ShouldHaveLength, 1)) // non-empty map
 	this.pass(so("hi", ShouldHaveLength, 2))                    // non-empty string
 	this.pass(so(&[]int{1}, ShouldHaveLength, 1))               // pointer to non-empty slice

doc.go

@@ -38,7 +38,7 @@ func GoConveyMode(yes bool) {
 }
 
 type testingT interface {
-	Error(args ...interface{})
+	Error(args ...any)
 }
 
 type Assertion struct {
@@ -58,7 +58,7 @@ func (this *Assertion) Failed() bool {
 }
 
 // So calls the standalone So function and additionally, calls t.Error in failure scenarios.
-func (this *Assertion) So(actual interface{}, assert SoFunc, expected ...interface{}) bool {
+func (this *Assertion) So(actual any, assert SoFunc, expected ...any) bool {
 	ok, result := So(actual, assert, expected...)
 	if !ok {
 		this.failed = true
@@ -86,7 +86,7 @@ func (this *Assertion) So(actual interface{}, assert SoFunc, expected ...interfa
 //
 // For an alternative implementation of So (that provides more flexible return options)
 // see the `So` function in the package at github.com/smartystreets/assertions/assert.
-func So(actual interface{}, assert SoFunc, expected ...interface{}) (bool, string) {
+func So(actual any, assert SoFunc, expected ...any) (bool, string) {
 	if result := so(actual, assert, expected...); len(result) == 0 {
 		return true, result
 	} else {
@@ -96,14 +96,14 @@ func So(actual interface{}, assert SoFunc, expected ...interface{}) (bool, strin
 
 // so is like So, except that it only returns the string message, which is blank if the
 // assertion passed. Used to facilitate testing.
-func so(actual interface{}, assert SoFunc, expected ...interface{}) string {
+func so(actual any, assert SoFunc, expected ...any) string {
 	return assert(actual, expected...)
 }
 
 // SoFunc is an alias for a function with a signature that the So()
 // function can handle. Any future or custom assertions should conform to this
 // method signature. The return value should be an empty string if the SoFunc
 // passes and a well-formed failure message if not.
-type SoFunc func(actual interface{}, expected ...interface{}) string
+type SoFunc func(actual any, expected ...any) string
 
 ////////////////////////////////////////////////////////////////////////////

doc_test.go

@@ -69,6 +69,6 @@ type FakeT struct {
 	buffer *bytes.Buffer
 }
 
-func (this *FakeT) Error(args ...interface{}) {
+func (this *FakeT) Error(args ...any) {
 	fmt.Fprint(this.buffer, args...)
 }

equal_method.go

@@ -3,16 +3,16 @@ package assertions
 import "reflect"
 
 type equalityMethodSpecification struct {
-	a interface{}
-	b interface{}
+	a any
+	b any
 
 	aType reflect.Type
 	bType reflect.Type
 
 	equalMethod reflect.Value
 }
 
-func newEqualityMethodSpecification(a, b interface{}) *equalityMethodSpecification {
+func newEqualityMethodSpecification(a, b any) *equalityMethodSpecification {
 	return &equalityMethodSpecification{
 		a: a,
 		b: b,