*          that this closure is now in the scope of an instrumented call, so changing its delegate must be reflected in updating the new delegate's
 *          metaclass for call interception.
 *     <li> Overrides {@link Closure#setDelegate}, adding a call to {@link InstrumentedGroovyMetaClassHelper#addInvocationHooksInClosureDispatchObject} with

            }
        });

        testComponent.getTestBinary().convention(project.provider(new Callable<CppTestExecutable>() {
            @Override
            public CppTestExecutable call() throws Exception {
                return getAllBuildableTestExecutable()
                        .filter(it -> isCurrentArchitecture(it.getNativePlatform()))
                        .findFirst()

     *
     * @param caller the lookup for the caller (JVM-supplied)
     * @param callType the type of the call (corresponds to {@link IndyInterface.CallType} constant)
     * @param type the call site type
     * @param name the real method name
     * @param flags call flags
     * @return the produced CallSite
     * @see IndyInterface
     */
    // Called by generated code

```
someTask {
    inputFile.from(jar.archivePath)
}
```

The `jar.archivePath` property is of type `File`, which doesn't carry any task dependency.
It means that if you call `someTask` _after_ `jar` has been called, the task will succeed, but if the jar is removed, for example, the task would fail.

To fix this, you can declare a `Property` as an input instead:

```
someTask {

            }
        }

        try {
            return invokeOriginal.call();
        } catch (Throwable e) {
            ThrowAsUnchecked.doThrow(e);
            throw new IllegalStateException("this is unreachable code, the call above should always throw an exception");
        }
    }

    //region implementations delegating to adaptee
    @Override

`--warning-mode=(all,fail,none,summary)`::
Specifies how to log warnings. Default is `summary`.
+
Set to `all` to log all warnings.
+
Set to `fail` to log all warnings and fail the build if there are any warnings.
+
Set to `summary` to suppress all warnings and log a summary at the end of the build.
+
Set to `none` to suppress all warnings, including the summary at the end of the build.

 * task myTask(type: SomeType) { configure closure }
 * </pre>
 *
 * <p>Each task has a name, which can be used to refer to the task within its owning project, and a fully qualified
 * path, which is unique across all tasks in all projects. The path is the concatenation of the owning project's path
 * and the task's name. Path elements are separated using the {@value org.gradle.api.Project#PATH_SEPARATOR}
 * character.</p>
 *
 * <h3>Task Actions</h3>

}

rootProject.name = 'tutorial'
include('app')
----
=====

The `tutorial` root project includes the `app` subproject.
The presence of the `include` call turns the `app` directory into a subproject.

== Step 7. Understanding the Build script
Each subproject contains its own `build.gradle(.kts)` file.

    private transient MarkupBuilder suiteXmlBuilder;

    private final Cached<String> cachedSuiteXml = Cached.of(new Callable<String>() {
        @Override
        public String call() {
            return suiteXmlWriter != null ? suiteXmlWriter.toString() : null;
        }
    });

    private final File projectDir;

    @Inject
    public TestNGOptions(ProjectLayout projectLayout) {

                    tasks.all.logger.lifecycle("build finished from \${tasks.all.path}")
                }
            }

            threaded {
                println("threaded configuration output")
            }

            def threaded(Closure action) {
                Thread.start(action).join()
            }
        """

        when:
        succeeds("all")

        then: