diff --git a/controllers/numaresourcesoperator_controller_test.go b/controllers/numaresourcesoperator_controller_test.go
index cda73cb73..c062f7ee1 100644
--- a/controllers/numaresourcesoperator_controller_test.go
+++ b/controllers/numaresourcesoperator_controller_test.go
@@ -23,6 +23,8 @@ import (
 
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
+	"github.com/onsi/gomega/gcustom"
+	gomegatypes "github.com/onsi/gomega/types"
 
 	appsv1 "k8s.io/api/apps/v1"
 	corev1 "k8s.io/api/core/v1"
@@ -102,9 +104,7 @@ var _ = Describe("Test NUMAResourcesOperator Reconcile", func() {
 		Expect(err).ToNot(HaveOccurred())
 
 		key := client.ObjectKeyFromObject(nro)
-		result, err := reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})
-		Expect(err).ToNot(HaveOccurred())
-		Expect(result).To(Equal(reconcile.Result{}))
+		Expect(reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})).ToNot(CauseRequeue())
 
 		Expect(reconciler.Client.Get(context.TODO(), key, nro)).ToNot(HaveOccurred())
 		degradedCondition := getConditionByType(nro.Status.Conditions, status.ConditionDegraded)
@@ -171,9 +171,7 @@ var _ = Describe("Test NUMAResourcesOperator Reconcile", func() {
 				Expect(err).ToNot(HaveOccurred())
 
 				key := client.ObjectKeyFromObject(nro)
-				result, err := reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})
-				Expect(err).ToNot(HaveOccurred())
-				Expect(result).To(Equal(reconcile.Result{}))
+				Expect(reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})).ToNot(CauseRequeue())
 
 				Expect(reconciler.Client.Get(context.TODO(), key, nro)).ToNot(HaveOccurred())
 				degradedCondition := getConditionByType(nro.Status.Conditions, status.ConditionDegraded)
@@ -227,9 +225,7 @@ var _ = Describe("Test NUMAResourcesOperator Reconcile", func() {
 					Expect(err).ToNot(HaveOccurred())
 
 					// on the first iteration with the default RTE SELinux policy we expect immediate update, thus the reconciliation result is empty
-					result, err := reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: nroKey})
-					Expect(err).ToNot(HaveOccurred())
-					Expect(result).To(Equal(reconcile.Result{}))
+					Expect(reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: nroKey})).ToNot(CauseRequeue())
 
 					Expect(reconciler.Client.Get(context.TODO(), client.ObjectKeyFromObject(nro), nro)).ToNot(HaveOccurred())
 
@@ -298,9 +294,7 @@ var _ = Describe("Test NUMAResourcesOperator Reconcile", func() {
 					}).WithPolling(1 * time.Second).WithTimeout(30 * time.Second).ShouldNot(HaveOccurred())
 
 					//  immediate update
-					result, err := reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: nroKey})
-					Expect(err).ToNot(HaveOccurred())
-					Expect(result).To(Equal(reconcile.Result{}))
+					Expect(reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: nroKey})).ToNot(CauseRequeue())
 
 					Expect(reconciler.Client.Get(context.TODO(), nroKey, nroUpdated)).ToNot(HaveOccurred())
 					Expect(nroUpdated.Spec.NodeGroups[0].Config).To(Equal(conf1))
@@ -337,9 +331,7 @@ var _ = Describe("Test NUMAResourcesOperator Reconcile", func() {
 						Expect(reconciler.Client.Update(context.TODO(), nro)).NotTo(HaveOccurred())
 
 						// immediate update reflection with no reboot needed -> no need to reconcileafter this
-						thirdLoopResult, err := reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: nroKey})
-						Expect(err).ToNot(HaveOccurred())
-						Expect(thirdLoopResult).To(Equal(reconcile.Result{}))
+						Expect(reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: nroKey})).ToNot(CauseRequeue())
 					})
 					It("should delete also the corresponding DaemonSet", func() {
 						ds := &appsv1.DaemonSet{}
@@ -740,9 +732,7 @@ var _ = Describe("Test NUMAResourcesOperator Reconcile", func() {
 					}).WithPolling(1 * time.Second).WithTimeout(30 * time.Second).ShouldNot(HaveOccurred())
 
 					// immediate update reflection with no reboot needed -> no need to reconcile after this
-					result, err := reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})
-					Expect(err).ToNot(HaveOccurred())
-					Expect(result).To(Equal(reconcile.Result{}))
+					Expect(reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})).ToNot(CauseRequeue())
 
 					dsUpdated := &appsv1.DaemonSet{}
 					Expect(reconciler.Client.Get(context.TODO(), dsKey, dsUpdated)).ToNot(HaveOccurred())
@@ -807,9 +797,7 @@ var _ = Describe("Test NUMAResourcesOperator Reconcile", func() {
 					}).WithPolling(1 * time.Second).WithTimeout(30 * time.Second).ShouldNot(HaveOccurred())
 
 					// immediate update reflection with no reboot needed -> no need to reconcile after this
-					thirdLoopResult, err := reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})
-					Expect(err).ToNot(HaveOccurred())
-					Expect(thirdLoopResult).To(Equal(reconcile.Result{}))
+					Expect(reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})).ToNot(CauseRequeue())
 
 					dsUpdated := &appsv1.DaemonSet{}
 					Expect(reconciler.Client.Get(context.TODO(), dsKey, dsUpdated)).ToNot(HaveOccurred())
@@ -1102,9 +1090,7 @@ var _ = Describe("Test NUMAResourcesOperator Reconcile", func() {
 				Expect(err).ToNot(HaveOccurred())
 
 				key := client.ObjectKeyFromObject(nro)
-				result, err := reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})
-				Expect(err).ToNot(HaveOccurred())
-				Expect(result).To(Equal(reconcile.Result{}))
+				Expect(reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})).ToNot(CauseRequeue())
 
 				Expect(reconciler.Client.Get(context.TODO(), key, nro)).ToNot(HaveOccurred())
 				degradedCondition := getConditionByType(nro.Status.Conditions, status.ConditionDegraded)
@@ -1142,9 +1128,7 @@ var _ = Describe("Test NUMAResourcesOperator Reconcile", func() {
 				Expect(err).ToNot(HaveOccurred())
 
 				key := client.ObjectKeyFromObject(nro)
-				result, err := reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})
-				Expect(err).ToNot(HaveOccurred())
-				Expect(result).To(Equal(reconcile.Result{}))
+				Expect(reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})).ToNot(CauseRequeue())
 
 				// we still expect that all objects be created as usual without blockers (no hard requirement for now) in addition to the Degraded condition
 				By("Verify all needed objects were created as expected: CRD, MCP, RTE DSs")
@@ -1204,9 +1188,7 @@ var _ = Describe("Test NUMAResourcesOperator Reconcile", func() {
 
 				key := client.ObjectKeyFromObject(nro)
 				// on the first iteration we expect the CRDs and MCPs to be created, yet, it will wait one minute to update MC, thus RTE daemonsets and complete status update is not going to be achieved at this point
-				firstLoopResult, err := reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})
-				Expect(err).ToNot(HaveOccurred())
-				Expect(firstLoopResult).To(Equal(reconcile.Result{RequeueAfter: time.Minute}))
+				Expect(reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})).To(CauseRequeue())
 
 				// Ensure mcp1 is ready
 				Expect(reconciler.Client.Get(context.TODO(), client.ObjectKeyFromObject(mcp1), mcp1)).To(Succeed())
@@ -1239,9 +1221,7 @@ var _ = Describe("Test NUMAResourcesOperator Reconcile", func() {
 				Expect(reconciler.Client.Update(context.TODO(), mcp2)).To(Succeed())
 
 				// triggering a second reconcile will create the RTEs and fully update the statuses making the operator in Available condition -> no more reconciliation needed thus the result is clean
-				secondLoopResult, err := reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})
-				Expect(err).ToNot(HaveOccurred())
-				Expect(secondLoopResult).To(Equal(reconcile.Result{}))
+				Expect(reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})).ToNot(CauseRequeue())
 
 				By("Check DaemonSets are created")
 				mcp1DSKey := client.ObjectKey{
@@ -1290,9 +1270,7 @@ var _ = Describe("Test NUMAResourcesOperator Reconcile", func() {
 				Expect(err).ToNot(HaveOccurred())
 
 				key := client.ObjectKeyFromObject(nro)
-				result, err := reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})
-				Expect(err).ToNot(HaveOccurred())
-				Expect(result).To(Equal(reconcile.Result{}))
+				Expect(reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})).ToNot(CauseRequeue())
 
 				Expect(reconciler.Client.Get(context.TODO(), key, nro)).ToNot(HaveOccurred())
 				degradedCondition := getConditionByType(nro.Status.Conditions, status.ConditionDegraded)
@@ -1565,12 +1543,10 @@ var _ = Describe("Test NUMAResourcesOperator Reconcile", func() {
 									Expect(reconciler.Client.Update(context.TODO(), nro)).NotTo(HaveOccurred())
 
 									// immediate update reflection with no reboot needed -> no need to reconcileafter this
-									firstLoopResult, err := reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})
-									Expect(err).ToNot(HaveOccurred())
-									Expect(firstLoopResult).To(Equal(reconcile.Result{}))
+									Expect(reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})).ToNot(CauseRequeue())
 								})
-								It("should delete also the corresponding Machineconfig", func() {
 
+								It("should delete also the corresponding Machineconfig", func() {
 									mc := &machineconfigv1.MachineConfig{}
 
 									// Check ds1 still exist
@@ -1629,9 +1605,7 @@ var _ = Describe("Test NUMAResourcesOperator Reconcile", func() {
 
 						It("should create the machine config", func() {
 							// on the first iteration we expect the CRDs and MCPs to be created, yet, it will wait one minute to update MC, thus RTE daemonsets and complete status update is not going to be achieved at this point
-							firstLoopResult, err := reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})
-							Expect(err).ToNot(HaveOccurred())
-							Expect(firstLoopResult).To(Equal(reconcile.Result{RequeueAfter: time.Minute}))
+							Expect(reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})).To(CauseRequeue())
 
 							mc := &machineconfigv1.MachineConfig{}
 							mcKey := client.ObjectKey{
@@ -1688,9 +1662,7 @@ var _ = Describe("Test NUMAResourcesOperator Reconcile", func() {
 
 					key := client.ObjectKeyFromObject(nro)
 					// on the first iteration we expect the CRDs and MCPs to be created, yet, it will wait one minute to update MC, thus RTE daemonsets and complete status update is not going to be achieved at this point
-					firstLoopResult, err := reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})
-					Expect(err).ToNot(HaveOccurred())
-					Expect(firstLoopResult).To(Equal(reconcile.Result{RequeueAfter: time.Minute}))
+					Expect(reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})).To(CauseRequeue())
 
 					// Ensure mcp1 is ready
 					Expect(reconciler.Client.Get(context.TODO(), client.ObjectKeyFromObject(mcp1), mcp1)).To(Succeed())
@@ -1723,9 +1695,7 @@ var _ = Describe("Test NUMAResourcesOperator Reconcile", func() {
 					Expect(reconciler.Client.Update(context.TODO(), mcp2)).To(Succeed())
 
 					// triggering a second reconcile will create the RTEs and fully update the statuses making the operator in Available condition -> no more reconciliation needed thus the result is clean
-					secondLoopResult, err := reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})
-					Expect(err).ToNot(HaveOccurred())
-					Expect(secondLoopResult).To(Equal(reconcile.Result{}))
+					Expect(reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})).ToNot(CauseRequeue())
 
 					By("Check DaemonSets are created")
 					mcp1DSKey := client.ObjectKey{
@@ -1751,9 +1721,7 @@ var _ = Describe("Test NUMAResourcesOperator Reconcile", func() {
 					Expect(reconciler.Client.Update(context.TODO(), nro)).NotTo(HaveOccurred())
 
 					// removing the annotation will trigger reboot which requires resync after 1 min
-					thirdLoopResult, err := reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})
-					Expect(err).ToNot(HaveOccurred())
-					Expect(thirdLoopResult).To(Equal(reconcile.Result{RequeueAfter: time.Minute}))
+					Expect(reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})).To(CauseRequeue())
 				})
 				It("should not create a machine config", func() {
 					mc := &machineconfigv1.MachineConfig{}
@@ -1785,9 +1753,7 @@ var _ = Describe("Test NUMAResourcesOperator Reconcile", func() {
 					key := client.ObjectKeyFromObject(nro)
 					// when the SELinux custom annotation is not set, the controller will not wait for
 					// the selinux update on MC thus no reboot is required hence no need to reconcile again
-					firstLoopResult, err := reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})
-					Expect(err).ToNot(HaveOccurred())
-					Expect(firstLoopResult).To(Equal(reconcile.Result{}))
+					Expect(reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})).ToNot(CauseRequeue())
 				})
 
 				It("should create RTE daemonsets from the first reconcile iteration - MachineConfigPoolSelector", func() {
@@ -1916,9 +1882,7 @@ var _ = Describe("Test NUMAResourcesOperator Reconcile", func() {
 				Expect(reconciler.Client.Update(context.TODO(), nro)).To(Succeed())
 
 				// removing the annotation will trigger reboot which requires resync after 1 min
-				thirdLoopResult, err := reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})
-				Expect(err).ToNot(HaveOccurred())
-				Expect(thirdLoopResult).To(Equal(reconcile.Result{RequeueAfter: time.Minute}))
+				Expect(reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})).To(CauseRequeue())
 			})
 			It("should delete existing mc", func() {
 				mc1Key := client.ObjectKey{
@@ -1997,9 +1961,7 @@ func reconcileObjectsOpenshift(nro *nropv1.NUMAResourcesOperator, mcp *machineco
 		Expect(mcp.Status.Configuration.Source[0].Name).To(Equal(mcName))
 
 		// triggering a second reconcile will create the RTEs and fully update the statuses making the operator in Available condition -> no more reconciliation needed thus the result is clean
-		secondLoopResult, err := reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})
-		Expect(err).ToNot(HaveOccurred())
-		Expect(secondLoopResult).To(Equal(reconcile.Result{}))
+		Expect(reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})).ToNot(CauseRequeue())
 	}
 
 	return reconciler
@@ -2014,9 +1976,13 @@ func reconcileObjectsHypershift(nro *nropv1.NUMAResourcesOperator) *NUMAResource
 	key := client.ObjectKeyFromObject(nro)
 
 	// immediate update
-	firstLoopResult, err := reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})
-	Expect(err).ToNot(HaveOccurred())
-	Expect(firstLoopResult).To(Equal(reconcile.Result{}))
+	Expect(reconciler.Reconcile(context.TODO(), reconcile.Request{NamespacedName: key})).ToNot(CauseRequeue())
 
 	return reconciler
 }
+
+func CauseRequeue() gomegatypes.GomegaMatcher {
+	return gcustom.MakeMatcher(func(rr reconcile.Result) (bool, error) {
+		return rr.RequeueAfter > 0, nil
+	}).WithTemplate("Reconciliation step should cause requeue")
+}
diff --git a/vendor/github.com/onsi/gomega/gcustom/make_matcher.go b/vendor/github.com/onsi/gomega/gcustom/make_matcher.go
new file mode 100644
index 000000000..5372fa441
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/gcustom/make_matcher.go
@@ -0,0 +1,270 @@
+/*
+package gcustom provides a simple mechanism for creating custom Gomega matchers
+*/
+package gcustom
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"text/template"
+
+	"github.com/onsi/gomega/format"
+)
+
+var interfaceType = reflect.TypeOf((*interface{})(nil)).Elem()
+var errInterface = reflect.TypeOf((*error)(nil)).Elem()
+
+var defaultTemplate = template.Must(ParseTemplate("{{if .Failure}}Custom matcher failed for:{{else}}Custom matcher succeeded (but was expected to fail) for:{{end}}\n{{.FormattedActual}}"))
+
+func formatObject(object any, indent ...uint) string {
+	indentation := uint(0)
+	if len(indent) > 0 {
+		indentation = indent[0]
+	}
+	return format.Object(object, indentation)
+}
+
+/*
+ParseTemplate allows you to precompile templates for MakeMatcher's custom matchers.
+
+Use ParseTemplate if you are concerned about performance and would like to avoid repeatedly parsing failure message templates.  The data made available to the template is documented in the WithTemplate() method of CustomGomegaMatcher.
+
+Once parsed you can pass the template in either as an argument to MakeMatcher(matchFunc, <template>) or using MakeMatcher(matchFunc).WithPrecompiledTemplate(template)
+*/
+func ParseTemplate(templ string) (*template.Template, error) {
+	return template.New("template").Funcs(template.FuncMap{
+		"format": formatObject,
+	}).Parse(templ)
+}
+
+/*
+MakeMatcher builds a Gomega-compatible matcher from a function (the matchFunc).
+
+matchFunc must return (bool, error) and take a single argument.  If you want to perform type-checking yourself pass in a matchFunc of type `func(actual any) (bool, error)`.  If you want to only operate on a specific type, pass in `func(actual DesiredType) (bool, error)`; MakeMatcher will take care of checking types for you and notifying the user if they use the matcher with an invalid type.
+
+MakeMatcher(matchFunc) builds a matcher with generic failure messages that look like:
+
+	Custom matcher failed for:
+	    <formatted actual>
+
+for the positive failure case (i.e. when Expect(actual).To(match) fails) and
+
+	Custom matcher succeeded (but was expected to fail) for:
+	     <formatted actual>
+
+for the negative case (i.e. when Expect(actual).NotTo(match) fails).
+
+There are two ways to provide a different message.  You can either provide a simple message string:
+
+	matcher := MakeMatcher(matchFunc, message)
+	matcher := MakeMatcher(matchFunc).WithMessage(message)
+
+(where message is of type string) or a template:
+
+	matcher := MakeMatcher(matchFunc).WithTemplate(templateString)
+
+where templateString is a string that is compiled by WithTemplate into a matcher.  Alternatively you can provide a precompiled template like this:
+
+	template, err = gcustom.ParseTemplate(templateString) //use gcustom's ParseTemplate to get some additional functions mixed in
+	matcher := MakeMatcher(matchFunc, template)
+	matcher := MakeMatcher(matchFunc).WithPrecompiled(template)
+
+When a simple message string is provided the positive failure message will look like:
+
+	Expected:
+		<formatted actual>
+	to <message>
+
+and the negative failure message will look like:
+
+	Expected:
+		<formatted actual>
+	not to <message>
+
+A template allows you to have greater control over the message.  For more details see the docs for WithTemplate
+*/
+func MakeMatcher(matchFunc any, args ...any) CustomGomegaMatcher {
+	t := reflect.TypeOf(matchFunc)
+	if !(t.Kind() == reflect.Func && t.NumIn() == 1 && t.NumOut() == 2 && t.Out(0).Kind() == reflect.Bool && t.Out(1).Implements(errInterface)) {
+		panic("MakeMatcher must be passed a function that takes one argument and returns (bool, error)")
+	}
+	var finalMatchFunc func(actual any) (bool, error)
+	if t.In(0) == interfaceType {
+		finalMatchFunc = matchFunc.(func(actual any) (bool, error))
+	} else {
+		matchFuncValue := reflect.ValueOf(matchFunc)
+		finalMatchFunc = reflect.MakeFunc(reflect.TypeOf(finalMatchFunc),
+			func(args []reflect.Value) []reflect.Value {
+				actual := args[0].Interface()
+				if actual == nil && reflect.TypeOf(actual) == reflect.TypeOf(nil) {
+					return matchFuncValue.Call([]reflect.Value{reflect.New(t.In(0)).Elem()})
+				} else if reflect.TypeOf(actual).AssignableTo(t.In(0)) {
+					return matchFuncValue.Call([]reflect.Value{reflect.ValueOf(actual)})
+				} else {
+					return []reflect.Value{
+						reflect.ValueOf(false),
+						reflect.ValueOf(fmt.Errorf("Matcher expected actual of type <%s>.  Got:\n%s", t.In(0), format.Object(actual, 1))),
+					}
+				}
+			}).Interface().(func(actual any) (bool, error))
+	}
+
+	matcher := CustomGomegaMatcher{
+		matchFunc:       finalMatchFunc,
+		templateMessage: defaultTemplate,
+	}
+
+	for _, arg := range args {
+		switch v := arg.(type) {
+		case string:
+			matcher = matcher.WithMessage(v)
+		case *template.Template:
+			matcher = matcher.WithPrecompiledTemplate(v)
+		}
+	}
+
+	return matcher
+}
+
+// CustomGomegaMatcher is generated by MakeMatcher - you should always use MakeMatcher to construct custom matchers
+type CustomGomegaMatcher struct {
+	matchFunc                   func(actual any) (bool, error)
+	templateMessage             *template.Template
+	templateData                any
+	customFailureMessage        func(actual any) string
+	customNegatedFailureMessage func(actual any) string
+}
+
+/*
+WithMessage returns a CustomGomegaMatcher configured with a message to display when failure occurs.  Matchers configured this way produce a positive failure message that looks like:
+
+	Expected:
+		<formatted actual>
+	to <message>
+
+and a negative failure message that looks like:
+
+	Expected:
+		<formatted actual>
+	not to <message>
+*/
+func (c CustomGomegaMatcher) WithMessage(message string) CustomGomegaMatcher {
+	return c.WithTemplate("Expected:\n{{.FormattedActual}}\n{{.To}} " + message)
+}
+
+/*
+WithTemplate compiles the passed-in template and returns a CustomGomegaMatcher configured to use that template to generate failure messages.
+
+Templates are provided the following variables and functions:
+
+{{.Failure}} - a bool that, if true, indicates this should be a positive failure message, otherwise this should be a negated failure message
+{{.NegatedFailure}} - a bool that, if true, indicates this should be a negated failure message, otherwise this should be a positive failure message
+{{.To}} - is set to "to" if this is a positive failure message and "not to" if this is a negated failure message
+{{.Actual}} - the actual passed in to the matcher
+{{.FormattedActual}} - a string representing the formatted actual.  This can be multiple lines and is always generated with an indentation of 1
+{{format <object> <optional-indentation}} - a function that allows you to use Gomega's default formatting from within the template.  The passed-in <object> is formatted and <optional-indentation> can be set to an integer to control indentation.
+
+In addition, you can provide custom data to the template by calling WithTemplate(templateString, data) (where data can be anything).  This is provided to the template as {{.Data}}.
+
+Here's a simple example of all these pieces working together:
+
+	func HaveWidget(widget Widget) OmegaMatcher {
+		return MakeMatcher(func(machine Machine) (bool, error) {
+			return machine.HasWidget(widget), nil
+		}).WithTemplate("Expected:\n{{.FormattedActual}}\n{{.To}} have widget named {{.Data.Name}}:\n{{format .Data 1}}", widget)
+	}
+
+	Expect(machine).To(HaveWidget(Widget{Name: "sprocket", Version: 2}))
+
+Would generate a failure message that looks like:
+
+	Expected:
+		<formatted machine>
+	to have widget named sprocket:
+		<formatted sprocket>
+*/
+func (c CustomGomegaMatcher) WithTemplate(templ string, data ...any) CustomGomegaMatcher {
+	return c.WithPrecompiledTemplate(template.Must(ParseTemplate(templ)), data...)
+}
+
+/*
+WithPrecompiledTemplate returns a CustomGomegaMatcher configured to use the passed-in template.  The template should be precompiled with gcustom.ParseTemplate().
+
+As with WithTemplate() you can provide a single pice of additional data as an optional argument.  This is accessed in the template via {{.Data}}
+*/
+func (c CustomGomegaMatcher) WithPrecompiledTemplate(templ *template.Template, data ...any) CustomGomegaMatcher {
+	c.templateMessage = templ
+	c.templateData = nil
+	if len(data) > 0 {
+		c.templateData = data[0]
+	}
+	return c
+}
+
+/*
+WithTemplateData() returns a CustomGomegaMatcher configured to provide it's template with the passed-in data.  The following are equivalent:
+
+MakeMatcher(matchFunc).WithTemplate(templateString, data)
+MakeMatcher(matchFunc).WithTemplate(templateString).WithTemplateData(data)
+*/
+func (c CustomGomegaMatcher) WithTemplateData(data any) CustomGomegaMatcher {
+	c.templateData = data
+	return c
+}
+
+// Match runs the passed-in match func and satisfies the GomegaMatcher interface
+func (c CustomGomegaMatcher) Match(actual any) (bool, error) {
+	return c.matchFunc(actual)
+}
+
+// FailureMessage generates the positive failure message configured via WithMessage or WithTemplate/WithPrecompiledTemplate
+// i.e. this is the failure message when Expect(actual).To(match) fails
+func (c CustomGomegaMatcher) FailureMessage(actual any) string {
+	return c.renderTemplateMessage(actual, true)
+}
+
+// NegatedFailureMessage generates the negative failure message configured via WithMessage or WithTemplate/WithPrecompiledTemplate
+// i.e. this is the failure message when Expect(actual).NotTo(match) fails
+func (c CustomGomegaMatcher) NegatedFailureMessage(actual any) string {
+	return c.renderTemplateMessage(actual, false)
+}
+
+type templateData struct {
+	Failure         bool
+	NegatedFailure  bool
+	To              string
+	FormattedActual string
+	Actual          any
+	Data            any
+}
+
+func (c CustomGomegaMatcher) renderTemplateMessage(actual any, isFailure bool) string {
+	var data templateData
+	formattedActual := format.Object(actual, 1)
+	if isFailure {
+		data = templateData{
+			Failure:         true,
+			NegatedFailure:  false,
+			To:              "to",
+			FormattedActual: formattedActual,
+			Actual:          actual,
+			Data:            c.templateData,
+		}
+	} else {
+		data = templateData{
+			Failure:         false,
+			NegatedFailure:  true,
+			To:              "not to",
+			FormattedActual: formattedActual,
+			Actual:          actual,
+			Data:            c.templateData,
+		}
+	}
+	b := &strings.Builder{}
+	err := c.templateMessage.Execute(b, data)
+	if err != nil {
+		return fmt.Sprintf("Failed to render failure message template: %s", err.Error())
+	}
+	return b.String()
+}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 662f9d659..224e9dfe0 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -301,6 +301,7 @@ github.com/onsi/ginkgo/v2/types
 ## explicit; go 1.20
 github.com/onsi/gomega
 github.com/onsi/gomega/format
+github.com/onsi/gomega/gcustom
 github.com/onsi/gomega/internal
 github.com/onsi/gomega/internal/gutil
 github.com/onsi/gomega/matchers