hash.writeBytesTo(bb, 0, bb.length);
    assertTrue(Arrays.equals(expectedHashCode.bytes, bb));
    assertEquals(expectedHashCode.asInt, hash.asInt());
    if (expectedHashCode.asLong == null) {
      try {
        hash.asLong();
        fail();
      } catch (IllegalStateException expected) {
      }
    } else {
      assertEquals(expectedHashCode.asLong.longValue(), hash.asLong());
    }

        when(limitedConfig.getLeaseBreakTimeout()).thenReturn(60);

        LeaseManager limitedManager = new LeaseManager(limitedContext);

        try {
            // Request 3 leases (should evict the oldest when requesting the 3rd)
            Smb2LeaseKey key1 = limitedManager.requestLease("/share/file1.txt", Smb2LeaseState.SMB2_LEASE_READ_CACHING);

                if (s.ordinal() > severity.ordinal()) {
                    List<P> problems = getProblems(s);
                    while (!problems.isEmpty()) {
                        try {
                            return problems.remove(0) != null;
                        } catch (IndexOutOfBoundsException e) {
                            // empty, continue
                        }

                if (logger.isDebugEnabled()) {
                    logger.debug("Storing accessResult: {}", accessResult);
                }
                try {
                    // store
                    CrawlingParameterUtil.getDataService().store(accessResult);
                } catch (final Exception e) {
                    crawlerContext.decrementAndGetAccessCount();

            throwValidationErrorApi(messages -> messages.addErrorsFailedToUploadProtwordsFile(GLOBAL));
            return null;
        });
        try (InputStream inputStream = form.charMappingFile.getInputStream()) {
            file.update(inputStream);
        } catch (final IOException e) {
            logger.warn("Failed to process a request.", e);

        assertArgumentNotNull("contents", contents);

        if (encoding == null) {
            return new ByteArrayInputStream(contents.getBytes());
        }
        try {
            return new ByteArrayInputStream(contents.getBytes(encoding));
        } catch (final UnsupportedEncodingException ex) {
            throw new IORuntimeException(ex);
        }
    }

    /**

        final OsddHelper osddHelper = new OsddHelper();
        osddHelper.setContentType("application/opensearchdescription+xml");
        osddHelper.init();
        assertFalse(osddHelper.hasOpenSearchFile());

        try {
            osddHelper.asStream();
            fail();
        } catch (final Exception e) {
            assertEquals("Unsupported Open Search Description Document response.", e.getMessage());
        }
    }

        // Match should work
        ResponseData responseData = new ResponseData();
        assertTrue(ruleWithoutContainer.match(responseData));

        // Register should fail with null container
        try {
            ruleWithoutContainer.register(0);
            fail("Should throw exception with null container");
        } catch (NullPointerException e) {
            // Expected
        }
    }

    /**

        if (rule != null) {
          wildcardMatch = rule
          break
        }
      }
    }

    // Exception rules only apply to wildcard rules, so only try it if we matched a wildcard.
    var exception: String? = null
    if (wildcardMatch != null) {
      for (labelIndex in 0 until domainLabelsUtf8Bytes.size - 1) {
        val rule =

        return FileAuthenticationDbm.getInstance();
    }

    @Override
    protected <RESULT extends FileAuthentication> RESULT createEntity(Map<String, Object> source, Class<? extends RESULT> entityType) {
        try {
            final RESULT result = entityType.newInstance();
            result.setCreatedBy(DfTypeUtil.toString(source.get("createdBy")));
            result.setCreatedTime(DfTypeUtil.toLong(source.get("createdTime")));