assertEquals(facetResponse, searchRenderData.getFacetResponse());
        assertNotNull(facetResponse.getQueryCountMap());
        assertTrue(facetResponse.getQueryCountMap().isEmpty());
    }

    public void test_setAndGetAppendHighlightParams() {
        // Test with null
        searchRenderData.setAppendHighlightParams(null);
        assertNull(searchRenderData.getAppendHighlightParams());

        RenderDataUtil.register(data, "displayCreateLink", !crawlingConfigHelper.getAllWebConfigList(false, false, false, null).isEmpty());
        // restore from pager
        copyBeanToBean(webAuthPager, form, op -> op.include("id"));
    }

    // ===================================================================================

         */
        @Nonnull
        public DependencyResolverRequestBuilder dependency(@Nullable DependencyCoordinates dependency) {
            if (dependency != null) {
                if (this.dependencies.isEmpty()) {
                    this.dependencies = new ArrayList<>();
                }
                this.dependencies.add(dependency);
            }
            return this;
        }

        /**

     */
    public void crawl(final String sessionId) {
        final List<DataConfig> configList = ComponentUtil.getCrawlingConfigHelper().getAllDataConfigList();

        if (configList.isEmpty()) {
            // nothing
            if (logger.isInfoEnabled()) {
                logger.info("No crawling target data.");
            }
            return;
        }

    assume().that(network.allowsSelfLoops()).isTrue();

    addNode(N1);
    addEdge(N1, N1, E11);
    assertThat(networkAsMutableNetwork.removeNode(N1)).isTrue();
    assertThat(network.nodes()).isEmpty();
    assertThat(network.edges()).doesNotContain(E11);
  }

  @Test
  public void removeEdge_existingSelfLoopEdge() {
    assume().that(graphIsMutable()).isTrue();

    assertThat(subset).containsExactly("b", "c", "d", "e").inOrder();

    subset.clear();
    assertThat(elementSet).containsExactly("a", "f").inOrder();
    assertThat(subset).isEmpty();
    assertEquals(3, ms.size());
  }

  public void testCustomComparator() throws Exception {
    Comparator<String> comparator =
        new Comparator<String>() {
          @Override

        result.get(10, SECONDS);
      }
      // TODO(cpovirk): Verify that the cancelled futures are exactly ones that we expect.
    }

    assertThat(logHandler.getStoredLogRecords()).isEmpty();
  }

  public void testAvoidsStackOverflow_manySubmitted() throws Exception {
    SettableFuture<@Nullable Void> settableFuture = SettableFuture.create();

        directoryLeaseManager.handleDirectoryChange(directoryPath, "", DirectoryChangeNotifier.DirectoryChangeType.DIRECTORY_RENAMED);
        assertFalse(entry.isComplete());
        assertTrue(entry.getChildren().isEmpty());
    }

    @Test
    public void testHandleDirectoryLeaseBreak() {
        String directoryPath = "/test/dir";
        Smb2LeaseKey leaseKey = new Smb2LeaseKey();

        // Create cache entry

                    buf.append('&');
                } else {
                    buf.append('?');
                }
                buf.append(loginReqParams);
                if (!responseParams.isEmpty()) {
                    buf.append('&');
                    responseParams.stream().forEach(p -> {
                        try {
                            buf.append(URLEncoder.encode(p.getFirst(), encoding));

      }
    }
  }

  @Throws(UnknownHostException::class)
  private fun throwBestFailure(
    hostname: String,
    failures: List<Exception>,
  ): List<InetAddress> {
    if (failures.isEmpty()) {
      throw UnknownHostException(hostname)
    }

    val failure = failures[0]

    if (failure is UnknownHostException) {
      throw failure
    }