You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: asserts.go
    path of file: ./repos/protoreflect/internal/testutil
    
    the code of the file until where you have to start completion: package testutil

import (
	"bytes"
	"math"
	"reflect"
	"testing"
)

// Ceq is a custom equals check; the given function returns true if its arguments are equal
func Ceq(t *testing.T, expected, actual interface{}, eq func(a, b interface{}) bool, context ...interface{}) bool {
	t.Helper()
	e := eq(expected, actual)
	Require(t, e, mergeContext(context, "Expecting %v (%v), got %v (%v)", expected, reflect.TypeOf(expected), actual, reflect.TypeOf(actual))...)
	return e
}

// Cneq is a custom not-equals check; the given function returns true if its arguments are equ
    
func eqany(expected, actual interface{}) bool {
	if expected == nil && actual == nil {
		return true
	}
	if expected == nil || actual == nil {
		return false
	}

	// We don't want reflect.DeepEquals because of its recursive nature. So we need
	// a custom compare for slices and maps. Two slices are equal if they have the
	// same number of elements and the elements at the same index are equal to each
	// other. Two maps are equal if their key sets are the same and the corresponding
	// values are equal. (The relationship is not recursive,  slices or maps that
	// contain other slices or maps can't be tested.)
	et := reflect.TypeOf(expected)

	if et.Kind() == reflect.Slice {
		return eqslice(reflect.ValueOf(expected), reflect.ValueOf(actual))
	} else if et.Kind() == reflect.Map {
		return eqmap(reflect.ValueOf(expected), reflect.ValueOf(actual))
	} else {
		return eqscalar(expected, actual)
	}
}