when(tree.send(any(Smb2IoctlRequest.class), eq(RequestParam.NO_RETRY))).thenThrow(new SmbException("boom"));

        IOException ex = assertThrows(IOException.class, stream::available, "Should convert SmbException to IOException");
        assertTrue(ex.getMessage().contains("boom"));
    }

    @Test
    @DisplayName("ensureTreeConnected delegates to handle")

            SmbException se = new SmbException("x", new jcifs.util.transport.TransportException(new InterruptedException("boom")));
            IOException ioe = SmbFileInputStream.seToIoe(se);
            assertTrue(ioe instanceof InterruptedIOException);
            assertTrue(ioe.getMessage().contains("boom"));
        }
    }

            when(src.getContext()).thenReturn(ctx);

            // Force failure before any stream construction
            when(src.openUnshared(anyInt(), anyInt(), anyInt(), anyInt(), anyInt())).thenThrow(new SmbException("boom"));

            SmbTreeHandleImpl sh = newTreeHandle(false); // force non-SMB2 path to avoid server-side branch
            SmbTreeHandleImpl dh = newTreeHandle(false);

            setChallenge(challengeBytes);
        }
        pos += 8;

        if (targetNameOff < pos + 8 || input.length < pos + 8) {
            // no room for Context/Reserved
            return;
        }

        if (!allZeros8(input, pos)) {
            final byte[] contextBytes = new byte[8];

   * array, it is returned therein. Otherwise, a new array is allocated with the runtime type of the
   * specified array and the size of the specified collection.
   *
   * <p>If the collection fits in the specified array with room to spare (i.e., the array has more
   * elements than the collection), the element in the array immediately following the end of the
   * collection is set to {@code null}. This is useful in determining the length of the collection

            preSteps = preBuildSteps,
        )

        failureConditions {
            // JavaExecDebugIntegrationTest.debug session fails without debugger might cause JVM crash
            // Some soak tests produce OOM exceptions
            // There are also random worker crashes for some tests.
            // We have test-retry to handle the crash in tests
            javaCrash = false
        }
    })

   * array, it is returned therein. Otherwise, a new array is allocated with the runtime type of the
   * specified array and the size of the specified collection.
   *
   * <p>If the collection fits in the specified array with room to spare (i.e., the array has more
   * elements than the collection), the element in the array immediately following the end of the
   * collection is set to {@code null}. This is useful in determining the length of the collection

        SearchLogHelper mockSearchLogHelper = new SearchLogHelper() {
            @Override
            public void storeSearchLog() {
                throw new OutOfMemoryError("Simulated OOM");
            }
        };
        ComponentUtil.register(mockSearchLogHelper, "searchLogHelper");

        // Execute the job - Error should NOT be caught since implementation only catches Exception
        try {

     * is present.
     */
    @Test
    @DisplayName("toString with root cause contains stack trace")
    void testToStringWithRootCause() {
        RuntimeException cause = new RuntimeException("boom");
        SmbException ex = new SmbException(0, cause);
        assertTrue(ex.toString().contains("RuntimeException"), "String representation must include the root cause stack trace");
    }

    /**

        // First call throws, second accepts
        when(filter.accept(any())).thenThrow(new CIFSException("boom")).thenReturn(true);

        ShareEnumIterator it = new ShareEnumIterator(parent, entries.iterator(), filter);

        assertTrue(it.hasNext());
        SmbResource res = it.next();
        assertNotNull(res);