}

    /**
     * Set the referral data from a referral response
     *
     * @param ref the referral response
     * @param reqPath the requested path
     * @param expire the expiration time
     * @param consumed the number of characters consumed from the path
     * @return referral data
     */

     */
    @Size(max = 1000)
    public String defaultLabelValue;

    /**
     * Default sort order for search results.
     * Defines how search results are ordered when no specific sort is requested.
     */
    @Size(max = 1000)
    public String defaultSortValue;

    /**
     * Virtual host configuration for multi-tenant setups.
     * Allows different search configurations based on the request host.

  private var contextSwitchCount = 0

  /** Guarded by `this`. */
  private var activeThreads = 0

  /** A task runner that posts tasks to this fake. Tasks won't be executed until requested. */
  val taskRunner: TaskRunner =
    TaskRunner(
      object : TaskRunner.Backend {
        override fun execute(
          taskRunner: TaskRunner,
          runnable: Runnable,
        ) {

  /**
   * When we need a new thread to run tasks, we call [Backend.execute]. A few microseconds later we
   * expect a newly-started thread to call [Runnable.run]. We shouldn't request new threads until
   * the already-requested ones are in service, otherwise we might create more threads than we need.
   *
   * We use [executeCallCount] and [runCallCount] to defend against starting more threads than we
   * need. Both fields are guarded by `this`.
   */

   * in turn invoke arbitrary code it is not safe to call while holding a lock.
   */
  @SuppressWarnings("Interruption") // We are implementing a user-requested interrupt.
  final void interruptTask() {
    // Since the Thread is replaced by DONE before run() invokes listeners or returns, if we succeed

   * X-Device-Requested-With}</a> header field name. Header used for VAST requests to provide the
   * {@link #X_REQUESTED_WITH} header value that the on-behalf-of client would have used when making
   * a request itself.
   *
   * @since 31.0
   */
  public static final String X_DEVICE_REQUESTED_WITH = "X-Device-Requested-With";

  /** The HTTP {@code X-Do-Not-Track} header field name. */

 *
 * @since 4.0.0
 */
@Experimental
public interface PathType {
    /**
     * The type for all paths that could not be placed in any of the types requested by a caller.
     * This type can appear in the return value of a call to
     * {@link Session#resolveDependencies resolveDependencies(...)} when at least one dependency

**Consequence**: A private, written warning from community leaders, providing
clarity around the nature of the violation and an explanation of why the
behavior was inappropriate. A public apology may be requested.

### 2. Warning

**Community Impact**: A violation through a single incident or series
of actions.

**Consequence**: A warning with consequences for continued behavior. No

    public static final int ACCEPT_INCOMPLETE = 1;
    /**
     * Result code indicating authentication was rejected
     */
    public static final int REJECTED = 2;
    /**
     * Result code indicating MIC token is requested
     */
    public static final int REQUEST_MIC = 3;

    private ASN1ObjectIdentifier mechanism;

    private int result = UNSPECIFIED_RESULT;

    /**
     * Default constructor for NegTokenTarg
     */

            assertSame(mockSmbPipeHandleInternal, unwrapped, "Unwrap should return the underlying handle implementation.");
        }

        /**
         * Verifies that unwrap returns null if the requested type is not available.
         */
        @Test
        public void testUnwrap_ReturnsNullForUnsupportedType() {
            when(smbPipeHandle.unwrap(SmbPipeHandle.class)).thenReturn(null);