assertEquals(17, JvmUtil.getJavaVersion());

        System.setProperty("java.version", "8.0.332");
        assertEquals(8, JvmUtil.getJavaVersion());

        // Edge case: version starts with 1 but not old format
        System.setProperty("java.version", "18.0.1");
        assertEquals(18, JvmUtil.getJavaVersion());

        // Test with extra parts

        webApiRequest = new WebApiRequest(mockRequest, customPath);

        assertEquals(originalPath, webApiRequest.getServletPath());
    }

    // Test edge cases for SAStruts.method detection
    public void test_getServletPath_withSAStrutsMethodSubstring_returnsSuperPath() {
        final String originalPath = "/original/path";
        final String customPath = "/api/v1/search";

            SMBUtil.writeInt2(0, buffer, 14); // WriteChannelInfoLength
            return buffer;
        }
    }

    @Nested
    @DisplayName("Edge Case Tests")
    class EdgeCaseTests {

        @Test
        @DisplayName("Should handle structure size exactly 17")
        void testExactStructureSize() throws SMBProtocolDecodingException {

            assertTrue(str.contains("nativeFileSystem=NTFS"), "Should contain file system");
        }
    }

    /**
     * Tests for edge cases and error conditions
     */
    @Nested
    @DisplayName("Edge Case Tests")
    class EdgeCaseTests {

        @Test
        @DisplayName("Should handle null configuration gracefully")
        void testNullConfiguration() {

        // Verify query was processed
        // Note: Field logging behavior depends on implementation
    }

    public void test_convertPhraseQuery_emptyString() {
        // Test with empty string term (edge case)
        PhraseQuery.Builder builder = new PhraseQuery.Builder();
        builder.add(new Term(Constants.DEFAULT_FIELD, ""));
        PhraseQuery phraseQuery = builder.build();

        // Act
        itr.remove();

        // Assert
        verify(delegate, times(1)).remove();
    }

    @Test
    @DisplayName("Edge: empty delegate yields no elements")
    void emptyDelegate_hasNoNext() {
        // Arrange - no parent setup needed since no URLs are created
        when(delegate.hasNext()).thenReturn(false);

    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 1, -1, Integer.MIN_VALUE, Integer.MAX_VALUE })
    @DisplayName("hasCapability(cap): returns configured value and captures argument across edge caps")
    void hasCapability_variousCaps_returnsTrue_andCapturesArgument(int cap) throws Exception {
        // Arrange: stub to return true regardless of input
        when(handle.hasCapability(anyInt())).thenReturn(true);

        void testVariousDefaultValues(String defaultValue) throws IOException {
            assertEquals(defaultValue, mimeMap.getMimeType("notinmap", defaultValue));
        }
    }

    @Nested
    @DisplayName("Edge cases and special scenarios")
    class EdgeCases {

        @Test
        @DisplayName("Should handle multiple extensions for same mime type")
        void testMultipleExtensionsForSameMimeType() throws IOException {

import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

/**
 * Tests for {@link Graphs}. Tests assume that the implementation of the method {@code addEdge} adds
 * the missing nodes to the graph, then adds the edge between them.
 */
@RunWith(JUnit4.class)
@NullUnmarked
public class GraphsTest {
  private static final Integer N1 = 1;
  private static final Integer N2 = 2;
  private static final Integer N3 = 3;

import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import jcifs.CIFSException;
import jcifs.Configuration;

/**
 * Tests for SpnegoContext focusing on delegation, error handling, and edge cases.
 */
@ExtendWith(MockitoExtension.class)
class SpnegoContextTest {

    @Mock
    Configuration config;

    @Mock
    SSPContext mechContext;

    private ASN1ObjectIdentifier[] mechs;