* executor. The listener will have the corresponding transition method called whenever the
   * service changes state. The listener will not have previous state changes replayed, so it is
   * suggested that listeners are added before the service starts.
   *
   * <p>{@code addListener} guarantees execution ordering across calls to a given listener but not

    Map<K, V> delegate = Maps.newLinkedHashMap();
    for (Entry<? extends K, ? extends V> entry : entries) {
      K key = checkNotNull(entry.getKey());
      V previous = delegate.put(key, checkNotNull(entry.getValue()));
      if (throwIfDuplicateKeys && previous != null) {
        throw new IllegalArgumentException("duplicate key: " + key);
      }
    }
    this.delegate = Collections.unmodifiableMap(delegate);
  }

        @Override
        public Integer next(Integer value) {
          return integers().next(value);
        }

        @Override
        public Integer previous(Integer value) {
          return integers().previous(value);
        }

        @Override
        public long distance(Integer start, Integer end) {
          return integers().distance(start, end);
        }

        @Override

            java: 21
            root-pom: pom.xml
    runs-on: ${{ matrix.os }}
    env:
      ROOT_POM: ${{ matrix.root-pom }}
    steps:
      # Cancel any previous runs for the same branch that are still running.
      - name: 'Cancel previous runs'
        uses: styfle/cancel-workflow-action@85880fa0301c86cca9da44039ee3bb12d3bedbfa # 0.12.1
        with:
          access_token: ${{ github.token }}

        saveToken();
        return doSearch(form);
    }

    /**
     * Navigates to the previous page of search results.
     *
     * @param form the list form containing current search criteria
     * @return HTML response with previous page results
     */
    @Execute
    @Secured({ ROLE, ROLE + VIEW })
    public HtmlResponse prev(final ListForm form) {

    }

    @CanIgnoreReturnValue
    RoundToDoubleTester setExpectation(double expectedValue, RoundingMode... modes) {
      for (RoundingMode mode : modes) {
        Double previous = expectedValues.put(mode, expectedValue);
        if (previous != null) {
          throw new AssertionError();
        }
      }
      return this;
    }

    @CanIgnoreReturnValue
    RoundToDoubleTester roundUnnecessaryShouldThrow() {

     */
    public boolean isExistNextPage() {
        return existNextPage;
    }

    /**
     * Checks whether there is a previous page available.
     *
     * @return true if a previous page exists, false otherwise
     */
    public boolean isExistPrevPage() {
        return existPrevPage;
    }

    /**

</div>
<div class="row">
	<nav id="subfooter" class="mx-auto">
		<ul class="pagination justify-content-center">
			<c:if test="${existPrevPage}">
				<li class="page-item"><la:link styleClass="page-link" aria-label="Previous"
						href="/search/prev?q=${f:u(q)}&pn=${f:u(currentPageNumber)}&num=${f:u(pageSize)}&sdh=${f:u(fe:sdh(sdh))}${fe:pagingQuery(null)}${fe:facetQuery()}${fe:geoQuery()}">
						<span aria-hidden="true">&laquo;</span>

 * cannot do TLS over domain sockets.
 */
public class ClientAndServer {
  public void run() throws Exception {
    File socketFile = new File("/tmp/ClientAndServer.sock");
    socketFile.delete(); // Clean up from previous runs.

    MockWebServer server = new MockWebServer();
    server.setServerSocketFactory(new UnixDomainServerSocketFactory(socketFile));
    server.setProtocols(Collections.singletonList(Protocol.H2_PRIOR_KNOWLEDGE));

        });
    return holder.get();
  }

  /**
   * Updates the value currently associated with {@code key} by combining it with {@code x} via the
   * specified accumulator function, returning the new value. The previous value associated with
   * {@code key} (or zero, if there is none) is passed as the first argument to {@code
   * accumulatorFunction}, and {@code x} is passed as the second argument.
   *
   * @since 21.0
   */