* (<strong>Be sure to note the ambiguity in this value</strong>)
     * @implSpec implementations <strong>MUST</strong> return {@code false} if the repository is not disabled by this call
     */
    boolean tryDisableRepository(String repositoryId, Throwable throwable);

    enum NoOpDisabler implements RepositoryDisabler {
        INSTANCE;

        @Override

//  private:
//   void MyMethod();
//   FRIEND_TEST(MyClassTest, MyMethod);
// };
//
// class MyClassTest : public testing::Test {
//   // ...
// };
//
// TEST_F(MyClassTest, MyMethod) {
//   // Can call MyClass::MyMethod() here.
// }

#define FRIEND_TEST(test_case_name, test_name)\
friend class test_case_name##_##test_name##_Test

        1 * target.getExtensions() >> extensions
        1 * softwareType.modelPublicType() >> Foo.class
        1 * softwareType.name() >> "foo"
        1 * propertyValue.call() >> foo
        1 * extensions.add(Foo.class, "foo", foo)

        and:
        1 * delegate.applyImperative(null, plugin)
    }

    def "does not add software types for plugins that are not registered"() {

     *
     * The Callable's call() needs to be called from this method.
     */
    <T> T onExecute(Callable<T> command) throws Exception;

    /**
     * Special behavior after an executor is stopped.
     *
     * This is called after the underlying Executor has been stopped.
     */
    void onStop();

    /**
     * Runs the Runnable, catches all Throwables and logs them.
     *

    byte[] instrumentClass(@Nullable String className, @Nullable ProtectionDomain protectionDomain, byte[] classfileBuffer);

    /**
     * This is called by the agent if a throwable is thrown while instrumenting a class during the call of the {@link #instrumentClass(String, ProtectionDomain, byte[])} method,
     * or anywhere else in the agent. Throwing an exception from this method has no effect on the class loading.
     * <p>

        JavaCompiler.CompilationTask task = compiler.getTask(null, fileManager, diagnostics, null, null, classesToCompile)

        if (task.call()) {
            def result = new ByteArrayOutputStream()
            def target = new JarOutputStream(result)
            target.putNextEntry(new JarEntry("META-INF/MANIFEST.MF"))

        val tree = parseAsTopLevelBlock(
            """
            myFun {
                a = "x"
                a = b
                b = f(a = "x")
                b = f(a = "x") { test() }
                call(x = { }) // TODO: right now, it is reported as an unsupported language feature FunctionDeclaration, report it in a more precise way?
                multiLambda({ }, { })
                1
                a.b()

 *
 * This is the lifecycle for the watchable hierarchies:
 * - During a build, there will be various calls to {@link FileWatcherUpdater#registerWatchableHierarchy(File, SnapshotHierarchy)},
 *   each call augmenting the collection. The watchers will be updated accordingly.
 * - When updating the watches, we watch watchable hierarchies registered for this build or old watched directories from previous builds instead of

        subprojectDir.mkdirs()
        FileTreeBuilder builder = new FileTreeBuilder(subprojectDir)
        config.setDelegate(builder)
        config.resolveStrategy = Closure.DELEGATE_FIRST
        config.call()
    }

                .collect(Collectors.toList());
        });
        return variant;
    }

    /**
     * A custom artifact type which allows the getFile call to be done lazily only when the
     * artifact is actually needed.
     */
    private static class LazyJavaDirectoryArtifact extends AbstractPublishArtifact {
        private final String type;