----
=====
====

If you have just gotten the latest version of the source from your version control system, which included changes in other projects that `:api` depends on, you might want to build all the projects you depend on AND test them too.

The `buildNeeded` task builds AND tests all the projects from the project dependencies of the `testRuntime` configuration:

====
[.multi-language-sample]

=== Delegation

The <<#groovy:properties,section on properties>> lists where unqualified properties might be found. One common place is on the `Project` object. But there is an alternative source for those unqualified properties and methods inside a block: the block's _delegate object_.

        passedInIgnoredTestDetails.assertPassed()

        def ignoredTestDetails = someIgnoredClassFile.testDetails('ignored')
        ignoredTestDetails.assertDuration("-") //is this right? it seems an ignored test may still have a duration?
        ignoredTestDetails.assertIgnored()

        def failingClassFile = results(reportDir.file('classes/org.gradle.failing.SomeIgnoredSomePassedSomeFailed.html'))

====

In other cases, you might want to modify a variant that was added by one of the Java plugins already.
For example, if you activate publishing of Javadoc and sources, these become additional variants of the `java` component.

Gradle doesn't consider private getters as inputs for up-to-date checking, which means that your annotations effectively are ignored.
It is important to fix because you might think that you have declared an input when it's not the case.

To fix this, either make the getter public, or annotate an existing getter instead, or create a new annotated getter.

[[ignored_property_must_not_be_annotated]]

        and:
        // rebuild for Swift3
        succeeds("compileDebugSwift")
        outputs.recompiledClasses('main', 'sum', 'greeter', 'multiply')
    }

    // This isn't quite right, we really want to assert something like "has both swiftc3 and swiftc4"
    @RequiresInstalledToolChain(ToolChainRequirement.SWIFTC_4)
    def 'changing Swift tool chain rebuilds everything'() {
        given:

NOTE: This means that using toolchains with a recent Java version and an old Scala version can result in failures because Scala only supported Java 8 bytecode for some time.
The solution is then to either use the right Java version in the toolchain or explicitly downgrade the target when needed.

The following table explains the values computed by Gradle:

.Scala target parameter based on project configuration

            connection.dispatch(build);
            result = connection.receive();
        } catch (StaleDaemonAddressException e) {
            LOGGER.debug("Connected to a stale daemon address.", e);
            // We might fail hard here on the assumption that something weird happened to the daemon.
            // However, since we haven't yet started running the build, we can recover by just trying again.

                    val unfinishedTasks = shutdownNow()
                    logger.warn(
                        "Configuration cache report is taking too long to write... "
                            + "The build might finish before the report has been completely written."
                    )
                    logger.info("Unfinished tasks: {}", unfinishedTasks)
                }
            }

            private

        }

        @Override
        protected void handle(Pair<BuildOperationDescriptor, OperationFinishEvent> message) {
            listenerProvider.get().finished(message.left, message.right);
        }

        @Override
        public List<Object> getListeners() {
            return ImmutableList.of(this);
        }
    }