from fastapi._compat import ModelField
from fastapi.security.base import SecurityBase


@dataclass
class SecurityRequirement:
    security_scheme: SecurityBase
    scopes: Optional[Sequence[str]] = None


@dataclass
class Dependant:
    path_params: List[ModelField] = field(default_factory=list)
    query_params: List[ModelField] = field(default_factory=list)

import org.lastaflute.web.validation.ActionValidator;

public class FessActionValidator<MESSAGES extends UserMessages> extends ActionValidator<MESSAGES> {

    public FessActionValidator(final RequestManager requestManager, final UserMessagesCreator<MESSAGES> messagesCreator,
            final Class<?>[] runtimeGroups) {
        super(requestManager, messagesCreator, runtimeGroups);
    }

        session.setSession(new DefaultSessionFactory(
                        getContainer().lookup(RepositorySystem.class),
                        getContainer().lookup(MavenRepositorySystem.class),
                        new DefaultLookup(getContainer()),
                        getContainer().lookup(RuntimeInformation.class))
                .newSession(session));

        legacySupport.setSession(session);
    }

from sqlmodel import Field, Session, SQLModel, create_engine, select


class HeroBase(SQLModel):
    name: str = Field(index=True)
    age: Union[int, None] = Field(default=None, index=True)


class Hero(HeroBase, table=True):
    id: Union[int, None] = Field(default=None, primary_key=True)
    secret_name: str


class HeroPublic(HeroBase):
    id: int


class HeroCreate(HeroBase):
    secret_name: str

     * would want to do as the jcifs.smb1.netbios.SocketXxxputStream classes
     * arraycopy all data read or written into a new buffer shifted over 4!)
     */

    byte command, flags;
    int headerStart,
        length,
        batchLevel,
        errorCode,
        flags2,
        tid, pid, uid, mid,
        wordCount, byteCount;

    return new ClassSanityTester()
        .setDefault(byte[].class, new byte[] {1, 2, 3, 4})
        .setDistinctValues(byte[].class, new byte[] {1, 2, 3, 4}, new byte[] {5, 6, 7, 8})
        .setDistinctValues(String.class, "7f8005ff0e", "7f8005ff0f")
        .forAllPublicStaticMethods(HashCode.class);
  }

  private static void assertExpectedHashCode(ExpectedHashCode expectedHashCode, HashCode hash) {

        return new AbstractModule() {
            @Override
            protected void configure() {
                bind(ILoggerFactory.class).toInstance(context.loggerFactory);
                bind(CoreExports.class).toInstance(exports);
                bind(MessageBuilderFactory.class).toInstance(context.invokerRequest.messageBuilderFactory());
            }
        };
    }

import org.gradle.api.Incubating

class IncubatingInternalInterfaceAddedRuleTest extends AbstractContextAwareRuleSpecification {
    IncubatingInternalInterfaceAddedRule rule

    static class OldSuper {}

    static class OldBase extends OldSuper {}

    static class NewSuper {}

    static class NewBase extends NewSuper {}

    @Incubating
    static class NewIncubatingBase extends NewSuper {}

method parameter. It will be shut down automatically after the test runs.

```
class MyTest {
  @Test
  void test(MockWebServer server) {
    ...
  }
}
```

Alternately you may add the [MockWebServer] as a constructor parameter:

```
class MyTest {
  private final MockWebServer server;

  MyTest(MockWebServer server) {
    this.server = server;
  }

    assertThrows(IllegalStateException.class, () -> emptyAccumulator.sampleVariance());
    assertThrows(
        IllegalStateException.class, () -> emptyAccumulatorByAddAllEmptyIterable.sampleVariance());
    assertThrows(
        IllegalStateException.class, () -> emptyAccumulatorByAddAllEmptyStats.sampleVariance());
    assertThrows(IllegalStateException.class, () -> oneValueAccumulator.sampleVariance());
    assertThrows(