* to determine if a given response data matches the rule, retrieve the rule's identifier,
 * and obtain the associated response processor.
 */
public interface Rule extends Serializable {

    /**
     * Determines if the given response data matches the rule.
     *
     * @param responseData the response data to be evaluated
     * @return true if the response data matches the rule, false otherwise
     */

    public void setPassword(final String password) {
        this.password = password;
    }

    /**
     * Checks if this authentication matches the given FTP path.
     * @param path The FTP path to check.
     * @return true if it matches, false otherwise.
     */
    boolean matches(final String path) {
        if (StringUtil.isBlank(path)) {
            return false;
        }

        try {

        return a -> matches(artifact.getGroupId(), a.getGroupId())
                && matches(artifact.getArtifactId(), a.getArtifactId())
                && matches(artifact.getBaseVersion(), a.getBaseVersion())
                && matches(artifact.getExtension(), a.getExtension())
                && matches(artifact.getClassifier(), a.getClassifier());
    }

        // same auth instance => matches
        assertTrue(s1.matches(a1));
        // different instance but equal content => matches
        assertTrue(s1.matches(a2));
        // not equal => no match
        NtlmPasswordAuthentication other = new NtlmPasswordAuthentication("OTHER", "u", "p");
        assertFalse(s1.matches(other));
    }

    @Test
    void toStringContainsKeyFields() {

        // verify
        InOrder inOrder = inOrder(logger);
        inOrder.verify(logger).info(matches(".*Apache Maven Embedder 1.*\\[1\\/3\\]"));
        inOrder.verify(logger).info(matches(".*Apache Maven Embedder 2.*\\[2\\/3\\]"));
        inOrder.verify(logger).info(matches(".*Apache Maven Embedder 3.*\\[3\\/3\\]"));
    }

    @Test
    void testMultiModuleProjectResumeFromProgress() {

        assertTrue(fileInfo.matches(1024L, 1000L, 0x20));

        // Should not match with different size
        assertFalse(fileInfo.matches(2048L, 1000L, 0x20));

        // Should not match with different last modified
        assertFalse(fileInfo.matches(1024L, 2000L, 0x20));

        // Should not match with different attributes
        assertFalse(fileInfo.matches(1024L, 1000L, 0x10));
    }

    @Test

                    logger.debug("Using exclude pattern: {}", pattern);
                }
            }
            if (paramMap.get(URL_EXCLUDE_PATTERN) instanceof final Pattern pattern) {
                if (pattern.matcher(url).matches()) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Skipping URL {} due to exclude pattern: {}", url, pattern);
                    }
                    return false;

	matches := []madmin.KMSKeyInfo{}
	if req.Prefix == "" {
		req.Prefix = "*"
	}
	for _, keyName := range s.KeyNames {
		if wildcard.MatchAsPatternPrefix(req.Prefix, keyName) {
			matches = append(matches, madmin.KMSKeyInfo{Name: keyName, CreatedAt: StubCreatedAt, CreatedBy: StubCreatedBy})
		}
	}

	return matches, "", nil
}

        NdrBuffer decodeBuffer = new NdrBuffer(buffer, 0);
        lsarpc.LsarDomainInfo decodedInfo = new lsarpc.LsarDomainInfo();
        decodedInfo.decode(decodeBuffer);

        // Verify the decoded data matches
        assertEquals(domainInfo.name.length, decodedInfo.name.length);
        assertEquals(domainInfo.name.maximum_length, decodedInfo.name.maximum_length);
        assertNotNull(decodedInfo.name.buffer);

 * limitations under the License.
 */
package okhttp3.compare

import assertk.assertThat
import assertk.assertions.isEqualTo
import assertk.assertions.isNull
import assertk.assertions.matches
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import mockwebserver3.junit5.StartStop
import org.eclipse.jetty.client.HttpClient
import org.junit.jupiter.api.AfterEach