}
    return adjacentNodes;
  }

  @Override
  public Set<E> edgesConnecting(N node) {
    return new MultiEdgesConnecting<E>(incidentEdgeMap, node) {
      @Override
      public int size() {
        return adjacentNodesMultiset().count(node);
      }
    };
  }

  @Override
  @CheckForNull
  public N removeInEdge(E edge, boolean isSelfLoop) {
    if (!isSelfLoop) {

     * @param url
     * @param pipeType
     *            the type of the pipe
     * @return the SMB pipe resource at the specified location
     * @throws CIFSException
     */
    SmbPipeResource getPipe ( String url, int pipeType ) throws CIFSException;


    /**
     * 
     * @return whether any connection was still in use
     * @throws CIFSException
     */
    boolean close () throws CIFSException;


    /**

// closer which only closes the associated *os.File when the ref count.
// has reached zero, i.e when all the readers have given up their locks.
type RLockedFile struct {
	*LockedFile
	mutex sync.Mutex
	refs  int // Holds read lock refs.
}

// IsClosed - Check if the rlocked file is already closed.
func (r *RLockedFile) IsClosed() bool {
	r.mutex.Lock()
	defer r.mutex.Unlock()
	return r.refs == 0
}

    def value

    TestDomainObject(String value) {
        this.value = value
    }

    @Override
    boolean equals(Object o) {
        return o.value == value
    }

    @Override
    int hashCode() {
        return value.hashCode()
    }

    void attach(ClassMetaDataRepository<TestDomainObject> repository) {
    }

    // Avoid expectEquals() here to delay reason manufacture until necessary.
    if (getList().size() != expectedList.size()) {
      fail("size mismatch: " + reportContext(expectedList));
    }
    for (int i = 0; i < expectedList.size(); i++) {
      E expected = expectedList.get(i);
      E actual = getList().get(i);
      if (expected != actual && (expected == null || !expected.equals(actual))) {

    assertEquals(toString, func.toString());
    assertEquals(value, func.hashBytes(bytes).padToLong());
  }

  private static void assertHash32(
      int expected, ImmutableSupplier<Checksum> supplier, String input) {
    byte[] bytes = HashTestUtils.ascii(input);
    String toString = "name";
    HashFunction func = new ChecksumHashFunction(supplier, 32, toString);

@ElementTypesAreNonnullByDefault
final class ReverseNaturalOrdering extends Ordering<Comparable<?>> implements Serializable {
  static final ReverseNaturalOrdering INSTANCE = new ReverseNaturalOrdering();

  @Override
  public int compare(Comparable<?> left, Comparable<?> right) {
    checkNotNull(left); // right null is caught later
    if (left == right) {
      return 0;
    }

    return ((Comparable<Object>) right).compareTo(left);
  }

    return Maps.valueIterator(multimap.entries().iterator());
  }

  @Override
  public boolean contains(@CheckForNull Object o) {
    return multimap.containsValue(o);
  }

  @Override
  public int size() {
    return multimap.size();
  }

  @Override
  public boolean remove(@CheckForNull Object o) {
    Predicate<? super Entry<K, V>> entryPredicate = multimap.entryPredicate();

                .getHandle("ncacn_np:" + getTestServer() + "[\\PIPE\\lsarpc]", withTestNTLMCredentials(getContext())) ) {
            String server = handle.getServerWithDfs();
            int dot = server.indexOf('.');
            if ( dot > 0 && Character.isDigit(server.charAt(0)) == false )
                server = server.substring(0, dot);

from pydantic import BaseModel


class Model1(BaseModel):
    foo: str
    bar: str


class Model2(BaseModel):
    ref: Model1
    baz: str


class Model3(BaseModel):
    name: str
    age: int
    ref2: Model2


app = FastAPI()


@app.get(
    "/simple_include",
    response_model=Model2,
    response_model_include={"baz": ..., "ref": {"foo"}},
)
def simple_include():