/** The key of the message: SSO login process failed. */
    public static final String ERRORS_sso_login_error = "{errors.sso_login_error}";

    /** The key of the message: Could not find {0}. */
    public static final String ERRORS_could_not_find_log_file = "{errors.could_not_find_log_file}";

    /** The key of the message: Failed to start a crawl process. */

        Thread.sleep(100);
        try (FileWriter writer = new FileWriter(lmhostsFile)) {
            writer.write("192.168.1.200 NEWHOST\n");
        }

        // Should reload file and find new host
        result = lmhosts.getByName("NEWHOST", mockContext);
        assertNotNull(result);

        // Old host should not be found
        result = lmhosts.getByName("TESTHOST", mockContext);

         * only the documents from the current session.
         *
         * <p>The deletion process:</p>
         * <ul>
         *   <li>Checks if old document deletion is enabled</li>
         *   <li>Builds a query to find old documents for this configuration</li>
         *   <li>Optionally preserves expired documents based on configuration</li>
         *   <li>Executes the deletion query against the search engine</li>
         * </ul>

The important thing to keep in mind is that the `sub` key should have a unique identifier across the entire application, and it should be a string.

## Check it { #check-it }

    if not (match_start and match_end):
        raise RuntimeError("Couldn't auto-generate sponsors section")
    if not match_pre:
        raise RuntimeError("Couldn't find pre section (<style>) in index.md")
    frontmatter_end = match_pre.end()
    pre_end = match_start.end()
    post_start = match_end.start()
    template = Template(index_sponsors_template)

    may be on a different server (operated by you or a third party)
    that supports equivalent copying facilities, provided you maintain
    clear directions next to the object code saying where to find the
    Corresponding Source.  Regardless of what server hosts the
    Corresponding Source, you remain obligated to ensure that it is
    available for as long as needed to satisfy these requirements.

    }

    @Override
    public void remove() {
      if (lastRet < 0) throw new IllegalStateException();
      Object x = array[lastRet];
      lastRet = -1;
      // Traverse underlying queue to find == element,
      // not just a .equals element.
      monitor.enter();
      try {
        for (Iterator<E> it = q.iterator(); it.hasNext(); ) {
          if (it.next() == x) {
            it.remove();

   *        0 +----------+-------+--------------→ storedPermits
   *          0 thresholdPermits maxPermits
   * </pre>
   *
   * Before going into the details of this particular function, let's keep in mind the basics:
   *
   * <ol>
   *   <li>The state of the RateLimiter (storedPermits) is a vertical line in this figure.
   *   <li>When the RateLimiter is not used, this goes right (up to maxPermits)

		var expiryRuleRemoved bool
		if len(meta.LifecycleConfigXML) > 0 {
			var lcCfg lifecycle.Lifecycle
			if err := xml.Unmarshal(meta.LifecycleConfigXML, &lcCfg); err != nil {
				return updatedAt, err
			}
			// find a single expiry rule set the flag
			for _, rl := range lcCfg.Rules {
				if !rl.Expiration.IsNull() || !rl.NoncurrentVersionExpiration.IsNull() {
					expiryRuleRemoved = true
					break
				}
			}
		}

     *
     * @param count number of leases to evict
     */
    private void evictOldestLeases(int count) {
        if (count <= 0 || leases.isEmpty()) {
            return;
        }

        // Find oldest leases by last access time
        leases.entrySet()
                .stream()
                .sorted((e1, e2) -> Long.compare(e1.getValue().getLastAccessTime(), e2.getValue().getLastAccessTime()))