edge('org:testA:1.0', 'org:testB:1.0')
                    .byConflictResolution("On capability org.test:cap we like testB better")
                module('org:testB:1.0')
            }
        }

        where:
        rule << [
            "select(candidates.find { it.id.module == 'testB'})",
            "select('org:testB:1.0')",
            "select('org:testB:1.1')", // we are lenient wrt to the version number

	}
}
-- b/b.go --
package b

import (
	"M/a"
	"M/d"
)

func BFunc() int {
	return -d.FortyTwo + a.AFunc()
}
-- b/b_test.go --
package b

import "testing"

func TestB(t *testing.T) {
	if BFunc() == 1010101 {
		t.Fatalf("bad!")
	}
}
-- c/c.go --
package c

var G int

func CFunc(x, y int) int {
	G += x
	G -= y
	return x + y
}
-- c/c_test.go --

func TestA(*testing.T) {}
-- a/default.pgo --
-- b/b.go --
package main
import _ "test/dep"
import _ "test/dep2"
func main() {}
-- b/b_test.go --
package main
import "testing"
import _ "test/testdep"
func TestB(*testing.T) {}
-- b/default.pgo --
-- nopgo/nopgo.go --
package main
import _ "test/dep"
import _ "test/dep2"
func main() {}
-- nopgo/nopgo_test.go --
package main
import "testing"

import "testing"

func TestA(t *testing.T) {
	// Edge-case testing, mixing unparallel tests too
	t.Logf("LOG: %s", t.Name())
}

func TestFailingA(t *testing.T) {
	t.Errorf("FAIL - %s", t.Name())
}

func TestB(t *testing.T) {
	// Edge-case testing, mixing unparallel tests too
	t.Logf("LOG: %s", t.Name())
}

func TestParallelFailingA(t *testing.T) {
	t.Parallel()
	t.Errorf("FAIL - %s", t.Name())
}

	a[0] &= 200
	// amd64:`ORL\s[$]220,\s4\([A-Z][A-Z0-9]+\)`
	a[1] |= 220
	// amd64:`XORL\s[$]240,\s8\([A-Z][A-Z0-9]+\)`
	a[2] ^= 240
}

func bitcheckMostNegative(b uint8) bool {
	// amd64:"TESTB"
	return b&0x80 == 0x80
}

// Check AND masking on arm64 (Issue #19857)

func and_mask_1(a uint64) uint64 {
	// arm64:`AND\t`
	return a & ((1 << 63) - 1)
}

func and_mask_2(a uint64) uint64 {