import java.util.Set;
import org.jspecify.annotations.Nullable;

/**
 * Based on what a {@link Type} is, dispatch it to the corresponding {@code visit*} method. By
 * default, no recursion is done for type arguments or type bounds. But subclasses can opt to do
 * recursion by calling {@link #visit} for any {@code Type} while visitation is in progress. For
 * example, this can be used to reject wildcards or type variables contained in a type as in:

        // Zeroed upon release
        for (byte value : fromCache) {
            assertEquals(0, value);
        }
    }

    // Invalid inputs: negative sizes for constructor arguments
    @Nested
    class InvalidConstruction {
        @Test
        @DisplayName("Negative maxBuffers throws immediately in constructor")
        void negativeMaxBuffersThrows() {

                  <goal>exec</goal>
                </goals>
                <configuration>
                  <executable>echo</executable>
                  <arguments>
                    <argument>${javaHome}</argument>
                  </arguments>
                  <outputFile>${project.build.directory}/java_11_home</outputFile>
                </configuration>
              </execution>
            </executions>

                  <goal>exec</goal>
                </goals>
                <configuration>
                  <executable>echo</executable>
                  <arguments>
                    <argument>${javaHome}</argument>
                  </arguments>
                  <outputFile>${project.build.directory}/java_11_home</outputFile>
                </configuration>
              </execution>
            </executions>

     *
     * @param clazz
     *            The class. Must not be {@literal null}.
     * @return The primitive class if the argument is a wrapper class, otherwise the class passed as the argument.
     */
    public static Class<?> getPrimitiveClassIfWrapper(final Class<?> clazz) {
        assertArgumentNotNull("clazz", clazz);

        verify(session).treeConnectLogon();
    }

    // Happy path: getSmbTree returns a tree and receives correct args
    @Test
    @DisplayName("getSmbTree returns tree and captures arguments")
    void getSmbTree_happy() {
        when(session.getSmbTree(anyString(), anyString())).thenReturn(tree);

        String share = "share";

import org.apache.maven.api.services.MessageBuilderFactory;

/**
 * Represents a Maven invocation request, encapsulating all necessary information
 * for invoking a Maven build or command. Arguments are parsed and exposed via methods.
 *
 * @since 4.0.0
 */
@Immutable
@Experimental
public interface InvokerRequest {
    /**
     * The parser request this instance was created from.
     */
    @Nonnull

        KerberosAuthData mockAuthData2 = mock(KerberosAuthData.class);

        // Mock the parse method to return two different objects based on input
        // Must use matchers for all arguments when using any matcher
        mockedStaticAuthData.when(() -> KerberosAuthData.parse(eq(1), eq(new byte[] { 0x01 }), any(Map.class)))
                .thenReturn(Collections.singletonList(mockAuthData1));

/// tip

Here we are using `Query()` because this is a **query parameter**. Later we will see others like `Path()`, `Body()`, `Header()`, and `Cookie()`, that also accept the same arguments as `Query()`.

///

FastAPI will now:

* **Validate** the data making sure that the max length is 50 characters
* Show a **clear error** for the client when the data is not valid

   * methods, or methods declared by final classes are not overridable.
   */
  public abstract boolean isOverridable();

  /** Returns {@code true} if this was declared to take a variable number of arguments. */
  public abstract boolean isVarArgs();

  /**
   * Invokes with {@code receiver} as 'this' and {@code args} passed to the underlying method and