// Compiler does not support "--version" flag: not Clang or GCC.
				return nil
			}

			var match [][]byte
			if bytes.HasPrefix(out, []byte("gcc")) {
				compiler.name = "gcc"
				cmd, err := cc("-dumpfullversion", "-dumpversion")
				if err != nil {
					return err
				}
				out, err := cmd.Output()
				if err != nil {
					// gcc, but does not support gcc's "-v" flag?!
					return err
				}

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.nativeplatform.toolchain.internal.gcc

import org.gradle.nativeplatform.toolchain.internal.NativeCompileSpec
import org.gradle.nativeplatform.toolchain.internal.NativeCompilerTest

abstract class GccCompatibleNativeCompilerTest extends NativeCompilerTest {

			pods := []*v1.Pod{test.pod}

			client := setupNewSimpleClient(nil, pods)
			gcc, podInformer, _ := NewFromClient(ctx, client, -1)
			gcc.quarantineTime = time.Duration(-1)
			podInformer.Informer().GetStore().Add(test.pod)
			gcc.gc(ctx)

			actions := client.Actions()

			var patchAction clienttesting.PatchAction
			var deleteAction clienttesting.DeleteAction

	}
	fmt.Fprintf(&buf, "\t}\n")
	if cc := defaultcc[""]; cc != "" {
		fmt.Fprintf(&buf, "\treturn %s\n", quote(cc))
	} else {
		clang, gcc := "clang", "gcc"
		if strings.HasSuffix(name, "CXX") {
			clang, gcc = "clang++", "g++"
		}
		fmt.Fprintf(&buf, "\tswitch goos {\n")
		fmt.Fprintf(&buf, "\tcase ")
		for i, os := range clangos {
			if i > 0 {
				fmt.Fprintf(&buf, ", ")
			}

            // There is not a built-in tool for querying pdb files, so we just check that the debug file exists
            assertDebugFileExists()
        } else if (toolChain.meets(ToolChainRequirement.GCC) && OperatingSystem.current().windows) {
            // Currently cannot probe the actual symbols yet, just verify that there are some
            binaryInfo.assertHasDebugSymbols()
        } else {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.nativeplatform.toolchain.internal.gcc;

import org.gradle.nativeplatform.platform.NativePlatform;
import org.gradle.nativeplatform.toolchain.internal.ArgsTransformer;
import org.gradle.nativeplatform.toolchain.internal.MacroArgsConverter;

plugins { id 'cpp' }
"""

        helloWorld.writeSources(file("src/main"))
    }

    @Requires(UnitTestPreconditions.CanInstallExecutable)
    @RequiresInstalledToolChain(ToolChainRequirement.GCC)
    @ToBeFixedForConfigurationCache
    def "can build with multiple tool chains"() {
        AvailableToolChains.InstalledToolChain x86ToolChain = OperatingSystem.current().isWindows() ?

    // Define a compiler options
    compilerArgs.add '-W3'

    // Define toolchain-specific compiler options
    compilerArgs.addAll toolChain.map { toolChain ->
        if (toolChain in [ Gcc, Clang ]) {
            return ['-O2', '-fno-access-control']
        } else if (toolChain in VisualCpp) {
            return ['/Zi']
        }
        return []
    }
}
// end::cpp-compiler-options-all-variants[]

import org.gradle.nativeplatform.toolchain.internal.PlatformToolProvider
import org.gradle.nativeplatform.toolchain.internal.ToolType
import org.gradle.nativeplatform.toolchain.internal.gcc.metadata.GccMetadata
import org.gradle.nativeplatform.toolchain.internal.gcc.metadata.SystemLibraryDiscovery
import org.gradle.nativeplatform.toolchain.internal.metadata.CompilerMetaDataProvider

        StringBuilder toolChainPath = new StringBuilder();

        NativeToolChain toolChain = getToolChain().get();
        if (toolChain instanceof Gcc) {
            // Gcc on windows requires the path to be set
            toolChainPath.append("SET PATH=");
            for (File pathEntry : ((Gcc) toolChain).getPath()) {
                toolChainPath.append(pathEntry.getAbsolutePath()).append(";");
            }