Properties properties =
                loadResumptionFile(Paths.get(rootProject.getBuild().getDirectory()));
        applyResumptionProperties(request, properties);
    }

    @Override
    public void removeResumptionData(MavenProject rootProject) {
        Path resumeProperties = Paths.get(rootProject.getBuild().getDirectory(), RESUME_PROPERTIES_FILENAME);
        try {

	fmt.Println("On Unix:", filepath.SplitList("/a/b/c:/usr/bin"))
	// Output:
	// On Unix: [/a/b/c /usr/bin]
}

func ExampleRel() {
	paths := []string{
		"/a/b/c",
		"/b/c",
		"./b/c",
	}
	base := "/a"

	fmt.Println("On Unix:")
	for _, p := range paths {
		rel, err := filepath.Rel(base, p)
		fmt.Printf("%q: %q %v\n", p, rel, err)
	}

	// Output:
	// On Unix:
	// "/a/b/c": "b/c" <nil>

     *
     * @param paths The paths to the files. May be empty.
     * @return The file collection.
     */
    @Suppress("unused")
    fun files(vararg paths: Any): ConfigurableFileCollection =
        fileOperations.configurableFiles(paths)

    /**
     * Creates a [ConfigurableFileCollection] containing the given files.
     *

        List<String> paths = new ArrayList<String>(classpath.size());
        for (File file : classpath) {
            String path = constructRelativeClasspathUri(jarFile, file);
            paths.add(path);
        }

        return CollectionUtils.join(" ", paths);
    }

    private static String constructRelativeClasspathUri(File jarFile, File file) {

                    "Java toolchain without the " + JavaToolchainImpl.KEY_JAVAHOME + " configuration element.");
        }
        Path normal = Paths.get(javahome.getValue()).normalize();
        if (Files.exists(normal)) {
            jtc.setJavaHome(Paths.get(javahome.getValue()).normalize().toString());
        } else {
            throw new MisconfiguredToolchainException(

        delegate.projectDir

    override fun files(vararg paths: Any?): ConfigurableFileCollection =
        delegate.files(*paths)

    override fun files(paths: Any, configureClosure: Closure<*>): ConfigurableFileCollection =
        delegate.files(paths, configureClosure)

    override fun files(paths: Any, configureAction: Action<in ConfigurableFileCollection>): ConfigurableFileCollection =

        def file1 = new File("1")
        def file2 = new File("2")

        when:
        def paths = ["a"]
        collection.from({ paths })
        def files = collection.files

        then:
        1 * fileResolver.resolve("a") >> file1
        files as List == [file1]

        when:
        paths.add("b")
        files = collection.files

        then:

			config := &config2.BugReportConfig{}
			if err := yaml.Unmarshal([]byte(tt.config), config); err != nil {
				t.Fatal(err)
			}

			paths, err := GetMatchingPaths(config, testClusterResources)
			if err != nil {
				t.Fatal(err)
			}
			g.Expect(paths).Should(ConsistOf(tt.want))
		})
	}
}

func TestGetMatchingPathsMultiple(t *testing.T) {
	g := NewWithT(t)

	tests := []struct {

		}
	}
}

// failMessage creates a nicely formatted error message when there is no result to show.
func failMessage(paths []string, symbol, method string) error {
	var b bytes.Buffer
	if len(paths) > 1 {
		b.WriteString("s")
	}
	b.WriteString(" ")
	for i, path := range paths {
		if i > 0 {
			b.WriteString(", ")
		}
		b.WriteString(path)
	}
	if method == "" {

arguments must satisfy the following constraints:

 - Arguments must be package paths or package patterns (with "..." wildcards).
 They must not be standard packages (like fmt), meta-patterns (std, cmd,
 all), or relative or absolute file paths.

 - All arguments must have the same version suffix. Different queries are not
 allowed, even if they refer to the same version.