)

// multiple initialization
const (
	a1, a2, a3 = 7, 3.1415926, "foo"
	b1, b2, b3 = b3, b1, 42
	c1, c2, c3  /* ERROR "missing init expr for c3" */ = 1, 2
	d1, d2, d3 = 1, 2, 3, 4 /* ERROR "extra init expr 4" */
	_p0 = assert(a1 == 7)
	_p1 = assert(a2 == 3.1415926)
	_p2 = assert(a3 == "foo")
	_p3 = assert(b1 == 42)
	_p4 = assert(b2 == 42)
	_p5 = assert(b3 == 42)
)

func _() {
	const (

		d *= 10
	}
	for nano%int64(d) == 0 && d < 2*time.Second {
		d *= 2
	}
	return t.Truncate(d)
}

func main() {
	var t1 time.Time
	b1, err := os.ReadFile(os.Args[1])
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	if err := json.Unmarshal(b1, &t1); err != nil  {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}

	var t2 time.Time
	b2, err := os.ReadFile(os.Args[2])

-- sametime/sametime.go --
package main

import (
	"encoding/json"
	"fmt"
	"os"
	"time"
)


func main() {
	var t1 time.Time
	b1, err := os.ReadFile(os.Args[1])
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	if err := json.Unmarshal(b1, &t1); err != nil  {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}

	var t2 time.Time
	b2, err := os.ReadFile(os.Args[2])
	if err != nil {

}

type UnpairedVersion interface {
	Version
}

var _ Constraint = UnpairedVersion(nil)


// derived test case from issue #21804

type (
	_ interface{ m(B1) }
	A1 interface{ a(D1) }
	B1 interface{ A1 }
	C1 interface{ B1 }
	D1 interface{ C1 }
)

var _ A1 = C1(nil)


// derived test case from issue #22701

func F(x I4) interface{} {
	return x.Method()
}

			parts := yml.SplitString(c.doc)
			g := NewWithT(t)
			g.Expect(parts).To(Equal(expected))
		})
	}
}

func TestSplitWithNestedDocument(t *testing.T) {
	doc := `
b
    b1
    ---
    b2
`
	expected := []string{
		`b
    b1
    ---
    b2`,
	}

	g := NewWithT(t)
	parts := yml.SplitString(doc)
	g.Expect(parts).To(Equal(expected))
}

func TestJoinRemovesEmptyParts(t *testing.T) {

func (A4) m() {} // ERROR "cannot define new methods on non-local type|may not define methods on non-local type"

type B1 = struct{}

func (B1) m() {} // ERROR "invalid receiver type"

00000240  df d3 20 64 38 92 24 3a  00 bc cf 9c 7d b7 40 20  |.. d8.$:....}.@ |
00000250  01 5f aa d3 16 61 09 a2  76 fd 13 c3 cc e1 0c 5c  |._...a..v......\|
00000260  ee b1 87 82 f1 6c 04 ed  73 bb b3 43 77 8d 0c 1c  |.....l..s..Cw...|
00000270  f1 0f a1 d8 40 83 61 c9  4c 72 2b 9d ae db 46 06  |******@****.***+...F.|
00000280  06 4d f4 c1 b3 3e c0 d1  bd 42 d4 db fe 3d 13 60  |.M...>...B...=.`|

// Valid and invalid variations.
type B0 any
type B1[_ any] any
type B2[_, _ any] any

func _[T1 B0]() {}
func _[T1 B1[T1]]() {}
func _[T1 B2 /* ERRORx `cannot use generic type .* without instantiation` */ ]() {}

func _[T1, T2 B0]() {}
func _[T1 B1[T1], T2 B1[T2]]() {}
func _[T1, T2 B2 /* ERRORx `cannot use generic type .* without instantiation` */ ]() {}

func _[T1 B0, T2 B1[T2]]() {} // here B1 applies to T2

        createDirs("buildSrc", "buildSrc/b1", "buildSrc/b2")
        file("buildSrc/settings.gradle") << """
            $settings
            include 'b1', 'b2'
        """

        file("buildSrc/build.gradle") << """
            allprojects { apply plugin: 'java' }
            dependencies { implementation project(':b1') }
            project(':b1') { dependencies { implementation project(':b2') } }

00000260  d9 0b f2 97 df d3 20 64  38 92 24 3a 00 bc cf 9c  |...... d8.$:....|
00000270  7d b7 40 20 01 5f aa d3  16 61 09 a2 76 fd 13 c3  |}.@ ._...a..v...|
00000280  cc e1 0c 5c ee b1 87 82  f1 6c 04 ed 73 bb b3 43  |...\.....l..s..C|
00000290  77 8d 0c 1c f1 0f a1 d8  40 83 61 c9 4c 72 2b 9d  |******@****.***+.|
000002a0  ae db 46 06 06 4d f4 c1  b3 3e c0 d1 bd 42 d4 db  |..F..M...>...B..|