}

	if runtime.GOARCH == "mips" || runtime.GOARCH == "mips64" {
		t.Skipf("skipping on %s", runtime.GOARCH)
	}

	attempts := 1000
	threads := 4

	// Restrict the number of attempts based on RLIMIT_NPROC.
	// Tediously, RLIMIT_NPROC was left out of the syscall package,
	// probably because it is not in POSIX.1, so we define it here.
	// It is not defined on Solaris.
	var nproc int
	setNproc := true
	switch runtime.GOOS {

			t.Errorf("ReadByte: got (%q, %v), want (%q, %v)", c, err, byte(0), io.EOF)
		}
	}
}

func TestLargeStringWrites(t *testing.T) {
	var buf Buffer
	limit := 30
	if testing.Short() {
		limit = 9
	}
	for i := 3; i < limit; i += 3 {
		s := fillString(t, "TestLargeWrites (1)", &buf, "", 5, testString)
		empty(t, "TestLargeStringWrites (2)", &buf, s, make([]byte, len(testString)/i))
	}

			// Keep in sync with cmd/link/internal/ld/data.go:wasmMinDataAddr.
			const wasmMinDataAddr = 4096 + 8192;
			if (offset >= wasmMinDataAddr) {
				throw new Error("total length of command line and environment variables exceeds limit");
			}

			this._inst.exports.run(argc, argv);
			if (this.exited) {
				this._resolveExitPromise();
			}
			await this._exitPromise;
		}

		_resume() {
			if (this.exited) {

a <a href="#Run_time_panics">run-time panic</a> occurs.
The shift operators implement arithmetic shifts if the left operand is a signed
integer and logical shifts if it is an unsigned integer.
There is no upper limit on the shift count. Shifts behave
as if the left operand is shifted <code>n</code> times by 1 for a shift
count of <code>n</code>.
As a result, <code>x &lt;&lt; 1</code> is the same as <code>x*2</code>

pkg syscall (freebsd-arm64), const RLIMIT_AS = 10
pkg syscall (freebsd-arm64), const RLIMIT_AS ideal-int
pkg syscall (freebsd-arm64), const RLIMIT_CORE = 4
pkg syscall (freebsd-arm64), const RLIMIT_CORE ideal-int
pkg syscall (freebsd-arm64), const RLIMIT_CPU = 0
pkg syscall (freebsd-arm64), const RLIMIT_CPU ideal-int
pkg syscall (freebsd-arm64), const RLIMIT_DATA = 2

pkg syscall (darwin-arm64), const RLIMIT_DATA = 2
pkg syscall (darwin-arm64), const RLIMIT_DATA ideal-int
pkg syscall (darwin-arm64), const RLIMIT_FSIZE = 1
pkg syscall (darwin-arm64), const RLIMIT_FSIZE ideal-int
pkg syscall (darwin-arm64), const RLIMIT_NOFILE = 8
pkg syscall (darwin-arm64), const RLIMIT_NOFILE ideal-int
pkg syscall (darwin-arm64), const RLIMIT_STACK = 3
pkg syscall (darwin-arm64), const RLIMIT_STACK ideal-int

		"-gdwarf-2",   // generate DWARF v2 debugging symbols
		"-c",          // do not link
		"-xc",         // input language is C
	)
	if p.GccIsClang {
		c = append(c,
			"-ferror-limit=0",
			// Apple clang version 1.7 (tags/Apple/clang-77) (based on LLVM 2.9svn)
			// doesn't have -Wno-unneeded-internal-declaration, so we need yet another
			// flag to disable the warning. Yes, really good diagnostics, clang.

pkg syscall (freebsd-riscv64), const RLIMIT_DATA ideal-int #53466
pkg syscall (freebsd-riscv64), const RLIMIT_FSIZE = 1 #53466
pkg syscall (freebsd-riscv64), const RLIMIT_FSIZE ideal-int #53466
pkg syscall (freebsd-riscv64), const RLIMIT_NOFILE = 8 #53466
pkg syscall (freebsd-riscv64), const RLIMIT_NOFILE ideal-int #53466
pkg syscall (freebsd-riscv64), const RLIMIT_STACK = 3 #53466
pkg syscall (freebsd-riscv64), const RLIMIT_STACK ideal-int #53466

This behavior is controlled by the `winreadlinkvolume` setting.
For Go 1.23, it defaults to `winreadlinkvolume=1`.
Previous versions default to `winreadlinkvolume=0`.

### Go 1.22

Go 1.22 adds a configurable limit to control the maximum acceptable RSA key size
that can be used in TLS handshakes, controlled by the [`tlsmaxrsasize` setting](/pkg/crypto/tls#Conn.Handshake).
The default is tlsmaxrsasize=8192, limiting RSA to 8192-bit keys. To avoid

	nameSize   = 100 // Max length of the name field in USTAR format
	prefixSize = 155 // Max length of the prefix field in USTAR format

	// Max length of a special file (PAX header, GNU long name or link).
	// This matches the limit used by libarchive.
	maxSpecialFileSize = 1 << 20
)

// blockPadding computes the number of bytes needed to pad offset up to the
// nearest block edge where 0 <= n < blockSize.