JobNotFoundException exception = new JobNotFoundException("Fill stack trace test");

        Throwable filled = exception.fillInStackTrace();

        assertNotNull(filled);
        assertEquals(exception, filled);
        assertNotNull(filled.getStackTrace());
        assertTrue(filled.getStackTrace().length > 0);
    }

    public void test_getMessage_consistency() {

   * initial write to timer is never definitely visible to Fire.run since it is assigned after
   * SES.schedule is called. Therefore Fire.run has to check for null. However, it should be visible
   * if Fire.run is called by delegate.addListener since addListener is called after the assignment
   * to timer, and importantly this is the main situation in which we need to be able to see the
   * write.
   *

    }

    public void u(U u) {
      fail(
          "Method with parameter <U extends T> where <T extends @Nullable Object> should not be"
              + " called");
    }

    public <A extends @Nullable Object> void a(A a) {
      fail("Method with parameter <A extends @Nullable Object> should not be called");
    }

          private boolean called = false;

          @Override
          public void onSuccess(String result) {
            fail("Was not expecting onSuccess() to be called.");
          }

          @Override
          public void onFailure(Throwable t) {
            synchronized (monitor) {
              assertFalse(called);
              assertThat(t).isInstanceOf(CancellationException.class);

        } catch (IllegalArgumentException e) {
            // Expected exception for empty field name
            assertTrue(e.getMessage().contains("field name is null or empty"));
        }

        // Assert deleteByQuery was NOT called due to exception in query building
        assertFalse(deleteByQueryCalled);
    }

    public void test_execute_withOutOfMemoryError() {

   * <p>This method should return promptly; prefer to do work on a different thread where it is
   * convenient. It is invoked exactly once on service shutdown, even when {@link #stopAsync} is
   * called multiple times.
   *
   * <p>If {@link #stopAsync} is called on a {@link State#STARTING} service, this method is not
   * invoked immediately. Instead, it will be deferred until after the service is {@link

        DataStoreException exception = new DataStoreException("Stack trace test");
        Throwable filled = exception.fillInStackTrace();

        assertNotNull(filled);
        assertEquals(exception, filled);
        assertNotNull(filled.getStackTrace());
        assertTrue(filled.getStackTrace().length > 0);
    }

     * allowing the CAS below to succeed.
     */
    Thread currentThread = Thread.currentThread();
    if (!compareAndSet(null, currentThread)) {
      return; // someone else has run or is running.
    }

    boolean run = !isDone();
    T result = null;
    Throwable error = null;
    try {
      if (run) {
        result = runInterruptibly();

        // Execute
        String result = purgeLogJob.execute();

        // Assert crawling info and status update were called
        assertTrue(deleteCrawlingInfoCalled[0]);
        assertTrue(updateJobLogStatusCalled[0]);

        // Assert other services were not called
        assertFalse(deleteSearchLogCalled[0]);
        assertFalse(deleteJobLogCalled[0]);
        assertFalse(deleteUserInfoCalled[0]);

            }

            @Override
            public jakarta.servlet.ServletConnection getServletConnection() {
                return null;
            }

            @Override
            public String getAuthType() {
                return null;
            }

            @Override
            public jakarta.servlet.http.Cookie[] getCookies() {
                return null;