response = client.get("/docs")
    assert response.status_code == 404, response.text
    response = client.get("/redoc")
    assert response.status_code == 404, response.text


def test_root():
    client = get_client()
    response = client.get("/")
    assert response.status_code == 200
    assert response.json() == {"message": "Hello World"}


def test_default_openapi():
    client = get_client()

import pytest
from httpx import ASGITransport, AsyncClient

from .main import app


@pytest.mark.anyio
async def test_root():
    async with AsyncClient(
        transport=ASGITransport(app=app), base_url="http://test"
    ) as ac:
        response = await ac.get("/")
    assert response.status_code == 200

async def create_item(
    token: Optional[str] = Security(oauth2_scheme, scopes=["read", "write"]),
):
    return {"token": token}


app.include_router(router)

client = TestClient(app)


def test_root():
    response = client.get("/", headers={"Authorization": "Bearer testtoken"})
    assert response.status_code == 200, response.text
    assert response.json() == {"message": "Hello World"}

import org.apache.maven.api.annotations.Provider;

/**
 * Represents a dependency node within a Maven project's dependency collector.
 *
 * @since 4.0.0
 * @see org.apache.maven.api.services.DependencyResolverResult#getRoot()
 */
@Experimental
@Immutable
@Provider
public interface Node {

    /**
     * @return artifact for this node
     */
    @Nullable
    Artifact getArtifact();

    /**

    List<Exception> getExceptions();

    /**
     * Gets the root node of the dependency graph.
     *
     * @return the root node of the dependency graph or {@code null} if none
     */
    @Nullable
    Node getRoot();

    /**
     * The ordered list of the flattened dependency nodes.
     *
     * @return the ordered list of the flattened dependency nodes
     */
    @Nonnull
    List<Node> getNodes();

    /**

                        Mockito.any(PathScope.class)))
                .thenReturn(resolverResult);
        Node node = Mockito.mock(Node.class);
        Mockito.when(resolverResult.getRoot()).thenReturn(node);
        Node child = Mockito.mock(Node.class);
        Mockito.when(node.getChildren()).thenReturn(List.of(child));

        services.addAll(List.of(
                new DefaultRequestCacheFactory(),

            DcerpcBinding binding = DcerpcHandle.parseBinding(url);

            // Then: Should parse correctly
            assertNotNull(binding);
            assertEquals(expectedProto, binding.getProto());
            assertEquals(expectedServer, binding.getServer());
            assertEquals(expectedEndpoint, binding.getEndpoint());
        }

        @ParameterizedTest

    @Nonnull
    RequestType getRequestType();

    @Nonnull
    Optional<Project> getProject();

    @Nonnull
    Optional<Artifact> getRootArtifact();

    @Nonnull
    Optional<DependencyCoordinates> getRoot();

    @Nonnull
    Collection<DependencyCoordinates> getDependencies();

    @Nonnull
    Collection<DependencyCoordinates> getManagedDependencies();

    boolean getVerbose();

    @Nonnull

        this.proto = proto;
        this.server = server;
    }

    /**
     * Get the protocol for this binding.
     * @return the proto
     */
    public String getProto() {
        return this.proto;
    }

    /**
     * Get the options for this binding.
     * @return the options
     */
    public Map<String, Object> getOptions() {
        return this.options;
    }

        DcerpcBinding.addInterface("wkssvc", "6BFFD098-A112-3610-9833-46C3F87E345A:1.0");
    }

    @Test
    void testConstructorAndGetters() {
        assertEquals(PROTO, dcerpcBinding.getProto(), "Protocol should match the constructor argument.");
        assertEquals(SERVER, dcerpcBinding.getServer(), "Server should match the constructor argument.");