*/
@Incubating
public interface VisualCpp extends NativeToolChain {
    /**
     * The directory where Visual Studio or Visual C++ is installed.
     */
    File getInstallDir();

    /**
     * The directory where Visual Studio or Visual C++ is installed.
     */
    void setInstallDir(Object installDir);

    /**
     * The directory where Windows SDK is installed.
     */
    File getWindowsSdkDir();

    /**

	if _, err := os.Stat(path); os.IsNotExist(err) {
		t.Errorf("file/directory does not exist; error: %s", err)
		t.Errorf("file/directory does not exist: %s", path)
	}
}

func assertNotExists(t *testing.T, path string) {
	if _, err := os.Stat(path); err == nil {
		t.Errorf("file/dir exists: %s", path)
	}
}

// assertDirEmpty verifies a directory either does not exist, or is empty.

The directory `buildSrc` is treated as an <<composite_builds.adoc#composite_build_intro,included build>>. Upon discovery of the directory, Gradle automatically compiles this code and puts it in the classpath of your build script.
For multi-project builds there can be only one `buildSrc` directory, which has to sit in the root project directory.

	}
	if err := validateNonFlagArgument(src.Directory, "directory"); err != nil {
		return err
	}
	if (src.Revision != "") && (src.Directory != "") {
		cleanedDir := filepath.Clean(src.Directory)
		if strings.Contains(cleanedDir, "/") || (strings.Contains(cleanedDir, "\\")) {
			return fmt.Errorf("%q is not a valid directory, it must not contain a directory separator", src.Directory)
		}
	}
	return nil
}

    /**
     * whether current module should inherit project's output directory.
     *
     * @return inherit output dirs flag
     * @see #getOutputDir()
     * @see #getTestOutputDir()
     */
    boolean getInheritOutputDirs();

    /**
     * directory to store module's production classes and resources.
     *
     * @return directory to store production output. non-<code>null</code> if

    <defaultGoal>initialize</defaultGoal>
    <directory>out</directory>
    <sourceDirectory>src/main</sourceDirectory>
    <scriptSourceDirectory>src/scripts</scriptSourceDirectory>
    <testSourceDirectory>src/test</testSourceDirectory>
    <outputDirectory>out/main</outputDirectory>
    <testOutputDirectory>out/test</testOutputDirectory>
    <resources>
      <resource>
        <directory>res/main</directory>
      </resource>

## For developers

Release notes should be added to `next` by editing existing files or creating
new files. **Do not add RELNOTE=yes comments in CLs.** Instead, add a file to
the CL (or ask the author to do so).

At the end of the development cycle, the files will be merged by being
concatenated in sorted order by pathname. Files in the directory matching the

    }

    @Override
    public List<String> list(ExternalResourceName directory) {
        LockableSftpClient client = sftpClientFactory.createSftpClient(directory.getUri(), credentials);

        try {
            @SuppressWarnings("unchecked")
            Vector<ChannelSftp.LsEntry> entries = client.getSftpClient().ls(directory.getPath());
            List<String> list = new ArrayList<String>();

    }

    def "fails when attempting to execute tasks #tasks in directory with no settings or build file"() {
        when:
        fails(*tasks)

        then:
        failure.assertHasDescription("Directory '$testDirectory' does not contain a Gradle build.")
        failure.assertHasResolutions(
            "Run gradle init to create a new Gradle build in this directory.",
            STACKTRACE_MESSAGE,
            INFO_DEBUG,

/**
 * Instructs Spock to use {@link CleanupTestDirectoryExtension} to clean up the test directory provided by a
 * {@link org.gradle.test.fixtures.file.TestDirectoryProvider}.  This is to work around the fact that using
 * a test directory provider as a TestRule causes spock to swallow any test failures and the test directory
 * is cleaned up even for failed tests.  {@link CleanupTestDirectoryExtension} on the other hand, registers