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));

        } else {
            fileConfigList = Collections.emptyList();
        }

        if (webConfigList.isEmpty() && fileConfigList.isEmpty()) {
            // nothing
            if (logger.isInfoEnabled()) {
                logger.info("No crawling target urls.");
            }
            return;
        }

    public void test_robotsTxtUrlSet() {
        Set<String> urlSet = crawlerContext.getRobotsTxtUrlSet();
        assertNotNull(urlSet);
        assertTrue(urlSet instanceof LruHashSet);
        assertTrue(urlSet.isEmpty());

        // Add URLs to default set
        urlSet.add("http://example.com/robots.txt");
        urlSet.add("http://test.com/robots.txt");
        assertEquals(2, crawlerContext.getRobotsTxtUrlSet().size());

    if (address.size == 4) return inet4AddressToAscii(address) // An IPv4-mapped IPv6 address.
    throw AssertionError("Invalid IPv6 address: '$host'")
  }

  val result = idnToAscii(host) ?: return null
  if (result.isEmpty()) return null
  if (result.containsInvalidHostnameAsciiCodes()) return null
  if (result.containsInvalidLabelLengths()) return null

  return result
}

internal fun idnToAscii(host: String): String? {

                        }
                    }
                }

                wordsList.add(word);
                readingList.add(l.toArray(new String[l.size()]));
            }
            if (wordsList.isEmpty()) {
                return null;
            }
            return new SuggestItem(wordsList.toArray(new String[wordsList.size()]), readingList.toArray(new String[readingList.size()][]),

  }

  internal fun check(
    hostname: String,
    cleanedPeerCertificatesFn: () -> List<X509Certificate>,
  ) {
    val pins = findMatchingPins(hostname)
    if (pins.isEmpty()) return

    val peerCertificates = cleanedPeerCertificatesFn()

    for (peerCertificate in peerCertificates) {
      // Lazily compute the hashes for each certificate.
      var sha1: ByteString? = null

    }

    private NetworkInterfaceInfo selectLocalInterface(int index) {
        if (localInterfaces.isEmpty())
            return null;
        return localInterfaces.get(index % localInterfaces.size());
    }

    private NetworkInterfaceInfo selectRemoteInterface(int index) {
        if (remoteInterfaces.isEmpty())
            return null;
        return remoteInterfaces.get(index % remoteInterfaces.size());
    }

     */
    public static void loadConfigParams(final Map<String, Object> paramMap, final String configParam) {
        final Map<String, String> map = ParameterUtil.parse(configParam);
        if (!map.isEmpty()) {
            paramMap.putAll(map);
        }
    }

    /**
     * Creates a configuration parameter map.
     *
     * @param configParameters the configuration parameters

    assertThat(min((byte) 0, (byte) -128, (byte) -1, (byte) 127, (byte) 1)).isEqualTo((byte) -128);
  }

  public void testJoin() {
    assertThat(SignedBytes.join(",", EMPTY)).isEmpty();
    assertThat(SignedBytes.join(",", ARRAY1)).isEqualTo("1");
    assertThat(SignedBytes.join(",", (byte) 1, (byte) 2)).isEqualTo("1,2");
    assertThat(SignedBytes.join("", (byte) 1, (byte) 2, (byte) 3)).isEqualTo("123");