int bufferIndex = 0;

        // Set up max values
        int namedPipeState = Integer.MAX_VALUE;
        int readDataAvailable = Integer.MAX_VALUE;
        int numberOfMessages = Integer.MAX_VALUE;
        int messageLength = Integer.MAX_VALUE;
        byte[] testData = { 0x7F, 0x7F, 0x7F, 0x7F };

        // Write values to buffer

        byte[] smallBuffer = new byte[10];

        // Test with maximum offset
        int result = response.writeSetupWireFormat(smallBuffer, Integer.MAX_VALUE);
        assertEquals(0, result);

        result = response.readSetupWireFormat(smallBuffer, Integer.MAX_VALUE, 0);
        assertEquals(0, result);

        // Test with negative length (should still return 0)

    }

    /**
     * Parameterised test for a selection of edge and typical values.
     */
    @ParameterizedTest(name = "Encode and decode {0}")
    @ValueSource(longs = { 0L, 1L, -1L, Long.MAX_VALUE, Long.MIN_VALUE })
    public void testEncodeWithVariousValues(long val) throws NdrException {
        NdrHyper hyper = new NdrHyper(val);
        // Create buffer with extra space for alignment

        }

        public MyToken(final String word, final int startOffset, final int endOffset, final int posInc) {
            this(word, startOffset, endOffset, posInc, Integer.MAX_VALUE); // Integer.MAX_VALUE for seq means unused
        }

        public MyToken(final String word, final int startOffset, final int endOffset, final int posInc, final int seq) {
            this.word = word;

     */
    public int safeAdd(int a, int b) throws SmbException {
        totalValidations.incrementAndGet();

        long result = (long) a + (long) b;
        if (result > Integer.MAX_VALUE || result < Integer.MIN_VALUE) {
            failedValidations.incrementAndGet();
            integerOverflowsPrevented.incrementAndGet();
            log.warn("Integer overflow in addition: {} + {} = {}", a, b, result);

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

                    long multiplier = 1L << safeShift;
                    // Check for potential overflow before multiplication
                    long delay = (retryDelayMs > Long.MAX_VALUE / multiplier) ? MAX_RETRY_DELAY
                            : Math.min(MAX_RETRY_DELAY, retryDelayMs * multiplier);
                    Thread.sleep(delay);
                }

            when(mock.length()).thenReturn(-10L);
            assertEquals(-10L, mock.length());
        }
    }

    @ParameterizedTest(name = "getType returns {0}")
    @ValueSource(ints = { 0, 1, -5, Integer.MAX_VALUE })
    @DisplayName("Parameterized type values")
    void typeParameterized(int type) {
        FileEntry mock = mock(FileEntry.class);
        when(mock.getType()).thenReturn(type);

        assertNotNull(trans2SetFileInfo);

        // Test with maximum values
        trans2SetFileInfo = new Trans2SetFileInformation(config, 0xFFFF, Integer.MAX_VALUE, Long.MAX_VALUE, Long.MAX_VALUE, Long.MAX_VALUE);
        assertNotNull(trans2SetFileInfo);
    }

    @Test
    @DisplayName("Test attributes with OR operation")
    void testAttributesWithOrOperation() {

        settings.set(key, value);
        assertEquals(value, settings.getAsInt(key, -1));
    }

    @Test
    public void test_setAndGetAsLong() {
        String key = "key";
        long value = Long.MAX_VALUE;
        settings.set(key, value);
        assertEquals(value, settings.getAsLong(key, -1));
    }

    @Test
    public void test_setAndGetAsFloat() {
        String key = "key";