}

        then:
        stashDirIsEmpty

        where:
        pattern                              | directoryPath | description
        new PatternSet()                     | "sourceDir"   | "empty pattern"
        new PatternSet().include("**/*.txt") | null          | "empty directory"
    }

    def "stash and backup directory are generated"() {
        given:

            if (generatorTask != null) {
                languageSourceSet.builtBy(generatorTask);
                maybeSetSourceDir(languageSourceSet.getSource(), generatorTask, "sourceDir");
                if (languageSourceSet instanceof HeaderExportingSourceSet) {
                    maybeSetSourceDir(((HeaderExportingSourceSet) languageSourceSet).getExportedHeaders(), generatorTask, "headerDir");

        this.description = description;
        this.sourceFile = sourceUri.getScheme().equals("file") ? FileUtils.normalize(new File(sourceUri.getPath())) : null;
        this.sourceUri = sourceUri;
        this.resolver = resolver;
    }

    public static UriTextResource from(String description, File sourceFile, RelativeFilePathResolver resolver) {

    @Test
    fun `can download source distribution`() {

        withBuildScript(
            """

            val sourceDirs =
                ${SourceDistributionResolver::class.qualifiedName}(project).run {
                    sourceDirs()
                }

            require(sourceDirs.isNotEmpty()) {
                "Expected source directories but got none"
            }

        when:
        underTest = new DownloadedUriTextResource("Test description", sourceUri, "", downloadedFile, resolver)

        then:
        underTest.getDisplayName() == "Test description '$sourceUri'"
    }

    def "content should not be cached"() {
        when:
        underTest = new DownloadedUriTextResource("Test description", sourceUri, "", downloadedFile, resolver)

        then:
        !underTest.isContentCached()

        """

        when:
        run 'eclipse'

        then:
        classpath.sourceDirs.size() == 4
        classpath.sourceDirs[0].output == 'custom-output/main'
        classpath.sourceDirs[1].output == 'custom-output/main'
        classpath.sourceDirs[2].output == 'custom-output/test'
        classpath.sourceDirs[3].output == 'custom-output/test'
    }

    @ToBeFixedForConfigurationCache

      return "";
    }
  }

  mlir::MLIRContext context;
  context.printOpOnDiagnostic(true);
  llvm::SourceMgr sourceMgr;
  sourceMgr.AddNewSourceBuffer(std::move(input), llvm::SMLoc());

  mlir::OwningOpRef<mlir::ModuleOp> module =
      FlatBufferFileToMlirTranslation(&sourceMgr, &context);
  if (!module || failed(verify(*module))) return "";

  std::string mlir_output;

      tensorflow::str_util::Split(source_dir, "/");
  auto source_tfroot_pos = std::find(source_path_components.begin(),
                                     source_path_components.end(), tf_root_dir);
  if (source_tfroot_pos != source_path_components.end()) {
    tf_prefix_dir =
        absl::StrJoin(source_path_components.begin(), source_tfroot_pos, "/");
  } else {
    tf_prefix_dir = source_dir;
  }

                        def sourceJar = this.project(":child1").tasks.getByName("sourceJar")
                        def javadocJar = this.project(":child1").tasks.getByName("javadocJar")
                        dep.buildDependencies(sourceJar, javadocJar)
                        dep.publicationSourcePath = cp.fileReference(sourceJar.archiveFile.get().asFile)

		return nil, err
	}

	var sourceVip string
	var hostMac string
	if isOverlay(hnsNetworkInfo) {
		if !utilfeature.DefaultFeatureGate.Enabled(kubefeatures.WinOverlay) {
			return nil, fmt.Errorf("WinOverlay feature gate not enabled")
		}
		err = hcn.RemoteSubnetSupported()
		if err != nil {
			return nil, err
		}
		sourceVip = config.SourceVip
		if len(sourceVip) == 0 {