)

replace (
	example.com/b v0.1.0 => ./b1
	example.com/b v0.2.0 => ./b2
	example.com/c v0.1.0 => ./c1
	example.com/c v0.2.0 => ./c2
	example.com/d v0.1.0 => ./d
	example.com/d v0.2.0 => ./d
)
-- go.mod.down2 --
module example.com/a

go 1.15

require example.com/c v0.1.0

replace (
	example.com/b v0.1.0 => ./b1
	example.com/b v0.2.0 => ./b2
	example.com/c v0.1.0 => ./c1

	a := 1
	b := 2
	c := add(a, b)
	d := a + b
	fmt.Println(c, d)
}

//go:noinline
func add(a1, b1 int) int {
	// The arguments.
	// When -asan is enabled, unsafe.Pointer(&a1) conversion is escaping.
	var p *int = (*int)(unsafe.Add(unsafe.Pointer(&a1), 1*unsafe.Sizeof(int(1))))
	*p = 10 // BOOM
	return a1 + b1

        buildB.buildFile << """
            dependencies { implementation project(':b1') }
        """

        when:
        execute(buildA, ":dependencies")

        then:
        outputContains("""
runtimeClasspath - Runtime classpath of source set 'main'.
\\--- org.test:${dependencyName}:1.0 -> project :${buildName}
     \\--- project :${buildName}:b1
""")

        where:

replace (
	example.net/a v0.1.0 => ./a
	example.net/b v0.1.0 => ./b1
	example.net/b v0.2.0 => ./b2
	example.net/c v0.1.0 => ./c1
	example.net/c v0.2.0 => ./c2
	example.net/d v0.1.0 => ./d
)

require (
	example.net/b v0.1.0
)
-- a/go.mod --
module example.net/a

go 1.18

require example.net/b v0.2.0
-- a/a.go --
package a

import _ "example.net/b"
-- b1/go.mod --
module example.net/b

go 1.16

}

func TestBlockGeneric(t *testing.T) {
	var b1, b2 [32]uint64
	s := seed // byte seed
	seed := [4]uint64{
		binary.LittleEndian.Uint64(s[0*8:]),
		binary.LittleEndian.Uint64(s[1*8:]),
		binary.LittleEndian.Uint64(s[2*8:]),
		binary.LittleEndian.Uint64(s[3*8:]),
	}

	Block(&seed, &b1, 4)
	Block_generic(&seed, &b2, 4)
	if !slices.Equal(b1[:], b2[:]) {
		var out bytes.Buffer

	addMul64(r0, 19, a4, b1)

	// r1 = a0×b1 + a1×b0 + 19×(a2×b4 + a3×b3 + a4×b2)
	r1 := uint128{"r1", GP64(), GP64()}
	mul64(r1, 1, a0, b1)
	addMul64(r1, 1, a1, b0)
	addMul64(r1, 19, a2, b4)
	addMul64(r1, 19, a3, b3)
	addMul64(r1, 19, a4, b2)

	// r2 = a0×b2 + a1×b1 + a2×b0 + 19×(a3×b4 + a4×b3)
	r2 := uint128{"r2", GP64(), GP64()}
	mul64(r2, 1, a0, b2)
	addMul64(r2, 1, a1, b1)
	addMul64(r2, 1, a2, b0)

// Copyright 2019 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

func hashBytesRaw(b0, b1, b2, b3, b7 byte) uint64 {
	return (uint64(b0) | uint64(b1)<<8 | uint64(b2)<<16 | uint64(b3)<<24)
}

func doStuff(data []byte) uint64 {
	return hashBytesRaw(data[0], data[1], data[2], data[3], data[7])

        List<SynonymItem> itemList = new ArrayList<>();
        itemList.add(new SynonymItem(1, new String[] { "a1" }, new String[] { "A1" }));
        itemList.add(new SynonymItem(2, new String[] { "b1", "b2" }, new String[] { "B1" }));
        itemList.add(new SynonymItem(3, new String[] { "c1" }, new String[] { "C1", "C2" }));
        itemList.add(new SynonymItem(4, new String[] { "x1", "X1" }, new String[] { "x1", "X1" }));

    assertSame(s1, s2);

    Long n1 = 42L;
    Long n2 = MoreObjects.firstNonNull(null, n1);
    assertSame(n1, n2);

    Boolean b1 = true;
    Boolean b2 = MoreObjects.firstNonNull(b1, null);
    assertSame(b1, b2);
  }

  public void testFirstNonNull_throwsNullPointerException() {
    try {
      MoreObjects.firstNonNull(null, null);
      fail();

        given:
        buildA.buildFile << """
            task resolveJars {
                dependsOn gradle.includedBuild('buildB').task(':b1:resolveJars')
            }
        """
        buildB.buildFile << """
            project(':b1') {
                dependencies {
                    implementation "org.test:buildC:1.0"
                }
                task resolveJars(type: Copy) {