void testWriteAndXWireFormatWithoutAndx() {
        DummyAndXBlock block = new DummyAndXBlock();
        byte[] buf = new byte[128];
        int n = block.writeAndXWireFormat(buf, 0);

        assertTrue(n > 0);
        // Common AndX header: command at +1, reserved at +2, offset at +3/+4

    int readRDataWireFormat(final byte[] src, int srcIndex) {
        final int start = srcIndex;
        this.numberOfNames = src[srcIndex] & 0xFF;
        final int namesLength = this.numberOfNames * 18;
        final int statsLength = this.rDataLength - namesLength - 1;
        this.numberOfNames = src[srcIndex] & 0xFF;
        srcIndex++;
        // gotta read the mac first so we can populate addressArray with it

    assertThat(converter.convert("0")).isEqualTo(0);
    assertThat(converter.convert("-1")).isEqualTo(-1);
    assertThat(converter.convert("0xff")).isEqualTo(255);
    assertThat(converter.convert("0xFF")).isEqualTo(255);
    assertThat(converter.convert("-0xFF")).isEqualTo(-255);
    assertThat(converter.convert("#0000FF")).isEqualTo(255);
    assertThat(converter.convert("0666")).isEqualTo(438);
  }

        return SCOPE_OFFSET + writeScopeWireFormat(dst, dstIndex + SCOPE_OFFSET);
    }

    int readWireFormat(final byte[] src, final int srcIndex) {

        final byte tmp[] = new byte[SCOPE_OFFSET];
        int length = 15;
        for (int i = 0; i < 15; i++) {
            tmp[i] = (byte) ((src[srcIndex + 2 * i + 1] & 0xFF) - 0x41 << 4);

@DisplayName("Hexdump Utility Tests")
class HexdumpTest extends BaseTest {

    @Test
    @DisplayName("Should convert byte array to hex string")
    void testToHexString() {
        // Given
        byte[] data = { 0x00, 0x0F, (byte) 0xFF, 0x7F, (byte) 0x80 };

        // When
        String result = Hexdump.toHexString(data);

        // Then
        assertNotNull(result);
        assertEquals("000FFF7F80", result);
    }

    @Test

    static int readInt2(final byte[] src, final int srcIndex) {
        return (src[srcIndex] & 0xFF) + ((src[srcIndex + 1] & 0xFF) << 8);
    }

    static int readInt4(final byte[] src, final int srcIndex) {
        return (src[srcIndex] & 0xFF) + ((src[srcIndex + 1] & 0xFF) << 8) + ((src[srcIndex + 2] & 0xFF) << 16)
                + ((src[srcIndex + 3] & 0xFF) << 24);
    }

    static long readInt8(final byte[] src, final int srcIndex) {

    }

    @Test
    public void testByteOperations() {
        // Test byte operations that were used in the original test
        byte b = (byte) 0xFF;
        int value = b & 0xFF;
        assertEquals(255, value, "Byte to unsigned conversion should work");

        // Test comparison operation
        assertTrue(value == 255, "Comparison should work correctly");
    }

    /**

        assertEquals(24, resumeKey.length, "Resume key should be 24 bytes");

        // Verify all bytes are 0xFF
        for (int i = 0; i < 24; i++) {
            assertEquals((byte) 0xFF, resumeKey[i], "Resume key byte " + i + " should be 0xFF");
        }
    }

    @Test
    @DisplayName("Test decode with larger buffer and length")

          bytes.length >= 4,
          "HashCode#asInt() requires >= 4 bytes (it only has %s bytes).",
          bytes.length);
      return (bytes[0] & 0xFF)
          | ((bytes[1] & 0xFF) << 8)
          | ((bytes[2] & 0xFF) << 16)
          | ((bytes[3] & 0xFF) << 24);
    }

    @Override
    public long asLong() {
      checkState(
          bytes.length >= 8,

        // Check FID (little-endian)
        assertEquals(0x34, dst[0] & 0xFF);
        assertEquals(0x12, dst[1] & 0xFF);
        // Check count
        assertEquals(10, dst[2] & 0xFF);
        assertEquals(0, dst[3] & 0xFF);
        // Check offset
        assertEquals(0x78, dst[4] & 0xFF);
        assertEquals(0x56, dst[5] & 0xFF);
    }

    /**
     * Test writeBytesWireFormat writes data correctly