import com.google.common.annotations.J2ktIncompatible;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import com.google.common.primitives.Ints;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import com.google.errorprone.annotations.concurrent.LazyInit;
import com.google.j2objc.annotations.WeakOuter;
import java.io.IOException;

import com.google.common.annotations.J2ktIncompatible;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import com.google.common.primitives.Ints;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.io.IOException;
import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

    @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

        @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 })

        }
    }

    @Nested
    @DisplayName("Constant Validation Tests")
    class ConstantValidationTests {

        @ParameterizedTest
        @ValueSource(ints = { ACE.FILE_READ_DATA, ACE.FILE_WRITE_DATA, ACE.FILE_APPEND_DATA, ACE.FILE_READ_EA, ACE.FILE_WRITE_EA,
                ACE.FILE_EXECUTE, ACE.FILE_DELETE, ACE.FILE_READ_ATTRIBUTES, ACE.FILE_WRITE_ATTRIBUTES, ACE.DELETE, ACE.READ_CONTROL,

    }

    // 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);

    void testDefaultFlags() {
        assertEquals(0, msg.getFlags(), "Initial flags should be 0");
    }

    @ParameterizedTest(name = "setFlags({0}) ➜ getFlags() == {0}")
    @ValueSource(ints = { 0x0, 0x1, 0x2, 0xFFFFFFFF, -123456 })
    void testSetAndGetFlags(int value) {
        msg.setFlags(value);
        assertEquals(value, msg.getFlags(), "getFlags should return the value set");
    }

    @Test

    List<Integer> ints = Arrays.asList(0, 1, 2);
    List<Float> floats = Arrays.asList(0.0f, 1.0f, 2.0f);
    List<Long> longs = Arrays.asList(0L, 1L, 2L);
    List<Double> doubles = Arrays.asList(0.0, 1.0, 2.0);

    assertThat(Doubles.toArray(bytes)).isEqualTo(array);
    assertThat(Doubles.toArray(shorts)).isEqualTo(array);
    assertThat(Doubles.toArray(ints)).isEqualTo(array);

            // Then
            assertEquals(HEADER_SIZE + CHUNK_SIZE, size);
        }

        @ParameterizedTest
        @DisplayName("Should return correct size with multiple chunks")
        @ValueSource(ints = { 1, 2, 3, 5, 10, 100 })
        void testSizeWithMultipleChunks(int chunkCount) {
            // Given
            byte[] sourceKey = new byte[SOURCE_KEY_SIZE];

        assertEquals("DFS resolution failed", ex.getMessage());
        verify(handle, times(1)).ensureDFSResolved();
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 1, -1, Integer.MIN_VALUE, Integer.MAX_VALUE })
    @DisplayName("hasCapability(cap): returns configured value and captures argument across edge caps")