assertFalse(result, "Verify should return false for invalid signature");
        verify(signingDigest, times(1)).verify(testData, offset, length, extraPad, message);
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 2, 4, 8, 16 })
    @DisplayName("Test verify method with different extra padding values")
    void testVerifyWithDifferentExtraPadding(int extraPad) {
        // Arrange
        int offset = 0;

        assertEquals(0, bytesRead);
        assertEquals(0, response.getAttributes());
        assertEquals(0, response.getSize());
    }

    @ParameterizedTest
    @ValueSource(ints = { 0x0001, 0x0002, 0x0004, 0x0010, 0x0020, 0x0080, 0x0100 })
    void testDifferentFileAttributes(int fileAttribute) {
        // Test various file attribute values

        K castKey = (K) key;
        result.put(castKey, value);
        hits++;
      }
    }
    globalStatsCounter.recordHits(hits);
    globalStatsCounter.recordMisses(misses);
    return result.buildKeepingLast();
  }

  ImmutableMap<K, V> getAll(Iterable<? extends K> keys) throws ExecutionException {
    int hits = 0;
    int misses = 0;

    Map<K, V> result = new LinkedHashMap<>();

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;

import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Sets;
import com.google.common.primitives.Ints;
import com.google.common.testing.EqualsTester;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.charset.Charset;
import java.util.Arrays;
import java.util.Random;
import java.util.Set;

    }

    // Parameterized: exercise small variations of cache size for a simple reuse cycle
    @ParameterizedTest
    @ValueSource(ints = { 1, 2 })
    @DisplayName("Parameterized: buffer reuse works for various small cache sizes")
    void reuseWorksForVariousCacheSizes(int cacheSize) {
        BufferCacheImpl impl = new BufferCacheImpl(cacheSize, 6);

 * <i>unsigned</i> (that is, any negative value {@code x} is treated as the positive value {@code
 * 2^32 + x}). The methods for which signedness is not an issue are in {@link Ints}, as well as
 * signed versions of methods for which signedness is an issue.
 *
 * <p>In addition, this class provides several static methods for converting an {@code int} to a

     * CRC(A000A000A000...), CRC(0B000B000B...), CRC(00C000C000C...), CRC(000D000D000D...)
     * and then to XOR them together.  The strideTable enables us to hash an int followed by 12
     * zero bytes (3 ints), while the byteTable is for advancing one byte at a time.
     * This algorithm is due to the paper "Everything we know about CRC but [are] afraid to forget"
     * by Kadatch and Jenkins, 2010.
     */

    Crc32cHasher() {

    @Nested
    @DisplayName("Constructor Tests")
    class ConstructorTests {

        @ParameterizedTest
        @DisplayName("Should mask input values with 0xFF correctly")
        @ValueSource(ints = { 0, 1, 127, 128, 255, 256, -1, -128, -255, -256, 32767, -32768, 65535, 65536 })
        void testConstructorMasking(int inputValue) {
            // Given: An input value
            // When: Creating NdrShort with that value

        assertEquals(1, SMBUtil.readInt2(buffer, 10));
    }

    /**
     * Test that a large file lock (bit 0x10 set) is encoded and decoded correctly.
     */
    @ParameterizedTest
    @ValueSource(ints = { 0x10, 0x11 })
    void largeFileFlagSet_and_decoded_according_to_type(int type) throws Exception {
        Configuration cfg = mock(Configuration.class);
        SmbComLockingAndX cmd = new SmbComLockingAndX(cfg);

        @DisplayName("Should handle various padding values")
        @ValueSource(ints = { 0, 1, 15, 127, 255 })
        void testVariousPadding(int padding) {
            assertDoesNotThrow(() -> request.setPadding((byte) padding));
        }

        @ParameterizedTest
        @DisplayName("Should handle various read lengths")
        @ValueSource(ints = { 0, 1, 512, 1024, 4096, 65536, 1048576 })