map.put("lastModified", new Date(Files.getLastModifiedTime(filePath).toMillis()));
                    } catch (final IOException e) {
                        throw new IORuntimeException(e);
                    }
                    logFileItems.add(map);
                });
            } catch (final Exception e) {
                throw new FessSystemException("Failed to access log files: logFilePath=" + logFilePath, e);

                    logger.warn("Failed to send {} to {}. HTTP Status is {}. {}", body, url, response.getHttpStatusCode(),
                            response.getContentAsString());
                }
            } catch (final IOException e) {
                logger.warn("Failed to send {} to {}.", body, url, e);
            }
        }));
    }

    /**
     * Converts the discloser to a Slack message format.
     *

        // This will return false because getFessConfig() will fail
        // We verify the method handles the case gracefully
        try {
            emptyGenerator.isTarget(docMap);
        } catch (IllegalStateException e) {
            // Expected when container is not initialized
            assertTrue(e.getMessage().contains("Not initialized"));
        }
    }

    @Test
    public void test_getName() {

        String expectedMessage = "Job execution failed";
        boolean exceptionCaught = false;

        try {
            throw new ScheduledJobException(expectedMessage);
        } catch (ScheduledJobException e) {
            exceptionCaught = true;
            assertEquals(expectedMessage, e.getMessage());
        }

        assertTrue(exceptionCaught);
    }

    @Test

        // Test throwing and catching the exception
        String expectedMessage = "Storage failure";

        try {
            throw new StorageException(expectedMessage);
        } catch (StorageException e) {
            assertEquals(expectedMessage, e.getMessage());
            assertNull(e.getCause());
        }
    }

    @Test
    public void test_throwAndCatchExceptionWithCause() {

      fail("Expected NullPointerException or UnsupportedOperationException");
    } catch (NullPointerException | UnsupportedOperationException expected) {
    }
  }

  public void testMergeNullFunction() {
    try {
      getMap().merge(k0(), v3(), null);
      fail("Expected NullPointerException or UnsupportedOperationException");
    } catch (NullPointerException | UnsupportedOperationException expected) {
    }
  }

            () -> {
              enterLatch.countDown();
              try {
                new CountDownLatch(1).await(); // wait forever
                throw new AssertionError();
              } catch (InterruptedException e) {
                interruptedExceptionThrown.set(true);
                throw e;
              } finally {
              }
            });
    assertFalse(task.isDone());
    Thread thread =

        getDuplicateHost(form).ifPresent(entity -> {
            try {
                duplicateHostService.store(entity);
                saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationError(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)),

                try {
                    projectState.verifyTestFilesCleanup(projectPath, projectPathToLeftoverFiles.getValue(projectPath))
                } catch (e: Exception) {
                    exceptions.add(e)
                }
            }

        when {
            exceptions.size == 1 -> throw exceptions.first()

              return task.toString();
            }
          };
      queue.add(submittedTask);
      workerRunningState = QUEUING;
    }

    try {
      executor.execute(worker);
    } catch (Throwable t) {
      // Any Exception is either a RuntimeException or sneaky checked exception.
      synchronized (queue) {
        boolean removed =
            (workerRunningState == IDLE || workerRunningState == QUEUING)