assertAssignable(
        new TypeToken<ArrayList<? super Number>>() {}, new TypeToken<List<? super N11>>() {});

    // ? super Number
    assertNotAssignable(
        new TypeToken<ArrayList<N11>>() {}, new TypeToken<List<? super Number>>() {});
    assertAssignable(
        new TypeToken<ArrayList<Number>>() {}, new TypeToken<List<? super Number>>() {});
    assertAssignable(

   *
   * @since 21.0
   */
  public static <T extends @Nullable Object, K, V>
      Collector<T, ?, ImmutableSortedMap<K, V>> toImmutableSortedMap(
          Comparator<? super K> comparator,
          Function<? super T, ? extends K> keyFunction,
          Function<? super T, ? extends V> valueFunction) {
    return CollectCollectors.toImmutableSortedMap(comparator, keyFunction, valueFunction);
  }

  /**

    public ContentOutputStream(final int threshold, final File tmpDir) {
        super(threshold, PREFIX, SUFFIX, tmpDir);
    }

    @Override
    public File getFile() {
        done = true;
        return super.getFile();
    }

    @Override
    public void close() throws IOException {
        try {
            super.close();
        } finally {
            if (!isInMemory() && !done) {

  public TestWriter(TestOutputStream out) {
    super(new OutputStreamWriter(checkNotNull(out), UTF_8));
    this.out = out;
  }

  @Override
  public void write(int c) throws IOException {
    super.write(c);
    flush(); // flush write to TestOutputStream to get its behavior
  }

  @Override
  public void write(char[] cbuf, int off, int len) throws IOException {
    super.write(cbuf, off, len);
    flush();
  }

    @Deprecated
    public ArtifactMetadataRetrievalException(String message) {
        super(message, null, null);
    }

    /**
     * @param cause a cause
     * @deprecated use {@link #ArtifactMetadataRetrievalException(String, Throwable, Artifact)}
     */
    @Deprecated
    public ArtifactMetadataRetrievalException(Throwable cause) {
        super(null, cause, null);
    }

    /**
     * @param message a message

        "/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"}


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

    public int size() {
      assertTrue(Thread.holdsLock(mutex));
      return super.size();
    }

    @Override
    public boolean isEmpty() {
      assertTrue(Thread.holdsLock(mutex));
      return super.isEmpty();
    }

    @Override
    public @Nullable V remove(Object object) {
      assertTrue(Thread.holdsLock(mutex));
      return super.remove(object);
    }

    @Override
    public void clear() {

        super(shortMessage);
        this.source = source;
        this.longMessage = longMessage;
    }

    /**
     * Construct a new <code>MojoFailureException</code> exception providing a message.
     *
     * @param message
     */
    public MojoFailureException(String message) {
        super(message);
    }

    /**

    private static final long serialVersionUID = 1L;

    public SuggestSettingsException(final String msg) {
        super(msg);
    }

    public SuggestSettingsException(final Throwable cause) {
        super(cause);
    }

    public SuggestSettingsException(final String msg, final Throwable cause) {
        super(msg, cause);
    }

            super(invoker, invokerRequest);
        }

        @Override
        public void close() throws InvokerException {
            // we are resident, we do not shut down here
        }

        public void shutDown() throws InvokerException {
            super.close();
        }