* @return HTML response for the duplicate host list page with cleared search
     */
    @Execute
    @Secured({ ROLE, ROLE + VIEW })
    public HtmlResponse reset(final SearchForm form) {
        duplicateHostPager.clear();
        return asHtml(path_AdminDuplicatehost_AdminDuplicatehostJsp).renderWith(data -> {
            searchPaging(data, form);
        });
    }

    /**
     * Sets up search pagination data for rendering.

    assertEquals("4", map.get("d"));

    underlying.remove("c");
    assertEquals(underlying.size(), map.size());
    assertFalse(map.containsKey("c"));

    underlying.clear();
    assertEquals(underlying.size(), map.size());
  }

  public void testTransformChangesAreReflectedInUnderlyingMap() {
    Map<String, Integer> underlying = new LinkedHashMap<>();
    underlying.put("a", 1);

     * @param form The search form.
     * @return The HTML response.
     */
    @Execute
    @Secured({ ROLE, ROLE + VIEW })
    public HtmlResponse reset(final SearchForm form) {
        badWordPager.clear();
        return asHtml(path_AdminBadword_AdminBadwordJsp).renderWith(data -> {
            searchPaging(data, form);
        });
    }

    /**
     * Search with paging.

          if (!isRecoverable) throw e.withSuppressed(recoveredFailures)
          recoveredFailures += e
          newRoutePlanner = false
          continue
        }

        // Clear out downstream interceptor's additional request headers, cookies, etc.
        response =
          response
            .newBuilder()
            .request(request)
            .priorResponse(priorResponse?.stripBody())

{* ../../docs_src/dependencies/tutorial011_an_py39.py hl[22] *}

/// tip

All this might seem contrived. And it might not be very clear how is it useful yet.

These examples are intentionally simple, but show how it all works.

In the chapters about security, there are utility functions that are implemented in this same way.

        if (executorIsShutdown) {
          return@synchronized Effects(
            callsToExecute =
              readyAsyncCalls
                .toList()
                .also { readyAsyncCalls.clear() },
            idleCallbackToRun = idleCallbackToRun,
          )
        }

        val callsToExecute = mutableListOf<AsyncCall>()
        val i = readyAsyncCalls.iterator()
        while (i.hasNext()) {

        .contains(Maps.immutableEntry("foo", (Collection<Integer>) singleton(1)));
    multimapView.clear();
    assertFalse(multimapView.containsKey("foo"));
    assertFalse(map.containsKey("foo"));
    assertTrue(map.isEmpty());
    assertTrue(multimapView.isEmpty());
    multimap.clear();
    assertEquals(multimap.toString(), multimapView.toString());
    assertEquals(multimap.hashCode(), multimapView.hashCode());

            assertEquals(ServerMessageBlock2.SMB2_FLAGS_SIGNED | ServerMessageBlock2.SMB2_FLAGS_DFS_OPERATIONS, testMessage.getFlags());
        }

        @Test
        @DisplayName("Should clear flags correctly")
        void testClearFlags() {
            testMessage.addFlags(ServerMessageBlock2.SMB2_FLAGS_SIGNED | ServerMessageBlock2.SMB2_FLAGS_DFS_OPERATIONS);

                entity.setCreatedBy(Constants.SYSTEM_USER);
                entity.setCreatedTime(systemHelper.getCurrentTimeAsLong());
                list.add(entity);
            }
        });
        taskList.clear();
        if (logger.isDebugEnabled()) {
            logger.debug("Storing {} thumbnail tasks.", list.size());
        }
        final ThumbnailQueueBhv thumbnailQueueBhv = ComponentUtil.getComponent(ThumbnailQueueBhv.class);

         * that this will suffice. I have not even benchmarked with different size limits.
         */
        if (validClasses.size() > 1000) {
          validClasses.clear();
        }

        validClasses.add(new WeakReference<Class<? extends Exception>>(exceptionClass));
      }
    }

    /**