try ( SmbResource subdir = this.base.resolve("test/") ) {
            subdir.mkdir();
            try ( SmbWatchHandle w = this.base.watch(FileNotifyInformation.FILE_NOTIFY_CHANGE_FILE_NAME, true) ) {
                setupWatch(w);
                try ( SmbResource cr = new SmbFile(subdir, "created") ) {
                    cr.createNewFile();

        }
        if (currentDepth < maxDepth) {
            for (int i = 0; i < dirCount; i++) {
                TestFile subDir = parentDir.createDir("dir" + fileIdGenerator.incrementAndGet())
                generateFilesAndSubDirectories(subDir, fileCount, dirCount, maxDepth, currentDepth + 1, fileIdGenerator)
            }
        }
    }

        // received file changes for all the files inside.
        def inputSubdirectories = (1..changesLimit).collect { inputDir.createDir("subdir${it}")}
        def inputFiles = inputSubdirectories.collect { inputDir.file("input.txt") }
        when:
        succeeds("theTask")
        inputFiles.each { it.createFile() }

        then:

        when:
        run 'copy'

        then:
        file('dest').assertHasDescendants(
            'transformedAgain/transformed/subdir/one/one.a',
            'transformedAgain/transformed/subdir/two/two.a',
            'subdir/one',
            'subdir/two'
        )
    }

    def "include exclude with CopySpec"() {
        given:
        buildScript '''

        def destinationDir = spec.getDestinationDir()
        createNewFile(new File(destinationDir, "file.txt"))
        createNewFile(new File(destinationDir, "subDir/another-file.txt"))
        createNewFile(new File(destinationDir, "subDir/some-dest-file.class"))
        def annotationOutput = createNewDirectory(file("annotationOut"))
        createNewFile(new File(annotationOutput, "some-ann-file.ann"))

      IsOk());
  ASSERT_THAT(env->RecursivelyCreateDir(absl::StrCat(*tmp_dir, "/subdir")),
              IsOk());

  absl::StatusOr<std::vector<std::string>> children = ListDirectory(*tmp_dir);
  EXPECT_THAT(children, IsOk());
  EXPECT_THAT(children.value(), SizeIs(3));
  EXPECT_THAT(children.value(),
              UnorderedElementsAre("subdir", "tmp_file1", "tmp_file2"));
}

}  // namespace

  WriteString(file, "test");
  EXPECT_TF_OK(status_);

  const std::string subdir = io::JoinPath(base, "SubDir");
  tf_gcs_filesystem::CreateDir(filesystem_, subdir.c_str(), status_);
  EXPECT_TF_OK(status_);
  const std::string subfile = io::JoinPath(subdir, "TestSubFile.csv");
  WriteString(subfile, "test");
  EXPECT_TF_OK(status_);

  char** entries;

	// remains up to date. If so, whatever cached object it was
	// taken from can be reused.
	// The subdir gives subdirectory name where the module root is expected to be found,
	// "" for the root or "sub/dir" for a subdirectory (no trailing slash).
	CheckReuse(ctx context.Context, old *Origin, subdir string) error

	// Tags lists all tags with the given prefix.
	Tags(ctx context.Context, prefix string) (*Tags, error)

	if old == nil {
		return fmt.Errorf("missing origin")
	}
	if old.VCS != "git" || old.URL != r.remoteURL {
		return fmt.Errorf("origin moved from %v %q to %v %q", old.VCS, old.URL, "git", r.remoteURL)
	}
	if old.Subdir != subdir {
		return fmt.Errorf("origin moved from %v %q %q to %v %q %q", old.VCS, old.URL, old.Subdir, "git", r.remoteURL, subdir)
	}

		if !strings.HasPrefix(zf.Name, subdir) || strings.HasSuffix(zf.Name, "/") {
			continue
		}

		n := strings.TrimPrefix(zf.Name, subdir)
		if n == "" {
			continue
		}
		n = strings.TrimPrefix(n, "/")

		fs = append(fs, zipFile{
			name: n,
			f:    zf,
		})
		if n == "LICENSE" {
			haveLICENSE = true
		}
	}

	if !haveLICENSE && subdir != "" {