go list -m all
cmp stdout m_all.txt

go mod edit -go=1.16
go list -m all
cmp stdout m_all.txt


# If we explicitly drop compatibility with 1.16, we retain fewer checksums,
# which gives a cleaner go.sum file but causes 1.16 to fail in readonly mode.

cp go.mod.orig go.mod
go mod tidy -compat=1.17
cmp go.mod go.mod.orig

# Make sure that -diff behaves the same as tidy.
[exec:patch] mv go.mod go.mod.tidyResult

	zDump := c.ztunnelDump

	svcs := slices.Filter(zDump.Services, filter.Verify)
	slices.SortFunc(svcs, func(a, b *ZtunnelService) int {
		if r := cmp.Compare(a.Namespace, b.Namespace); r != 0 {
			return r
		}
		if r := cmp.Compare(a.Name, b.Name); r != 0 {
			return r
		}
		return cmp.Compare(a.Hostname, b.Hostname)
	})
	fmt.Fprintln(w, "NAMESPACE\tSERVICE NAME\tSERVICE VIP\tWAYPOINT")

	for _, svc := range svcs {

	// short path to handle 0-byte case
	CBZ	R2, equal
	// short path to handle equal pointers
	CMP	R0, R1
	BEQ	equal
	B	memeqbody<>(SB)
equal:
	MOVD	$1, R0
	RET

// memequal_varlen(a, b unsafe.Pointer) bool
TEXT runtime·memequal_varlen<ABIInternal>(SB),NOSPLIT,$0-17
	CMP	R0, R1
	BEQ	eq
	MOVD	8(R26), R2    // compiler stores size at offset 8 in the closure
	CBZ	R2, eq
	B	memeqbody<>(SB)
eq:

		return found && IsLeafNode(treeNode)
	}, cmp.Ignore()), nil
}

// genPathIgnoreOpt returns a cmp.Option to ignore paths specified in parameter ignorePaths.
func genPathIgnoreOpt(ignorePaths []string) cmp.Option {
	return cmp.FilterPath(func(curPath cmp.Path) bool {
		cp := strings.Join(pathToStringList(curPath), ".")
		for _, ip := range ignorePaths {
			if res, err := filepath.Match(ip, cp); err == nil && res {
				return true

! go mod tidy -diff
stdout 'diff current/go.mod tidy/go.mod'
! stdout 'diff current/go.sum tidy/go.sum'
cmp go.mod.orig go.mod

# go.sum requires updates, should return non-zero exit code.
go mod tidy
cp go.sum.orig go.sum
! go mod tidy -diff
! stdout 'diff current/go.mod tidy/go.mod'
stdout 'diff current/go.sum tidy/go.sum'
cmp go.sum.orig go.sum

# go.mod and go.sum require updates, should return non-zero exit code.

env GOROOT=$TESTGO_GOROOT
go build -o dist.exe cmd/dist

exec ./dist.exe list
cmp stdout tool.txt

exec ./dist.exe list -v
cmp stdout tool-v.txt

exec ./dist.exe list -broken
cmp stdout tool-broken.txt

exec ./dist.exe list -json
cmp stdout tool-json.txt

exec ./dist.exe list -json -broken

package echo

import (
	"testing"

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

	"istio.io/istio/pkg/test/framework/components/namespace"
)

func TestParseConfigs(t *testing.T) {
	cfgs, err := ParseConfigs([]byte(`
- Service: "foo"
  Namespace: "bar"
  DeployAsVM: true
  VMDistro: "Centos8"
`))
	if err != nil {
		t.Fatal(err)
	}
	if diff := cmp.Diff(cfgs, []Config{{
		Service:    "foo",

	MOVW	addr+0(FP), R0
	MOVW	(R0), R1

	MOVB	runtime·goarm(SB), R11
	CMP	$7, R11
	BGE	native_barrier
	BL	memory_barrier<>(SB)
	B	end
native_barrier:
	DMB	MB_ISH
end:
	MOVW	R1, ret+4(FP)
	RET

TEXT	·Store(SB),NOSPLIT,$0-8
	MOVW	addr+0(FP), R1
	MOVW	v+4(FP), R2

	MOVB	runtime·goarm(SB), R8
	CMP	$7, R8
	BGE	native_barrier
	BL	memory_barrier<>(SB)
	B	store
native_barrier:

	x, y = curve.Add(x, y, xG, yG)
	if !isInfinity(x, y) {
		t.Errorf("x^(q-1) + x != ∞")
	}
	x, y = curve.Add(xG, yG, x0, y0)
	if x.Cmp(xG) != 0 || y.Cmp(yG) != 0 {
		t.Errorf("x+∞ != x")
	}
	x, y = curve.Add(x0, y0, xG, yG)
	if x.Cmp(xG) != 0 || y.Cmp(yG) != 0 {
		t.Errorf("∞+x != x")
	}

	if curve.IsOnCurve(x0, y0) {
		t.Errorf("IsOnCurve(∞) == true")
	}

		v0.AuxInt = int64ToAuxInt(1)
		v.AddArg2(v0, cmp)
		return true
	}
	// match: (SETBC [0] cmp)
	// cond: buildcfg.GOPPC64 <= 9
	// result: (ISELZ [0] (MOVDconst [1]) cmp)
	for {
		if auxIntToInt32(v.AuxInt) != 0 {
			break
		}
		cmp := v_0
		if !(buildcfg.GOPPC64 <= 9) {
			break
		}
		v.reset(OpPPC64ISELZ)
		v.AuxInt = int32ToAuxInt(0)