//     || byte1 == (byte) 0xF4 && byte2 > (byte) 0x8F)
            || (((byte1 << 28) + (byte2 - (byte) 0x90)) >> 30) != 0
            // Third byte trailing-byte test
            || bytes[index++] > (byte) 0xBF
            // Fourth byte trailing-byte test
            || bytes[index++] > (byte) 0xBF) {
          return false;
        }
      }
    }
  }

	o = msgp.AppendString(o, z.Bucket)
	// string "Object"
	o = append(o, 0xa6, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74)
	o = msgp.AppendString(o, z.Object)
	// string "VersionID"
	o = append(o, 0xa9, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x44)
	o = msgp.AppendString(o, z.VersionID)
	// string "Versions"
	o = append(o, 0xa8, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73)
	o = msgp.AppendBytes(o, z.Versions)
	// string "SetIndex"

    void testEncode() {
        byte[] testBytes = new byte[] { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, (byte) 0x88, (byte) 0x99, (byte) 0xAA, (byte) 0xBB,
                (byte) 0xCC, (byte) 0xDD, (byte) 0xEE, (byte) 0xFF, 0x00 };

        Smb2LeaseKey key = new Smb2LeaseKey(testBytes);
        byte[] buffer = new byte[20];

        key.encode(buffer, 2);

        for (int i = 0; i < 16; i++) {

@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

	o = append(o, 0x85, 0xab, 0x4c, 0x6f, 0x63, 0x6b, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64)
	o = msgp.AppendBool(o, z.LockEnabled)
	// string "VersioningEnabled"
	o = append(o, 0xb1, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64)
	o = msgp.AppendBool(o, z.VersioningEnabled)
	// string "ForceCreate"
	o = append(o, 0xab, 0x46, 0x6f, 0x72, 0x63, 0x65, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65)

        @Test
        @DisplayName("Various byte values are converted to uppercase hex")
        void testHexConversion() {
            byte[] challenge = new byte[] { (byte) 0x00, (byte) 0x0F, (byte) 0x10, (byte) 0x7F, (byte) 0x80, (byte) 0xFF };
            UniAddress dc = mock(UniAddress.class);
            when(dc.toString()).thenReturn("DC");

            NtlmChallenge nc = new NtlmChallenge(challenge, dc);

	formatZstd
	formatLZ4
	formatS2
	formatBZ2
)

var magicHeaders = []struct {
	header []byte
	f      format
}{
	{
		header: []byte{0x1f, 0x8b, 8},
		f:      formatGzip,
	},
	{
		// Zstd default header.
		header: []byte{0x28, 0xb5, 0x2f, 0xfd},
		f:      formatZstd,
	},
	{
		// Zstd skippable frame header.
		header: []byte{0x2a, 0x4d, 0x18},
		f:      formatZstd,
	},
	{
		// LZ4

                new byte[] { (byte) 0xbb, (byte) 0x6e, (byte) 0xd3, (byte) 0x08, (byte) 0x70, (byte) 0xb7, (byte) 0xf0, (byte) 0xe0 });

        // 64-fold("kerberos")
        verifyNfold("kerberos", 8,
                new byte[] { (byte) 0x6b, (byte) 0x65, (byte) 0x72, (byte) 0x62, (byte) 0x65, (byte) 0x72, (byte) 0x6f, (byte) 0x73 });
    }

    /**
     * Helper method to verify n-fold expansion.

                Arguments.of(new byte[] { (byte) 0x0F }, "0f"), Arguments.of(new byte[] { (byte) 0x10 }, "10"),
                Arguments.of(new byte[] { (byte) 0xAB }, "ab"),
                Arguments.of(new byte[] { (byte) 0x7F, (byte) 0x80, (byte) 0xFF }, "7f80ff"));
    }

    // Verifies that toString() formats bytes as lower-case hex with zero-padding

          b2bit8 && b3bit8 -> 127
          b3bit8 -> 126
          b2bit8 -> 125
          else -> 124
        }
      }

    val b2: Int
      get() = mappedTo[0] and 0x7f

    val b3: Int
      get() = mappedTo[1] and 0x7f
  }

  data class InlineDelta(
    override val rangeStart: Int,
    val codepointDelta: Int,
  ) : MappedRange {
    private val absoluteDelta = abs(codepointDelta)