for (int i = 0; i < sz; i++) {
            char ch = str.charAt(i);
            // handle unicode
            if (ch > 0xfff) {
                out.append("\\u").append(hex(ch));
            } else if (ch > 0xff) {
                out.append("\\u0").append(hex(ch));
            } else if (ch > 0x7f) {
                out.append("\\u00").append(hex(ch));
            } else if (ch < 32) {

            return -1;
        }
        if (length < 0) {
            throw new EOFException("EOF found when length expected");
        }
        if (0xFF == length) {
            throw new IOException("invalid long form definite-length 0xFF");
        }

        final int octetsCount = length & 0x7F;
        int octetsPos = 0;

        length = 0;
        do {

	if l > len(b) {
		return nil, 0, errors.New("zip: invalid comment length")
	}
	d.comment = string(b[:l])

	// These values mean that the file can be a zip64 file
	if d.directoryRecords == 0xffff || d.directorySize == 0xffff || d.directoryOffset == 0xffffffff {
		p, err := findDirectory64End(r, directoryEndOffset)
		if err == nil && p >= 0 {
			directoryEndOffset = p
			err = readDirectory64End(r, p, d)
		}

        for (int i = 0; i < key.length; i++) {
            if (i > 0) {
                sb.append(' ');
            }
            sb.append(String.format("%02X", key[i] & 0xFF));
        }
        sb.append(']');
        return sb.toString();
    }

  private double[] dataset(int i) {
    // We must test on a fresh clone of the dataset each time. Doing sorts and quickselects on a
    // dataset which is already sorted or partially sorted is cheating.
    return datasets[i & 0xFF].clone();
  }

  @Benchmark
  double median(int reps) {
    double dummy = 0.0;
    for (int i = 0; i < reps; i++) {
      dummy += algorithm.singleQuantile(1, 2, dataset(i));
    }
    return dummy;
  }

        // Write test data at the specified offset
        byte[] testData = new byte[dataLength];
        for (int i = 0; i < dataLength; i++) {
            testData[i] = (byte) (i & 0xFF);
        }
        System.arraycopy(testData, 0, buffer, dataOffsetFromHeader, dataLength);

        // Use reflection to set headerStart

    require(streamId and 0x80000000.toInt() == 0) { "reserved bit set: $streamId" }
    sink.writeMedium(length)
    sink.writeByte(type and 0xff)
    sink.writeByte(flags and 0xff)
    sink.writeInt(streamId and 0x7fffffff)
  }

  @Throws(IOException::class)
  override fun close() {
    withLock {
      closed = true
      sink.close()
    }
  }

        tmp = new byte[TMP_BUFFER_SIZE];
    }

    @Override
    public synchronized int read() throws IOException {
        if (read(tmp, 0, 1) < 0) {
            return -1;
        }
        return tmp[0] & 0xFF;
    }

    @Override
    public synchronized int read(final byte[] b) throws IOException {
        return read(b, 0, b.length);
    }

    /* This method will not return until len bytes have been read

        assertEquals("Pattern_V1", CompressionNegotiateContext.getAlgorithmName(CompressionNegotiateContext.COMPRESSION_PATTERN_V1));
        assertTrue(CompressionNegotiateContext.getAlgorithmName(0xFF).startsWith("Unknown"));
    }

    @Test
    @DisplayName("Test empty algorithms context")
    public void testEmptyAlgorithms() {

)

type exprTest struct {
	input  string
	output int64
	atEOF  bool
}

var exprTests = []exprTest{
	// Simple
	{"0", 0, true},
	{"3", 3, true},
	{"070", 8 * 7, true},
	{"0x0f", 15, true},
	{"0xFF", 255, true},
	{"9223372036854775807", 9223372036854775807, true}, // max int64
	// Unary
	{"-0", 0, true},
	{"~0", -1, true},
	{"~0*0", 0, true},
	{"+3", 3, true},
	{"-3", -3, true},