func (m *MockedIpsetDeps) deleteIP(name string, ip netip.Addr, ipProto uint8) error {
	args := m.Called(name, ip, ipProto)
	return args.Error(0)
}

func (m *MockedIpsetDeps) flush(name string) error {
	args := m.Called(name)
	return args.Error(0)
}

func (m *MockedIpsetDeps) clearEntriesWithComment(name, comment string) error {
	args := m.Called(name, comment)
	return args.Error(0)
}

	MOVF	$1, X5				// ERROR "unsupported constant load"
	MOVBU	X5, (X6)			// ERROR "unsupported unsigned store"
	MOVHU	X5, (X6)			// ERROR "unsupported unsigned store"
	MOVWU	X5, (X6)			// ERROR "unsupported unsigned store"
	MOVF	F0, F1, F2			// ERROR "illegal MOV instruction"
	MOVD	F0, F1, F2			// ERROR "illegal MOV instruction"
	MOV	X10, X11, X12			// ERROR "illegal MOV instruction"

	_ = 0o567 // ERROR "octal"
	_ = 0xabc // ok
	_ = 0x0p1 // ERROR "hexadecimal floating-point"

	_ = 1_000i // ERROR "underscore"
	_ = 0b111i // ERROR "binary"
	_ = 0o567i // ERROR "octal"
	_ = 0xabci // ERROR "hexadecimal floating-point"
	_ = 0x0p1i // ERROR "hexadecimal floating-point"
)

// signed shift counts
var (
	s int

func assertErrorMessage(want string) func(*testing.T, error) {
	return func(t *testing.T, got error) {
		if got == nil {
			t.Error("expected non-nil error")
			return
		}
		if got.Error() != want {
			t.Errorf("got error %q, want %q", got.Error(), want)
		}
	}
}

func assertIdenticalError[E error](expected E) func(*testing.T, error) {
	return assertOnConcreteError(func(t *testing.T, actual E) {

						decision: authorizer.DecisionAllow,
						reason:   "test reason",
						error:    fmt.Errorf("test error"),
					},
				},
				{
					attributes: authorizer.AttributesRecord{Name: "test name"},
					expected: result{
						decision: authorizer.DecisionAllow,
						reason:   "test reason",
						error:    fmt.Errorf("test error"),
					},
				},
			},
			backend: []result{
				{

package labels

var x int

func f0() {
L1 /* ERROR "label L1 declared and not used" */ :
	for {
	}
L2 /* ERROR "label L2 declared and not used" */ :
	select {
	}
L3 /* ERROR "label L3 declared and not used" */ :
	switch {
	}
L4 /* ERROR "label L4 declared and not used" */ :
	if true {
	}
L5 /* ERROR "label L5 declared and not used" */ :
	f0()
L6:
	f0()
L6 /* ERROR "label L6 already declared" */ :
	f0()

		if closeErr := rows.Close(); closeErr != nil {
			http.Error(w, closeErr.Error(), http.StatusInternalServerError)
			return
		}

		// Check for row scan error.
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		// Check for errors during row iteration.
		if err = rows.Err(); err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

// specified by the developer. The purpose is to simulate errors
// that are hard to simulate in practice like DiskNotFound.
// Programmed errors are stored in errors field.
type naughtyDisk struct {
	// The real disk
	disk StorageAPI
	// Programmed errors: API call number => error to return
	errors map[int]error
	// The error to return when no error value is programmed
	defaultErr error

	deleteIP(name string, ip netip.Addr, ipProto uint8) error
	flush(name string) error
	clearEntriesWithComment(name string, comment string) error
	clearEntriesWithIP(name string, ip netip.Addr) error
	listEntriesByIP(name string) ([]netip.Addr, error)
}

// TODO this should actually create v6 and v6 subsets of type `hash:ip`, add them both to a

                error(UnsupportedSyntax(DanglingExpr)[251..251]
                error(UnsupportedSyntax(ElementWithExplicitReceiver)[259..261]
                error(UnsupportedSyntax(AssignmentWithExplicitReceiver)[267..273]
                error(UnsupportedSyntax(LocalVal)[279..287]
                error(SyntaxError(Parsing failure, unexpected tokenType in expression: POSTFIX_EXPRESSION)[307..319]