// func memmove(to, from unsafe.Pointer, n uintptr)
TEXT runtime·memmove<ABIInternal>(SB), NOSPLIT|NOFRAME, $0-24
	CBZ	R2, copy0

	// Small copies: 1..16 bytes
	CMP	$16, R2
	BLE	copy16

	// Large copies
	CMP	$128, R2
	BHI	copy_long
	CMP	$32, R2
	BHI	copy32_128

	// Small copies: 17..32 bytes.
	LDP	(R1), (R6, R7)
	ADD	R1, R2, R4          // R4 points just past the last source byte
	LDP	-16(R4), (R12, R13)

See the License for the specific language governing permissions and
limitations under the License.
*/

package v1_test

import (
	"testing"

	"github.com/google/go-cmp/cmp"
	v1 "k8s.io/api/core/v1"
	discovery "k8s.io/api/discovery/v1"
	apiequality "k8s.io/apimachinery/pkg/api/equality"
	"k8s.io/kubernetes/pkg/api/legacyscheme"
	_ "k8s.io/kubernetes/pkg/apis/discovery/install"

# 'go get -u local/...' should be equivalent to 'go get -u ./...'
# (assuming no nested modules)
cp go.mod.orig go.mod
go get -u local/...
cmp go.mod go.mod.implicitmod

# For the main module, @patch should be a no-op.
cp go.mod.orig go.mod
go get -u local/...@patch
cmp go.mod go.mod.implicitmod

# 'go get -u' in the empty root of the main module should fail.
# 'go get -u .' should also fail.
cp go.mod.orig go.mod

limitations under the License.
*/

package modes_test

import (
	"fmt"
	"testing"

	"github.com/fxamacker/cbor/v2"
	"github.com/google/go-cmp/cmp"
)

func TestEncode(t *testing.T) {
	for _, tc := range []struct {
		name          string
		modes         []cbor.EncMode
		in            interface{}
		want          []byte

	CALL	libc_mmap(SB)
	MOVD	$0, R4
	CMP	R3, $-1
	BNE	noerr
	CALL	libc_errno(SB)
	MOVW	(R3), R4		// errno
	MOVD	$0, R3
noerr:
	MOVD	R3, 32(R14)
	MOVD	R4, 40(R14)
	RET

TEXT runtime·munmap_trampoline(SB),NOSPLIT,$32
	MOVD	8(R3), R4		// arg 2 - len
	MOVD	0(R3), R3		// arg 1 - addr
	CALL	libc_munmap(SB)
	CMP	R3, $-1
	BNE	3(PC)
	MOVD	$0, R3			// crash on failure

	//  arg 1 ---> R1
	CMP  R8, $0
	BEQ  docall
	SUB  $1, R8
	MOVD 0(R7), R1

	//  arg 2 ---> R2
	CMP  R8, $0
	BEQ  docall
	SUB  $1, R8
	ADD  $8, R7
	MOVD 0(R7), R2

	//  arg 3 --> R3
	CMP  R8, $0
	BEQ  docall
	SUB  $1, R8
	ADD  $8, R7
	MOVD 0(R7), R3

	CMP  R8, $0
	BEQ  docall

limitations under the License.
*/

package load

import (
	"bytes"
	"os"
	"reflect"
	"strings"
	"testing"
	"time"

	"github.com/google/go-cmp/cmp"

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	api "k8s.io/apiserver/pkg/apis/apiserver"
)

var defaultConfig = &api.AuthorizationConfiguration{}

func writeTempFile(t *testing.T, content string) string {

	// compared to ARM64 and others.
	CMP	$0, R9
	BEQ	sigtrampnog // g == nil

	// g is not nil. Check further.
	MOVD	g_m(R9), R6
	CMP	$0, R6
	BEQ	sigtramp    // g.m == nil
	MOVW	m_ncgo(R6), R7
	CMPW	$0, R7
	BEQ	sigtramp    // g.m.ncgo = 0
	MOVD	m_curg(R6), R7
	CMP	$0, R7
	BEQ	sigtramp    // g.m.curg == nil
	MOVD	g_syscallsp(R7), R7
	CMP	$0, R7
	BEQ	sigtramp    // g.m.curg.syscallsp == 0

      return 0;
    }
    // The cast is safe because we call this method only if hasLowerBound().
    int cmp =
        comparator()
            .compare(uncheckedCastNullableTToT(range.getLowerEndpoint()), node.getElement());
    if (cmp < 0) {
      return aggregateBelowRange(aggr, node.left);
    } else if (cmp == 0) {
      switch (range.getLowerBoundType()) {
        case OPEN:

//
// On exit:
// R4 and R8 are clobbered
TEXT countbytebody<>(SB),NOSPLIT,$0
	MOVW	$0, R8	// R8 = count of byte to search
	CMP	$0, R1
	B.EQ	done	// short path to handle 0-byte case
	ADD	R0, R1	// R1 is the end of the range
byte_loop:
	MOVBU.P	1(R0), R4
	CMP	R4, R2
	ADD.EQ	$1, R8
	CMP	R0, R1
	B.NE	byte_loop
done:
	MOVW	R8, (R7)