return false
	}
	b0 := b[0]
	if b0 < hangulBase0 {
		return false
	}
	b1 := b[1]
	switch {
	case b0 == hangulBase0:
		return b1 >= hangulBase1
	case b0 < hangulEnd0:
		return true
	case b0 > hangulEnd0:
		return false
	case b1 < hangulEnd1:
		return true
	}
	return b1 == hangulEnd1 && b[2] < hangulEnd2
}

func isHangulString(b string) bool {

00000000  14 03 03 00 01 01 16 03  03 00 40 9e 65 27 5b 92  |..........@.e'[.|
00000010  1e 2b 1a bc 81 ab 85 29  51 c1 38 04 b6 97 e5 4b  |.+.....)Q.8....K|
00000020  b1 7d a5 e2 6d e7 b1 1a  33 6c f1 3d a4 9c de 2d  |.}..m...3l.=...-|
00000030  b3 8a 01 da cc f1 d7 83  b1 1e 84 cb b7 e7 fe e6  |................|
00000040  26 83 b0 2d 6f a9 77 46  55 44 7a                 |&..-o.wFUDz|
>>> Flow 5 (client to server)

000000a0  44 17 03 03 00 42 b7 5e  0d fe db fd 32 64 15 d2  |D....B.^....2d..|
000000b0  b6 14 7f 18 fe 39 f3 50  c2 d4 0d 36 cd 60 e7 49  |.....9.P...6.`.I|
000000c0  e1 eb fe 36 be ec dd b1  3a 75 d4 12 b1 13 7d eb  |...6....:u....}.|
000000d0  a0 47 18 4a e1 b4 1c 1f  91 33 5f a7 99 28 89 d0  |.G.J.....3_..(..|
000000e0  0e 4e 79 9e be 5c 7e 36  17 03 03 02 6d 0b b3 0e  |.Ny..\~6....m...|

            }
        """
        createDirs("buildB", "buildB/b1", "buildB/b1/b11")
        buildB.settingsFile << """
            include ':b1:b11'
        """
        buildB.buildFile << """
            dependencies {
                implementation project(':b1')
            }

            project(":b1") {
                dependencies {

	r := New(NewSource(1))
	b1 := make([]byte, 100)
	_, err := io.ReadFull(iotest.OneByteReader(r), b1)
	if err != nil {
		t.Errorf("read by one byte: %v", err)
	}
	r = New(NewSource(1))
	b2 := make([]byte, 100)
	_, err = r.Read(b2)
	if err != nil {
		t.Errorf("read: %v", err)
	}
	if !bytes.Equal(b1, b2) {
		t.Errorf("read by one byte vs single read:\n%x\n%x", b1, b2)
	}
}

000002d0  bb 06 22 d7 d6 97 39 d1  f4 dc 95 06 b3 a4 a7 00  |.."...9.........|
000002e0  d1 e5 98 bc 97 12 03 25  03 12 ab 20 4f 00 80 71  |.......%... O..q|
000002f0  8d 3c 54 44 ba df 73 92  76 16 d1 ec b1 de a2 27  |.<TD..s.v......'|
00000300  97 b1 e9 31 37 ea a7 5d  a9 00 ce 85 08 5a b3 ac  |...17..].....Z..|
00000310  ef a6 8d c3 9f a5 ba 97  e8 bc 9f 81 63 77 7b 2e  |............cw{.|

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

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