* processing the response, and extracting child URLs.
 *
 * <p>
 * This class implements the {@link Runnable} interface, allowing it to be executed in a separate thread.
 * It uses various services and components, such as {@link UrlQueueService}, {@link DataService},
 * {@link CrawlerContainer}, {@link LogHelper}, {@link CrawlerClientFactory}, and {@link CrawlerContext},
 * to perform its tasks.
 * </p>
 *

import jakarta.annotation.Resource;

/**
 * API action for admin group management.
 * Provides RESTful API endpoints for managing user group settings in the Fess search engine.
 * Groups define user permissions and access controls for search and administrative functions.
 */
public class ApiAdminGroupAction extends FessApiAdminAction {

    private static final Logger logger = LogManager.getLogger(ApiAdminGroupAction.class);

// port "80" and "443" before displaying on the startup
// banner.  Returns a new list of API endpoints.
func stripStandardPorts(apiEndpoints []string, host string) (newAPIEndpoints []string) {
	if len(apiEndpoints) == 1 {
		return apiEndpoints
	}
	newAPIEndpoints = make([]string, len(apiEndpoints))
	// Check all API endpoints for standard ports and strip them.
	for i, apiEndpoint := range apiEndpoints {

    @Mock
    private NdrObject mockNdrObject;

    /**
     * Test the constructor of MsrpcQueryInformationPolicy.
     * It should correctly call the super constructor and set ptype and flags.
     */
    @Test
    @DisplayName("Constructor should initialize fields and call super constructor")
    void constructorTest() {
        short level = 1;

        // Create an instance of the class under test

    return CollectCollectors.toImmutableList();
  }

  /**
   * Returns the empty immutable list. This list behaves and performs comparably to {@link
   * Collections#emptyList}, and is preferable mainly for consistency and maintainability of your
   * code.
   *
   * <p><b>Performance note:</b> the instance returned is a singleton.
   */

   * Short#decode} and {@link Short#toString()}. The returned converter throws {@link
   * NumberFormatException} if the input string is invalid.
   *
   * <p><b>Warning:</b> please see {@link Short#decode} to understand exactly how strings are
   * parsed. For example, the string {@code "0123"} is treated as <i>octal</i> and converted to the
   * value {@code 83}.
   *

   * higher value than you need can waste space and time, and a significantly lower value can lead
   * to thread contention. But overestimates and underestimates within an order of magnitude do not
   * usually have much noticeable impact. A value of one permits only one thread to modify the cache
   * at a time, but since read operations and cache loading computations can proceed concurrently,

      apply {
        this.code = code
      }

    /** Sets the status and returns this. */
    public fun status(status: String): Builder =
      apply {
        this.status = status
      }

    /**
     * Removes all HTTP headers including any "Content-Length" and "Transfer-encoding" headers that
     * were added by default.
     */
    public fun clearHeaders(): Builder =

			return h.New()
		}
	}
}

// HashBorrower allows borrowing hashes and will keep track of them.
func (s *SigningMethodHMAC) HashBorrower() HashBorrower {
	return HashBorrower{pool: &s.HasherPool, borrowed: make([]hash.Hash, 0, 2)}
}

// HashBorrower keeps track of borrowed hashers and allows to return them all.
type HashBorrower struct {
	pool     *bpool.Pool[hash.Hash]
	borrowed []hash.Hash
}

  /*
   * Conceptually, these two variables describe the executor being in
   * one of three states:
   *   - Active: shutdown == false
   *   - Shutdown: runningTasks > 0 and shutdown == true
   *   - Terminated: runningTasks == 0 and shutdown == true
   */
  @GuardedBy("lock")
  private int runningTasks = 0;

  @GuardedBy("lock")
  private boolean shutdown = false;

  @Override