public NavigableSet<E> subSet(
      @ParametricNullness E fromElement,
      boolean fromInclusive,
      @ParametricNullness E toElement,
      boolean toInclusive) {
    return delegate().subSet(fromElement, fromInclusive, toElement, toInclusive);
  }

  /**
   * A sensible definition of {@link #subSet(Object, boolean, Object, boolean)} in terms of the

  private static final boolean useSecurityManager = Boolean.getBoolean("jsr166.useSecurityManager");

  protected static final boolean expensiveTests = Boolean.getBoolean("jsr166.expensiveTests");

  /**
   * If true, report on stdout all "slow" tests, that is, ones that take more than profileThreshold
   * milliseconds to execute.
   */

        }
        return false;
    }

    /**
     * Class definition
     */
    private final boolean errors;

    private final T value;

    private final Iterable<? extends ModelProblem> problems;

    private Result(boolean errors, T model, Iterable<? extends ModelProblem> problems) {
        this.errors = errors;
        this.value = model;
        this.problems = problems;
    }

        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;

  val npnProtocols: List<String>,
  val platform: String?,
  val requiresSha2: Boolean,
  val signatureAlgorithms: List<Int>,
  val suiteIds: List<Int>,
  val suiteNames: List<String>,
  val supportsCompression: Boolean,
  val supportsNpn: Boolean,
  val supportsRi: Boolean,
  val supportsSni: Boolean,
  val supportsStapling: Boolean,
  val supportsTickets: Boolean,
  val userAgent: String?,
  val version: String,

    }

  var protocolNegotiationEnabled: Boolean by delegate::protocolNegotiationEnabled

  @get:JvmName("protocols")
  var protocols: List<Protocol>
    get() = delegate.protocols
    set(value) {
      delegate.protocols = value
    }

  init {
    delegate.dispatcher = dispatcher.wrap()
  }

  private var started: Boolean = false

  @Synchronized override fun before() {

    private int fid, createAction, extFileAttributes, fileType, deviceState;
    private long creationTime, lastAccessTime, lastWriteTime, changeTime, allocationSize, endOfFile;
    private boolean directory;
    private boolean isExtended;


    /**
     * 
     * @param config
     */
    public SmbComNTCreateAndXResponse ( Configuration config ) {
        super(config);
    }


    /**

    private boolean determineNameMatch(String expectedName, String actualName) {
        String test = expectedName.toLowerCase(Locale.ENGLISH);
        boolean reverse = false;

        if (test.startsWith("!")) {
            reverse = true;
            test = test.substring(1);
        }

        boolean result = actualName.equals(test);

        return reverse != result;
    }

        return this.nativeFileSystem;
    }


    /**
     * @return the supportSearchBits
     */
    public final boolean isSupportSearchBits () {
        return this.supportSearchBits;
    }


    /**
     * @return the shareIsInDfs
     */
    @Override
    public final boolean isShareDfs () {
        return this.shareIsInDfs;
    }


    /**
     * {@inheritDoc}
     *

      @JvmStatic
      fun isAlpnBootEnabled(): Boolean =
        try {
          Class.forName("org.eclipse.jetty.alpn.ALPN", true, null)
          true
        } catch (cnfe: ClassNotFoundException) {
          false
        }

      val isCorrettoSupported: Boolean =
        try {