private final ArchRule delegate;

    public FreezeInstructionsPrintingArchRule(ArchRule delegate) {
        this.delegate = delegate;
    }

    @Override
    public void check(JavaClasses classes) {
        Assertions.check(this, classes);
    }

    @Override
    public ArchRule because(String reason) {
        return new FreezeInstructionsPrintingArchRule(delegate.because(reason));
    }

    @Override

    /**
     * Return a sequence of [KaClassifierSymbol] which current scope contain if classifier name matches [nameFilter]. The sequence includes:
     * nested classes, inner classes, nested type aliases for the class scope, and top-level classes and top-level type aliases for file scope.
     *
     * This function needs to retrieve a set of all possible names before processing the scope.

     * collects all classes that are inside these sources, but were not detected as a dependency of changed classes.
     * This is important so all .class files that will be re-created are removed before compilation, otherwise
     * it confuse a compiler: for example Groovy compiler could generate incorrect classes for Spock.
     * <p>

    String EXECUTION_FAILURE = "failed to execute tests";

    /**
     * Asserts that the given test classes (and only the given test classes) were executed.
     */
    TestExecutionResult assertTestClassesExecuted(String... testClasses);

    /**
     * Asserts that the given test classes (and only the given test classes) were <strong>NOT</strong> executed.
     */

        !file("build/classes/$languageName/main/a/").exists()
        !file("build/classes/$languageName/main/c/").exists()

        when:
        b.text = "package b; class B {}"
        run language.compileTaskName

        then:
        outputs.recompiledClasses("A", "C")
    }

        def value = Mock(RegularFile)
        def file = new File("classes-1.zip")

        _ * value.getAsFile() >> file

        when:
        def publishArtifact = publishArtifactNotationParser.parseNotation(value)

        then:
        publishArtifact instanceof DecoratingPublishArtifact
        publishArtifact.file == file
        publishArtifact.name == "classes-1"
        publishArtifact.extension == "zip"

                'org.gradle.libraryelements': of('jar', 'classes'),
                'org.gradle.usage': of('java-api', 'java-api'),
                'org.gradle.jvm.environment': of('', 'standard-jvm')
            ])}

---------------------
Unselected Variant(s)
---------------------

${variantOf('apiElements-classes', [
                'org.gradle.category': of('library', 'library'),

            "${file("build/generated/sources/annotationProcessor/java/main/ServiceRegistry.java")}]")
        outputContains("Restoring stashed files: [" +
            "${file("build/classes/java/main/A.class")}, " +
            "${file("build/classes/java/main/ServiceRegistry.class")}, " +
            "${file("build/classes/java/main/ServiceRegistryResource.txt")}, " +

        "layout.buildDirectory.dir('classes/main')"                            | "build/classes/main"
        "layout.buildDirectory.dir(providers.provider { 'classes/main' })"     | "build/classes/main"
        "layout.buildDirectory.file('classes/main')"                           | "build/classes/main"
        "layout.buildDirectory.file(providers.provider { 'classes/main' })"    | "build/classes/main"
    }

        </content>
        <orderEntry type="sourceFolder" forTests="false"/>
        <orderEntry type="module-library">
            <library>
                <CLASSES>
                    <root url="file://$MODULE_DIR$/gradle/lib"/>
                </CLASSES>
                <JAVADOC>
                    <root url="file://$MODULE_DIR$/gradle/javadoc"/>
                </JAVADOC>
                <SOURCES>