"Should throw exception when length < 24");

        assertEquals("Invalid resume key", exception.getMessage(), "Exception message should match");
    }

    @Test
    @DisplayName("Test decode throws exception with zero length")
    void testDecodeThrowsExceptionWithZeroLength() {
        byte[] buffer = new byte[28];

        try {
            new CurlRequest(null, url);
            fail("Expected IllegalArgumentException");
        } catch (IllegalArgumentException e) {
            assertTrue(e.getMessage().contains("method must not be null"));
        }
    }

    @Test
    public void testSingleArgumentConstructor() {
        CurlRequest request = new CurlRequest(Method.POST);

            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 {

        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;
        }

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

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

        }, "A PACDecodingException should be thrown for a non-empty string with a zero pointer.");

        // Verify the exception message
        assertEquals("Non-empty string", exception.getMessage(), "The exception message is not correct.");
    }

    /**
     * Tests the {@link PacUnicodeString#check(String)} method with a string of incorrect length.
     */
    @Test

            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 {

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

    /**