if (file != null) {
                            return file;
                        }
                    }
                } catch (final Exception e) {
                    final String filePath = fileMap.get("path") != null ? fileMap.get("path").toString() : "unknown";

     * @param path      The file path of the dictionary.
     * @param timestamp The last modified timestamp of the file.
     * @return A new {@link SynonymFile} associated with the dictionary manager.
     */
    @Override
    protected DictionaryFile<? extends DictionaryItem> newDictionaryFile(final String id, final String path, final Date timestamp) {

  private final CountDownLatch latch;

  public ListenableFutureTester(ListenableFuture<?> future) {
    this.exec = newCachedThreadPool();
    this.future = checkNotNull(future);
    this.latch = new CountDownLatch(1);
  }

  public void setUp() {
    future.addListener(
        new Runnable() {
          @Override
          public void run() {
            latch.countDown();
          }
        },

			// - mount.Path doesn't match (means cross-device mount), should error out.
			if mount.Path != path {
				crossMounts = append(crossMounts, mount)
			}
		}
	}
	msg := `Cross-device mounts detected on path (%s) at following locations %s. Export path should not have any sub-mounts, refusing to start.`
	if len(crossMounts) > 0 {
		// if paths didn't match then we do have cross-device mount.
		return fmt.Errorf(msg, path, crossMounts)
	}

    /**
     * Creates a file with the specified path, handling directory creation and duplicate names.
     *
     * @param path the file path to create
     * @return the created file
     * @throws CrawlerSystemException if directory creation fails
     */
    protected File createFile(final String path) {
        final String[] paths = path.split("/");
        File targetFile = baseDir;

        // Execute and verify
        CIFSException thrown = assertThrows(CIFSException.class, () -> {
            watchHandle.watch();
        });

        assertEquals("Watch operation failed", thrown.getMessage());
        verify(watchHandle, times(1)).watch();
    }

    /**
     * Test call() method delegates to watch()
     */
    @Test

        this.recursive = recursive;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbWatchHandle#watch()
     */
    @Override
    public List<FileNotifyInformation> watch() throws CIFSException {
        if (!this.handle.isValid()) {
            throw new SmbException("Watch was broken by tree disconnect");
        }
        try (SmbTreeHandleImpl th = this.handle.getTree()) {

    assertThat(reader.readLine()).isEqualTo("hello world")
    val request = server.takeRequest()
    assertThat(request.requestLine).isEqualTo(
      "GET /a/deep/path?key=foo%20bar HTTP/1.1",
    )
    assertThat(request.path).isEqualTo("/a/deep/path?key=foo%20bar")
    val requestUrl = request.requestUrl
    assertThat(requestUrl!!.scheme).isEqualTo("http")
    assertThat(requestUrl.host).isEqualTo(server.hostName)

        RobotsTxt robotsTxt = new RobotsTxt();

        // Should return true when no directives match
        assertTrue(robotsTxt.allows("/path", "MyBot"));
        assertTrue(robotsTxt.allows("/admin", "GoogleBot"));
    }

    public void test_allowsWithAllowedPath() {
        // Test allows method with allowed path
        RobotsTxt robotsTxt = new RobotsTxt();

        Directive directive = new Directive("MyBot");

                    final Path fessJsonPath = getFessJsonPath();
                    try (final InputStream in = Files.newInputStream(fessJsonPath)) {
                        out.write(in);
                    }
                });
            } else if ("doc.json".equals(id)) {
                return asStream(id).contentTypeOctetStream().stream(out -> {
                    final Path fessJsonPath = getDocJsonPath();