if (server != null) {
                server.stop();
            }
        }
    }

    public void test_accessTimeout_null_safety() {
        // Test that accessTimeoutTask null check prevents NPE
        FtpClient client = new FtpClient() {
            @Override
            protected ResponseData getResponseData(final String uri, final boolean includeContent) {

   * endpoints are unordered and the graph is directed; it simply returns {@code false}. This is for
   * consistency with the behavior of {@link Collection#contains(Object)} (which does not generally
   * throw if the object cannot be present in the collection), and the desire to have this method's
   * behavior be compatible with {@code edges().contains(endpoints)}.
   *
   * @since 27.1
   */
  @Override

   * endpoints are unordered and the graph is directed; it simply returns {@code false}. This is for
   * consistency with the behavior of {@link Collection#contains(Object)} (which does not generally
   * throw if the object cannot be present in the collection), and the desire to have this method's
   * behavior be compatible with {@code edges().contains(endpoints)}.
   *
   * @since 27.1
   */
  @Override

          if (nanos == expirationNanos) { // recheck for lost race
            T t = delegate.get();
            value = t;
            nanos = now + durationNanos;
            // In the very unlikely event that nanos is 0, set it to 1;
            // no one will notice 1 ns of tardiness.
            expirationNanos = (nanos == 0) ? 1 : nanos;
            return t;
          }
        }
      }

        keyList.tail = node;
      }
    } else { // non-empty list, insert before nextSibling
      /*
       * requireNonNull is safe as long as callers pass a nextSibling that (a) has the same key and
       * (b) is present in the multimap. (And they do, except maybe in case of concurrent
       * modification, in which case all bets are off.)
       */
      KeyList<K, V> keyList = requireNonNull(keyToKeyList.get(key));
      keyList.count++;

   * GWT SortedMap implementation that we delegate to throws
   * NullPointerException if the comparator does. Since our construction
   * methods ensure that null is never present in the map, it's OK for the
   * comparator to look for it wherever it wants.
   *
   * Note that we do NOT touch the comparator returned by comparator(), which

        getFirstAddress();
        for (;;) {
            try {
                doConnect();
                return;
            } catch (final SmbAuthException sae) {
                throw sae; // Prevents account lockout on servers with multiple IPs
            } catch (final SmbException se) {
                if (getNextAddress() == null) {
                    throw se;
                }

the appropriateness of using or redistributing the Work and assume any risks 
associated with Your exercise of permissions under this License. 

8. Limitation of Liability. In no event and under no legal theory, whether 
in tort (including negligence), contract, or otherwise, unless required by 
applicable law (such as deliberate and grossly negligent acts) or agreed to 

     *     service is the origin of the stream. When zero, the origin is specified in the `origin`
     *     parameter.
     * @param origin when present, the [origin](http://tools.ietf.org/html/rfc6454) is typically
     *     represented as a combination of scheme, host and port. When empty, the origin is that of
     *     the `streamId`.

        addr = getCachedAddress(name);

        /*
         * This is almost exactly like InetAddress.java. See the
         * comments there for a description of how the LOOKUP_TABLE prevents
         * redundant queries from going out on the wire.
         */
        if ((addr == null) && ((addr = (NbtAddress) checkLookupTable(name)) == null)) {
            try {
                addr = getByName(name, svr);