controller *namedresourcesmodel.Controller
}

func (c claimController) nodeIsSuitable(ctx context.Context, nodeName string, resources resources) (bool, error) {
	nodeResources := resources[nodeName]
	for driverName, perDriver := range c.namedresources {
		okay, err := perDriver.controller.NodeIsSuitable(ctx, nodeResources[driverName].NamedResources)
		if err != nil {

		}
		c.requests = append(c.requests, compilation)
	}
	return c, nil
}

type Controller struct {
	filter   *cel.CompilationResult
	requests []cel.CompilationResult
}

func (c *Controller) NodeIsSuitable(ctx context.Context, model Model) (bool, error) {
	indices, err := c.allocate(ctx, model)
	return len(indices) == len(c.requests), err
}

					isSuitable, err := controller.nodeIsSuitable(tCtx, nodeName, tc.resources)
					if err != nil {
						if expect.suitableErr == "" {
							tCtx.Fatalf("unexpected nodeIsSuitable error: %v", err)
						}
						require.Equal(tCtx, expect.suitableErr, err.Error())
						return
					}
					if expect.suitableErr != "" {
						tCtx.Fatalf("did not get expected nodeIsSuitable error: %v", expect.suitableErr)
					}

				expectAllocation = append(expectAllocation, &resourceapi.NamedResourcesAllocationResult{Name: name})
			}
			require.Equal(tCtx, expectAllocation, allocation)

			isSuitable, isSuitableErr := controller.NodeIsSuitable(tCtx, tc.model)
			assert.Equal(tCtx, len(expectAllocation) == len(tc.requests), isSuitable, "is suitable")
			assert.Equal(tCtx, createErr, isSuitableErr)
		})
	}

				}
			}
			// Can the builtin controller tell us whether the node is suitable?
			if state.informationsForClaim[index].structuredParameters {
				suitable, err := state.informationsForClaim[index].controller.nodeIsSuitable(ctx, node.Name, state.resources)
				if err != nil {
					// An error indicates that something wasn't configured correctly, for example
					// writing a CEL expression which doesn't handle a map lookup error. Normally