var commaFound = false
  loop@ while (!exhausted()) {
    when (this[0]) {
      ','.code.toByte() -> {
        // Consume ','.
        readByte()
        commaFound = true
      }

      ' '.code.toByte(), '\t'.code.toByte() -> {
        readByte()
        // Consume space or tab.
      }

      else -> {
        break@loop
      }
    }
  }
  return commaFound
}

  fun writeObjectIdentifier(s: String) {
    val utf8 = Buffer().writeUtf8(s)
    val v1 = utf8.readDecimalLong()
    require(utf8.readByte() == '.'.code.toByte())
    val v2 = utf8.readDecimalLong()
    writeVariableLengthLong(v1 * 40 + v2)

    while (!utf8.exhausted()) {
      require(utf8.readByte() == '.'.code.toByte())
      val vN = utf8.readDecimalLong()
      writeVariableLengthLong(vN)
    }
  }

		t.Errorf("r.Len(): got %d, want %d", got, want)
	}
}

var UnreadRuneErrorTests = []struct {
	name string
	f    func(*Reader)
}{
	{"Read", func(r *Reader) { r.Read([]byte{0}) }},
	{"ReadByte", func(r *Reader) { r.ReadByte() }},
	{"UnreadRune", func(r *Reader) { r.UnreadRune() }},
	{"Seek", func(r *Reader) { r.Seek(0, io.SeekCurrent) }},
	{"WriteTo", func(r *Reader) { r.WriteTo(&Buffer{}) }},
}

      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"

	n = copy(b, r.s[off:])
	if n < len(b) {
		err = io.EOF
	}
	return
}

// ReadByte implements the [io.ByteReader] interface.
func (r *Reader) ReadByte() (byte, error) {
	r.prevRune = -1
	if r.i >= int64(len(r.s)) {
		return 0, io.EOF
	}
	b := r.s[r.i]
	r.i++
	return b, nil
}

// UnreadByte complements [Reader.ReadByte] in implementing the [io.ByteScanner] interface.
func (r *Reader) UnreadByte() error {

    }

    /**
     * Reads a single byte value.
     * @return the byte value
     * @throws IOException if an I/O error occurs
     */
    public byte readByte() throws IOException {
        return this.dis.readByte();
    }

    /**
     * Reads a 16-bit short value with proper alignment and byte order.
     * @return the short value in little-endian format

  @Override
  int skipBytes(int n);

  @CanIgnoreReturnValue // to skip a byte
  @Override
  boolean readBoolean();

  @CanIgnoreReturnValue // to skip a byte
  @Override
  byte readByte();

  @CanIgnoreReturnValue // to skip a byte
  @Override
  int readUnsignedByte();

  @CanIgnoreReturnValue // to skip some bytes
  @Override
  short readShort();

  @Override
  public char readChar() throws IOException {
    return (char) readUnsignedShort();
  }

  @CanIgnoreReturnValue // to skip a byte
  @Override
  public byte readByte() throws IOException {
    return (byte) readUnsignedByte();
  }

  @CanIgnoreReturnValue // to skip a byte
  @Override
  public boolean readBoolean() throws IOException {
    return readUnsignedByte() != 0;

        byte[] data = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05 };
        PacDataInputStream pdis = createInputStream(data);
        pdis.readByte(); // position is 1
        pdis.align(4);
        assertEquals(1, pdis.available());
        assertEquals(0x05, pdis.readByte());

        // Test no alignment needed
        pdis = createInputStream(new byte[] { 0x01, 0x02, 0x03, 0x04 });
        pdis.readInt(); // position is 4

    // Read the command.
    val version = fromSource.readByte() and 0xff
    if (version != VERSION_5) throw ProtocolException("unexpected version: $version")

    val command = fromSource.readByte() and 0xff

    val reserved = fromSource.readByte() and 0xff
    if (reserved != 0) throw ProtocolException("unexpected reserved: $reserved")

    val addressType = fromSource.readByte() and 0xff
    val toAddress =