*
 * {@snippet :
 *        h
 *      / | \
 *     /  e  \
 *    d       g
 *   /|\      |
 *  / | \     f
 * a  b  c
 * }
 *
 * <p>can be iterated over in preorder (hdabcegf), postorder (abcdefgh), or breadth-first order
 * (hdegabcf).
 *
 * <p>Null nodes are strictly forbidden.
 *
 * <p>Because this is an abstract class, not an interface, you can't use a lambda expression to
 * implement it:
 *

		}
	}
}

var scanTests = []string{
	"",
	"a",
	"¼",
	"☹",
	"\x81",   // UTF-8 error
	"\uFFFD", // correctly encoded RuneError
	"abcdefgh",
	"abc def\n\t\tgh    ",
	"abc¼☹\x81\uFFFD日本語\x82abc",
}

func TestScanByte(t *testing.T) {
	for n, test := range scanTests {
		buf := strings.NewReader(test)
		s := NewScanner(buf)
		s.Split(ScanBytes)

	}{
		{
			name:    "small store w desc",
			content: []byte("gophers"),
			method:  Store,
			flags:   0x8,
		},
		{
			name:    "small deflate wo desc",
			content: bytes.Repeat([]byte("abcdefg"), 2048),
			method:  Deflate,
		},
	}

	// write a zip file
	archive := new(bytes.Buffer)
	w := NewWriter(archive)

	for i := range files {
		f := &files[i]

        }
      },
    )
  }

  @Test fun goAwayWithDebugDataRoundTrip() {
    val expectedError = ErrorCode.PROTOCOL_ERROR
    val expectedData: ByteString = "abcdefgh".encodeUtf8()

    // Compose the expected GOAWAY frame without debug data.
    writeMedium(frame, 8 + expectedData.size)
    frame.writeByte(TYPE_GOAWAY)
    frame.writeByte(FLAG_NONE)

    //     the smaller of these blocks with the far end of the other one. That leaves us with a
    //     smaller version of the same problem.
    //     Say we are rotating abcdefgh by 5. We start with abcde|fgh. The smaller block is [fgh]:
    //     [abc]de|[fgh] -> [fgh]de|[abc]. Now [fgh] is in the right place, but we need to swap [de]

  @Test
  fun inputStreamAvailableWithNoLengthHeaders() {
    testInputStreamAvailable(TransferKind.END_OF_STREAM)
  }

  private fun testInputStreamAvailable(transferKind: TransferKind) {
    val body = "ABCDEFGH"
    val builder = MockResponse.Builder()
    transferKind.setBody(builder, body, 4)
    server.enqueue(builder.build())
    val response = getResponse(newRequest("/"))

// that the file has no data in it, which is rather odd.
//
// As an example, if the underlying raw file contains the 10-byte data:
//
//	var compactFile = "abcdefgh"
//
// And the sparse map has the following entries:
//
//	var spd sparseDatas = []sparseEntry{
//		{Offset: 2,  Length: 5},  // Data fragment for 2..6
//		{Offset: 18, Length: 3},  // Data fragment for 18..20

			testReadFrom{fileOps{int64(2), "abc", int64(1), "\x00"}, 7, nil},
			testRemaining{0, 0},
		},
	}, {
		maker: makeSparse{makeReg{3, ""}, sparseHoles{{0, 2}, {5, 2}}, 7},
		tests: []testFnc{
			testWrite{"abcdefg", 0, errWriteHole},
		},
	}, {
		maker: makeSparse{makeReg{3, "abc"}, sparseHoles{{0, 2}, {5, 2}}, 7},
		tests: []testFnc{
			testWrite{"\x00\x00abcde", 5, errWriteHole},
		},
	}, {

            // Read next chunk
            bytesRead = in.read(buffer);
            assertEquals(10, bytesRead, "Should read next chunk");
            assertEquals("ABCDEFGHIJ", new String(buffer, 0, bytesRead, "UTF-8"));
        }
    }

    @Test
    void testZeroByteFile() throws Exception {
        // Test handling of zero-byte files

	for rno, read := range readers {
		// Some input data that is longer than the minimum reader buffer size.
		const n = 10
		var buf bytes.Buffer
		for i := 0; i < n; i++ {
			buf.WriteString("abcdefg")
		}

		r := NewReaderSize(&buf, minReadBufferSize)
		readTo := func(delim byte, want string) {
			data, err := read(r, delim)
			if err != nil {