func (e *Expectation) Check(err error) error {
	if !e.failure && err != nil {
		return fmt.Errorf("unexpected error while reading the trace: %v", err)
	}
	if e.failure && err == nil {
		return fmt.Errorf("expected error while reading the trace: want something matching %q, got none", e.errorMatcher)
	}
	if e.failure && err != nil && !e.errorMatcher.MatchString(err.Error()) {

		if r == nil {
			panic("no fault or bounds check failure happened")
		}
		s := fmt.Sprintf("%s", r)
		if s != "runtime error: index out of range [1] with length 1" {
			panic("bad panic: " + s)
		}
	}()
	return uint16(x[i]) | uint16(x[i+1])<<8
}

func test32(x []byte) uint32 {
	defer func() {
		r := recover()
		if r == nil {
			panic("no fault or bounds check failure happened")
		}
		s := fmt.Sprintf("%s", r)

small:
	TESTQ	BX, BX
	JEQ	failure

	// Check if we'll load across a page boundary.
	LEAQ	16(SI), AX
	TESTW	$0xff0, AX
	JEQ	endofpage

	MOVOU	(SI), X1 // Load data
	PCMPEQB	X0, X1	// Compare target byte with each byte in data.
	PMOVMSKB X1, DX	// Move result bits to integer register.
	BSFL	DX, DX	// Find first set bit.
	JZ	failure	// No set bit, failure.
	CMPL	DX, BX

# This is a somewhat inexact check, but since we don't prefix the error with anything
# and as the error suffix is platform dependent, this is the best we can do. In the
# deadlock failure case, the test will just deadlock and timeout anyway, so it should
# be clear that that failure mode is different.
stdout 'open'

-- go.mod --
module test

-- cov_test.go --
package dead

import (
	"os"
	"path/filepath"
	"testing"
	"time"

	alertDecryptionFailed:             "decryption failed",
	alertRecordOverflow:               "record overflow",
	alertDecompressionFailure:         "decompression failure",
	alertHandshakeFailure:             "handshake failure",
	alertBadCertificate:               "bad certificate",
	alertUnsupportedCertificate:       "unsupported certificate",
	alertCertificateRevoked:           "revoked certificate",

//go:build freebsd && (amd64 || arm64 || riscv64)

package unix

import "syscall"

func PosixFallocate(fd int, off int64, size int64) error {
	// If successful, posix_fallocate() returns zero. It returns an error on failure, without
	// setting errno. See https://man.freebsd.org/cgi/man.cgi?query=posix_fallocate&sektion=2&n=1
	r1, _, _ := syscall.Syscall(posixFallocateTrap, uintptr(fd), uintptr(off), uintptr(size))
	if r1 != 0 {

-- expect --
FAILURE ".*expected a proc but didn't have one.*"
-- trace --
Trace Go1.22
EventBatch gen=1 m=0 time=0 size=34
GoCreateSyscall dt=1 new_g=4
ProcStatus dt=1 p=0 pstatus=2
ProcStart dt=1 p=0 p_seq=1
GoSyscallEndBlocked dt=1
GoStart dt=1 g=4 g_seq=1
GoSyscallBegin dt=1 p_seq=2 stack=0
GoDestroySyscall dt=1
GoCreateSyscall dt=1 new_g=4
GoSyscallEnd dt=1
GoSyscallBegin dt=1 p_seq=3 stack=0
GoDestroySyscall dt=1

	void *p;

	_cgo_tsan_acquire();
	p = mmap(addr, length, prot, flags, fd, offset);
	_cgo_tsan_release();
	if (p == MAP_FAILED) {
		/* This is what the Go code expects on failure.  */
		return (uintptr_t)errno;
	}
	return (uintptr_t)p;
}

void
x_cgo_munmap(void *addr, uintptr_t length) {
	int r;

	_cgo_tsan_acquire();
	r = munmap(addr, length);
	_cgo_tsan_release();

-- expect --
FAILURE "expected a proc but didn't have one"
-- trace --
Trace Go1.22
EventBatch gen=1 m=0 time=0 size=5
Frequency freq=15625000
EventBatch gen=1 m=0 time=0 size=5
GoCreate dt=0 new_g=1 new_stack=0 stack=0

// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package lostcancel defines an Analyzer that checks for failure to
// call a context cancellation function.
//
// # Analyzer lostcancel
//
// lostcancel: check cancel func returned by context.WithCancel is called
//
// The cancellation function returned by context.WithCancel, WithTimeout,