import java.util.List;

import org.codelibs.fess.util.ComponentUtil;

/**
 * Pager for managing synonym pagination.
 * This class handles the state and logic for paginating through a list of synonyms,
 * including total record count, page size, and current page number.
 */
public class SynonymPager implements Serializable {

    /**
     * Constructs a new pager for synonyms.
     */
    public SynonymPager() {

    if (!platform.isBouncyCastle()) {
      assertThat(recordedRequest.handshakeServerNames).containsExactly(url.host)
    }
  }

  /**
   * Use different hostnames for the TLS handshake (including SNI) and the HTTP request (in the
   * Host header).
   */
  @Test
  fun domainFronting() {
    val heldCertificate =
      HeldCertificate
        .Builder()
        .commonName("server name")

import jcifs.smb.FileEntry;
import jcifs.util.Strings;

/**
 * Represents the FILE_BOTH_DIR_INFORMATION structure used in SMB directory enumeration operations.
 * This structure contains comprehensive file information including timestamps, attributes, sizes,
 * short name (8.3 format), and full filename for directory entries.
 */
public class FileBothDirectoryInfo implements FileEntry, Decodable {

    private int nextEntryOffset;

package org.codelibs.fess.crawler.entity;

import org.codelibs.core.lang.StringUtil;

/**
 * Represents a Sitemap file entry, conforming to the Sitemap XML format.
 * This class holds information about a single Sitemap, including its location and last modification timestamp.
 * It implements the {@link Sitemap} interface.
 *
 * <p>
 * A Sitemap file provides search engines with a list of URLs available for crawling.

    )

    val call = client.newCall(Request(url))
    val response = call.execute()
    assertThat(response.body.string()).isEqualTo("hello from IPv6")

    // In the process we made two connection attempts including one failure.
    assertThat(listener.recordedEventTypes().filter { it == "ConnectStart" }).hasSize(1)
    assertThat(listener.recordedEventTypes().filter { it == "ConnectEnd" }).hasSize(1)

import org.dbflute.tomcat.props.BootPropsTranslator;

/**
 * Main boot class for the Fess search engine application.
 * This class extends TomcatBoot to provide Fess-specific Tomcat server configuration
 * and initialization, including SSL setup, context path handling, and resource management.
 *
 * <p>The class handles system property configuration for paths, ports, and other
 * Fess-specific settings during application startup.</p>
 *
 * @since 1.0

/**
 * CompactLinkedHashSet is an implementation of a Set, which a predictable iteration order that
 * matches the insertion order. All optional operations (adding and removing) are supported. All
 * elements, including {@code null}, are permitted.
 *
 * <p>{@code contains(x)}, {@code add(x)} and {@code remove(x)}, are all (expected and amortized)
 * constant time operations. Expected in the hashtable sense (depends on the hash function doing a

   * "inherited" from superclasses of the same package.
   */
  public void testAllPublicStaticMethods(Class<?> c) {
    testStaticMethods(c, Visibility.PUBLIC);
  }

  /**
   * Runs {@link #testMethod} on every instance method of the class of {@code instance} with at
   * least {@code minimalVisibility}, including those inherited from superclasses of the same

	if len(p) > sr.max {
		p = p[0:sr.max]
	}
	return sr.buf.Read(p)
}

// genLine writes to buf a predictable but non-trivial line of text of length
// n, including the terminal newline and an occasional carriage return.
// If addNewline is false, the \r and \n are not emitted.
func genLine(buf *bytes.Buffer, lineNum, n int, addNewline bool) {
	buf.Reset()
	doCR := lineNum%5 == 0

     * This method must be implemented by concrete searcher classes.
     *
     * @param query the search query string
     * @param params the search request parameters including pagination, filters, etc.
     * @param userBean the optional user bean for access control and personalization
     * @return the search result containing matched documents and metadata
     */