abstract class AbstractCppPublishingIntegrationTest extends AbstractInstalledToolChainIntegrationSpec implements CppTaskNames {

    abstract int getVariantCount(List<Map<String,String>> targetMachines)
    abstract List<String> getLinkages()
    abstract List<String> getMainModuleArtifacts(String module, String version)
    abstract List<String> getVariantModuleArtifacts(String variantModuleNameWithVersion)

    }

    @Override
    int getVariantCount(List<Map<String, String>> targetMachines) {
        return 2 * linkages.size() * targetMachines.size() + 1
    }

    @Override
    List<String> getLinkages() {
        return ['Link', 'Runtime']
    }

    @Override
    List<String> getMainModuleArtifacts(String module, String version) {

        run("install")

        then:
        def installation = installation("consumer/install")
        installation.exec().out == app.expectedOutput
    }

    @Override
    List<String> getLinkages() {
        return ['Runtime']
    }

    @Override
    List<String> getMainModuleArtifacts(String module, String version) {
        return ["${module}-${version}.pom", "${module}-${version}.module"]
    }

    }

    @Override
    List<String> getLinkages() {
        return ['Link', 'Runtime']
    }

    @Override
    List<String> getMainModuleArtifacts(String module, String version) {

            }
        }
    }

    private String getLinkage(NativeBinaryRequirementResolveResult resolution) {
        if (resolution.getRequirement() == null) {
            return null;
        }
        return resolution.getRequirement().getLinkage();
    }

    private static class ApiAdaptedNativeLibraryRequirement implements NativeLibraryRequirement {

    private final Linkage linkage;

    public DefaultLibraryProduct(String name, DefaultTarget target, Linkage linkage) {
        super(name, target);
        this.linkage = linkage;
    }

    public Linkage getLinkage() {
        return linkage;
    }

    @Override
    public boolean isExecutable() {
        return false;
    }

                    }
                    targets.add(target);

                    if (library.getLinkage().get().contains(Linkage.SHARED)) {
                        products.add(new DefaultLibraryProduct(p.getName(), target, Linkage.SHARED));
                    }
                    if (library.getLinkage().get().contains(Linkage.STATIC)) {

        }

        public NativeLibraryBinary resolveLibrary(DomainObjectSet<NativeLibraryBinary> allBinaries) {
            Class<? extends NativeLibraryBinary> type = getTypeForLinkage(requirement.getLinkage());
            DomainObjectSet<? extends NativeLibraryBinary> candidateBinaries = allBinaries.withType(type);
            return resolve(candidateBinaries);
        }

     */
    String getProjectPath();

    /**
     * The name of the required library.
     */
    String getLibraryName();

    /**
     * The required linkage.
     */
    String getLinkage();

    /**
     * Creates a copy of this requirement with the specified project path
     */
    NativeLibraryRequirement withProjectPath(String projectPath);

 */
public interface ConfigurableComponentWithLinkUsage extends ComponentWithLinkUsage, ComponentWithNames {
    Configuration getImplementationDependencies();

    @Nullable
    Linkage getLinkage();

    @Override
    Property<Configuration> getLinkElements();

    Provider<RegularFile> getLinkFile();

    AttributeContainer getLinkAttributes();