implements SortedSet<E> {
    SynchronizedSortedSet(SortedSet<E> delegate, @Nullable Object mutex) {
      super(delegate, mutex);
    }

    @Override
    SortedSet<E> delegate() {
      return (SortedSet<E>) super.delegate();
    }

    @Override
    public @Nullable Comparator<? super E> comparator() {
      synchronized (mutex) {
        return delegate().comparator();
      }
    }

          I, O, AsyncFunction<? super I, ? extends O>, ListenableFuture<? extends O>> {
    AsyncTransformFuture(
        ListenableFuture<? extends I> inputFuture, AsyncFunction<? super I, ? extends O> function) {
      super(inputFuture, function);
    }

    @Override
    ListenableFuture<? extends O> doTransform(
        AsyncFunction<? super I, ? extends O> function, @ParametricNullness I input)

    // Anything not assigned was the default 0.
    return expected;
  }

  /**
   * Helper to run the loop to test all the permutations for the number of bytes specified.
   *
   * @param numBytes the number of bytes in the byte array
   * @param expectedCount the expected number of roundtrippable permutations
   */
  @GwtIncompatible // java.nio.charset.Charset
  private static void testBytes(int numBytes, long expectedCount) {

    response = client.get(
        "/items/", headers={"X-Token": "fake-super-secret-token", "X-Key": "invalid"}
    )
    assert response.status_code == 400, response.text
    assert response.json() == {"detail": "X-Key header invalid"}


def test_get_invalid_second_header_users(client: TestClient):
    response = client.get(
        "/users/", headers={"X-Token": "fake-super-secret-token", "X-Key": "invalid"}
    )

    public SuperPomProviderException() {
        super();
    }

    public SuperPomProviderException(String message) {
        super(message);
    }

    public SuperPomProviderException(String message, Throwable cause) {
        super(message, cause);
    }

    public SuperPomProviderException(Throwable cause) {
        super(cause);
    }

   * hexadecimal number in lower case.
   *
   * <p>Note that if the output is considered to be a single hexadecimal number, whether this string
   * is big-endian or little-endian depends on the byte order of {@link #asBytes}. This may be
   * surprising for implementations of {@code HashCode} that represent the number in big-endian

            final StringWriter sw = new StringWriter();
            final PrintWriter pw = new PrintWriter(sw);
            rootCause.printStackTrace(pw);
            return super.toString() + "\n" + sw;
        }
        return super.toString();
    }

    private Throwable rootCause;

    DcerpcException(final int error) {
        super(getMessageByDcerpcError(error));
        this.error = error;
    }

    /**
     * Constructs a DcerpcException with the specified message
     *
     * @param msg the error message
     */
    public DcerpcException(final String msg) {
        super(msg);
    }

    /**

                            "title": "Description",
                        },
                        "price": {"type": "number", "title": "Price"},
                        "tax": {
                            "anyOf": [{"type": "number"}, {"type": "null"}],
                            "title": "Tax",
                        },
                    },
                    "type": "object",

        /**
         * Default constructor for DfsEnumArray1
         */
        public DfsEnumArray1() {
            // Default constructor
        }

        /**
         * Number of DFS entries in the array
         */
        public int count;
        /**
         * Array of DFS information level 1 structures
         */
        public DfsInfo1[] s;

        @Override