NtStatusConsumer mock = mock(NtStatusConsumer.class);
        findNtStatus(dosErr).ifPresent(mock::consume);
        verify(mock).consume(expectedNt);
    }

    @Test
    @DisplayName("DOS_ERROR_MESSAGES length matches expectations")
    void testMessageArrayLength() {
        assertNotNull(DosError.DOS_ERROR_MESSAGES, "DOS_ERROR_MESSAGES should be non‑null");

      <id>dynamic-property-available</id>
      <activation>
        <property>
          <name>${activationProperty}</name>
        </property>
      </activation>
    </profile>

    <profile>
      <id>matches-another-property</id>
      <activation>
        <property>
          <name>foo</name>
          <value>${bar}</value>
        </property>
      </activation>
    </profile>
  </profiles>

            throw new IllegalStateException("Malformed distributionUrl line: " + distributionUrl);
        }
        String url = distributionUrl.substring(idx + 1).trim();

        Matcher m = WRAPPER_VERSION_EXTRACT.matcher(url);
        if (!m.matches()) {
            throw new IllegalStateException("Could not extract wrapper version from distributionUrl: " + url);
        }
        return m.group(1);
    }

}

// doesPolicySignatureMatch - Verify query headers with post policy
//   - http://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-HTTPPOSTConstructPolicy.html
//
// returns ErrNone if the signature matches.
func doesPolicySignatureV4Match(formValues http.Header) (auth.Credentials, APIErrorCode) {
	// Server region.
	region := globalSite.Region()

	// Parse credential tag.

            if (!(node instanceof Text)) {
                return false;
            }
            Text text = (Text) node;
            if (!text.getTextContent().matches("\\s*")) {
                return false;
            }
        }
        return true;
    }

   * {@inheritDoc}
   *
   * <p>The {@code AbstractListTester} implementation overrides {@link
   * AbstractCollectionTester#expectContents(Collection)} to verify that the order of the elements
   * in the list under test matches what is expected.
   */
  @Override
  protected void expectContents(Collection<E> expectedCollection) {
    List<E> expectedList = copyToList(expectedCollection);

    }
  }

  @SuppressWarnings("rawtypes") // class literals
  protected abstract List<Class<? extends AbstractTester>> getTesters();

  private boolean matches(Test test) {
    Method method;
    try {
      method = extractMethod(test);
    } catch (IllegalArgumentException e) {
      logger.finer(Platform.format("%s: including by default: %s", test, e.getMessage()));

type ChecksumMismatch struct {
	Want string
	Got  string
}

func (e ChecksumMismatch) Error() string {
	return "Bad checksum: Want " + e.Want + " does not match calculated " + e.Got
}

// IsChecksumMismatch matches if 'err' is hash.ChecksumMismatch
func IsChecksumMismatch(err error) bool {
	var herr ChecksumMismatch
	return errors.As(err, &herr)

        }

        /**
         * 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) {

func (e metaCacheEntry) hasPrefix(s string) bool {
	return strings.HasPrefix(e.name, s)
}

// matches returns if the entries have the same versions.
// If strict is false we allow signatures to mismatch.
func (e *metaCacheEntry) matches(other *metaCacheEntry, strict bool) (prefer *metaCacheEntry, matches bool) {
	if e == nil && other == nil {
		return nil, true
	}
	if e == nil {
		return other, false
	}