package os

import (
	"syscall"
	_ "unsafe" // for linkname
)

//go:linkname executablePath
var executablePath string // set by sysauxv in ../runtime/os3_solaris.go

var initCwd, initCwdErr = Getwd()

func executable() (string, error) {
	path := executablePath
	if len(path) == 0 {
		path, err := syscall.Getexecname()
		if err != nil {
			return path, err
		}
	}
	if len(path) > 0 && path[0] != '/' {

package os

import (
	"errors"
	_ "unsafe" // for linkname
)

//go:linkname executablePath
var executablePath string // set by ../runtime/os_darwin.go

var initCwd, initCwdErr = Getwd()

func executable() (string, error) {
	ep := executablePath
	if len(ep) == 0 {
		return ep, errors.New("cannot find executable path")
	}
	if ep[0] != '/' {
		if initCwdErr != nil {
			return ep, initCwdErr

	if !filepathlite.IsAbs(path) {
		// If the path is relative, we need to prepend the working directory
		// plus a separator to the path before we can determine if it's too long.
		// We don't want to call syscall.Getwd here, as that call is expensive to do
		// every time fixLongPath is called with a relative path, so we use a cache.
		// Note that getwdCache might be outdated if the working directory has been

	keys = make([]string, 0, len(envs))
	for k := range envs {
		keys = append(keys, k)
	}
	slices.Sort(keys)
	for _, key := range keys {
		fmt.Printf("env-%s=%s\r\n", key, envs[key])
	}

	cwd, _ := os.Getwd()
	fmt.Printf("cwd=%s\r\n", cwd)
}

type neverEnding byte

func (b neverEnding) Read(p []byte) (n int, err error) {
	for i := range p {
		p[i] = byte(b)
	}
	return len(p), nil
}

	// is exercised even if long path are supported by the system, else the
	// function might not be tested at all if/when all test builders support long paths.
	cwd, err := os.Getwd()
	if err != nil {
		t.Fatal("cannot get cwd")
	}
	drive := strings.ToLower(filepath.VolumeName(cwd))
	cwd = strings.ToLower(cwd[len(drive)+1:])

        assertThat(dl.getLifeCycles().get(0).getId(), is("clean"));
        assertThat(dl.getLifeCycles().get(1).getId(), is("default"));
        assertThat(dl.getLifeCycles().get(2).getId(), is("site"));
        assertThat(dl.getLifeCycles().get(3).getId(), is("wrapper"));
        assertThat(dl.getLifeCycles().get(4).getId(), is("etl"));
    }

    private Lifecycle getLifeCycleById(String id) {

            PluginCoordinates altCoords = pluginRequest.getAlternativeCoordinates().orElse(null);
            if (altCoords != null && pluginManager.hasPlugin(altCoords.getId().getId())) {
                return;
            }

            pluginManager.apply(pluginRequest.getId().getId());
        }
    }

    private PluginResolutionResult handleNotFound(String message) {

        if (replace) {
            Set<String> ids = repos.stream().map(RemoteRepository::getId).collect(Collectors.toSet());
            repositories =
                    repositories.stream().filter(r -> !ids.contains(r.getId())).toList();
            pomRepositories = pomRepositories.stream()
                    .filter(r -> !ids.contains(r.getId()))
                    .toList();
        } else {
            Set<String> ids =

            resultProcessor.failure(suiteDescriptor.getId(), TestFailure.fromTestFrameworkFailure(rawFailure));
        } finally {
            resultProcessor.completed(suiteDescriptor.getId(), new TestCompleteEvent(clock.getCurrentTime()));
        }
    }

    @Override
    public void stopNow() {

            CalculatedValue<File> artifactSource = calculatedValueFactory.create(Describables.of(artifact.getId()), () -> resolveArtifactLater(artifact, component.getSources(), sourceRepository));