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();

var s S = 42
var t = &T{S: s}

var fn = (*T).M // force a method wrapper

func main() {
	a := 123
	x := [2]int{456, 789}
	b := 1.2
	y := [2]float64{3.4, 5.6}
	s1, a1, x1, b1, y1 := fn(t, a, x, b, y)
	if a1 != a || x1 != x || b1 != b || y1 != y || s1 != s {
		panic("FAIL")
	}

cmp go1.14-modules.txt vendor/modules.txt

-- go.mod --
module example.com/foo
go 1.14

require (
	example.com/a v0.1.0
)

replace (
	example.com/a v0.1.0 => ./a
	example.com/b v0.1.0 => ./b1
	example.com/b v0.2.0-unused => ./b2
	example.com/c => ./c
	example.com/d v0.1.0 => ./d1
	example.com/d v0.2.0 => ./d2
	example.com/e => example.com/e v0.1.0-unused
)
-- foo.go --
package foo

        given:
        file("a").with {
            createFile("a")
        }
        file("b").with {
            createFile("b")
            createDir("b1").createFile("b1")
        }

        def resolver = TestFiles.resolver(testDirectory)
        def fileCollectionFactory = TestFiles.fileCollectionFactory(testDirectory)

 * that follows.
 *
 * b1
 * --
 *
 * This is either a mapping decision or the length of the mapped output, according to this table:
 *
 * ```
 *  0..63 : Length of the UTF-16 sequence that this range maps to. The offset is b2b3.
 * 64..79 : Offset by a fixed negative offset. The bottom 4 bits of b1 are the top 4 bits of the offset.

        final byte b0 = DECODE_TABLE[inData.charAt(inIndex)];
        final byte b1 = DECODE_TABLE[inData.charAt(inIndex + 1)];
        final byte b2 = DECODE_TABLE[inData.charAt(inIndex + 2)];
        final byte b3 = DECODE_TABLE[inData.charAt(inIndex + 3)];
        outData[outIndex] = (byte) (b0 << 2 & 0xfc | b1 >> 4 & 0x3);
        outData[outIndex + 1] = (byte) (b1 << 4 & 0xf0 | b2 >> 2 & 0xf);

	x2 := [4]int16{-1, 99, 99, 99}
	if x1 == x2 {
		panic("bad comparison")
	}

	a1 := [2]int8{-1, 88}
	a2 := [2]int8{-1, 99}
	if a1 == a2 {
		panic("bad comparison")
	}
	b1 := [4]int8{-1, 88, 88, 88}
	b2 := [4]int8{-1, 99, 99, 99}
	if b1 == b2 {
		panic("bad comparison")
	}
	c1 := [8]int8{-1, 88, 88, 88, 88, 88, 88, 88}
	c2 := [8]int8{-1, 99, 99, 99, 99, 99, 99, 99}
	if c1 == c2 {
		panic("bad comparison")
	}

// array with five elements
type B [5]int

func main() {
	var i interface{}

	var s1, s2 S
	i = s1 == s2

	var t1, t2 T
	i = t1 == t2

	var a1, a2 A
	i = a1 == a2

	var b1, b2 B
	i = b1 == b2

	_ = i

	if err != nil {
		panic(err)
	}
	// (defer statement belongs here)
}
-- vetall/p_test.go --
package p
-- vetcycle/p.go --
package p

type (
	_  interface{ m(B1) }
	A1 interface{ a(D1) }
	B1 interface{ A1 }
	C1 interface {
		B1 /* ERROR issue #18395 */
	}
	D1 interface{ C1 }
)

var _ A1 = C1 /* ERROR cannot use C1 */ (nil)
-- vetfail/p1/p1.go --
// +build !foo-bar

package p1

)

-- a1/go.mod --
module example.com/a

go 1.16

require example.com/b v0.1.0
-- a1/a.go --
package a

import _ "example.com/b"

-- b1/go.mod --
module example.com/b

go 1.16

require example.com/c v0.1.0
-- b1/b.go --
package b

import _ "example.com/c"

-- b2/go.mod --
module example.com/b

go 1.16

require (
	example.com/c v0.2.0