}

    /**
     * Returns the element type of the parameterized collection declared as the method's argument type.
     *
     * @param method
     *            The method. Cannot be {@literal null}
     * @param position
     *            The position of the parameterized collection in the method's argument list
     * @return The element type of the parameterized collection
     */

     * </p>
     * <p>
     * If <code>type</code> is a parameterized type but has no direct type arguments, an empty array is returned.
     * This includes cases where the parameterized type contains nested types without type arguments.
     * </p>
     * <p>
     * If <code>type</code> is not a parameterized type, <code>null</code> is returned.
     * </p>
     *
     * @param type

        assertArgumentNotNull("field", field);

        return Modifier.isFinal(field.getModifiers());
    }

    /**
     * Returns the element type of a parameterized collection field.
     *
     * @param field a field of a parameterized collection type (must not be {@literal null})
     * @return the element type of the collection
     */
    public static Class<?> getElementTypeOfCollection(final Field field) {

        // Verify instance is created
        assertNotNull(fileInfo);
        assertEquals(FileInformation.FILE_ENDOFFILE_INFO, fileInfo.getFileInformationLevel());
    }

    @Test
    @DisplayName("Test parameterized constructor with end of file value")
    void testParameterizedConstructor() {
        // Test with specific end of file value
        long endOfFile = 1024L;

            return length;
        }

        @Override
        public int getFileIndex() {
            return fileIndex;
        }
    }

    // Functional helpers for concise parameterized tests
    private interface IntGetter {
        int apply(FileEntry e);
    }

    private interface LongGetter {
        long apply(FileEntry e);
    }

            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);
        assertEquals(type, mock.getType());
    }

    @Test

        assertEquals(3, third.length, "Allocated buffer length matches configured maximum size");
    }

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

 */
@ExtendWith(MockitoExtension.class)
class SMBProtocolDowngradeExceptionTest {

    /**
     * Provides messages including edge cases (null and empty) for parameterized testing.
     */
    static Stream<Arguments> messages() {
        return Stream.of(Arguments.of((String) null), Arguments.of(""), Arguments.of("unexpected downgrade"));
    }

    @Test

    private static final String SPNEGO_OID_STR = SpnegoConstants.SPNEGO_MECHANISM;

    // Helper to build a SPNEGO NegTokenInit as per NegTokenInit#toByteArray but parameterized for tests
    private static byte[] buildInitToken(ASN1ObjectIdentifier[] mechs, Integer flags, byte[] mechToken, byte[] mic, boolean micInTag4,

                "The error string should match the expected message for given error class and code");
    }

    /**
     * Provides arguments for the testGetErrorString parameterized test.
     * Covers all defined error classes and codes, including default cases.
     */
    private static Stream<Arguments> provideErrorClassAndCodeForGetErrorString() {
        return Stream.of(