void setClassesToCompile(Set<String> classes);

    /**
     * Classes to compile are all classes that we know from Java sources that will be compiled.
     * These classes are deleted before a compilation and are not passed to Java compiler (their sources are passed to a compiler).
     * We only need them in {@link CompilationClassBackupService} so we know what files don't need a backup.
     */

     * {@code [varInitializer, processCreator, expectedPwdSuffix, expectedEnvVar]}.
     * @return the list of test cases
     */
    abstract def testCases()

    /**
     * Produces a list of indy compilation modes. Each test case from {@link #testCases()} will run in every mode from the returned list.
     * @return the list of indy modes
     */
    def indyModes() {
        return [true, false]
    }

""".trim()

    def "successfully normalizes Scala compiler output"() {
        given:
        String input = """
> Task :app:compileJava NO-SOURCE
> Task :app:compileScala
Scala Compiler interface compilation took 1 hrs 20 mins 41.884 secs

> Task :app:processResources NO-SOURCE
> Task :app:classes
> Task :app:jar
> Task :app:startScripts
> Task :app:distTar
> Task :app:distZip
> Task :app:assemble

					if !matchedCompileErrs.Has(i) {
						unmatchedErrs = append(unmatchedErrs, *issue)
					}
				}
				require.Empty(t, unmatchedErrs, "unexpected compilation errors")
			}
		}

		require.Empty(t, missingCompileErrs, "expected compilation errors")
		return
	} else if len(issues.Errors()) > 0 {
		errorStrings := []string{}
		source := common.NewTextSource(expr)
		for _, issue := range issues.Errors() {

                }
            }
        """)

        val result = buildAndFail("classes")

        result.assertHasFailure("Execution failed for task ':compileKotlin'.") {
            it.assertHasCause("Compilation error. See log for more details")
        }
        result.assertHasErrorOutput("src/main/kotlin/code.kt:7:25 Unresolved reference. None of the following candidates is applicable because of receiver type mismatch")
    }

};

void ClearControlInputs(Operation* op, int& num_control_inputs_removed) {
  // We only call this function for island or fetch ops. The second pair of
  // parentheses is needed for successful compilation.
  assert((isa<IslandOp, FetchOp>(op)));
  if (auto island = dyn_cast<IslandOp>(op)) {
    num_control_inputs_removed += island.getControlInputs().size();
    island.getControlInputsMutable().clear();

}

// New creates an instance of admission plugins initializer.
// This constructor is public with a long param list so that callers immediately know that new information can be expected
// during compilation when they update a level.
func New(
	extClientset kubernetes.Interface,
	dynamicClient dynamic.Interface,
	extInformers informers.SharedInformerFactory,
	authz authorizer.Authorizer,

- Worker processes. Long-running daemon processes that the Gradle daemon starts to run specific kinds of work, such as compilation or test execution.

The diagram below shows the relationships between the different processes:

```mermaid
    graph LR
        
        gradle["Gradle CLI client"]
    
        gradlew["Gradlew CLI client"]

        })
        fails("build")

        then:
        failure.assertHasDescription("Execution failed for task ':compileJava'.")
        failure.assertHasCause("Compilation failed with exit code")

        when:
        sourceFile.replace("() -> { }", "new Runnable() { public void run() { } }")

    static {
        SUPPORTED_BY_JDK = groovyVersionsSupportedByJdk(JavaVersion.current())
        SUPPORTS_GROOVYDOC = VersionCoverage.versionsAtLeast(SUPPORTED_BY_JDK, "1.6.9")
        // Indy compilation doesn't work in 2.2.2 and before
        SUPPORTS_INDY = VersionCoverage.versionsAtLeast(SUPPORTED_BY_JDK, "2.3.0")
        SUPPORTS_TIMESTAMP = VersionCoverage.versionsAtLeast(SUPPORTED_BY_JDK, "2.4.6")