import (
	"bytes"
	"fmt"
	"reflect"
	"strings"
	"text/tabwriter"

	"github.com/google/go-cmp/cmp"
	"k8s.io/apimachinery/pkg/util/dump"
)

func legacyDiff(a, b interface{}) string {
	return cmp.Diff(a, b)
}

// StringDiff diffs a and b and returns a human readable diff.
// DEPRECATED: use github.com/google/go-cmp/cmp.Diff
func StringDiff(a, b string) string {
	return legacyDiff(a, b)
}

	CMP	$4, R1
	ADD	R0, R1		// R1 is the end of the range to compare
	B.LT	byte_loop	// length < 4
	AND	$3, R0, R6
	CMP	$0, R6
	B.NE	byte_loop	// unaligned a, use byte-wise compare (TODO: try to align a)
	AND	$3, R2, R6
	CMP	$0, R6
	B.NE	byte_loop	// unaligned b, use byte-wise compare
	AND	$0xfffffffc, R1, R6
	// length >= 4
chunk4_loop:
	MOVW.P	4(R0), R4
	MOVW.P	4(R2), R5
	CMP	R4, R5
	B.NE	notequal
	CMP	R0, R6

# why a package?
go mod why golang.org/x/text/language
cmp stdout why-language.txt

# why a module?
go mod why -m golang.org...
cmp stdout why-text-module.txt

# why a package used only in tests?
go mod why rsc.io/testonly
cmp stdout why-testonly.txt

# why a module used only in a test of a dependency?
go mod why -m rsc.io/testonly
cmp stdout why-testonly.txt

# test package not needed

	CMP	R10, R0
	BNE	chunk16_loop
	AND	$0xf, R6, R6
	CBZ	R6, samebytes
	SUBS	$8, R6
	BLT	tail
	// the length of tail > 8 bytes
	MOVD.P	8(R0), R4
	MOVD.P	8(R2), R5
	CMP	R4, R5
	BNE	cmp
	SUB	$8, R6
	// compare last 8 bytes
tail:
	MOVD	(R0)(R6), R4
	MOVD	(R2)(R6), R5
	CMP	R4, R5
	BEQ	samebytes
cmp:
	REV	R4, R4
	REV	R5, R5
	CMP	R4, R5
ret:
	MOVD	$1, R0
	CNEG	HI, R0, R0
	RET
small:

# but 'go mod vendor' cannot write go.mod.
cp go.mod.toodirect go.mod
go list all
cmp go.mod go.mod.toodirect


# Redundant requirements should be preserved...
cp go.mod.redundant go.mod
go list all
cmp go.mod go.mod.redundant
go mod vendor
cmp go.mod go.mod.redundant
rm -r vendor

# ...except by 'go mod tidy'.
go mod tidy
cmp go.mod go.mod.tidy


# A missing "go" version directive should be added.

	// ppc64x:"RLDICL","XOR",-"CMP",-"ISEL"
	return x&1 == 0
}

func TestSetEq64(x uint64, y uint64) bool {
	// ppc64x/power10:"SETBC\tCR0EQ",-"ISEL"
	// ppc64x/power9:"CMP","ISEL",-"SETBC\tCR0EQ"
	// ppc64x/power8:"CMP","ISEL",-"SETBC\tCR0EQ"
	b := x == y
	return b
}
func TestSetNeq64(x uint64, y uint64) bool {
	// ppc64x/power10:"SETBCR\tCR0EQ",-"ISEL"
	// ppc64x/power9:"CMP","ISEL",-"SETBCR\tCR0EQ"

! go get github.com/google/go-cmp
stderr '^go: GOVCS disallows using git for public github.com/google/go-cmp; see ''go help vcs''$'
env GOVCS='github.com/google/go-cmp/inner:git,github.com:svn|hg'
! go get github.com/google/go-cmp
stderr '^go: GOVCS disallows using git for public github.com/google/go-cmp; see ''go help vcs''$'

# bad patterns are reported (for more bad patterns, see TestGOVCSErrors)
env GOVCS='git'

aligned_a:
	AND	$3, R3, R8
	CMP	$0, R8
	BNE	byte_loop	// unaligned b, use byte-wise compare
	AND	$0xfffffffc, R6, R8
	// length >= 4
chunk4_loop:
	MOVW.P	4(R2), R4
	MOVW.P	4(R3), R5
	CMP	R4, R5
	BNE	cmp
	CMP	R2, R8
	BNE	chunk4_loop
	CMP	R2, R6
	BEQ	samebytes	// all compared bytes were the same; compare lengths
byte_loop:
	MOVBU.P	1(R2), R4
	MOVBU.P	1(R3), R5
	CMP	R4, R5
	BNE	ret
	CMP	R2, R6
	BNE	byte_loop

      int cmp = comparator.compare(getUpperEndpoint(), other.getUpperEndpoint());
      if (cmp > 0 || (cmp == 0 && other.getUpperBoundType() == OPEN)) {
        upEnd = other.getUpperEndpoint();
        upType = other.getUpperBoundType();
      }
    }

    if (hasLowBound && hasUpBound) {
      int cmp = comparator.compare(lowEnd, upEnd);

	MOVW	ptr+0(FP), R1
	MOVW	old+4(FP), R2
	MOVW	new+8(FP), R3
casl:
	LDREX	(R1), R0
	CMP	R0, R2
	BNE	casfail

#ifndef GOARM_7
	MOVB	internal∕cpu·ARM+const_offsetARMHasV7Atomics(SB), R11
	CMP	$0, R11
	BEQ	2(PC)
#endif
	DMB	MB_ISHST

	STREX	R3, (R1), R0
	CMP	$0, R0
	BNE	casl
	MOVW	$1, R0

#ifndef GOARM_7
	CMP	$0, R11
	BEQ	2(PC)
#endif
	DMB	MB_ISH

	MOVB	R0, ret+12(FP)
	RET
casfail: