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

 * @author Darick Tong
 */
@NullUnmarked
public class CycleDetectingLockFactoryBenchmark {

  @Param({"2", "3", "4", "5", "10"})
  int lockNestingDepth;

  CycleDetectingLockFactory factory;
  private Lock[] plainLocks;
  private Lock[] detectingLocks;

  @BeforeExperiment
  void setUp() throws Exception {
    this.factory = CycleDetectingLockFactory.newInstance(CycleDetectingLockFactory.Policies.WARN);

 */

package jcifs.smb1.smb1;

import java.io.IOException;

class TransactNamedPipeOutputStream extends SmbFileOutputStream {

    private final String path;
    private final SmbNamedPipe pipe;
    private final byte[] tmp = new byte[1];
    private final boolean dcePipe;

    TransactNamedPipeOutputStream(final SmbNamedPipe pipe) throws IOException {

    /**
     * Creates a new witness register request.
     */
    public WitnessRegisterRequest() {
        // Default constructor
    }

    private int version;
    private String shareName;
    private String serverAddress;
    private int flags;

    /**
     * Gets the witness protocol version.
     *
     * @return the protocol version
     */
    public int getVersion() {

  }

  private static ClassInfo classInfo(Class<?> cls) {
    return classInfo(cls, cls.getClassLoader());
  }

  private static ClassInfo classInfo(Class<?> cls, ClassLoader classLoader) {
    String resource = cls.getName().replace('.', '/') + ".class";
    return new ClassInfo(FILE, resource, classLoader);
  }

    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