}

  @J2ktIncompatible
  @GwtIncompatible // NullPointerTester
  public void testNullPointers() {
    /*
     * Don't bother testing: Preconditions defines a bunch of methods that accept a template (or
     * even entire message) that simultaneously:
     *
     * - _shouldn't_ be null, so we don't annotate it with @Nullable
     *

#### client-go:

                resp.setContentType( mimeMap.getMimeType( type ));
            }
            resp.setHeader( "Content-Length", file.length() + "" );
            resp.setHeader( "Accept-Ranges", "Bytes" );

            while(( n = in.read( buf )) != -1 ) {
                out.write( buf, 0, n );
            }
        }
        // TODO catch IOException
    }

   * @throws IllegalArgumentException if {@code duration} is negative
   * @throws IllegalStateException if {@link #expireAfterWrite} was already set
   */
  @SuppressWarnings("GoodTime") // should accept a Duration
  @CanIgnoreReturnValue
  public CacheBuilder<K, V> expireAfterWrite(long duration, TimeUnit unit) {
    checkState(
        expireAfterWriteNanos == UNSET_INT,

   * Number value = first.or(0.5); // fine
   * }</pre>
   *
   * <p><b>Comparison to {@code java.util.Optional}:</b> this method is similar to Java 8's {@code
   * Optional.orElse}, but will not accept {@code null} as a {@code defaultValue} ({@link #orNull}
   * must be used instead). As a result, the value returned by this method is guaranteed non-null,
   * which is not the case for the {@code java.util} equivalent.
   */

   * Preconditions.checkNotNull.
   *
   * (verifyNotNull has many fewer "problem" callers, so we could try to be stricter. On the other
   * hand, verifyNotNull arguably has more reason to accept nullable arguments in the first
   * place....)
   */

  /**
   * Ensures that {@code reference} is non-null, throwing a {@code VerifyException} with a default
   * message otherwise.
   *

                    final BiConsumer<Map<String, Object>, IndexRequestBuilder> options) {
                sentIndex.set(index);
                docList.forEach(x -> options.accept(x, new IndexRequestBuilder(this, IndexAction.INSTANCE)));
                sentDocList.addAll(docList);
                return new BulkResponse(new BulkItemResponse[0], documentSizeByQuery);
            }

            resp.setContentType("text/plain");
            resp.setContentType(URLConnection.guessContentTypeFromName(url));
            resp.setHeader("Content-Length", file.length() + "");
            resp.setHeader("Accept-Ranges", "Bytes");

            while ( ( n = in.read(buf) ) != -1 ) {
                out.write(buf, 0, n);
            }
        }
    }

api.access.token.length=60
api.access.token.required=false
api.access.token.request.parameter=
api.admin.access.permissions=Radmin-api
api.search.accept.referers=
api.search.scroll=false
api.json.response.headers=
api.json.response.exception.included=false
api.gsa.response.headers=
api.gsa.response.exception.included=false
api.dashboard.response.headers=

      }

      @Override
      public void forEach(Consumer<? super Entry<K, V>> action) {
        checkNotNull(action);
        for (Node<K, V> node = head; node != null; node = node.next) {
          action.accept(node);
        }
      }
    }
    return new EntriesImpl();
  }

  @Override
  Iterator<Entry<K, V>> entryIterator() {
    throw new AssertionError("should never be called");
  }