}
  }

  /**
   * Returns a hash code, having the same bit length as each of the input hash codes, that combines
   * the information of these hash codes in an ordered fashion. That is, whenever two equal hash
   * codes are produced by two calls to this method, it is <i>as likely as possible</i> that each
   * was computed from the <i>same</i> input hash codes in the <i>same</i> order.
   *

    for (int i = 0; i < keyBits; i++) {
      int same = 0x0; // bitset for output bits with same values
      int diff = 0x0; // bitset for output bits with different values
      int count = 0;
      // originally was 2 * Math.log(...), making it try more times to avoid flakiness issues
      int maxCount = (int) (4 * Math.log(2 * keyBits * hashBits) + 1);
      while (same != 0xffffffff || diff != 0xffffffff) {

        assertEquals(0L, info.length());
    }

    @Test
    @DisplayName("Test equals method with same netName")
    void testEqualsWithSameNetName() {
        SmbShareInfo info1 = new SmbShareInfo("Share1", 0, "Remark1");
        SmbShareInfo info2 = new SmbShareInfo("Share1", 1, "Remark2");

        // Same netName, different type and remark
        assertTrue(info1.equals(info2));
        assertTrue(info2.equals(info1));

        SmbTreeHandleImpl t2 = h.getTree();

        assertSame(tree, t1, "Expected same mocked tree");
        assertSame(tree, t2, "Expected same mocked tree");

        // acquire is called once in ctor + once per getTree() call
        verify(tree, times(3)).acquire();
    }

    @Test
    @DisplayName("isValid() true when open, same tree id, connected")
    void isValid_true_whenOpenSameTreeConnected() {

	encodedQuery := query.Encode()

	// Verify if date query is same.
	if req.Form.Get(xhttp.AmzDate) != query.Get(xhttp.AmzDate) {
		return ErrSignatureDoesNotMatch
	}
	// Verify if expires query is same.
	if req.Form.Get(xhttp.AmzExpires) != query.Get(xhttp.AmzExpires) {
		return ErrSignatureDoesNotMatch
	}
	// Verify if signed headers query is same.

        // Act & Assert
        // unwrap to interface itself should return same instance
        CredentialsInternal unwrapped = creds.unwrap(CredentialsInternal.class);
        assertNotNull(unwrapped, "unwrap to CredentialsInternal returns instance");
        assertSame(creds, unwrapped, "unwrap returns the same object instance");

And of course, it supports the same:

* data validation
* data serialization
* data documentation, etc.

This works the same way as with Pydantic models. And it is actually achieved in the same way underneath, using Pydantic.

/// info

Keep in mind that dataclasses can't do everything Pydantic models can do.

    }
}
```

/// note

Notice that even though the `item` was declared the same way as before, it is now expected to be inside of the body with a key `item`.

///

**FastAPI** will do the automatic conversion from the request, so that the parameter `item` receives its specific content and the same for `user`.

import java.lang.annotation.Retention;

import static java.lang.annotation.RetentionPolicy.RUNTIME;

/**
 * Provides a unique identifier for dependencies when multiple implementations
 * of the same type are available.
 * <p>
 * This annotation can be used in conjunction with {@link Inject} to specify
 * which implementation should be injected when multiple candidates exist.

You can easily use the same Pydantic settings to configure your generated OpenAPI and the docs UIs.

For example:

{* ../../docs_src/conditional_openapi/tutorial001_py39.py hl[6,11] *}

Here we declare the setting `openapi_url` with the same default of `"/openapi.json"`.

And then we use it when creating the `FastAPI` app.