doThrow(new SmbException("capability check failed")).when(transport).hasCapability(eq(42));
        SmbException ex = assertThrows(SmbException.class, () -> transport.hasCapability(42));
        assertTrue(ex.getMessage().contains("failed"));
        verify(transport).hasCapability(42);
    }

    // Edge: disconnected status toggles
    @ParameterizedTest
    @DisplayName("isDisconnected reflects current mocked state")

            try {
                while (used == 0) {
                    lock.wait();
                }
            } catch (final InterruptedException ie) {
                throw new IOException(ie.getMessage());
            }
            result = pipe_buf[beg_idx] & 0xFF;
            beg_idx = (beg_idx + 1) % pipe_buf.length;
        }
        return result;
    }

    @Override

     */
    @Override
    public ActionResponse godHandPrologue(final ActionRuntime runtime) {
        if (!isAccessAllowed()) {
            return asJson(new ApiErrorResponse().message(getMessage(messages -> messages.addErrorsUnauthorizedRequest(GLOBAL)))
                    .status(Status.UNAUTHORIZED)
                    .result());
        }
        return super.godHandPrologue(runtime);
    }

    /**

            ipad[i] = IPAD;
            opad[i] = OPAD;
        }
        try {
            md5 = MessageDigest.getInstance("MD5");
        } catch (final Exception ex) {
            throw new IllegalStateException(ex.getMessage());
        }
        engineReset();
    }

    private HMACT64(final HMACT64 hmac) throws CloneNotSupportedException {
        super("HMACT64");
        this.ipad = hmac.ipad;
        this.opad = hmac.opad;

            return new Metadata(new MetadataStaxReader().read(input, false));
        } catch (IOException | XMLStreamException e) {
            throw new RepositoryException("Could not parse metadata " + metadataPath + ": " + e.getMessage(), e);
        }
    }

    private void write(Path metadataPath, Metadata metadata) throws RepositoryException {
        try {
            Files.createDirectories(metadataPath.getParent());

    }

    private static String getMessage(Throwable error, String def) {
        if (error == null) {
            return def;
        }
        String msg = error.getMessage();
        if (msg != null && !msg.isEmpty()) {
            return msg;
        }
        return getMessage(error.getCause(), def);
    }

        });
        // aggregate all exceptions
        if (!prerequisiteExceptions.isEmpty()) {
            String messages = prerequisiteExceptions.stream()
                    .map(IllegalStateException::getMessage)
                    .collect(Collectors.joining("\n\t"));
            PluginIncompatibleException pie = new PluginIncompatibleException(
                    pluginDescriptor.getPlugin(),

            // For now, just return the file object
            return file;
        } catch (Exception e) {
            log.warn("Failed to create SmbFile for {}: {}", filePath, e.getMessage());
            throw new IOException("Failed to create SmbFile: " + e.getMessage(), e);
        }
    }

    /**
     * Get the CIFS context
     *
     * @return CIFS context
     */
    public CIFSContext getContext() {

            // Only count specific exceptions as failures using custom predicate
            java.util.function.Predicate<Exception> isFailure = e -> e.getMessage() != null && e.getMessage().contains("critical");

            // Non-critical failures - should NOT open circuit
            for (int i = 0; i < 5; i++) {
                try {

            fail("Expected CrawlerSystemException to be thrown");
        } catch (final CrawlerSystemException e) {
            // Expected
            assertTrue(e.getMessage().contains("Could not stop a process"));
        }
    }

    /**
     * Test CrawlerSystemException is re-thrown when ignoreException = false
     */
    public void test_crawlerSystemExceptionRethrown() {