}

        /**
         * Check if this file info matches the given attributes
         *
         * @param otherSize size to compare
         * @param otherLastModified last modified time to compare
         * @param otherAttributes attributes to compare
         * @return true if attributes match
         */
        public boolean matches(long otherSize, long otherLastModified, long otherAttributes) {

                    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;

                "color": "red",
                "value": 80
              }
            ]
          },
          "unit": "none"
        },
        "overrides": [
          {
            "matcher": {
              "id": "byName",
              "options": "available 10.13.1.25:9000"
            },
            "properties": [
              {
                "id": "color",
                "value": {

 * and access mask of each ACE. If the SID matches, the allow/deny flags
 * and access mask are considered. If the ACE is a "deny"
 * ACE and <i>any</i> of the desired access bits match bits in the access
 * mask of the ACE, the whole access check fails. If the ACE is an "allow"
 * ACE and <i>all</i> of the bits in the desired access bits match bits in
 * the access mask of the ACE, the access check is successful. Otherwise,

 *  Fix: Don't reuse a connection on redirect if certs match but DNS does not. For better
    locality and performance OkHttp attempts to use the same pooled connection across redirects and
    follow-ups. It independently shares connections when the IP addresses and certificates match,
    even if the host names do not. In 4.4.0 we introduced a regression where we shared a connection

        private void body(Snippet snippet, boolean inSetup) {
            parse("$snippet", snippet.contents, SYNTAX) { matcher, last ->
                if (matcher.group("comment") != null) {
                    // Comment
                    return
                }
                String yamlRequest = matcher.group("yaml");
                if (yamlRequest != null) {
                    current.println(yamlRequest)

        verifyNoInteractions(mocked);
    }

    // Reflection-based check: ensure serialVersionUID remains the declared constant
    @Test
    @DisplayName("serialVersionUID matches declared constant")
    void serialVersionUID_hasExpectedValue() throws Exception {
        // Arrange
        Field f = SMBSignatureValidationException.class.getDeclaredField("serialVersionUID");
        f.setAccessible(true);

        }
        final Matcher matcher = regexPattern.matcher(input);
        if (matcher.find()) {
            if (pathMapperFunc == null) {
                final String replacement = StringUtil.isNotBlank(getReplacement()) ? getReplacement() : StringUtil.EMPTY;
                pathMapperFunc = pathMappingHelper.createPathMatcher(matcher, replacement);
            }
            try {

	f.buf.Write(data)
	// Flush to w until a potential match of exitRe
	b := f.buf.Bytes()
	match := f.exitRe.FindIndex(b)
	if match == nil {
		// Flush all of the buffer.
		_, err := f.w.Write(b)
		f.buf.Reset()
		if err != nil {
			return n, err
		}
	} else {
		// Flush up to the beginning of the (potential) match.
		_, err := f.w.Write(b[:match[0]])
		f.buf.Next(match[0])
		if err != nil {
			return n, err
		}

            strategy.doApply(context, pomMap);

            // Verify correct behavior when version doesn't match:
            // - groupId should be removed (can be inferred from project regardless of version)
            // - version should remain (doesn't match project version, so can't be inferred)
            // - artifactId should remain (always required)