/**
     * Constructs an AV flags pair from integer flags
     * @param flags the flag values as integer
     */
    public AvFlags(final int flags) {
        this(encode(flags));
    }

    /**
     * Gets the flags as an integer value
     * @return flags
     */
    public int getFlags() {
        return SMBUtil.readInt4(this.getRaw(), 0);
    }

    private static byte[] encode(final int flags) {

 *
 * @deprecated use {@code org.apache.maven.api.services.ModelBuilder} instead
 */
@Deprecated(since = "4.0.0")
public interface SuperPomProvider {

    /**
     * Gets the super POM for the specified model version. The returned model is supposed to be read-only, i.e. if the
     * caller intends to make updates to the model the return value must be cloned before updating to ensure the

from fastapi import FastAPI

app = FastAPI()


@app.get("/items/", operation_id="some_specific_id_you_define")
async def read_items():

    assertThat(reader.readLine()).isEqualTo("This is the new location!")
    val first = server.takeRequest()
    assertThat(first.requestLine).isEqualTo("GET / HTTP/1.1")
    val redirect = server.takeRequest()
    assertThat(redirect.requestLine).isEqualTo("GET /new-path HTTP/1.1")
  }

  /**
   * Test that MockWebServer blocks for a call to enqueue() if a request is made before a mock
   * response is ready.
   */

   *  * The second race is between plan2 and plan3, with a 250 ms head start for plan2.
   *
   * We get plan0 and plan1 from the route planner.
   * We get plan2 as a follow-up to plan1, typically retry the same IP but different TLS.
   * We get plan3 as a retry of plan0, which was canceled when it lost the race.
   *

        assertNotNull(resolveOrder);
        assertEquals(3, resolveOrder.size());
        assertEquals(ResolverType.RESOLVER_WINS, resolveOrder.get(0));
        assertEquals(ResolverType.RESOLVER_BCAST, resolveOrder.get(1));
        assertEquals(ResolverType.RESOLVER_DNS, resolveOrder.get(2));
    }

    @Test
    @DisplayName("Should handle security properties")
    void testSecurityProperties() throws CIFSException {

    // Log after all static init is finished; if an installed logger uses any Futures methods, it
    // shouldn't break in cases where reflection is missing/broken.
    if (thrownReflectionFailure != null) {
      log.get().log(Level.SEVERE, "SafeAtomicHelper is broken!", thrownReflectionFailure);
    }
  }

  AggregateFutureState(int remainingFutures) {
    this.remainingField = remainingFutures;
  }

    sort(entries, Helpers.entryComparator(navigableMap.comparator()));

    // some tests assume SEVERAL == 3
    if (entries.size() >= 1) {
      a = entries.get(0);
      if (entries.size() >= 3) {
        b = entries.get(1);
        c = entries.get(2);
      }
    }
  }

  /** Resets the contents of navigableMap to have entries a, c, for the navigation tests. */

    sort(values, navigableSet.comparator());

    // some tests assume SEVERAL == 3
    if (values.size() >= 1) {
      a = values.get(0);
      if (values.size() >= 3) {
        b = values.get(1);
        c = values.get(2);
      }
    }
  }

  /** Resets the contents of navigableSet to have elements a, c, for the navigation tests. */
  protected void resetWithHole() {

   */
  public void dispatch() {
    // iterate by index to avoid concurrent modification exceptions
    for (int i = 0; i < listeners.size(); i++) {
      listeners.get(i).dispatch();
    }
  }

  /**
   * A special purpose queue/executor that dispatches listener events serially on a configured
   * executor. Each event can be added and dispatched as separate phases.
   *