/**
 * A connection user that is a specific [RealCall].
 */
internal class CallConnectionUser(
  private val call: RealCall,
  private val poolConnectionListener: ConnectionListener,
  private val chain: RealInterceptorChain,
) : ConnectionUser {
  private val eventListener: EventListener
    get() = call.eventListener

  override fun addPlanToCancel(connectPlan: ConnectPlan) {

public class FlexiblePorterStemFilterFactory extends AbstractTokenFilterFactory {

    private final boolean step1;

    private final boolean step2;

    private final boolean step3;

    private final boolean step4;

    private final boolean step5;

    private final boolean step6;

        private Boolean explain;

        private Float minScore;

        private String preference;

        private String routing;

        private String searchType;

        private long timeoutInMillis = -1;

        private Boolean version;

        private Boolean seqNoAndPrimaryTerm = Boolean.TRUE;

        private int terminateAfter = 0;

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

    private boolean smb2 = false;
    private InetAddress localAddr;
    private int localPort;
    private Address address;
    private Socket socket;
    private int port;
    private final AtomicLong mid = new AtomicLong();
    private OutputStream out;
    private InputStream in;

 * 4. Launch wireshark if not done externally `val process = eventListenerFactory.launchWireShark()`
 */
@SuppressSignatureCheck
class WireSharkListenerFactory(
  private val logFile: File,
  private val tlsVersions: List<TlsVersion>,
  private val launch: Launch? = null,
) : EventListener.Factory {
  override fun create(call: Call): EventListener {
    return WireSharkKeyLoggerListener(logFile, launch == null)
  }

    }
  }

  public static class BiMapValueSetGenerator<K extends @Nullable Object, V extends @Nullable Object>
      implements TestSetGenerator<V>, DerivedGenerator {
    private final OneSizeTestContainerGenerator<BiMap<K, V>, Entry<K, V>> mapGenerator;
    private final SampleElements<V> samples;

    public BiMapValueSetGenerator(
        OneSizeTestContainerGenerator<BiMap<K, V>, Entry<K, V>> mapGenerator) {

 *
 */
public abstract class ServerMessageBlock2Response extends ServerMessageBlock2 implements CommonServerMessageBlockResponse {

    private boolean received;
    private boolean error;
    private Long expiration;

    private boolean verifyFailed;
    private Exception exception;
    private boolean asyncHandled;


    /**
     * @param config
     * @param command
     */

 */

public abstract class NtlmServlet extends HttpServlet {

    private String defaultDomain;

    private String domainController;

    private boolean loadBalance;

    private boolean enableBasic;

    private boolean insecureBasic;

    private String realm;

    public void init(ServletConfig config) throws ServletException {
        super.init(config);

import jcifs.smb.SmbFile;


/**
 * @author mbechler
 *
 */
@SuppressWarnings ( "javadoc" )
public abstract class BaseCIFSTest {

    private Map<String, String> properties;
    private CIFSContext context;
    private Random rand = new Random();
    private String name;


    protected BaseCIFSTest ( String name, Map<String, String> properties ) {
        this.name = name;
        this.properties = properties;

        return new DefaultAlias(v3Phase, v4Phase);
    }

    static class DefaultPhase implements Lifecycle.Phase {
        private final String name;
        private final List<Plugin> plugins;
        private final Collection<Lifecycle.Link> links;
        private final List<Lifecycle.Phase> phases;

        DefaultPhase(