Search in sources :

Example 1 with ProductionCppComponent

use of org.gradle.language.cpp.ProductionCppComponent in project gradle by gradle.

the class CppUnitTestPlugin method configureTestSuiteWithTestedComponentWhenAvailable.

private void configureTestSuiteWithTestedComponentWhenAvailable(Project project, DefaultCppTestSuite testSuite, DefaultCppTestExecutable testExecutable) {
    CppComponent target = testSuite.getTestedComponent().getOrNull();
    if (!(target instanceof ProductionCppComponent)) {
        return;
    }
    final ProductionCppComponent testedComponent = (ProductionCppComponent) target;
    final TaskContainer tasks = project.getTasks();
    testedComponent.getBinaries().whenElementFinalized(testedBinary -> {
        if (!isTestedBinary(testExecutable, testedComponent, testedBinary)) {
            return;
        }
        // TODO - move this to a base plugin
        // Setup the dependency on the main binary
        // This should all be replaced by a single dependency that points at some "testable" variants of the main binary
        // Inherit implementation dependencies
        testExecutable.getImplementationDependencies().extendsFrom(((DefaultCppBinary) testedBinary).getImplementationDependencies());
        // Configure test binary to link against tested component compiled objects
        ConfigurableFileCollection testableObjects = project.files();
        if (target instanceof CppApplication) {
            // TODO - this should be an outgoing variant of the component under test
            TaskProvider<UnexportMainSymbol> unexportMainSymbol = tasks.register(testExecutable.getNames().getTaskName("relocateMainFor"), UnexportMainSymbol.class, task -> {
                String dirName = ((DefaultCppBinary) testedBinary).getNames().getDirName();
                task.getOutputDirectory().set(project.getLayout().getBuildDirectory().dir("obj/for-test/" + dirName));
                task.getObjects().from(testedBinary.getObjects());
            });
            testableObjects.from(unexportMainSymbol.map(task -> task.getRelocatedObjects()));
        } else {
            testableObjects.from(testedBinary.getObjects());
        }
        Dependency linkDependency = project.getDependencies().create(testableObjects);
        testExecutable.getLinkConfiguration().getDependencies().add(linkDependency);
    });
}
Also used : ConfigurableFileCollection(org.gradle.api.file.ConfigurableFileCollection) NativeTestingBasePlugin(org.gradle.nativeplatform.test.plugins.NativeTestingBasePlugin) UnexportMainSymbol(org.gradle.language.nativeplatform.tasks.UnexportMainSymbol) DefaultCppTestSuite(org.gradle.nativeplatform.test.cpp.internal.DefaultCppTestSuite) Callable(java.util.concurrent.Callable) Dimensions.tryToBuildOnHost(org.gradle.language.nativeplatform.internal.Dimensions.tryToBuildOnHost) NativePlatform(org.gradle.nativeplatform.platform.NativePlatform) DefaultCppBinary(org.gradle.language.cpp.internal.DefaultCppBinary) CppPlatform(org.gradle.language.cpp.CppPlatform) Inject(javax.inject.Inject) LifecycleBasePlugin(org.gradle.language.base.plugins.LifecycleBasePlugin) DefaultNativePlatform(org.gradle.nativeplatform.platform.internal.DefaultNativePlatform) TaskProvider(org.gradle.api.tasks.TaskProvider) TargetMachineFactory(org.gradle.nativeplatform.TargetMachineFactory) CppComponent(org.gradle.language.cpp.CppComponent) CppApplication(org.gradle.language.cpp.CppApplication) ImmutableAttributesFactory(org.gradle.api.internal.attributes.ImmutableAttributesFactory) NativeComponentFactory(org.gradle.language.internal.NativeComponentFactory) ConfigurableComponentWithLinkUsage(org.gradle.language.nativeplatform.internal.ConfigurableComponentWithLinkUsage) ProductionCppComponent(org.gradle.language.cpp.ProductionCppComponent) DefaultCppTestExecutable(org.gradle.nativeplatform.test.cpp.internal.DefaultCppTestExecutable) Project(org.gradle.api.Project) TargetMachine(org.gradle.nativeplatform.TargetMachine) Dimensions(org.gradle.language.nativeplatform.internal.Dimensions) InstallExecutable(org.gradle.nativeplatform.tasks.InstallExecutable) ToolChainSelector(org.gradle.language.nativeplatform.internal.toolchains.ToolChainSelector) CppTestSuite(org.gradle.nativeplatform.test.cpp.CppTestSuite) CppTestExecutable(org.gradle.nativeplatform.test.cpp.CppTestExecutable) SetProperty(org.gradle.api.provider.SetProperty) ProviderFactory(org.gradle.api.provider.ProviderFactory) Stream(java.util.stream.Stream) ObjectFactory(org.gradle.api.model.ObjectFactory) TaskContainer(org.gradle.api.tasks.TaskContainer) CppBinary(org.gradle.language.cpp.CppBinary) CppBasePlugin(org.gradle.language.cpp.plugins.CppBasePlugin) Dependency(org.gradle.api.artifacts.Dependency) Plugin(org.gradle.api.Plugin) RunTestExecutable(org.gradle.nativeplatform.test.tasks.RunTestExecutable) DefaultCppPlatform(org.gradle.language.cpp.internal.DefaultCppPlatform) TaskContainer(org.gradle.api.tasks.TaskContainer) CppComponent(org.gradle.language.cpp.CppComponent) ProductionCppComponent(org.gradle.language.cpp.ProductionCppComponent) ConfigurableFileCollection(org.gradle.api.file.ConfigurableFileCollection) CppApplication(org.gradle.language.cpp.CppApplication) UnexportMainSymbol(org.gradle.language.nativeplatform.tasks.UnexportMainSymbol) Dependency(org.gradle.api.artifacts.Dependency) ProductionCppComponent(org.gradle.language.cpp.ProductionCppComponent)

Example 2 with ProductionCppComponent

use of org.gradle.language.cpp.ProductionCppComponent in project gradle by gradle.

the class CppUnitTestPlugin method apply.

@Override
public void apply(final ProjectInternal project) {
    project.getPluginManager().apply(CppBasePlugin.class);
    project.getPluginManager().apply(NativeTestingBasePlugin.class);
    // Add the unit test and extension
    final DefaultCppTestSuite testComponent = componentFactory.newInstance(CppTestSuite.class, DefaultCppTestSuite.class, "test");
    project.getExtensions().add(CppTestSuite.class, "unitTest", testComponent);
    project.getComponents().add(testComponent);
    testComponent.getBaseName().set(project.getName() + "Test");
    project.afterEvaluate(new Action<Project>() {

        @Override
        public void execute(final Project project) {
            testComponent.getOperatingSystems().lockNow();
            Set<OperatingSystemFamily> operatingSystemFamilies = testComponent.getOperatingSystems().get();
            if (operatingSystemFamilies.isEmpty()) {
                throw new IllegalArgumentException("An operating system needs to be specified for the unit test.");
            }
            boolean hasHostOperatingSystem = CollectionUtils.any(operatingSystemFamilies, new Spec<OperatingSystemFamily>() {

                @Override
                public boolean isSatisfiedBy(OperatingSystemFamily element) {
                    return DefaultNativePlatform.getCurrentOperatingSystem().toFamilyName().equals(element.getName());
                }
            });
            if (hasHostOperatingSystem) {
                String operatingSystemSuffix = "";
                OperatingSystemFamily operatingSystem = objectFactory.named(OperatingSystemFamily.class, DefaultNativePlatform.getCurrentOperatingSystem().toFamilyName());
                Usage runtimeUsage = objectFactory.named(Usage.class, Usage.NATIVE_RUNTIME);
                Provider<String> group = project.provider(new Callable<String>() {

                    @Override
                    public String call() throws Exception {
                        return project.getGroup().toString();
                    }
                });
                Provider<String> version = project.provider(new Callable<String>() {

                    @Override
                    public String call() throws Exception {
                        return project.getVersion().toString();
                    }
                });
                AttributeContainer attributesDebug = attributesFactory.mutable();
                attributesDebug.attribute(Usage.USAGE_ATTRIBUTE, runtimeUsage);
                attributesDebug.attribute(DEBUGGABLE_ATTRIBUTE, true);
                attributesDebug.attribute(OPTIMIZED_ATTRIBUTE, false);
                // TODO: Fix this naming convention to follow C++ executable/library
                NativeVariantIdentity debugVariant = new NativeVariantIdentity("debug" + operatingSystemSuffix, testComponent.getBaseName(), group, version, true, false, operatingSystem, null, new DefaultUsageContext("debug" + operatingSystemSuffix + "Runtime", runtimeUsage, attributesDebug));
                ToolChainSelector.Result<CppPlatform> result = toolChainSelector.select(CppPlatform.class);
                testComponent.addExecutable("executable", debugVariant, result.getTargetPlatform(), result.getToolChain(), result.getPlatformToolProvider());
                // TODO: Publishing for test executable?
                final TaskContainer tasks = project.getTasks();
                final ProductionCppComponent mainComponent = project.getComponents().withType(ProductionCppComponent.class).findByName("main");
                if (mainComponent != null) {
                    testComponent.getTestedComponent().set(mainComponent);
                }
                testComponent.getBinaries().whenElementKnown(DefaultCppTestExecutable.class, new Action<DefaultCppTestExecutable>() {

                    @Override
                    public void execute(final DefaultCppTestExecutable executable) {
                        if (mainComponent != null) {
                            // TODO: This should be modeled as a kind of dependency vs wiring binaries together directly.
                            mainComponent.getBinaries().whenElementFinalized(new Action<CppBinary>() {

                                @Override
                                public void execute(CppBinary cppBinary) {
                                    if (cppBinary == mainComponent.getDevelopmentBinary().get()) {
                                        AbstractLinkTask linkTest = executable.getLinkTask().get();
                                        linkTest.source(cppBinary.getObjects());
                                    }
                                }
                            });
                        }
                        // TODO: Replace with native test task
                        final RunTestExecutable testTask = tasks.create(executable.getNames().getTaskName("run"), RunTestExecutable.class);
                        testTask.setGroup(LifecycleBasePlugin.VERIFICATION_GROUP);
                        testTask.setDescription("Executes C++ unit tests.");
                        final InstallExecutable installTask = executable.getInstallTask().get();
                        testTask.onlyIf(new Spec<Task>() {

                            @Override
                            public boolean isSatisfiedBy(Task element) {
                                return executable.getInstallDirectory().get().getAsFile().exists();
                            }
                        });
                        testTask.setExecutable(installTask.getRunScriptFile().get().getAsFile());
                        testTask.dependsOn(testComponent.getTestBinary().get().getInstallDirectory());
                        // TODO: Honor changes to build directory
                        testTask.setOutputDir(project.getLayout().getBuildDirectory().dir("test-results/" + executable.getNames().getDirName()).get().getAsFile());
                        executable.getRunTask().set(testTask);
                    }
                });
            }
            testComponent.getBinaries().realizeNow();
        }
    });
}
Also used : OperatingSystemFamily(org.gradle.nativeplatform.OperatingSystemFamily) Action(org.gradle.api.Action) Task(org.gradle.api.Task) AbstractLinkTask(org.gradle.nativeplatform.tasks.AbstractLinkTask) Set(java.util.Set) AttributeContainer(org.gradle.api.attributes.AttributeContainer) Callable(java.util.concurrent.Callable) CppPlatform(org.gradle.language.cpp.CppPlatform) DefaultCppTestExecutable(org.gradle.nativeplatform.test.cpp.internal.DefaultCppTestExecutable) InstallExecutable(org.gradle.nativeplatform.tasks.InstallExecutable) DefaultUsageContext(org.gradle.language.cpp.internal.DefaultUsageContext) Usage(org.gradle.api.attributes.Usage) CppBinary(org.gradle.language.cpp.CppBinary) NativeVariantIdentity(org.gradle.language.cpp.internal.NativeVariantIdentity) Provider(org.gradle.api.provider.Provider) ProductionCppComponent(org.gradle.language.cpp.ProductionCppComponent) RunTestExecutable(org.gradle.nativeplatform.test.tasks.RunTestExecutable) Project(org.gradle.api.Project) TaskContainer(org.gradle.api.tasks.TaskContainer) Spec(org.gradle.api.specs.Spec) AbstractLinkTask(org.gradle.nativeplatform.tasks.AbstractLinkTask) DefaultCppTestSuite(org.gradle.nativeplatform.test.cpp.internal.DefaultCppTestSuite)

Example 3 with ProductionCppComponent

use of org.gradle.language.cpp.ProductionCppComponent in project gradle by gradle.

the class CppBasePlugin method apply.

@Override
public void apply(final ProjectInternal project) {
    project.getPluginManager().apply(NativeBasePlugin.class);
    project.getPluginManager().apply(StandardToolChainsPlugin.class);
    final TaskContainerInternal tasks = project.getTasks();
    final DirectoryProperty buildDirectory = project.getLayout().getBuildDirectory();
    // Enable the use of Gradle metadata. This is a temporary opt-in switch until available by default
    project.getGradle().getServices().get(FeaturePreviews.class).enableFeature(GRADLE_METADATA);
    // Create the tasks for each C++ binary that is registered
    project.getComponents().withType(DefaultCppBinary.class, new Action<DefaultCppBinary>() {

        @Override
        public void execute(final DefaultCppBinary binary) {
            final Names names = binary.getNames();
            String language = "cpp";
            final NativePlatform currentPlatform = binary.getTargetPlatform();
            // TODO - make this lazy
            final NativeToolChainInternal toolChain = binary.getToolChain();
            Callable<List<File>> systemIncludes = new Callable<List<File>>() {

                @Override
                public List<File> call() {
                    PlatformToolProvider platformToolProvider = binary.getPlatformToolProvider();
                    return platformToolProvider.getSystemLibraries(ToolType.CPP_COMPILER).getIncludeDirs();
                }
            };
            CppCompile compile = tasks.create(names.getCompileTaskName(language), CppCompile.class);
            compile.includes(binary.getCompileIncludePath());
            compile.includes(systemIncludes);
            compile.source(binary.getCppSource());
            if (binary.isDebuggable()) {
                compile.setDebuggable(true);
            }
            if (binary.isOptimized()) {
                compile.setOptimized(true);
            }
            compile.getTargetPlatform().set(currentPlatform);
            compile.getToolChain().set(toolChain);
            compile.getObjectFileDir().set(buildDirectory.dir("obj/" + names.getDirName()));
            binary.getObjectsDir().set(compile.getObjectFileDir());
            binary.getCompileTask().set(compile);
        }
    });
    project.getComponents().withType(CppSharedLibrary.class, new Action<CppSharedLibrary>() {

        @Override
        public void execute(CppSharedLibrary library) {
            library.getCompileTask().get().setPositionIndependentCode(true);
        }
    });
    project.getComponents().withType(ProductionCppComponent.class, new Action<ProductionCppComponent>() {

        @Override
        public void execute(final ProductionCppComponent component) {
            project.afterEvaluate(new Action<Project>() {

                @Override
                public void execute(Project project) {
                    DefaultCppComponent componentInternal = (DefaultCppComponent) component;
                    publicationRegistry.registerPublication(project.getPath(), new DefaultProjectPublication(componentInternal.getDisplayName(), new SwiftPmTarget(component.getBaseName().get()), false));
                }
            });
        }
    });
}
Also used : Action(org.gradle.api.Action) Callable(java.util.concurrent.Callable) Names(org.gradle.language.nativeplatform.internal.Names) NativeToolChainInternal(org.gradle.nativeplatform.toolchain.internal.NativeToolChainInternal) List(java.util.List) CppSharedLibrary(org.gradle.language.cpp.CppSharedLibrary) FeaturePreviews(org.gradle.api.internal.FeaturePreviews) DefaultCppBinary(org.gradle.language.cpp.internal.DefaultCppBinary) SwiftPmTarget(org.gradle.swiftpm.internal.SwiftPmTarget) TaskContainerInternal(org.gradle.api.internal.tasks.TaskContainerInternal) ProductionCppComponent(org.gradle.language.cpp.ProductionCppComponent) Project(org.gradle.api.Project) DefaultCppComponent(org.gradle.language.cpp.internal.DefaultCppComponent) DirectoryProperty(org.gradle.api.file.DirectoryProperty) PlatformToolProvider(org.gradle.nativeplatform.toolchain.internal.PlatformToolProvider) NativePlatform(org.gradle.nativeplatform.platform.NativePlatform) CppCompile(org.gradle.language.cpp.tasks.CppCompile) DefaultProjectPublication(org.gradle.api.internal.artifacts.ivyservice.projectmodule.DefaultProjectPublication) File(java.io.File)

Aggregations

Callable (java.util.concurrent.Callable)3 Project (org.gradle.api.Project)3 ProductionCppComponent (org.gradle.language.cpp.ProductionCppComponent)3 Action (org.gradle.api.Action)2 TaskContainer (org.gradle.api.tasks.TaskContainer)2 CppBinary (org.gradle.language.cpp.CppBinary)2 CppPlatform (org.gradle.language.cpp.CppPlatform)2 DefaultCppBinary (org.gradle.language.cpp.internal.DefaultCppBinary)2 NativePlatform (org.gradle.nativeplatform.platform.NativePlatform)2 InstallExecutable (org.gradle.nativeplatform.tasks.InstallExecutable)2 DefaultCppTestExecutable (org.gradle.nativeplatform.test.cpp.internal.DefaultCppTestExecutable)2 DefaultCppTestSuite (org.gradle.nativeplatform.test.cpp.internal.DefaultCppTestSuite)2 RunTestExecutable (org.gradle.nativeplatform.test.tasks.RunTestExecutable)2 File (java.io.File)1 List (java.util.List)1 Set (java.util.Set)1 Stream (java.util.stream.Stream)1 Inject (javax.inject.Inject)1 Plugin (org.gradle.api.Plugin)1 Task (org.gradle.api.Task)1