public boolean isEmpty() {
        return results.isEmpty();
    }

    private static class Registration {
        private final ResolvableSelectorState selector;
        private ComponentIdResolveResult result;

        private Registration(ResolvableSelectorState selector, ComponentIdResolveResult result) {
            this.selector = selector;
            this.result = result;
        }

        @Override

// captured resource typed value is used for all region results, then that value
// is forwared to the result and the result is dropped.
LogicalResult CanonicalizeRegionIfCaseCluster(Operation *op) {
  // Check if the same value is used for all region results for this output.
  bool has_resource_result = false;
  for (OpResult result : op->getResults()) {
    if (!IsResource(result)) continue;
    has_resource_result = true;

        this.projectId = projectId;
        this.pomFile = pomFile;
    }

    public ProjectBuildingException(List<ProjectBuildingResult> results) {
        super("Some problems were encountered while processing the POMs");
        this.projectId = "";
        this.results = results;
    }

    public File getPomFile() {
        return pomFile;
    }

    /**
     * @deprecated use {@link #getPomFile()}
     */

import org.gradle.api.Action;
import org.gradle.api.GradleException;
import org.gradle.api.internal.tasks.testing.junit.result.TestClassResult;
import org.gradle.api.internal.tasks.testing.junit.result.TestFailure;
import org.gradle.api.internal.tasks.testing.junit.result.TestMethodResult;
import org.gradle.api.internal.tasks.testing.junit.result.TestResultsProvider;
import org.gradle.api.logging.Logger;
import org.gradle.api.logging.Logging;

            Test test = (Test) result;
            dirs.from(test.getBinaryResultsDirectory());
        } else if (result instanceof Iterable<?>) {
            Iterable<?> iterable = (Iterable<?>) result;
            for (Object nested : iterable) {
                addTo(nested, dirs);
            }
        } else {
            dirs.from(result);
        }
    }

    /**
     * Adds some results to include in the report.

app = FastAPI()


@app.get("/items/")
async def read_items(
    q: Annotated[Union[str, None], Query(min_length=3, max_length=50)] = None,
):
    results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
    if q:
        results.update({"q": q})

        objectListing.getCommonPrefixes() >> ['root/SNAPSHOT']

        S3ResourceResolver resolver = new S3ResourceResolver()

        when:
        def results = resolver.resolveResourceNames(objectListing)

        then:
        results == ['some.jar', 'someOther.jar', 'SNAPSHOT']
    }

    def "should clean common prefixes"() {
        setup:
        ObjectListing objectListing = Mock()

}

func ToStringKey(values ...interface{}) string {
	results := make([]string, len(values))

	for idx, value := range values {
		if valuer, ok := value.(driver.Valuer); ok {
			value, _ = valuer.Value()
		}

		switch v := value.(type) {
		case string:
			results[idx] = v
		case []byte:
			results[idx] = string(v)
		case uint:
			results[idx] = strconv.FormatUint(uint64(v), 10)
		default:

                        id = "ARTIFACT_DEPENDENCY_${performanceTest.id!!}"
                        cleanDestination = true
                        val perfResultArtifactRule = """results/performance/build/test-results-*.zip!performance-tests/perf-results*.json => $performanceResultsDir/${performanceTest.bucketIndex}/"""
                        artifactRules = if (index == 0) {

// Otherwise, allow folding if we do not know the shape of an operand or
// result i.e., one of these values has non-static shape. If we know all the
// shapes, find the total size of the operands and results. Folding of the op is
// allowed if one of the following conditions are met:
// 1. size of results is less than a certain threshold
// (`kResultsSizeThreshold`), or
// 2. size of results is within a factor (`kSizeFactor`) of size of operands, or