return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }

        if (obj instanceof AndArtifactFilter other) {
            return filters.equals(other.filters);
        } else {
            return false;
        }
    }

                    return event;
                }
                return new Log4jLogEvent.Builder(event).setLevel(Level.WARN).build();
            }
        }
        return event;
    }

    /**
     * Factory method to create an ErrorToWarnRewritePolicy instance.
     *
     * @param loggerNamePrefix comma-separated list of logger name prefixes
     * @return a new ErrorToWarnRewritePolicy instance
     */

     *
     * @return comparator that orders projects with longer dependency chains first
     */
    public Comparator<MavenProject> getComparator() {
        return comparator;
    }

    /**
     * Gets the calculated weight for a project, representing its dependency chain length.
     *
     * @param project the project
     * @return the project's weight (higher means longer dependency chain)

     * </p>
     *
     * @param inData
     *            The data to encode
     * @return The encoded data, or an empty string if the input is null or empty
     */
    public static String encode(final byte[] inData) {
        if (ArrayUtil.isEmpty(inData)) {
            return "";
        }
        return Base64.getEncoder().encodeToString(inData);
    }

    /**
     * Decodes data encoded in Base64.

        path.append(filename);

        return path.toString();
    }

    @Override
    public String pathOfRemoteRepositoryMetadata(ArtifactMetadata metadata) {
        return pathOfRepositoryMetadata(metadata.getRemoteFilename());
    }

    @Override
    public String toString() {
        return getId();
    }

            return compileScope;
        } else if (Artifact.SCOPE_RUNTIME.equals(artifact.getScope())) {
            return runtimeScope;
        } else if (Artifact.SCOPE_TEST.equals(artifact.getScope())) {
            return testScope;
        } else if (Artifact.SCOPE_PROVIDED.equals(artifact.getScope())) {
            return providedScope;

    @Test
    @DisplayName("getBuffer should return non-null byte array")
    void testGetBufferContract() {
        // Given
        byte[] expectedBuffer = new byte[1024];
        when(mockBufferCache.getBuffer()).thenReturn(expectedBuffer);

        // When
        byte[] buffer = mockBufferCache.getBuffer();

        // Then
        assertNotNull(buffer, "getBuffer should never return null");

    public String readLine() throws IOException {
        try {
            return prompter.prompt(null);
        } catch (org.apache.maven.api.services.PrompterException e) {
            throw new IOException("Unable to prompt", e);
        }
    }

    @Override
    public String readPassword() throws IOException {
        try {
            return prompter.promptForPassword(null);

        Set<Artifact> resolved = new LinkedHashSet<>();

        if (projects == null || projects.isEmpty()) {
            return resolved;
        }

        if ((scopesToCollect == null || scopesToCollect.isEmpty())
                && (scopesToResolve == null || scopesToResolve.isEmpty())) {
            return resolved;
        }

        /*

        Logic for transitive global exclusions

            return new String(FileUtil.readBytes(outputFile), Constants.UTF_8_CHARSET);
        }
    }

    /**
     * Gets the extractor for the specified file extension.
     *
     * @param ext the file extension
     * @return the extractor for the extension, or null if not found
     */
    private Extractor getExtractor(final String ext) {
        return extractorMap.get(ext);
    }

    /**