componentMetadataVersionListerFactory,
            injector,
            checksumService);
        this.dynamicResolve = dynamicResolve;
        this.m2Compatible = descriptor.isM2Compatible();
        this.localRepositoryAccess = new IvyLocalRepositoryAccess();
        this.remoteRepositoryAccess = new IvyRemoteRepositoryAccess();
    }

    @Override
    public String toString() {

    }

    @Override
    public Type getType() {
        return Type.IVY;
    }

    public List<String> getArtifactPatterns() {
        return artifactPatterns;
    }

    public boolean isM2Compatible() {
        return m2Compatible;
    }

    @Override
    protected void addProperties(ImmutableSortedMap.Builder<String, Object> builder) {
        super.addProperties(builder);

            ]
        ) {
            appendId(_) >> {}
            getLocalAccess() >> Stub(ModuleComponentRepositoryAccess)
            getRemoteAccess() >> Stub(ModuleComponentRepositoryAccess)
            isM2compatible() >> true
        }
    }

        CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA.javaName,
      )
    assertThat(tlsSpec.isCompatible(socket)).isTrue()
    socket.enabledCipherSuites =
      arrayOf(
        CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA.javaName,
      )
    assertThat(tlsSpec.isCompatible(socket)).isFalse()
  }

  @Test
  fun allEnabledCipherSuites() {
    platform.assumeNotConscrypt()

                        var isCompatible = true
                        val languageVersionSettings = analysisContext.resolveSession.languageVersionSettings
                        if (languageVersionSettings.supportsFeature(LanguageFeature.ProhibitComparisonOfIncompatibleEnums)) {
                            isCompatible = isCompatible && typeParameterOwner.classId != StandardClassIds.Enum
                        }

package org.gradle.api.internal.attributes;

import org.gradle.api.attributes.CompatibilityCheckDetails;

public interface CompatibilityCheckResult<T> extends CompatibilityCheckDetails<T> {
    boolean hasResult();
    boolean isCompatible();

        } else if (versions.latestVersion != null && !versions.latestVersion.isEmpty()) {
            version = versions.latestVersion;
            repo = versions.latestRepository;
        }
        if (version != null && !isCompatible(request, version)) {
            logger.info(
                    "Latest version of plugin {}:{} failed compatibility check",
                    request.getGroupId(),
                    request.getArtifactId());

        assert !Objects.equals(consumerValue, producerValue);
        this.consumerValue = consumerValue;
        this.producerValue = producerValue;
    }

    @Override
    public boolean isCompatible() {
        assert done;
        return compatible;
    }

    @Override
    public boolean hasResult() {
        return done;
    }

    @Override
    public T getConsumerValue() {

    BloomFilter<Integer> bf2 = BloomFilter.create(Funnels.integerFunnel(), 10);

    assertFalse(bf1.isCompatible(bf2));
    assertThrows(
        IllegalArgumentException.class,
        () -> {
          bf1.putAll(bf2);
        });

    assertFalse(bf2.isCompatible(bf1));
    assertThrows(
        IllegalArgumentException.class,
        () -> {
          bf2.putAll(bf1);
        });

                result = new DefaultCompatibilityCheckResult<>(requested, candidate);
                rules.execute(result);
                if (result.hasResult()) {
                    return result.isCompatible();
                }
            }

            rules = producerSchema.compatibilityRules(attribute);
            if (rules.doesSomething()) {
                if (result == null) {