}

    @Test
    @DisplayName("getInput/getOutput return cached streams when open; throw when closed")
    void getInputOutput_caching_and_closed() throws Exception {
        // Arrange: minimal stubs so stream construction works
        SmbPipeHandleImpl handle = newHandleWithBasicStubs(0, "\\\\pipe\\\\foo");
        when(pipe.ensureTreeConnected()).thenReturn(tree);
        when(tree.acquire()).thenReturn(tree);

            }
        }
    }

    @Nested
    @DisplayName("Edge Cases and Error Handling")
    class EdgeCasesTest {

        @Test
        @DisplayName("Should handle maximum size arrays")
        void testMaximumSizeArrays() throws SMBProtocolDecodingException {
            // Arrange
            int[] largeHashAlgos = new int[100];

   * chosen. Guarded by this.
   */
  internal var routeFailureCount = 0

  private var successCount = 0
  private var refusedStreamCount = 0

  /**
   * The maximum number of concurrent streams that can be carried by this connection. If
   * `allocations.size() < allocationLimit` then new streams can be created on this connection.
   */
  internal var allocationLimit = 1
    private set

     * Optimized for better performance with larger read sizes and reduced round trips.
     *
     * @param b the buffer to read into
     * @param off the offset in the buffer to start writing
     * @param len the maximum number of bytes to read
     * @return number of bytes read
     *
     * @throws IOException
     *             if a network error occurs
     */

import org.mockito.junit.jupiter.MockitoExtension;

import jcifs.CIFSContext;
import jcifs.CIFSException;
import jcifs.SidResolver;
import jcifs.dcerpc.rpc;

class SIDTest {

    // Helper to build a minimal sid_t
    private static rpc.sid_t buildSidT(byte revision, byte[] identAuth, int... subs) {
        rpc.sid_t s = new rpc.sid_t();
        s.revision = revision;
        s.sub_authority_count = (byte) subs.length;

        assertEquals("Expected structureSize = 17", exception.getMessage());
    }

    @Test
    @DisplayName("Should read valid structure with minimal test")
    void testReadBytesWireFormatBasicStructure() throws Exception {
        // Given - Create a complete SMB2 message with header
        byte[] buffer = new byte[512];
        int headerStart = 0;

            assertArrayEquals(Arrays.copyOfRange(fullData, offset, offset + length), Arrays.copyOfRange(buffer, 48, 48 + length));
        }

        @Test
        @DisplayName("Should handle maximum values correctly")
        void testMaximumValues() {
            request.setOffset(Long.MAX_VALUE);
            request.setRemainingBytes(Integer.MAX_VALUE);
            request.setWriteFlags(Integer.MAX_VALUE);

        assertNotNull(crawlerContext.removeSitemaps());
    }

    /**
     * Test boundary values
     */
    public void test_boundaryValues() {
        // Test with maximum values
        crawlerContext.setActiveThreadCount(Integer.MAX_VALUE);
        assertEquals(Integer.MAX_VALUE, crawlerContext.getActiveThreadCount().intValue());

        crawlerContext.setNumOfThread(Integer.MAX_VALUE);

  /*
   * If we make these calls inline inside toImmutableSortedMultiset, we get an Animal Sniffer error,
   * despite the @IgnoreJRERequirement annotation there. My assumption is that, because javac
   * generates a synthetic method for the body of the lambda, the actual method calls that Animal
   * Sniffer is flagging don't appear inside toImmutableSortedMultiset but rather inside that

    }

    /**
     * Gets the count of currently running crawler jobs.
     * This method queries the scheduled jobs to count active crawler processes.
     * Used to enforce maximum concurrent crawler limits.
     *
     * @return the number of currently running crawler jobs
     */
    protected int getRunningJobCount() {
        final AtomicInteger counter = new AtomicInteger(0);