buf.WriteByte(testString[1])
		c, err := buf.ReadByte()
		if want := testString[1]; err != nil || c != want {
			t.Errorf("ReadByte: got (%q, %v), want (%q, %v)", c, err, want, nil)
		}
		c, err = buf.ReadByte()
		if err != io.EOF {
			t.Errorf("ReadByte: got (%q, %v), want (%q, %v)", c, err, byte(0), io.EOF)
		}
	}
}

		cr.err = errMalformedEncoding
		return n, cr.err
	}
	b, err := cr.reader.ReadByte()
	if err == io.EOF {
		err = io.ErrUnexpectedEOF
	}
	if err != nil {
		cr.err = err
		return n, cr.err
	}
	if b != '\r' {
		cr.err = errMalformedEncoding
		return n, cr.err
	}
	b, err = cr.reader.ReadByte()
	if err == io.EOF {
		err = io.ErrUnexpectedEOF
	}
	if err != nil {
		cr.err = err

    val sourceCodePoint1 =
      when (select(optionsDot)) {
        DELIMITER_DOT -> {
          if (readByte() != '.'.code.toByte()) throw IOException("expected '..'")
          readHexadecimalUnsignedLong()
        }

        else -> sourceCodePoint0
      }

    skipWhitespace()
    if (readByte() != ';'.code.toByte()) throw IOException("expected ';'")

    // "valid" or "mapped"
    skipWhitespace()

    }


    public char readChar () throws IOException {
        align(2);
        return this.dis.readChar();
    }


    public byte readByte () throws IOException {
        return this.dis.readByte();
    }


    public short readShort () throws IOException {
        align(2);
        return Short.reverseBytes(this.dis.readShort());
    }

	}
	// Test error after ReadByte.
	_, _, err = r.ReadRune() // reset state
	if err != nil {
		t.Error("unexpected error on ReadRune (2):", err)
	}
	for range buf {
		_, err = r.ReadByte()
		if err != nil {
			t.Error("unexpected error on ReadByte (2):", err)
		}
	}
	if r.UnreadRune() == nil {
		t.Error("expected error after ReadByte")
	}
	// Test error after UnreadByte.

			readBytes += n
			read.Write(buf[:n])
			debugln("READ 1\t", n, readBytes)
			if err != nil {
				readErr = err
				break
			}

			// ReadByte
			b, err := rb.ReadByte()
			if err != nil {
				readErr = err
				break
			}
			readBytes++
			read.Write([]byte{b})
			debugln("READ 2\t", 1, readBytes)

			// TryRead

          dynamicTable[index] = entry
        }
        dynamicTableByteCount += delta
      }

      @Throws(IOException::class)
      private fun readByte(): Int {
        return source.readByte() and 0xff
      }

      @Throws(IOException::class)
      fun readInt(
        firstByte: Int,
        prefixMask: Int,
      ): Int {
        val prefix = firstByte and prefixMask

  writeByte(medium.ushr(8) and 0xff)
  writeByte(medium and 0xff)
}

@Throws(IOException::class)
internal fun BufferedSource.readMedium(): Int {
  return (
    readByte() and 0xff shl 16
      or (readByte() and 0xff shl 8)
      or (readByte() and 0xff)
  )
}

/** Run [block] until it either throws an [IOException] or completes. */
internal inline fun ignoreIoExceptions(block: () -> Unit) {
  try {

    in.readFully(b);
    assertEquals(-100, b[0]);
    assertEquals(100, b[1]);
    assertEquals(true, in.readBoolean());
    assertEquals(false, in.readBoolean());
    assertEquals(100, in.readByte());
    assertEquals(-100, in.readByte());
    assertEquals(200, in.readUnsignedByte());
    assertEquals('\u6100', in.readChar());
    assertEquals(-12150, in.readShort());
    assertEquals(20675, in.readUnsignedShort());

    in.readFully(b);
    assertEquals(-100, b[0]);
    assertEquals(100, b[1]);
    assertEquals(true, in.readBoolean());
    assertEquals(false, in.readBoolean());
    assertEquals(100, in.readByte());
    assertEquals(-100, in.readByte());
    assertEquals(200, in.readUnsignedByte());
    assertEquals('\u6100', in.readChar());
    assertEquals(-12150, in.readShort());
    assertEquals(20675, in.readUnsignedShort());