relativeExpected = project.file('/path/to/Thing.groovy').absolutePath - projectDirPath
                            println "3: ${relative == relativeExpected}"
                            assert relative == relativeExpected

                            assert p.theFile4
                            relative = p.theFile4.absolutePath - projectDirPath

import java.nio.file.Paths

// tag::simple-params[]
// Using a relative path
var configFile = file("src/config.xml")

// Using an absolute path
configFile = file(configFile.absolutePath)

// Using a File object with a relative path
configFile = file(File("src/config.xml"))

// Using a java.nio.file.Path object with a relative path
configFile = file(Paths.get("src", "config.xml"))

// Using an absolute java.nio.file.Path object

    /**
     * Converts the given distribution url to a URI.
     * <p>
     * If the url is relative, it is resolved against the given file root.
     * Otherwise, the URI is created from the url.
     *
     * @param distributionUrl The distribution url.
     * @param fileRoot The root directory to resolve relative urls against.
     * @return The URI.
     * @throws URISyntaxException If the url is not a valid URI.
     */

		return
	}

	// Print the location and kind of each declaration in f.
	for _, decl := range f.Decls {
		// Get the filename, line, and column back via the file set.
		// We get both the relative and absolute position.
		// The relative position is relative to the last line directive.
		// The absolute position is the exact position in the source.
		pos := decl.Pos()
		relPosition := fset.Position(pos)
		absPosition := fset.PositionFor(pos, false)

import jetbrains.buildServer.configs.kotlin.CheckoutMode
import jetbrains.buildServer.configs.kotlin.DslContext
import jetbrains.buildServer.configs.kotlin.FailureAction
import jetbrains.buildServer.configs.kotlin.RelativeId
import jetbrains.buildServer.configs.kotlin.triggers.VcsTrigger
import jetbrains.buildServer.configs.kotlin.triggers.vcs
import model.CIBuildModel
import model.StageName

    Manifest manifest = manifestClasspath("file:/with/absolute.jar relative.jar  relative/dir");
    assertThat(ClassPath.getClassPathFromManifest(jarFile, manifest))
        .containsExactly(
            fullpath("/with/absolute.jar"),
            fullpath("base/relative.jar"),
            fullpath("base/relative/dir"))
        .inOrder();
  }

    public String getLocation() {
        return location;
    }

    @Override
    public Source resolve(String relative) {
        return new PathSource(path.resolve(relative));
    }

    @Override
    public ModelSource resolve(ModelLocator locator, String relative) {
        String norm = relative.replace('\\', File.separatorChar).replace('/', File.separatorChar);
        Path path = getPath().getParent().resolve(norm);

[GOOS:windows] ! go env -w CC=bin\clang
[GOOS:windows] stderr 'go: CC entry is relative; must be absolute path'

# go env -w rejects relative CXX values
[!GOOS:windows] go env -w CC=/usr/bin/cpp
go env -w CXX=cpp
[!GOOS:windows] ! go env -w CXX=./cpp
[!GOOS:windows] ! go env -w CXX=bin/cpp
[!GOOS:windows] stderr 'go: CXX entry is relative; must be absolute path'

[GOOS:windows] go env -w CXX=$WORK\bin\cpp
[GOOS:windows] ! go env -w CXX=.\cpp

/**
 * A path translator that resolves relative paths against a specific base directory.
 *
 */
public class BasedirBeanConfigurationPathTranslator implements BeanConfigurationPathTranslator {

    private final File basedir;

    /**
     * Creates a new path translator using the specified base directory.
     *
     * @param basedir The base directory to resolve relative paths against, may be {@code null} to disable path

// go.work file located in directory workDir.
//
// If dir is relative, it is interpreted relative to base.Cwd()
// and its canonical form is relative to workDir if possible.
// If dir is absolute or cannot be made relative to workDir,
// its canonical form is absolute.
//
// Canonical absolute paths are clean.
// Canonical relative paths are clean and slash-separated.