assertEquals(0, result.size());
    }

    @Test
    public void test_buildQuery_emptyKeywords() {
        try {
            List<String> keywordList = Collections.emptyList();
            List<FilterFunctionBuilder> functionBuilders = new ArrayList<>();

            try {
                keyMatchHelper.buildQuery(keywordList, functionBuilders);
            } catch (Exception e) {

        try {
          for (int i = 0; i < iterations; i++) {
            try {
              Files.createDirectories(changingFile);
              Files.createFile(dirToDelete.resolve("j/k"));
            } catch (FileAlreadyExistsException expected) {
              // if a file already exists, that's fine... just continue
            }

            try {
              method.delete(dirToDelete);

    TestCloseable c1 = closer.register(TestCloseable.normal());
    TestCloseable c2 = closer.register(TestCloseable.normal());

    IOException exception = new IOException();

    try {
      try {
        throw exception;
      } catch (Throwable e) {
        throw closer.rethrow(e);
      } finally {
        closer.close();
      }
    } catch (Throwable caught) {

        try {
            ThreadDumpUtil.writeThreadDump(invalidPath);
            // Should not throw exception but log warning
        } catch (Exception e) {
            fail("writeThreadDump should handle invalid paths gracefully: " + e.getMessage());
        }
    }

    @Test
    public void test_writeThreadDump_withNullPath() {
        try {

        tempFile = File.createTempFile("test", ".tmp", Curl.tmpDir);

        // Write test content to file
        try (FileOutputStream fos = new FileOutputStream(tempFile)) {
            fos.write(testContent.getBytes("UTF-8"));
        }

        ContentCache cache = new ContentCache(tempFile);

        try (InputStream stream = cache.getInputStream()) {
            assertNotNull(stream);

    checkNotNull(e);
    Monitor monitor = this.monitor;
    monitor.enterWhen(notFull);
    try {
      insert(e);
    } finally {
      monitor.leave();
    }
  }

  @CanIgnoreReturnValue
  @Override
  public @Nullable E poll() {
    Monitor monitor = this.monitor;
    if (monitor.enterIf(notEmpty)) {
      try {
        return extract();
      } finally {
        monitor.leave();
      }

    TestCloseable c1 = closer.register(TestCloseable.normal());
    TestCloseable c2 = closer.register(TestCloseable.normal());

    IOException exception = new IOException();

    try {
      try {
        throw exception;
      } catch (Throwable e) {
        throw closer.rethrow(e);
      } finally {
        closer.close();
      }
    } catch (Throwable caught) {

        try {
          for (int i = 0; i < iterations; i++) {
            try {
              Files.createDirectories(changingFile);
              Files.createFile(dirToDelete.resolve("j/k"));
            } catch (FileAlreadyExistsException expected) {
              // if a file already exists, that's fine... just continue
            }

            try {
              method.delete(dirToDelete);

        String testKey = "test.property";
        String systemValue = "system-value";
        System.setProperty(Constants.FESS_CONFIG_PREFIX + testKey, systemValue);

        try {
            // Test that system property takes precedence
            String value = fessConfig.get(testKey);
            assertEquals(systemValue, value);
        } finally {
            // Clean up system property

        try {
            crawler.sendMail(infoMap);
        } catch (Exception e) {
            fail("Should not throw exception: " + e.getMessage());
        }
    }

    @Test
    public void test_sendMail_withEmptyInfoMap() {
        Map<String, String> infoMap = new HashMap<>();

        try {
            crawler.sendMail(infoMap);