*     State#TERMINATED TERMINATED}.
     */
    public void terminated(State from) {}

    /**
     * Called when the service transitions to the {@linkplain State#FAILED FAILED} state. The
     * {@linkplain State#FAILED FAILED} state is a terminal state in the transition diagram.
     * Therefore, if this method is called, no other methods will be called on the {@link Listener}.

       *   cause if this Future has failed.
       *
       * - And this future *has* failed: This method is called only from handleException (through
       *   getOrInitSeenExceptions). handleException tried to call setException and failed, so
       *   either this Future was cancelled (which we ruled out with the isCancelled check above),
       *   or it had already failed. (It couldn't have completed *successfully* or even had

      new Runnable() {
        @Override
        public void run() {}
      };

  boolean called = false;

  private void assertSingleCallWithCorrectParameters(
      Runnable command, long initialDelay, long delay, TimeUnit unit) {
    assertFalse(called); // only called once.
    called = true;
    assertEquals(INITIAL_DELAY, initialDelay);
    assertEquals(DELAY, delay);
    assertEquals(UNIT, unit);

      new Runnable() {
        @Override
        public void run() {}
      };

  boolean called = false;

  private void assertSingleCallWithCorrectParameters(
      Runnable command, long initialDelay, long delay, TimeUnit unit) {
    assertFalse(called); // only called once.
    called = true;
    assertEquals(INITIAL_DELAY, initialDelay);
    assertEquals(DELAY, delay);
    assertEquals(UNIT, unit);

		callMethod(db, func(value interface{}, tx *gorm.DB) (called bool) {
			if db.Statement.Schema.BeforeSave {
				if i, ok := value.(BeforeSaveInterface); ok {
					called = true
					db.AddError(i.BeforeSave(tx))
				}
			}

			if db.Statement.Schema.BeforeCreate {
				if i, ok := value.(BeforeCreateInterface); ok {
					called = true
					db.AddError(i.BeforeCreate(tx))
				}
			}
			return called

    }

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

        assertEquals("TESTHOST<00>/192.168.1.1", nbtAddress.toString());
    }

    // Tests for methods that call checkData(CIFSContext tc)
    @Test
    void testIsGroupAddress_CheckDataCalled() throws UnknownHostException {
        // Test isGroupAddress when checkData is called (hostName is unknown)
        when(mockContext.getNameServiceClient()).thenReturn(mockNameServiceClient);

                throw new RuntimeException("Delete operation failed");
            }
        };
        ComponentUtil.register(searchEngineClient, "searchEngineClient");

        // Execute the job
        String result = purgeDocJob.execute();

        // Assert error message is in the result
        assertTrue(result.contains("Delete operation failed"));
        assertTrue(result.endsWith("\n"));
    }

     * InterruptedException caught above) can linger and affect listeners.
     */
  }

  /**
   * Called before runInterruptibly - if true, runInterruptibly and afterRanInterruptibly will not
   * be called.
   */
  abstract boolean isDone();

  /**
   * Do interruptible work here - do not complete Futures here, as their listeners could be
   * interrupted.

    /**
     * Creates a new messages instance for handling validation and user messages.
     * This method can be called by the application to create message containers.
     *
     * @return a new FessMessages instance
     */
    @Override
    public FessMessages createMessages() { // application may call
        return new FessMessages(); // overriding to change return type to concrete-class
    }