transformer,
                    strict,
                    modelId,
                    location,
                    addDefaultEntities);
        }

        private static class DefaultXmlReaderRequest implements XmlReaderRequest {
            final Path path;
            final Path rootDirectory;
            final URL url;
            final InputStream inputStream;

      assertThat(
        connection.inputStream
          .source()
          .buffer()
          .readUtf8(),
      ).contains("Peter the person")
    }
  }

  private fun testRequest(function: (MockServerClient) -> Unit) {
    MockServerClient(mockServer.host, mockServer.serverPort).use { mockServerClient ->
      val request =
        request()
          .withPath("/person")

            queryFieldConfig.init();
        }
    }

    // Test configuration class extending FessConfig.SimpleImpl
    private static class TestFessConfig extends FessConfig.SimpleImpl {
        private static final long serialVersionUID = 1L;
    }

   * cache then this is the timestamp of the original response.
   */
  @get:JvmName("receivedResponseAtMillis") val receivedResponseAtMillis: Long,
  @get:JvmName("exchange") internal val exchange: Exchange?,
  private var trailersSource: TrailersSource,
) : Closeable {
  internal var lazyCacheControl: CacheControl? = null

  @JvmName("-deprecated_request")
  @Deprecated(
    message = "moved to val",

 * // Process the responseData
 * smbClient.close();
 * }
 * </pre>
 *
 * @author shinsuke
 */
public class SmbClient extends AbstractCrawlerClient {
    private static final Logger logger = LogManager.getLogger(SmbClient.class);

    /** Property key for SMB authentications configuration. */
    public static final String SMB_AUTHENTICATIONS_PROPERTY = "smbAuthentications";

  val ca: Boolean,
  /** The maximum number of intermediate CAs between this and leaf certificates. */
  val maxIntermediateCas: Long?,
)

/** A private key. Note that this class doesn't support attributes or an embedded public key. */
internal data class PrivateKeyInfo(
  // v1(0), v2(1).
  val version: Long,
  val algorithmIdentifier: AlgorithmIdentifier,

    require(c == '\t' || c in '\u0020'..'\u007e') {
      "Unexpected char 0x${c.charCode()} at $i in $name value" +
        (if (isSensitiveHeader(name)) "" else ": $value")
    }
  }
}

private fun Char.charCode() =
  code.toString(16).let {
    if (it.length < 2) {
      "0$it"
    } else {
      it
    }
  }

internal fun commonHeadersOf(vararg inputNamesAndValues: String): Headers {

   * comparator.
   */
  @Override
  public Collection<V> values() {
    return super.values();
  }

  @GwtIncompatible @J2ktIncompatible   private static final long serialVersionUID = 430848587173315748L;

    /** does the actual artifact for this metadata exists */
    protected boolean artifactExists = false;
    /** artifact URI */
    protected String artifactUri;

    /** error message  */
    private String error;

    // ------------------------------------------------------------------
    /**
     *
     */
    public ArtifactMetadata(String name) {
        if (name == null) {
            return;

  public static <E> ImmutableSortedMultiset<E> copyOfSorted(SortedMultiset<E> sortedMultiset) {
    return copyOfSortedEntries(
        sortedMultiset.comparator(), new ArrayList<>(sortedMultiset.entrySet()));
  }

  private static <E> ImmutableSortedMultiset<E> copyOfSortedEntries(
      Comparator<? super E> comparator, Collection<Entry<E>> entries) {
    if (entries.isEmpty()) {
      return emptyMultiset(comparator);
    }