}
	}
}

func pluginResponse(conf *Config) error {
	var result *cniv1.Result
	if conf.PrevResult == nil {
		result = &cniv1.Result{
			CNIVersion: cniv1.ImplementedSpecVersion,
		}
		return types.PrintResult(result, conf.CNIVersion)
	}

	// Pass through the result for the next plugin
	return types.PrintResult(conf.PrevResult, conf.CNIVersion)
}

        when:
        configurationCacheRun supportedTasks, 0

        then:
        result.assertConfigurationCacheStateStored()

        when:
        run([":configuration-cache:clean"])

        then:
        configurationCacheRun supportedTasks, 1

        then:
        result.assertConfigurationCacheStateLoaded()
        result.task(":configuration-cache:embeddedIntegTest").outcome == TaskOutcome.FROM_CACHE

     */
    @Nonnull
    Collection<BuilderProblem> getProblems();

    /**
     * Gets the result of the dependency resolution for the project.
     *
     * @return the result of the dependency resolution for the project
     */
    @Nonnull
    Optional<DependencyResolverResult> getDependencyResolverResult();

			var res *workloadapi.Workload
			if wrapper != nil {
				res = wrapper.Workload
			}
			assert.Equal(t, res, tt.result)
		})
	}
}

func TestWorkloadEntryWorkloads(t *testing.T) {
	cases := []struct {
		name   string
		inputs []any
		we     *networkingclient.WorkloadEntry
		result *workloadapi.Workload
	}{
		{
			name: "we with service",
			inputs: []any{
				model.ServiceInfo{

				result = append(result, MatchValue{IndexName: FieldIndex(field), Value: namespace})
			}
		}
	}
	for _, label := range s.IndexLabels {
		if value, ok := s.Label.RequiresExactMatch(label); ok {
			result = append(result, MatchValue{IndexName: LabelIndex(label), Value: value})
		}
	}
	return result
}

        then:
        configurationCache.assertStateLoaded()
        result.assertTaskSkipped(":$spec.copyTask")

        when:
        spec.mutateExcludedFiles()

        and:
        configurationCacheRun spec.copyTask

        then:
        configurationCache.assertStateLoaded()
        result.assertTasksSkipped(":$spec.copyTask")

        where:
        spec << DefaultExcludesFixture.specs()

        file('files/b/ignore.txt').createFile()
        run 'copy'

        then:
        result.assertTaskSkipped(':copy')
        file('dest').assertHasDescendants(
            'one.txt'
        )

        when:
        file('files/a/three.txt').createFile()
        run 'copy'

        then:
        result.assertTaskNotSkipped(':copy')
        file('dest').assertHasDescendants(
            'one.txt',

            write(value.result)
        }
    }

    override suspend fun ReadContext.decode(): TransformedExternalArtifactSet {
        return decodePreservingSharedIdentity {
            val result = readNonNull<CalculatedValueContainer<ImmutableList<ResolvedArtifactSet.Artifacts>, AbstractTransformedArtifactSet.CalculateArtifacts>>()
            TransformedExternalArtifactSet(result)
        }
    }

func (s *Settings) String() string {
	result := ""

	result += fmt.Sprintf("Kubeconfigs:           %s\n", s.KubeConfig)
	result += fmt.Sprintf("LoadBalancerSupported: %v\n", s.LoadBalancerSupported)
	result += fmt.Sprintf("MCSControllerEnabled:  %v\n", s.MCSControllerEnabled)
	result += fmt.Sprintf("ControlPlaneTopology:  %v\n", s.controlPlaneTopology)
	result += fmt.Sprintf("NetworkTopology:       %v\n", s.networkTopology)

        if (exception instanceof ProjectBuildingException) {
            List<ProjectBuildingResult> results = ((ProjectBuildingException) exception).getResults();

            children = new ArrayList<>();

            for (ProjectBuildingResult result : results) {
                ExceptionSummary child = handle(result);
                if (child != null) {
                    children.add(child);
                }