public class IntsTest extends TestCase {
  private static final int[] EMPTY = {};
  private static final int[] ARRAY1 = {(int) 1};
  private static final int[] ARRAY234 = {(int) 2, (int) 3, (int) 4};

  private static final int LEAST = Integer.MIN_VALUE;
  private static final int GREATEST = Integer.MAX_VALUE;

  private static final int[] VALUES = {LEAST, (int) -1, (int) 0, (int) 1, GREATEST};

  val platform: PlatformRule = PlatformRule()

  @RegisterExtension
  val clientTestRule: OkHttpClientTestRule = OkHttpClientTestRule()

  @StartStop
  private val server = MockWebServer()

  private val handshakeCertificates = platform.localhostHandshakeCertificates()
  private var client: OkHttpClient = clientTestRule.newClient()

  @Test
  fun connectionsAreReused() {
    server.enqueue(MockResponse(body = "a"))

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());
  }

 * information about all available shares on the target server.
 */
public class NetShareEnumResponse extends SmbComTransactionResponse {

    private static final Logger log = LoggerFactory.getLogger(NetShareEnumResponse.class);

    private int converter, totalAvailableEntries;

    /**
     * Constructs a NetShareEnumResponse
     * @param config
     *            the configuration to use
     */

 * DFS referral information for distributed file system path resolution.
 */
public class Trans2GetDfsReferral extends SmbComTransaction {

    private final int maxReferralLevel;

    private final DfsReferralRequestBuffer request;

    /**
     * Constructs a Trans2GetDfsReferral request with default referral level.
     *
     * @param config the configuration to use

    if (localTask != null) {
      return "task=[" + localTask + "]";
    }
    return super.pendingToString();
  }

  @WeakOuter
  private final class TrustedFutureInterruptibleTask extends InterruptibleTask<V> {
    private final Callable<V> callable;

    TrustedFutureInterruptibleTask(Callable<V> callable) {
      this.callable = checkNotNull(callable);
    }

    @Override