for _, tt := range compareTests {
			eql := Equal(tt.a, tt.b)
			if eql != (tt.i == 0) {
				t.Errorf(`Equal(%q, %q) = %v`, tt.a, tt.b, eql)
			}
		}
	})
	if allocs > 0 {
		t.Errorf("Equal allocated %v times", allocs)
	}
}

func TestEqualExhaustive(t *testing.T) {
	var size = 128
	if testing.Short() {
		size = 32
	}
	a := make([]byte, size)
	b := make([]byte, size)
	b_init := make([]byte, size)

//go:build gccgo

#include "_cgo_export.h"
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

/* Test calling panic from C.  This is what SWIG does.  */

extern void _cgo_panic(const char *);
extern void *_cgo_allocate(size_t);

void
callPanic(void)
{
	_cgo_panic("panic from C");

corresponds to the type argument with which <code>P</code> was
<a href="#Instantiations">instantiated</a>.
</p>

<p>
The capacity of a slice is the number of elements for which there is
space allocated in the underlying array.
At any time the following relationship holds:
</p>

<pre>
0 &lt;= len(s) &lt;= cap(s)
</pre>

<p>
The length of a <code>nil</code> slice, map or channel is 0.

			// other than try to determine a Go representation.
			tt := *t
			tt.C = &TypeRepr{"%s %s", []interface{}{dt.Kind, tag}}
			// We don't know what the representation of this struct is, so don't let
			// anyone allocate one on the Go side. As a side effect of this annotation,
			// pointers to this type will not be considered pointers in Go. They won't
			// get writebarrier-ed or adjusted during a stack copy. This should handle

pkg syscall (windows-386), const FILE_TYPE_UNKNOWN ideal-int
pkg syscall (windows-386), const FILE_WRITE_ATTRIBUTES ideal-int
pkg syscall (windows-386), const FORMAT_MESSAGE_ALLOCATE_BUFFER ideal-int
pkg syscall (windows-386), const FORMAT_MESSAGE_ARGUMENT_ARRAY ideal-int
pkg syscall (windows-386), const FORMAT_MESSAGE_FROM_HMODULE ideal-int

pkg syscall (freebsd-arm64), const SYS_POSIX_FADVISE = 531
pkg syscall (freebsd-arm64), const SYS_POSIX_FADVISE ideal-int
pkg syscall (freebsd-arm64), const SYS_POSIX_FALLOCATE = 530
pkg syscall (freebsd-arm64), const SYS_POSIX_FALLOCATE ideal-int
pkg syscall (freebsd-arm64), const SYS_POSIX_OPENPT = 504
pkg syscall (freebsd-arm64), const SYS_POSIX_OPENPT ideal-int
pkg syscall (freebsd-arm64), const SYS_PPOLL = 545

reliable, and efficient software.

![Gopher image](https://golang.org/doc/gopher/fiveyears.jpg)
*Gopher image by [Renee French][rf], licensed under [Creative Commons 4.0 Attributions license][cc4-by].*

Our canonical Git repository is located at https://go.googlesource.com/go.
There is a mirror of the repository at https://github.com/golang/go.

Unless otherwise noted, the Go source files are distributed under the
BSD-style license found in the LICENSE file.

pkg syscall (freebsd-riscv64), const SYS_POSIX_FADVISE = 531 #53466
pkg syscall (freebsd-riscv64), const SYS_POSIX_FADVISE ideal-int #53466
pkg syscall (freebsd-riscv64), const SYS_POSIX_FALLOCATE = 530 #53466
pkg syscall (freebsd-riscv64), const SYS_POSIX_FALLOCATE ideal-int #53466
pkg syscall (freebsd-riscv64), const SYS_POSIX_OPENPT = 504 #53466
pkg syscall (freebsd-riscv64), const SYS_POSIX_OPENPT ideal-int #53466

)

// Equal reports whether a and b
// are the same length and contain the same bytes.
// A nil argument is equivalent to an empty slice.
func Equal(a, b []byte) bool {
	// Neither cmd/compile nor gccgo allocates for these string conversions.
	return string(a) == string(b)
}

// Compare returns an integer comparing two byte slices lexicographically.
// The result will be 0 if a == b, -1 if a < b, and +1 if a > b.

pkg syscall (windows-386), const FILE_TYPE_REMOTE = 32768
pkg syscall (windows-386), const FILE_TYPE_UNKNOWN = 0
pkg syscall (windows-386), const FILE_WRITE_ATTRIBUTES = 256
pkg syscall (windows-386), const FORMAT_MESSAGE_ALLOCATE_BUFFER = 256
pkg syscall (windows-386), const FORMAT_MESSAGE_ARGUMENT_ARRAY = 8192
pkg syscall (windows-386), const FORMAT_MESSAGE_FROM_HMODULE = 2048
pkg syscall (windows-386), const FORMAT_MESSAGE_FROM_STRING = 1024