matcher.go

package sqlmock

import (
	"reflect"
)

// anyArg marks a wildcard argument matcher.
type anyArg struct{}

// AnyArg returns a wildcard matcher that accepts any argument value.
func AnyArg() any {
	return anyArg{}
}

type anyArgOf struct {
	typ reflect.Type
}

// AnyArgOf returns a wildcard matcher that accepts values of type T.
//
// AnyArgOf[any]() is not supported because it cannot derive a concrete type;
// use AnyArg() for unconstrained wildcard matching.
func AnyArgOf[T any]() any {
	var zero T
	typ := reflect.TypeOf(zero)

	if typ == nil {
		panic("sqlmock: AnyArgOf[any]() is invalid, use AnyArg() instead")
	}

	return anyArgOf{
		typ: typ,
	}
}

// matchArgs compares expected and actual arguments with wildcard support.
func matchArgs(expected, actual []any) bool {
	if len(expected) == 0 {
		return true
	}

	if len(expected) != len(actual) {
		return false
	}

	for i := range expected {
		switch exp := expected[i].(type) {
		case anyArg:
			continue
		case anyArgOf:
			if actual[i] == nil {
				return false
			}

			if reflect.TypeOf(actual[i]) != exp.typ {
				return false
			}

			continue
		default:
			if expected[i] != actual[i] {
				return false
			}
		}
	}

	return true
}