aggregations.forEach(aggregation -> {
            if (aggregation.getName().startsWith(Constants.FACET_FIELD_PREFIX)) {
                final Terms termFacet = (Terms) aggregation;
                fieldList.add(new Field(termFacet));
            } else if (aggregation.getName().startsWith(Constants.FACET_QUERY_PREFIX)) {
                final Filter queryFacet = (Filter) aggregation;

            }
        }
        if (!variant.getCapabilities().isEmpty()) {
            for (Capability capability : variant.getCapabilities()) {
                warnings.addVariantUnsupported(String.format("Declares capability %s:%s:%s which cannot be mapped to Ivy", capability.getGroup(), capability.getName(), capability.getVersion()));
            }

    for (Method method : FuturesTest.class.getDeclaredMethods()) {
      if (Modifier.isPublic(method.getModifiers()) && method.getName().startsWith("test")) {
        suite.addTest(
            TestSuite.createTest(
                AggregateFutureStateFallbackAtomicHelperTest.class, method.getName()));
      }
    }
    return suite;
  }

  @Override

        assertEquals("p0-org", p0.getOrganization().getName());

        // ----------------------------------------------------------------------
        // Check p1 value for org name
        // ----------------------------------------------------------------------

        MavenProject p1 = getProject(projectFile("maven.t01", "p1"));

        assertEquals("p1-org", p1.getOrganization().getName());

        final Configuration variant = project.getConfigurations().consumable(TEST_RESULTS_ELEMENTS_VARIANT_PREFIX + StringUtils.capitalize(target.getName())).get();
        variant.setDescription("Directory containing binary results of running tests for the " + suite.getName() + " Test Suite's " + target.getName() + " target.");
        variant.setVisible(false);

        final ObjectFactory objects = project.getObjects();

            @Override
            public String getGroup() {
                return identifier.getGroup();
            }

            @Override
            public String getName() {
                return identifier.getName();
            }

            @Override
            public String getVersion() {
                return identifier.getVersion();
            }
        };
    }

        when:
        buildScript '''
            @Managed
            interface Person {
                String getName()
                void setName(String name)
            }

            @Managed
            interface Names {
                String getName()
                void setName(String name)
            }

            class RulePlugin extends RuleSource {
                @Model

        final PathInfo pi = convertToItem(id);
        if (StringUtil.isEmpty(pi.getName())) {
            throwValidationErrorApi(messages -> messages.addErrorsStorageFileNotFound(GLOBAL));
        }
        return asStream(pi.getName()).contentTypeOctetStream().stream(out -> {
            try {
                downloadObject(getObjectName(pi.getPath(), pi.getName()), out);
            } catch (final StorageException e) {

            collectionType.getName(), elementType.getName());

        T sanitized = sanitizer.sanitize(value);
        if (!elementType.isInstance(sanitized)) {
            throw new IllegalArgumentException(String.format(
                "Cannot get the value of a property of type %s with element type %s as the source value contains an element of type %s.",

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (isSetter(method)) {
            properties.put(getPropertyName(method.getName()), args[0]);
        } else if (isGetter(method)) {
            return properties.get(getPropertyName(method.getName()));
        }
        return null;
    }

    /**
     * Check if the given interface can be instantiated by this proxy.
     * <p>