{true, ElementOrder.unordered()},
          {false, ElementOrder.stable()},
          {true, ElementOrder.stable()},
        });
  }

  private final boolean allowsSelfLoops;
  private final ElementOrder<Integer> incidentEdgeOrder;

  public StandardMutableDirectedGraphTest(
      boolean allowsSelfLoops, ElementOrder<Integer> incidentEdgeOrder) {
    this.allowsSelfLoops = allowsSelfLoops;

        type = SESSION_RETARGET_RESPONSE;
        length = 6;
    }

    @Override
    int writeTrailerWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    int readTrailerWireFormat(final InputStream in, final byte[] buffer, int bufferIndex) throws IOException {
        if (in.read(buffer, bufferIndex, length) != length) {

     * @param elements the elements to join
     * @return elements separated by delimiter
     */
    public static String join(final CharSequence delimiter, final CharSequence... elements) {
        final StringBuilder sb = new StringBuilder();
        for (final CharSequence element : elements) {
            if (sb.length() > 0) {
                if (delimiter != null) {
                    sb.append(delimiter);

    private static final int MAX_LOG_PREFIX_SIZE = 8; // "[ERROR] "
    private static final int PROJECT_STATUS_SUFFIX_SIZE = 20; // "SUCCESS [  0.000 s]"
    private static final int MIN_TERMINAL_WIDTH = 60;
    private static final int DEFAULT_TERMINAL_WIDTH = 80;
    private static final int MAX_TERMINAL_WIDTH = 130;
    private static final int MAX_PADDED_BUILD_TIME_DURATION_LENGTH = 9;

/** Exception classes for use in tests. */
@GwtCompatible
final class TestExceptions {
  static final class SomeError extends Error {}

  static final class SomeCheckedException extends Exception {}

  static final class SomeOtherCheckedException extends Exception {}

  static final class YetAnotherCheckedException extends Exception {}

  static final class SomeUncheckedException extends RuntimeException {}

```python
from typing import Annotated

from fastapi import Depends, FastAPI

app = FastAPI()


def get_db():
    db = DBSession()
    try:
        yield db
    finally:
        db.close()


DBDep = Annotated[DBSession, Depends(get_db)]


@app.get("/items/")
async def read_items(db: DBDep):
    return db.query(Item).all()
```

     */
    public WebApiManager get(final HttpServletRequest request) {
        final String servletPath = request.getServletPath();
        if (logger.isDebugEnabled()) {
            logger.debug("Looking for WebApiManager. servletPath={}, registeredManagers={}", servletPath, webApiManagers.length);
        }
        for (final WebApiManager webApiManager : webApiManagers) {

     */
    public static Object lookup(final InitialContext ctx, final String jndiName) throws NamingRuntimeException {
        assertArgumentNotNull("ctx", ctx);
        assertArgumentNotEmpty("jndiName", jndiName);

        try {
            return ctx.lookup(jndiName);
        } catch (final NamingException ex) {
            throw new NamingRuntimeException(ex);
        }
    }

     */
    public Smb2OplockBreakNotification(final Configuration config) {
        super(config);
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#writeBytesWireFormat(byte[], int)
     */
    @Override
    protected int writeBytesWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    /**
     * {@inheritDoc}

        SYSTEM_ERROR(2),
        /** Unauthorized status indicating authentication failure. */
        UNAUTHORIZED(3),
        /** General failure status. */
        FAILED(9);

        private final int id;

        Status(final int id) {
            this.id = id;
        }

        /**
         * Gets the numeric ID of the status.
         * @return The numeric ID of the status.
         */
        public int getId() {