Entry<Class<? extends @NonNull B>, B> entry) {
    return new ForwardingMapEntry<Class<? extends @NonNull B>, B>() {
      @Override
      protected Entry<Class<? extends @NonNull B>, B> delegate() {
        return entry;
      }

      @Override
      @ParametricNullness
      public B setValue(@ParametricNullness B value) {
        cast(getKey(), value);
        return super.setValue(value);
      }
    };
  }

                .orElse(null);
    }

    public List<MavenProject> getSortedProjects() {
        return sortedProjects;
    }

    public boolean hasMultipleProjects() {
        return sortedProjects.size() > 1;
    }

    public List<String> getDependents(String id) {
        return graph.getVertex(id).getParents().stream().map(Vertex::getLabel).collect(Collectors.toList());
    }

    }

    /**
     * @return Optional active profile identifiers, never {@code null}.
     */
    public Set<String> getOptionalActiveProfileIds() {
        return getProfileIds(pa -> pa.optional() && pa.active());
    }

    /**
     * @return Required inactive profile identifiers, never {@code null}.
     */
    public Set<String> getRequiredInactiveProfileIds() {

        assertNotNull(deleteResponse);
        assertFalse(deleteResponse.hasError());

        suggester.refresh();

        // Document-only should be deleted, Query-only should remain, Both should remain but as Query only
        assertEquals(2, suggester.getAllWordsNum());
        assertEquals(0, suggester.getDocumentWordsNum());
        assertEquals(2, suggester.getQueryWordsNum());
    }

    @Test

    assert response.json() == "Hello World"


def test_nonexistent():
    response = client.get("/nonexistent")
    assert response.status_code == 404, response.text
    assert response.json() == {"detail": "Not Found"}


def test_path_foobar():
    response = client.get("/path/foobar")
    assert response.status_code == 200
    assert response.json() == "foobar"


def test_path_str_foobar():

      check(!closed) { "closed" }
      if (inputExhausted) return -1

      val read = super.read(sink, byteCount)
      if (read == -1L) {
        inputExhausted = true
        responseBodyComplete(trailers = Headers.EMPTY)
        return -1
      }
      return read
    }

    override fun close() {
      if (closed) return
      if (!inputExhausted) {

  // Modification Operations

  /**
   * {@inheritDoc}
   *
   * @throws IllegalArgumentException if the given value is already bound to a different key in this
   *     bimap. The bimap will remain unmodified in this event. To avoid this exception, call {@link
   *     #forcePut} instead.
   */
  @CanIgnoreReturnValue
  @Override
  @Nullable V put(@ParametricNullness K key, @ParametricNullness V value);

  /**

        }
        if (name.startsWith(concurrentPackage)) {
          Class<?> c = findLoadedClass(name);
          if (c == null) {
            return super.findClass(name);
          }
          return c;
        }
        return super.loadClass(name);
      }
    };
  }

~~ regarding copyright ownership.  The ASF licenses this file
~~ to you under the Apache License, Version 2.0 (the
~~ "License"); you may not use this file except in compliance
~~ with the License.  You may obtain a copy of the License at
~~
~~ http://www.apache.org/licenses/LICENSE-2.0
~~
~~ Unless required by applicable law or agreed to in writing,
~~ software distributed under the License is distributed on an

~~ regarding copyright ownership.  The ASF licenses this file
~~ to you under the Apache License, Version 2.0 (the
~~ "License"); you may not use this file except in compliance
~~ with the License.  You may obtain a copy of the License at
~~
~~ http://www.apache.org/licenses/LICENSE-2.0
~~
~~ Unless required by applicable law or agreed to in writing,
~~ software distributed under the License is distributed on an