000000b0  88 31 c0 a5 fb 63 05 95  52 b3 04 94 14 fe eb 0c  |.1...c..R.......|
000000c0  53 a0 c2 bf ae 58 e3 f9  84 22 6b ca 95 33 12 80  |S....X..."k..3..|
000000d0  09 e2 97 b0 2b 4b ed fa  34 e1 5a b1 de 52 b1 2c  |....+K..4.Z..R.,|
000000e0  a0 aa 11 d6 fa 07 e1 41  ed 36 9f 9a 1a 56 18 b0  |.......A.6...V..|
000000f0  ef e7 85 dc 5b 53 23 56  c2 ac 34 64 c8 9d 4b 49  |....[S#V..4d..KI|

    ByteSource b1 = ByteSource.wrap(new byte[] {0, 1, 2, 3});
    ByteSource b2 = ByteSource.wrap(new byte[0]);
    ByteSource b3 = ByteSource.wrap(new byte[] {4, 5});

    byte[] expected = {0, 1, 2, 3, 4, 5};

    assertArrayEquals(expected, ByteSource.concat(ImmutableList.of(b1, b2, b3)).read());
    assertArrayEquals(expected, ByteSource.concat(b1, b2, b3).read());

}

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) {

				// only same network/cluster, no VMs
				a1, a1Ns2, b1, c1, headless1, naked1, external1,
			},
		},
		"ReachableDestinations from vm": {
			filter: func(instances echo.Instances) echo.Instances {
				return echotest.ReachableDestinations(vm1, instances)
			},
			expect: echo.Instances{
				// all pods/vms, no external
				a1, a2, a1Ns2, a2Ns2, b1, b2, c1, c2, vm1, vm2,
				// only same network/cluster

					"key1": "a1",
					"key2": "a2",
					"val":  1,
				},
				map[string]interface{}{
					"key1": "b1",
					"key2": "b2",
					"val":  2,
				},
			}, &multiKeyMapListSchema),
			rhs: UnstructuredToVal([]interface{}{
				map[string]interface{}{
					"key1": "b1",
					"key2": "b2",
					"val":  2,
				},
				map[string]interface{}{
					"key1": "a1",
					"key2": "a2",

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"

	if err != nil {
		t.Fatal(err)
	}
	defer c2.Close()

	b1 := []byte("READ SIZE ERROR TEST")
	for _, genericRead := range []bool{false, true} {
		n, err := c2.Write(b1)
		if err != nil {
			t.Fatal(err)
		}
		if n != len(b1) {
			t.Errorf("got %d; want %d", n, len(b1))
		}
		b2 := make([]byte, len(b1)-1)
		if genericRead {
			n, err = c1.(Conn).Read(b2)
		} else {

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...=.`|

000000d0  9e 5a 15 42 7e 48 5a 46  52 aa 16 c1 af 31 e0 5e  |.Z.B~HZFR....1.^|
000000e0  1f 0b 2e 6c b0 77 2b 18  96 df 2c b1 14 98 ab 19  |...l.w+...,.....|
000000f0  f9 58 dc 2f 29 09 be 2f  6e 69 00 e0 de 49 5b ca  |.X./)../ni...I[.|
00000100  2f 3d c6 41 9d 18 ca ef  4b e4 06 12 1b 08 5f 62  |/=.A....K....._b|
00000110  53 85 a7 fc d1 26 b1 6b  20 56 56 16 87 54 bb e6  |S....&.k VV..T..|