}

    data object ErrorResolution : DocumentNodeResolution, UnsuccessfulResolution {
        override val reasons: Iterable<ResolutionFailureReason>
            get() = listOf(IsError)
    }

    sealed interface ValueNodeResolution : DocumentResolution {
        data class LiteralValueResolved(val value: Any) : ValueNodeResolution, SuccessfulResolution

	return status
}

// RunPreBindPlugins runs the set of configured prebind plugins. It returns a
// failure (bool) if any of the plugins returns an error. It also returns an
// error containing the rejection message or the error occurred in the plugin.
func (f *frameworkImpl) RunPreBindPlugins(ctx context.Context, state *framework.CycleState, pod *v1.Pod, nodeName string) (status *framework.Status) {

	pluginName := fmt.Sprintf("example-plugin")
	p := pluginwatcher.NewTestExamplePlugin(pluginName, registerapi.DevicePlugin, socketPath, supportedVersions...)
	require.NoError(t, p.Serve("v1beta1", "v1beta2"))
	defer func() {
		require.NoError(t, p.Stop())
	}()
	timestampBeforeRegistration := time.Now()
	dsw.AddOrUpdatePlugin(socketPath)
	waitForRegistration(t, socketPath, timestampBeforeRegistration, asw)

        protected CoderResult decodeLoop(ByteBuffer in, CharBuffer out) {
            mark(in);
            mark(out);

            CoderResult coderResult = decoder.decode(in, out, false);

            if (coderResult.isError() && utf8) {
                reset(in);
                reset(out);
                // Fallback to the ISO_8859_1 decoder
                decoder = StandardCharsets.ISO_8859_1.newDecoder();
                utf8 = false;

		assert.NoError(t, err, "create tempdir error")
		defer os.RemoveAll(tempDirPath)
		for _, filename := range tc.filenames {
			err = os.WriteFile(filepath.Join(tempDirPath, filename), []byte("a log line"), 0600)
			assert.NoError(t, err, "could not write log file")
		}
		count, err := calcRestartCountByLogDir(tempDirPath)
		if assert.NoError(t, err) {

		},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			err := ValidateOwnerGroups(tc.include, tc.exclude)
			assert.NoError(t, err)
		})
	}
}

func TestValidateOwnerGroups_Invalid(t *testing.T) {
	cases := []struct {
		name    string
		include string
		exclude string
	}{
		{
			name:    "capture 65 groups",

}

// ErrorPrioritizerExtender implements PriorityFunc function to always return error.
func ErrorPrioritizerExtender(pod *v1.Pod, nodes []*framework.NodeInfo) (*framework.NodeScoreList, error) {
	return &framework.NodeScoreList{}, fmt.Errorf("some error")
}

// Node1PrioritizerExtender implements PriorityFunc function to give score 10
// if the given node's name is "node1"; otherwise score 1.

        when:
        def results = dependencyResolver.resolveGraph(resolveContext)

        then:
        def resolvedConfig = results.legacyResults.resolvedConfiguration
        !resolvedConfig.hasError()
        resolvedConfig.rethrowFailure()

        resolvedConfig.getFiles(Specs.<Dependency> satisfyAll()).isEmpty()
        resolvedConfig.getFirstLevelModuleDependencies().isEmpty()

	cases := []execTestCase{
		{ // case 0, no args
			args:           []string{},
			noIstiod:       true,
			expectedOutput: "Error: debug type is required\n",
			wantException:  true,
		},
		{ // case 1, no istiod
			args:           []string{"adsz"},
			noIstiod:       true,
			expectedOutput: "Error: no running Istio pods in \"istio-system\"\n",
			wantException:  true,
		},
		{ // case 2, with Istiod instance

  result_tensors.resize(func->result_types().size() - 1);

  func->Execute(exec_ctx, arguments.values(), results);
  host->Await(results);

  for (auto& result : results) {
    EXPECT_FALSE(result->IsError());
  }
}

// Runs a BEF function that batches a function that does nothing just to measure
// the runtime overhead. The BEF function signature is adapted from a real model