package org.apache.maven.building;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Objects;

/**
 * Wraps an ordinary {@link File} as a source.
 *
 */
public class FileSource implements Source {
    private final Path path;

    private final int hashCode;

    /**
     * Creates a new source backed by the specified file.

 */
package org.apache.maven.building;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;

/**
 * Wraps an ordinary {@link CharSequence} as a source.
 *
 */
public class StringSource implements Source {
    private final String content;

    private final String location;

    private final int hashCode;

    /**

         * gets occasionally extended by newer Maven versions). This imposes the risk for existing plugins to
         * unintentionally use such a magic expression for an ordinary property. So here we check whether we
         * ended up with a magic value that is not compatible with the type of the configured mojo parameter (a string

# Because 'go mod' subcommands ignore build constraints, they can encounter
# package-import cycles that are not possible in an ordinary build. This test
# verifies that such cycles are handled even when they cross module boundaries.

# First, verify that the import graph depends on build tags as expected.
go list -deps example.com/left
stdout '^example.com/right$'
go list -deps example.com/right
! stdout left

env GOFLAGS=-tags=mirror

		t.Error(msg)
	}
	fn("4")

	t.Run("sub", func(t *testing.T) {
		helper(t, "5")
		notHelperCallingHelper(t, "6")
		// Check that calling Helper from inside a subtest entry function
		// works as if it were in an ordinary function call.
		t.Helper()
		t.Error("7")
	})

	// Check that right caller is reported for func passed to Cleanup when
	// multiple cleanup functions have been registered.
	t.Cleanup(func() {
		t.Helper()

// We have to avoid write barriers to avoid potential deadlock
// on write calls.
//
//go:nowritebarrierrec
func write(fd uintptr, p unsafe.Pointer, n int32) int32 {
	if !(fd == 1 || fd == 2) {
		// Do an ordinary write.
		return write1(fd, p, n)
	}

	// Write with the playback header.

	// First, lock to avoid interleaving writes.
	lock(&faketimeState.lock)

 * into TaskSegments. This class represents the execution context of one such task segment.
 * </p>
 * <p>
 * Wise voices have suggested that maybe aggregators shouldn't be bound to the ordinary
 * lifecycle at all, in which case we wouldn't be needing this class at all ( and
 * ProjectBuildList.getByTaskSegments). Or maybe they should be introduced in the calculation

package c_test

-- c_test/c_test_test.go --
package c_test_test

import "testing"

func Test(t *testing.T) {}

-- d_test/go.mod --
// Package d is an ordinary package in a deceptively-named directory.
module example.com/d

-- d_test/d.go --
package d

-- d_test/d_test.go --
package d_test

import "testing"

func Test(t *testing.T) {}

# The linker should accept the test case on systems not explicitly rejected.
#
# 64-bit systems do not attempt to execute test cases with frame sizes
# that are only 32-bit aligned.

# Ordinary function should work
start 0

# Large frame marked nosplit is always wrong.
# Frame is so large it overflows cmd/link's int16.
start 100000 nosplit
REJECT

# Calling a large frame is okay.
start 0 call big

				if len(dest) > volLen {
					dest += pathSeparator
				}
				dest += ".."
			} else {
				// Discard everything since the last slash.
				dest = dest[:r]
			}
			continue
		}

		// Ordinary path component. Add it to result.

		if len(dest) > filepathlite.VolumeNameLen(dest) && !os.IsPathSeparator(dest[len(dest)-1]) {
			dest += pathSeparator
		}

		dest += path[start:end]

		// Resolve symlink.