try {
            pomMap = PomDiscovery.discoverPoms(startingDirectory);
        } catch (IOException | DomTripException e) {
            context.failure("Failed to discover POM files: " + e.getMessage());
            return 1;
        }

        if (pomMap.isEmpty()) {
            context.warning("No POM files found in " + startingDirectory);
            return 0;
        }

            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());

    public void transferFailed(TransferEvent event) {
        transferCompleted(event);

        println(
                "transferFailed",
                event.getException().getClass() + ": " + event.getException().getMessage());
    }

    private void transferCompleted(TransferEvent event) {
        downloads.remove(event.getResource());

        StringBuilder buffer = new StringBuilder(64);
        pad(buffer, lastLength);

     */
    @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);
    }

    /**

            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

            assertTrue(true);
        } catch (Exception e) {
            // Should throw ThemeException or ZipException
            assertTrue(e instanceof ThemeException || e.getMessage().contains("zip") || e.getMessage().contains("install")
                    || e.getMessage().contains("format"));
        }
    }

    @Test
    public void test_install_zipWithSkippedEntries() throws IOException {

            fail("Should throw IllegalArgumentException");
        } catch (IllegalArgumentException e) {
            assertTrue(e.getMessage().contains("Both name and dataStore parameters are required"));
            assertTrue(e.getMessage().contains("name: null"));
        }
    }

    // Test add method with null dataStore
    @Test
    public void test_add_nullDataStore() {
        try {

        when(handle.ensureTreeConnected()).thenThrow(boom);

        // Act + Assert
        CIFSException ex = assertThrows(CIFSException.class, out::ensureTreeConnected);
        assertEquals("tree-fail", ex.getMessage());
        verify(handle, times(1)).ensureTreeConnected();
    }

    @Test
    @DisplayName("ensureOpen delegates and returns the file handle")
    void ensureOpen_delegatesAndReturns() throws Exception {

            return CANCELED;
        } catch (Exception e) {
            if (context.options().showErrors().orElse(false)) {
                context.logger.error(e.getMessage(), e);
            } else {
                context.logger.error(e.getMessage());
            }
            return ERROR;
        }
    }

    protected int badGoalsErrorMessage(String message, EncryptContext context) {