from typing import Dict, List, Optional, Tuple

import pytest
from fastapi import FastAPI, Query
from pydantic import BaseModel


def test_invalid_sequence():
    with pytest.raises(AssertionError):
        app = FastAPI()

        class Item(BaseModel):
            title: str

        @app.get("/items/")
        def read_items(q: List[Item] = Query(default=None)):
            pass  # pragma: no cover

#
# Environment Variable Prerequisites
#
#   JAVA_HOME           (Optional) Points to a Java installation.
#   MAVEN_ARGS          (Optional) Arguments passed to Maven before CLI arguments.
#   MAVEN_OPTS          (Optional) Java runtime options used when Maven is executed.
#   MAVEN_SKIP_RC       (Optional) Flag to disable loading of mavenrc files.

        stablePublicInterface = instanceScopedPool.get(StablePublicInterface.name)

        apiClass.changeStatus >> JApiChangeStatus.MODIFIED
        apiClass.oldClass >> Optional.of(oldBase)
        apiClass.newClass >> Optional.of(newBase)

        internalInterface.name = replaceAsInternal(internalInterface.name)

        interfaces = ['internal': internalInterface,

 */
package org.apache.maven.api.services;

import java.io.IOException;
import java.lang.module.ModuleDescriptor;
import java.nio.file.Path;
import java.util.List;
import java.util.Map;
import java.util.Optional;

import org.apache.maven.api.Dependency;
import org.apache.maven.api.DependencyScope;
import org.apache.maven.api.JavaPathType;
import org.apache.maven.api.Node;
import org.apache.maven.api.PathType;

  <dependencies>
    <dependency>
      <groupId>maven-test</groupId>
      <artifactId>t07-d</artifactId>
      <version>1.1</version>
      <type>jar</type>
      <scope>compile</scope>
      <optional>true</optional>
    </dependency>
  </dependencies>

from typing import Optional


def say_hi(name: Optional[str] = None):
    if name is not None:
        print(f"Hey {name}!")
    else:

from typing import Optional, Tuple


def get_authorization_scheme_param(
    authorization_header_value: Optional[str],
) -> Tuple[str, str]:
    if not authorization_header_value:
        return "", ""
    scheme, _, param = authorization_header_value.partition(" ")

                out,
                err,
                coreExtensions,
                options);
        this.jvmArguments = jvmArguments;
    }

    @Override
    public Optional<List<String>> jvmArguments() {
        return Optional.ofNullable(jvmArguments);
    }

 */
@Experimental
public interface ArtifactManager extends Service {

    /**
     * Returns the path of the file previously associated to this artifact
     * or {@code Optional.empty()} if no path has been associated.
     */
    @Nonnull
    Optional<Path> getPath(@Nonnull Artifact artifact);

    /**
     * Associates the given file path to the artifact.
     */
    void setPath(@Nonnull ProducedArtifact artifact, Path path);

  public Set<E> edgesConnecting(EndpointPair<N> endpoints) {
    return delegate().edgesConnecting(endpoints);
  }

  @Override
  public Optional<E> edgeConnecting(N nodeU, N nodeV) {
    return delegate().edgeConnecting(nodeU, nodeV);
  }

  @Override
  public Optional<E> edgeConnecting(EndpointPair<N> endpoints) {
    return delegate().edgeConnecting(endpoints);
  }

  @Override
  @CheckForNull