binary.installation >> installation

        when:
        toolProvider.getExecutableName("base_name") >> "exe_name"

        and:
        NativeBinaryRules.assignTools(binary, toolChains, tmpDir.testDirectory)

        then:
        executableFile.file == tmpDir.testDirectory.file("exe/comp_name/exe_name")
        installation.directory == tmpDir.testDirectory.file("install/comp_name")
    }

        !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,

        File executable = executables.get(exeName);
        if (executable == null) {
            executable = findExecutable(operatingSystem, exeName);
            if (executable != null) {
                executables.put(exeName, executable);
            }
        }
        return executable == null || !executable.isFile() ? new MissingTool(key, exeName, pathEntries) : new FoundTool(executable);

    }

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

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

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

    }

    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) {
                    }
                }
            }

	testenv.MustHaveGoRun(t)

	// Build ptrsort.go, which uses package mysort.
	var output []byte
	var err error
	filename := "ptrsort.go"
	exename := "ptrsort"
	outname := "ptrsort.out"
	gotool := testenv.GoToolPath(t)
	dest := filepath.Join(t.TempDir(), exename)
	cmd := testenv.Command(t, gotool, "build", "-o", dest, filepath.Join("testdata", filename))
	if output, err = cmd.CombinedOutput(); err != nil {

        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()) {

        VisualStudioTargetBinary targetBinary = Mock(VisualStudioTargetBinary)
        targetBinary.projectPath >> values.get("projectPath", ":")
        targetBinary.componentName >> values.get("componentName", "exeName")
        targetBinary.variantDimensions >> values.get("variantDimensions", ['buildTypeOne'])
        targetBinary.projectType >> values.get("projectType", EXE)
        return targetBinary
    }

	})
	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.