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

				// 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",

	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 {

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

      }, {
       // Body region
       // CHECK: ^bb0
       ^bb0(%barg0: tensor<i32>):
          %b0 = "tf.Const"() {value = dense<-1> : tensor<i32>} : () -> tensor<i32>
          %b1 = "tf.AddV2"(%barg0, %0) {T = i32, device = ""} : (tensor<i32>, tensor<i32>) -> tensor<i32>
          // CHECK: %[[COMPILE:.*]]:2 = "tf_device.launch"
          // CHECK-NEXT: "tf._TPUCompileMlir"()

00000070  2a 13 56 26 47 33 7d 4f  ab 5a fc 9c 9e 8d f4 75  |*.V&G3}O.Z.....u|
00000080  d0 64 16 ba f2 0d 04 ca  5d 94 6b da a8 09 b1 29  |.d......].k....)|
00000090  70 a9 37 1e ac 94 e3 81  60 c3 19 f3 a9 99 6a 11  |p.7.....`.....j.|
000000a0  b1 e7 23 45 8a f5 42 f5  50 76 9f 1e 9e a8 e7 75  |..#E..B.Pv.....u|
000000b0  4a 18 84 80 da 10 ed 83  9a 14 a9 a1 90 54 8e 8b  |J............T..|

	r1 := int32(r)
	g1 := int32(g)
	b1 := int32(b)

	// yy is in range [0,0xff].
	//
	// Note that 19595 + 38470 + 7471 equals 65536.
	yy := (19595*r1 + 38470*g1 + 7471*b1 + 1<<15) >> 16

	// The bit twiddling below is equivalent to
	//
	// cb := (-11056*r1 - 21712*g1 + 32768*b1 + 257<<15) >> 16
	// if cb < 0 {
	//     cb = 0
	// } else if cb > 0xff {

func averageDeltaBound(m0, m1 image.Image, b0, b1 image.Rectangle) int64 {
	var sum, n int64
	for y := b0.Min.Y; y < b0.Max.Y; y++ {
		for x := b0.Min.X; x < b0.Max.X; x++ {
			c0 := m0.At(x, y)
			c1 := m1.At(x-b0.Min.X+b1.Min.X, y-b0.Min.Y+b1.Min.Y)
			r0, g0, b0, _ := c0.RGBA()
			r1, g1, b1, _ := c1.RGBA()
			sum += delta(r0, r1)
			sum += delta(g0, g1)
			sum += delta(b0, b1)
			n += 3
		}
	}
	return sum / n
}

        empty.add(other1).add(other2).addAll([listener, listener]).remove(listener).removeAll([other1, other2]).empty

        // Add existing
        def b1 = empty.add(listener)
        b1.add(listener).is(b1)
        b1.addAll([listener, listener]).is(b1)
        def b2 = empty.add(other1).add(listener)
        b2.add(listener).is(b2)
        b2.addAll([listener, listener]).is(b2)
    }