saveTicker := time.NewTicker(10 * time.Second)
		defer saveTicker.Stop()
		quit := false
		after := time.Minute
		for !quit {
			select {
			case <-saveTicker.C:
			case <-ctx.Done():
				quit = true
			case <-saverQuitCh:
				quit = true
			}

			if quit {
				// save immediately if we are quitting
				after = 0
			}

          /*
           * requireNonNull is safe because the listener stack never contains TOMBSTONE until after
           * clearListeners.
           */
          executeListener(task, requireNonNull(curr.executor));
        }
      }
      break;
    }
  }

  /**
   * Callback method that is called exactly once after the future is completed.
   *

     */
    public FacetInfo() {
        // Default constructor
    }

    /**
     * Initializes the facet configuration from Fess configuration properties.
     * This method is called after dependency injection to load default facet settings.
     */
    @PostConstruct
    public void init() {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();

            buf.append(value).append("\n");
        }
        return buf.toString();
    }

    /**
     * Checks if the buffer contains a line that matches the specified value (after trimming).
     *
     * @param value the value to search for in the buffered lines
     * @return true if a matching line is found, false otherwise
     */
    public boolean contains(final String value) {

  var client = clientTestRule.newClient()

  @StartStop
  private val server = MockWebServer()

  @BeforeEach
  fun setUp() {
    // Default after JDK 14, but we are avoiding tests that assume special setup.
    // System.setProperty("jdk.tls.client.enableSessionTicketExtension", "true")
    // System.setProperty("jdk.tls.server.enableSessionTicketExtension", "true")

    }
  }

  private boolean hasRemaining() {
    return remaining() > 0;
  }

  private int remaining() {
    requireNonNull(seq); // safe as long as we call this only after checkOpen
    return seq.length() - pos;
  }

  /*
   * To avoid the need to call requireNonNull so much, we could consider more clever approaches,
   * such as:
   *

  public void testAddAtIndex_nullUnsupported() {
    assertThrows(NullPointerException.class, () -> getList().add(0, null));
    expectUnchanged();
    expectNullMissingWhenNullUnsupported("Should not contain null after unsupported add(n, null)");
  }

  @ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
  public void testAddAtIndex_negative() {
    assertThrows(IndexOutOfBoundsException.class, () -> getList().add(-1, e3()));

    E initialValue = getList().get(index);
    assertEquals(
        "set(i, x) should return the old element at position i.",
        initialValue,
        getList().set(index, newValue));
    assertEquals("After set(i, x), get(i) should return x", newValue, getList().get(index));
    assertEquals("set() should not change the size of a list.", getNumElements(), getList().size());
  }

  @ListFeature.Require(SUPPORTS_SET)

          <type>String</type>
          <defaultValue><![CDATA[]]></defaultValue>
          <description><![CDATA[If specified, identifies this phase as a dynamic phase to decorate the specified phase id, e.g. {@code after} or {@code before}.]]></description>
        </field>
        <field xml.attribute="true">
          <name>priority</name>
          <required>false</required>
          <version>2.0.0+</version>
          <type>int</type>

**FastAPI** lo proporciona como una conveniencia para ti, el desarrollador. Pero viene directamente de Starlette.

///

### Antes y después de la `response` { #before-and-after-the-response }

Puedes añadir código que se ejecute con la `request`, antes de que cualquier *path operation* la reciba.

Y también después de que se genere la `response`, antes de devolverla.