// With enforcement disabled, this should log a warning but not throw
        PreauthIntegrityService lenientService = new PreauthIntegrityService(secureRandom, PreauthIntegrityService.HASH_ALGO_SHA512, false);

        // Should not throw exception
        lenientService.updatePreauthHash("non-existent", "test".getBytes());

        // With enforcement enabled, should throw exception
        assertThrows(CIFSException.class, () -> {

    return toString;
  }

  private static MessageDigest getMessageDigest(String algorithmName) {
    try {
      return MessageDigest.getInstance(algorithmName);
    } catch (NoSuchAlgorithmException e) {
      throw new AssertionError(e);
    }
  }

  @Override
  public Hasher newHasher() {
    if (supportsClone) {
      try {
        return new MessageDigestHasher((MessageDigest) prototype.clone(), bytes);

            final String reason = String.format(
                    "Cannot evaluate expression '%s' for configuration entry '%s'", value, configuration.getName());

            throw new ComponentConfigurationException(configuration, reason, e);
        }
    }

    @Override
    public Object fromConfiguration(
            final ConverterLookup lookup,

                // Now emulate error thrown by transport for create chain
                throw new SmbException(NtStatus.NT_STATUS_NO_SUCH_FILE, false);
            }
            return null;
        }).when(tree).send(any(Request.class));

        // Act: constructing the iterator must not throw and results in empty iterator
        DirFileEntryEnumIterator2 it = new DirFileEntryEnumIterator2(tree, parent, "*", null, 0);

            throw new CrawlingAccessException("I/O exception(" + e.getMessage() + "): " + url, e);
        } catch (final CrawlerSystemException e) {
            closeResources(httpRequest, responseData);
            throw e;
        } catch (final Exception e) {
            closeResources(httpRequest, responseData);
            throw new CrawlerSystemException("Failed to access " + url, e);
        } finally {
            try {

                getLogger().error(message);
                fw.println(message);
            }
        } catch (IOException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
        throw new GradleException("Documentation assertion failed: found invalid internal links. See " + new org.gradle.internal.logging.ConsoleRenderer().asClickableFileUrl(reportFile));
    }

        val request = Request.Builder()
            .url("https://publicobject.com/robots.txt")
            .build()

        client.newCall(request).execute().use { response ->
          if (!response.isSuccessful) throw IOException("Unexpected code $response")

          for (certificate in response.handshake!!.peerCertificates) {
            println(CertificatePinner.pin(certificate))
          }
        }
      }
    ```

                throw new CIFSException("Failed to create any channels for session " + sessionId);
            }

            log.info("Created {} channels for session {}", channelGroup.getChannelCount(), sessionId);
            return channelGroup;

        } catch (Exception e) {
            sessionChannels.remove(sessionId);

        if (extractorFactory == null) {
            throw new FessSystemException("Could not find extractorFactory.");
        }
        Extractor extractor = extractorFactory.getExtractor(responseData.getMimeType());
        if (extractor == null) {
            extractor = ComponentUtil.getComponent("tikaExtractor");
            if (extractor == null) {
                throw new FessSystemException("Could not find tikaExtractor.");

  }

  @MapFeature.Require(absent = ALLOWS_NULL_KEY_QUERIES)
  public void testContains_nullNotContainedAndUnsupported() {
    expectNullKeyMissingWhenNullKeysUnsupported("containsKey(null) should return false or throw");
  }

  @MapFeature.Require(ALLOWS_NULL_KEYS)
  @CollectionSize.Require(absent = ZERO)
  public void testContains_nonNullWhenNullContained() {
    initMapWithNullKey();