import org.gradle.nativeplatform.toolchain.internal.compilespec.CppCompileSpec

class CppCompilerTest  extends VisualCppNativeCompilerTest {

    @Override
    protected NativeCompiler getCompiler(CommandLineToolContext invocationContext, String objectFileExtension, boolean useCommandFile) {

    }

    abstract protected Compiler<ScalaJavaJointCompileSpec> getCompiler(ScalaJavaJointCompileSpec spec);

    @TaskAction
    public void compile() {
        ScalaJavaJointCompileSpec spec = createSpec();
        configureIncrementalCompilation(spec);
        Compiler<ScalaJavaJointCompileSpec> compiler = getCompiler(spec);
        if (isNonIncrementalCompilation()) {

    }

    /**
     * For testing only.
     */
    public void setCompiler(org.gradle.language.base.internal.compile.Compiler<ScalaJavaJointCompileSpec> compiler) {
        this.compiler = compiler;
    }

    @Override
    protected org.gradle.language.base.internal.compile.Compiler<ScalaJavaJointCompileSpec> getCompiler(ScalaJavaJointCompileSpec spec) {
        assertScalaClasspathIsNonEmpty();

                return new RecompilationNotNecessary(previousCompilationData, recompilationSpec);
            }
            try {
                WorkResult result = cleaningCompiler.getCompiler().execute(spec);
                result = recompilationSpecProvider.decorateResult(recompilationSpec, previousCompilationData, result);
                return result.or(workResult);
            } finally {

            }
        } else {
            COMPILER_CLASSLOADER_CACHE = new ClassLoaderCache(new URLClassLoader(new URL[]{}));
        }
    }

    static ZincScalaCompiler getCompiler(GlobalScopedCacheBuilderFactory globalScopedCacheBuilderFactory, HashedClasspath hashedScalaClasspath) {
        ScalaInstance scalaInstance;
        try {
            scalaInstance = getScalaInstance(hashedScalaClasspath);

	var allErrors field.ErrorList
	var compiler plugincel.Compiler // composition compiler is stateful, create one lazily per policy
	getCompiler := func() plugincel.Compiler {
		if compiler == nil {
			needsComposition := len(spec.Variables) > 0
			compiler = createCompiler(needsComposition, opts.strictCostEnforcement)
		}
		return compiler
	}

        srcDir.mkdirs()

        scalaCompile = createTask(ScalaCompile)
        scalaCompile.setCompiler(scalaCompiler)

        FileUtils.touch(new File(srcDir, "incl/file.scala"))
        FileUtils.touch(new File(srcDir, "incl/file.java"))
    }

    def "default values"() {
        given:
        def compile = getCompile()

        expect:
        !compile.getDestinationDirectory().isPresent()

    }

    public Collection<GccCommandLineToolConfigurationInternal> getTools() {
        return tools.values();
    }

    public Collection<GccCommandLineToolConfigurationInternal> getCompilers() {
        return Arrays.asList(tools.get(ToolType.C_COMPILER), tools.get(ToolType.CPP_COMPILER), tools.get(ToolType.OBJECTIVEC_COMPILER), tools.get(ToolType.OBJECTIVECPP_COMPILER));
    }

        // Attempt to determine whether the compiler is the correct implementation
        for (GccCommandLineToolConfigurationInternal tool : platformToolChain.getCompilers()) {
            CommandLineToolSearchResult compiler = locate(tool);
            if (compiler.isAvailable()) {

        "getUrl"         | "isUrl"         | "setUrl"         | "url"
        "getURL"         | "isURL"         | "setURL"         | "URL"
        "getcCompiler"   | "iscCompiler"   | "setcCompiler"   | "cCompiler"
        "getCCompiler"   | "isCCompiler"   | "setCCompiler"   | "CCompiler"
        "getCppCompiler" | "isCppCompiler" | "setCppCompiler" | "cppCompiler"