org.gradle.ide.visualstudio.VisualStudioMultiProjectIntegrationTest.groovy Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of gradle-api Show documentation
Show all versions of gradle-api Show documentation
Gradle 6.9.1 API redistribution.
/*
* Copyright 2018 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.gradle.ide.visualstudio
import groovy.transform.NotYetImplemented
import org.gradle.ide.visualstudio.fixtures.AbstractVisualStudioIntegrationSpec
import org.gradle.nativeplatform.fixtures.app.CppAppWithLibrary
import org.gradle.nativeplatform.fixtures.app.CppHelloWorldApp
import org.gradle.nativeplatform.fixtures.app.ExeWithLibraryUsingLibraryHelloWorldApp
import org.gradle.util.Requires
import org.gradle.util.TestPrecondition
class VisualStudioMultiProjectIntegrationTest extends AbstractVisualStudioIntegrationSpec {
def app = new CppHelloWorldApp()
def setup() {
settingsFile << """
rootProject.name = 'app'
"""
buildFile << """
allprojects {
apply plugin: 'visual-studio'
}
"""
}
def "create visual studio solution for build without any C++ components"() {
when:
settingsFile << """
rootProject.name = 'app'
include 'one', 'two', 'three'
"""
and:
run ":visualStudio"
then:
result.assertTasksExecuted(":visualStudio", ":appVisualStudioSolution")
and:
final mainSolution = solutionFile("app.sln")
mainSolution.assertHasProjects()
}
def "includes a visual studio project for every project with a C++ component"() {
when:
settingsFile << """
rootProject.name = 'app'
include 'one', 'two', 'three'
"""
buildFile << """
apply plugin: 'cpp-application'
project(':one') {
apply plugin: 'cpp-application'
}
project(':two') {
apply plugin: 'cpp-library'
}
"""
and:
run ":visualStudio"
then:
result.assertTasksExecuted(":appVisualStudioSolution",
":appVisualStudioFilters", ":appVisualStudioProject",
":one:oneVisualStudioFilters", ":one:oneVisualStudioProject",
":two:twoDllVisualStudioFilters", ":two:twoDllVisualStudioProject",
":visualStudio")
and:
def appProject = projectFile("app.vcxproj")
def oneProject = projectFile("one/one.vcxproj")
def twoProject = projectFile("two/twoDll.vcxproj")
final mainSolution = solutionFile("app.sln")
mainSolution.assertHasProjects("app", "one", "twoDll")
mainSolution.assertReferencesProject(appProject, projectConfigurations)
mainSolution.assertReferencesProject(oneProject, projectConfigurations)
mainSolution.assertReferencesProject(twoProject, projectConfigurations)
}
def "create visual studio solution for executable that depends on a library in another project"() {
when:
app.executable.writeSources(file("exe/src/main"))
app.library.writeSources(file("lib/src/main"))
settingsFile << """
include ':exe', ':lib'
"""
file("exe", "build.gradle") << """
apply plugin: 'cpp-application'
dependencies {
implementation project(':lib')
}
"""
file("lib", "build.gradle") << """
apply plugin: 'cpp-library'
"""
and:
run ":visualStudio"
then:
result.assertTasksExecuted(":appVisualStudioSolution",
":exe:exeVisualStudioFilters", ":exe:exeVisualStudioProject",
":lib:libDllVisualStudioFilters", ":lib:libDllVisualStudioProject",
":visualStudio")
and:
final exeProject = projectFile("exe/exe.vcxproj")
exeProject.assertHasComponentSources(app.executable, "src/main")
exeProject.projectConfigurations.keySet() == projectConfigurations
exeProject.projectConfigurations.values().each {
assert it.includePath == filePath("src/main/headers", "../lib/src/main/public")
assert it.buildCommand.endsWith("gradle\" -p \"..\" :exe:install${it.name.capitalize()}")
}
and:
final dllProject = projectFile("lib/libDll.vcxproj")
dllProject.assertHasComponentSources(app.library, "src/main")
dllProject.projectConfigurations.keySet() == projectConfigurations
dllProject.projectConfigurations.values().each {
assert it.includePath == filePath("src/main/public", "src/main/headers")
assert it.buildCommand.endsWith("gradle\" -p \"..\" :lib:link${it.name.capitalize()}")
}
and:
final mainSolution = solutionFile("app.sln")
mainSolution.assertHasProjects("exe", "libDll")
mainSolution.assertReferencesProject(exeProject, projectConfigurations)
mainSolution.assertReferencesProject(dllProject, projectConfigurations)
}
def "visual studio solution does not reference the components of a project if it does not have visual studio plugin applied"() {
when:
app.executable.writeSources(file("exe/src/main"))
app.library.writeSources(file("lib/src/main"))
app.library.writeSources(file("other/src/main"))
settingsFile << """
include ':exe', ':lib', ':other'
"""
buildFile.text = """
allprojects {
if (name != 'other') {
apply plugin: 'visual-studio'
}
}
"""
file("exe", "build.gradle") << """
apply plugin: 'cpp-application'
dependencies {
implementation project(':lib')
}
"""
file("lib", "build.gradle") << """
apply plugin: 'cpp-library'
"""
file("other", "build.gradle") << """
apply plugin: 'cpp-library'
"""
and:
run ":visualStudio"
then:
result.assertTasksExecuted(":appVisualStudioSolution",
":exe:exeVisualStudioFilters", ":exe:exeVisualStudioProject",
":lib:libDllVisualStudioFilters", ":lib:libDllVisualStudioProject",
":visualStudio")
and:
final exeProject = projectFile("exe/exe.vcxproj")
exeProject.assertHasComponentSources(app.executable, "src/main")
exeProject.projectConfigurations.keySet() == projectConfigurations
exeProject.projectConfigurations.values().each {
assert it.includePath == filePath("src/main/headers", "../lib/src/main/public")
assert it.buildCommand.endsWith("gradle\" -p \"..\" :exe:install${it.name.capitalize()}")
}
and:
final dllProject = projectFile("lib/libDll.vcxproj")
dllProject.assertHasComponentSources(app.library, "src/main")
dllProject.projectConfigurations.keySet() == projectConfigurations
dllProject.projectConfigurations.values().each {
assert it.includePath == filePath("src/main/public", "src/main/headers")
assert it.buildCommand.endsWith("gradle\" -p \"..\" :lib:link${it.name.capitalize()}")
}
and:
final mainSolution = solutionFile("app.sln")
mainSolution.assertHasProjects("exe", "libDll")
mainSolution.assertReferencesProject(exeProject, projectConfigurations)
mainSolution.assertReferencesProject(dllProject, projectConfigurations)
and:
file("other").listFiles().every { !(it.name.endsWith(".vcxproj") || it.name.endsWith(".vcxproj.filters")) }
}
def "create visual studio solution for executable that transitively depends on multiple projects"() {
given:
def app = new ExeWithLibraryUsingLibraryHelloWorldApp()
app.writeSources(file("exe/src/main"), file("lib/src/main"), file("greet/src/main"))
and:
settingsFile << """
include ':exe', ':lib', ':greet'
"""
buildFile << """
project(":exe") {
apply plugin: "cpp-application"
dependencies {
implementation project(':lib')
}
}
project(":lib") {
apply plugin: "cpp-library"
dependencies {
implementation project(':greet')
}
}
project(":greet") {
apply plugin: "cpp-library"
library {
linkage = [Linkage.STATIC]
}
}
"""
when:
succeeds ":visualStudio"
then:
result.assertTasksExecuted(":appVisualStudioSolution",
":exe:exeVisualStudioFilters", ":exe:exeVisualStudioProject",
":greet:greetLibVisualStudioFilters", ":greet:greetLibVisualStudioProject",
":lib:libDllVisualStudioFilters", ":lib:libDllVisualStudioProject",
":visualStudio")
and:
final exeProject = projectFile("exe/exe.vcxproj")
final helloDllProject = projectFile("lib/libDll.vcxproj")
final greetLibProject = projectFile("greet/greetLib.vcxproj")
final mainSolution = solutionFile("app.sln")
and:
mainSolution.assertHasProjects("exe", "libDll", "greetLib")
mainSolution.assertReferencesProject(exeProject, projectConfigurations)
mainSolution.assertReferencesProject(helloDllProject, projectConfigurations)
mainSolution.assertReferencesProject(greetLibProject, projectConfigurations)
and:
exeProject.projectConfigurations['debug'].includePath == filePath("src/main/headers", "../lib/src/main/public")
helloDllProject.projectConfigurations['debug'].includePath == filePath("src/main/public", "src/main/headers", "../greet/src/main/public")
greetLibProject.projectConfigurations['debug'].includePath == filePath("src/main/public", "src/main/headers")
}
def "create visual studio solution for executable with a transitive api dependency"() {
given:
def app = new ExeWithLibraryUsingLibraryHelloWorldApp()
app.writeSources(file("exe/src/main"), file("lib/src/main"), file("greet/src/main"))
and:
settingsFile << """
include ':exe', ':lib', ':greet'
"""
buildFile << """
project(":exe") {
apply plugin: "cpp-application"
dependencies {
implementation project(':lib')
}
}
project(":lib") {
apply plugin: "cpp-library"
dependencies {
api project(':greet')
}
}
project(":greet") {
apply plugin: "cpp-library"
library {
linkage = [Linkage.STATIC]
}
}
"""
when:
succeeds ":visualStudio"
then:
result.assertTasksExecuted(":appVisualStudioSolution",
":exe:exeVisualStudioFilters", ":exe:exeVisualStudioProject",
":greet:greetLibVisualStudioFilters", ":greet:greetLibVisualStudioProject",
":lib:libDllVisualStudioFilters", ":lib:libDllVisualStudioProject",
":visualStudio")
and:
final exeProject = projectFile("exe/exe.vcxproj")
final helloDllProject = projectFile("lib/libDll.vcxproj")
final greetLibProject = projectFile("greet/greetLib.vcxproj")
final mainSolution = solutionFile("app.sln")
and:
mainSolution.assertHasProjects("exe", "libDll", "greetLib")
mainSolution.assertReferencesProject(exeProject, projectConfigurations)
mainSolution.assertReferencesProject(helloDllProject, projectConfigurations)
mainSolution.assertReferencesProject(greetLibProject, projectConfigurations)
and:
exeProject.projectConfigurations['debug'].includePath == filePath("src/main/headers", "../lib/src/main/public", "../greet/src/main/public")
helloDllProject.projectConfigurations['debug'].includePath == filePath("src/main/public", "src/main/headers", "../greet/src/main/public")
greetLibProject.projectConfigurations['debug'].includePath == filePath("src/main/public", "src/main/headers")
}
@Requires(TestPrecondition.MSBUILD)
def "can build executable that depends on static library in another project from visual studio"() {
useMsbuildTool()
def app = new CppAppWithLibrary()
given:
app.greeter.writeToProject(file("lib"))
app.main.writeToProject(file("exe"))
settingsFile << """
include ':exe', ':lib'
"""
file("exe", "build.gradle") << """
apply plugin: 'cpp-application'
dependencies {
implementation project(':lib')
}
"""
file("lib", "build.gradle") << """
apply plugin: 'cpp-library'
library {
linkage = [Linkage.STATIC]
}
"""
succeeds ":visualStudio"
when:
def resultDebug = msbuild
.withSolution(solutionFile('app.sln'))
.withConfiguration('debug')
.withProject("exe")
.succeeds()
then:
resultDebug.size() == 1
resultDebug[0].assertTasksExecuted(':exe:compileDebugCpp', ':exe:linkDebug', ':exe:installDebug', ':lib:compileDebugCpp', ':lib:createDebug')
installation('exe/build/install/main/debug').assertInstalled()
}
@Requires(TestPrecondition.MSBUILD)
def "skip unbuildable static library project when building solution from visual studio"() {
useMsbuildTool()
def app = new CppAppWithLibrary()
given:
app.greeter.writeToProject(file("lib"))
app.main.writeToProject(file("exe"))
settingsFile << """
include ':exe', ':lib'
"""
file("exe", "build.gradle") << """
apply plugin: 'cpp-application'
dependencies {
implementation project(':lib')
}
"""
file("lib", "build.gradle") << """
apply plugin: 'cpp-library'
library {
linkage = [Linkage.STATIC]
targetMachines = [machines.os('os-family')]
}
"""
succeeds ":visualStudio"
when:
def resultUnbuildableSolution = msbuild
.withSolution(solutionFile('app.sln'))
.withConfiguration('unbuildable')
.succeeds()
then:
resultUnbuildableSolution.size() == 1
resultUnbuildableSolution[0].executedTasks == []
resultUnbuildableSolution[0].assertOutputContains('The project "exe" is not selected for building in solution configuration "unbuildable|Win32".')
resultUnbuildableSolution[0].assertOutputContains('The project "libLib" is not selected for building in solution configuration "unbuildable|Win32".')
installation('exe/build/install/main/debug').assertNotInstalled()
when:
def resultDebug = msbuild
.withSolution(solutionFile('app.sln'))
.withConfiguration('debug')
.fails()
then:
resultDebug.executedTasks == []
resultDebug.assertHasCause("Could not resolve all task dependencies for configuration ':exe:nativeRuntimeDebug'.")
resultDebug.assertHasCause("Could not resolve project :lib.")
installation('exe/build/install/main/debug').assertNotInstalled()
}
@NotYetImplemented
def "create visual studio solution where multiple projects have same name"() {
given:
def app = new ExeWithLibraryUsingLibraryHelloWorldApp()
app.writeSources(file("exe/src/main"), file("some/lib/src/main"), file("other/lib/src/main"))
and:
settingsFile << """
include ':exe', ':some:lib', ':other:lib'
"""
buildFile << """
project(":exe") {
apply plugin: "cpp-application"
dependencies {
implementation project(':some:lib')
}
}
project(":some:lib") {
apply plugin: "cpp-library"
dependencies {
implementation project(':other:lib')
}
}
project(":other:lib") {
apply plugin: "cpp-library"
}
"""
when:
succeeds ":visualStudio"
then:
final exeProject = projectFile("exe/exe.vcxproj")
final someLibProject = projectFile("some/lib/libDll.vcxproj")
final otherLibProject = projectFile("other/lib/libDll.vcxproj")
final mainSolution = solutionFile("app.sln")
and:
mainSolution.assertHasProjects("exe", "libDll", "libDll")
mainSolution.assertReferencesProject(exeProject, projectConfigurations)
mainSolution.assertReferencesProject(someLibProject, projectConfigurations)
mainSolution.assertReferencesProject(otherLibProject, projectConfigurations)
and:
exeProject.projectConfigurations['debug'].includePath == filePath("src/main/headers", "../some/lib/src/main/public")
someLibProject.projectConfigurations['debug'].includePath == filePath("src/main/public", "src/main/headers", "../other/lib/src/main/public")
otherLibProject.projectConfigurations['debug'].includePath == filePath("src/main/public", "src/main/headers")
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy