import jcifs.util.Encdec;

/**
 * Represents encrypted Kerberos ticket data.
 */
public class KerberosEncData {

    private String userRealm;
    private String userPrincipalName;
    private ArrayList<InetAddress> userAddresses;
    private List<KerberosAuthData> userAuthorizations;

    /**
     * Constructs KerberosEncData from encrypted token bytes.
     *

    /** Total number of records matching the search criteria. */
    private int allRecordCount;

    /** Total number of pages based on record count and page size. */
    private int allPageCount;

    /** Flag indicating if a previous page exists. */
    private boolean existPrePage;

    /** Flag indicating if a next page exists. */
    private boolean existNextPage;

    /** List of page numbers for pagination navigation. */

public class DataConfig extends BsDataConfig implements CrawlingConfig {

    private static final long serialVersionUID = 1L;

    private static final Logger logger = LogManager.getLogger(DataConfig.class);

    private static final String CRAWLER_WEB_PREFIX = "crawler.web.";

    private static final String CRAWLER_WEB_HEADER_PREFIX = CRAWLER_WEB_PREFIX + "header.";

    private static final String CRAWLER_WEB_AUTH = CRAWLER_WEB_PREFIX + "auth";

    assertEquals(value, generator.generateFresh(type));
    assertEquals(value, generator.generateFresh(type));
  }

  private enum EmptyEnum {}

  private enum OneConstantEnum {
    CONSTANT1
  }

  private enum TwoConstantEnum {
    CONSTANT1,
    CONSTANT2
  }

  private static void assertCanGenerateOnly(TypeToken<?> type, Object expected) {
    FreshValueGenerator generator = new FreshValueGenerator();

import java.util.Date;

import jcifs.smb1.util.Hexdump;

class SmbComQueryInformationResponse extends ServerMessageBlock implements Info {

    private int fileAttributes = 0x0000;
    private long lastWriteTime = 0L;
    private final long serverTimeZoneOffset;
    private int fileSize = 0;

    SmbComQueryInformationResponse(final long serverTimeZoneOffset) {
        this.serverTimeZoneOffset = serverTimeZoneOffset;

import org.codelibs.fess.util.ComponentUtil;
import org.dbflute.optional.OptionalThing;

/**
 * An LDAP user.
 */
public class LdapUser implements FessUser {

    private static final long serialVersionUID = 1L;

    /** The environment for LDAP connection. */
    protected Hashtable<String, String> env;

    /** The name of the user. */
    protected String name;

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.dict;

import org.codelibs.fess.unit.UnitFessTestCase;

public class DictionaryItemTest extends UnitFessTestCase {

    private TestDictionaryItem dictionaryItem;

    @Override
    public void setUp() throws Exception {
        super.setUp();
        dictionaryItem = new TestDictionaryItem();
    }

  public static <E extends @Nullable Object> MinimalIterable<E> from(Collection<E> elements) {
    return (MinimalIterable) of(elements.toArray());
  }

  private @Nullable Iterator<E> iterator;

  private MinimalIterable(Iterator<E> iterator) {
    this.iterator = iterator;
  }

  @Override
  public Iterator<E> iterator() {
    if (iterator == null) {

  var username = ""
  var password: String? = null
  var host = ""
  var port = ""
  var path = ""
  var query = ""
  var fragment = ""

  fun expectParseFailure() = scheme.isEmpty()

  private operator fun set(
    name: String,
    value: String,
  ) {
    when (name) {
      "s" -> scheme = value
      "u" -> username = value
      "pass" -> password = value
      "h" -> host = value

 *
 * @author Louis Wasserman
 */
@GwtCompatible
abstract class AbstractSortedMultiset<E extends @Nullable Object> extends AbstractMultiset<E>
    implements SortedMultiset<E> {
  private final Comparator<? super E> comparator;

  // needed for serialization
  @SuppressWarnings("unchecked")
  AbstractSortedMultiset() {
    this((Comparator) Ordering.natural());
  }