// Then
        assertNotNull(result);
        assertFalse(result.isEmpty());
        // Check starts with byte at offset 16 (0x10)
        assertTrue(result.startsWith("10111213"));
        assertEquals(64, result.length()); // 32 bytes * 2 chars per byte
    }

    @Test
    @DisplayName("Should handle invalid offset and length parameters")
    void testInvalidParameters() {

   * {@code stream} and their indexes in the stream. For example,
   *
   * {@snippet :
   * mapWithIndex(
   *     IntStream.of(10, 11, 12),
   *     (e, index) -> index + ":" + e)
   * }
   *
   * <p>...would return {@code Stream.of("0:10", "1:11", "2:12")}.
   *
   * <p>The resulting stream is <a
   * href="http://gee.cs.oswego.edu/dl/html/StreamParallelGuidance.html">efficiently splittable</a>

    private static Stream<Arguments> valueProvider() {
        return Stream.of(Arguments.of(0, 0L, 0L, 0L, 0L), // all zeros
                Arguments.of(1, 1L, 1L, 1L, 1L), // ones
                Arguments.of(123, 456L, 789L, 101112L, 131415L), // arbitrary positives
                Arguments.of(Integer.MAX_VALUE, Long.MAX_VALUE, Long.MIN_VALUE, 999_999_999_999L, -1L), // extremes
                Arguments.of(-1, -2L, -3L, -4L, -5L) // negative values

    @DisplayName("toByteArray returns mechanismToken reference when present")
    void toByteArrayReturnsToken() throws IOException {
        TestSpnegoToken t = new TestSpnegoToken();
        byte[] raw = new byte[] { 11, 12, 13 };
        t.parse(raw);
        // Current behavior of test impl: returns same reference
        assertSame(raw, t.toByteArray(), "should return the same reference as mechanismToken");
    }

    @Test

        SmbPipeHandleImpl spyTarget = spy(target);
        SmbPipeOutputStream out = mock(SmbPipeOutputStream.class);
        doReturn(out).when(spyTarget).getOutput();

        byte[] b = new byte[] { 10, 11, 12 };
        spyTarget.send(b, 1, 2);
        verify(out).writeDirect(b, 1, 2, 1);
    }

    @Test
    @DisplayName("sendrecv with null buffers throws relevant exceptions")

    assertNoMorePermutations(permutations);
  }

  public void testOrderedPermutationSetRepeatedElementsSize() {
    List<Integer> list = newArrayList(1, 1, 1, 1, 2, 2, 3);
    Collection<List<Integer>> permutations =
        Collections2.orderedPermutations(list, Ordering.natural());

    assertPermutationsCount(105, permutations);
  }

        assertEquals("5", searchRenderData.getPageNumberList().get(4));

        // Test with list containing special values
        List<String> specialPages = Arrays.asList("...", "10", "11", "12", "...");
        searchRenderData.setPageNumberList(specialPages);
        assertEquals(specialPages, searchRenderData.getPageNumberList());
    }

    public void test_setAndIsPartialResults() {

        // Should start at offset 0 in display but show data from offset 16
        assertTrue(output.contains("00000:"));
        // First byte should be 0x10 (16 in decimal)
        assertTrue(output.contains(" 10 11 12"));
    }

    @Test
    @DisplayName("Should convert hex chars correctly")
    void testToHexChars() {
        // Test integer conversion
        char[] dst1 = new char[8];

    // re-order
    getAll(cache, asList(0, 1, 2));
    CacheTesting.drainRecencyQueues(cache);
    assertThat(keySet).containsExactly(3, 4, 5, 6, 7, 8, 9, 0, 1, 2);

    // evict 3, 4, 5
    getAll(cache, asList(10, 11, 12));
    CacheTesting.drainRecencyQueues(cache);
    assertThat(keySet).containsExactly(6, 7, 8, 9, 0, 1, 2, 10, 11, 12);

    // re-order
    getAll(cache, asList(6, 7, 8));

            Arrays.fill(sourceKey, (byte) 0x55);

            SrvCopychunk[] testCases = { new SrvCopychunk(1, 2, 3), new SrvCopychunk(4, 5, 6), new SrvCopychunk(7, 8, 9),
                    new SrvCopychunk(10, 11, 12), new SrvCopychunk(13, 14, 15) };

            for (int numChunks = 0; numChunks <= testCases.length; numChunks++) {
                // Create copy with varying number of chunks