!if_region.get_elseFuncNameAttr().getValue().empty()) {
      else_name =
          mapper.GetUniqueName(if_region.get_elseFuncNameAttr().getValue())
              .str();
    } else {
      else_name = GetName(if_region, "_else");
    }
    else_name = ExtractSingleBlockRegion(
        symbol_table, if_region.getElseBranch(), else_name, extern_values,
        worklist, /*extern_values_passthrough=*/false,

    }

    private static String[] getComponentTasks(String exeName) {
        return [getProjectTask(exeName), getFiltersTask(exeName)]
    }

    private static String getFiltersTask(String exeName) {
        ":${exeName}VisualStudioFilters"
    }

    private static String getProjectTask(String exeName) {
        return ":${exeName}VisualStudioProject"
    }

                return 0;
            }
        """)
    }

    void withProject(exeName, source) {
        file("${exeName}/src/${exeName}/c/${exeName}.c") << source
        file("${exeName}/build.gradle") << """
            apply plugin: 'org.gradle.c'

            model {
                components {
                    ${exeName}(NativeExecutableSpec) {
                    }
                }
            }

        String exeName = getExecutableName(name);
        if (exeName.contains(File.separator)) {
            File candidate = new File(exeName);
            if (candidate.isFile()) {
                return candidate;
            }
            return null;
        }
        for (File dir : getPath()) {
            File candidate = new File(dir, exeName);
            if (candidate.isFile()) {

	})
	if len(args) == 0 {
		return nil, nil, errors.New("no profile source specified")
	}

	var execName string
	// Recognize first argument as an executable or buildid override.
	if len(args) > 1 {
		arg0 := args[0]
		if file, err := o.Obj.Open(arg0, 0, ^uint64(0), 0, ""); err == nil {
			file.Close()
			execName = arg0
			args = args[1:]
		}
	}

	// Apply any specified flags to cfg.

        assert projectFile.headerFiles == app.headerFiles.collect({"src/main/cpp/${it.name}"}).sort()
    }

    private String[] getProjectTasks(String exeName) {
        return [":${exeName}VisualStudioProject", ":${exeName}VisualStudioFilters"]
    }

    private String stripped(String configurationName) {
        if (toolChain.visualCpp) {
            return ""
        } else {

	return true
}

func (c *exprClause) test(exprname ir.Node) ir.Node {
	// Integer range.
	if c.hi != c.lo {
		low := ir.NewBinaryExpr(c.pos, ir.OGE, exprname, c.lo)
		high := ir.NewBinaryExpr(c.pos, ir.OLE, exprname, c.hi)
		return ir.NewLogicalExpr(c.pos, ir.OANDAND, low, high)
	}

	// Optimize "switch true { ...}" and "switch false { ... }".
	if ir.IsConst(exprname, constant.Bool) && !c.lo.Type().IsInterface() {

        NativeTestSuiteBinarySpecInternal  | EXE
        TestFooBinary                      | NONE
    }

    def "maps executable binary types to visual studio project"() {
        when:
        exe.getName() >> "exeName"
        exeBinary.getProjectPath() >> ":"
        binaryNamingScheme.getVariantDimensions() >> ["buildTypeOne"]

        then:
        checkNames targetBinary, "exeNameExe", 'buildTypeOne'
    }

        failure.assertHasCause("A build operation failed.")
        def exeName = executable("build/binaries/mainExecutable/main").file.name
        failure.assertThatCause(containsText("Linker failed while linking ${exeName}"))
    }

    @ToBeFixedForConfigurationCache
    def "build fails when link library fails"() {
        given:
        buildFile << """

            KotlinCoreEnvironment.underApplicationLock {
                if (applicationArea.hasExtensionPoint(ClassTypePointerFactory.EP_NAME)) return@underApplicationLock
                CoreApplicationEnvironment.registerApplicationExtensionPoint(
                    ClassTypePointerFactory.EP_NAME,
                    ClassTypePointerFactory::class.java
                )