* 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.
 */

allprojects {
    tasks.withType(JavaCompile).configureEach {
        outputs.doNotCacheIf("CodeQL scanning", { true })
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

plugins {
    id 'java-library'
}

allprojects {
    repositories {
        mavenCentral()
    }
}

dependencies {
    implementation project(":lib")

                .assertHasFileName("Build file '$buildFile'")
                .assertHasLineNumber(3)
    }

    def "produces reasonable error when Gradle.allprojects action fails"() {
        def initScript = initScript """
allprojects {
    throw new RuntimeException("broken")
}
"""
        when:
        executer.usingInitScript(initScript)
        fails "a"

        then:

import spock.lang.Timeout

import static org.gradle.integtests.fixtures.ToBeFixedForConfigurationCache.Skip.INVESTIGATE

@Requires(IntegTestPreconditions.NotParallelExecutor)
@ToBeFixedForIsolatedProjects(because = "allprojects")
// no point, always runs in parallel
class ParallelTaskExecutionIntegrationTest extends AbstractIntegrationSpec implements ValidationMessageChecker {

    @Rule

        return StringUtils.capitalize(getName())
    }

    String getCompileTaskName() {
        return "compile${name.capitalize()}"
    }

    String projectGroovyDependencies(String allprojectsOrSubproject= 'allprojects') {
        this == GROOVY ?
            """
            ${allprojectsOrSubproject} {
                dependencies {
                    implementation localGroovy()
                }
            }
"""

        mavenRepo.module("group", "test2", "1.0").publish()

        createDirs("child1", "child2")
        settingsFile << """
rootProject.name = "main"
include "child1", "child2"
"""
        buildFile << """
allprojects {
    repositories {
        maven { url '${mavenRepo.uri}' }
    }
    configurations {
        compile
        create('default') { extendsFrom compile }
    }
}
artifacts {
    compile file("main.jar")

    }

    def "can use task selector"() {
        setup:
        settingsFile << '''
            rootProject.name = 'root'
            include 'a'
        '''
        buildFile << '''
            allprojects {
                tasks.register('foo')
            }
        '''
        file('a').mkdirs()

        when:
        launchTestWithTestFilter { tl ->
            tl.forTasks('foo', 'test')
        }

        //we should add coverage for nested multi-project builds with multiple parents.
        reactorProjects.add(mavenProject);
        List<ProjectBuildingResult> allProjects = builder.build(ImmutableList.of(pomFile), true, buildingRequest);
        CollectionUtils.collect(allProjects, reactorProjects, ProjectBuildingResult::getProject);

        MavenExecutionResult result = new DefaultMavenExecutionResult();
        result.setProject(mavenProject);

    def "nested action can run further nested actions"() {
        settingsFile << """
            rootProject.name = 'root'
            include 'a', 'b'
        """
        buildFile << """
            allprojects {
                apply plugin: CustomPlugin
                apply plugin: 'java'
            }
        """

        expect:
        def models = withConnection {

@FluidDependenciesResolveTest
class ResolvedConfigurationApiIntegrationTest extends AbstractHttpDependencyResolutionTest {
    def setup() {
        settingsFile << """
rootProject.name = 'test'
"""
        buildFile << """
allprojects {
    configurations {
        compile
        "default" {
            extendsFrom compile
        }
    }
}
"""
    }