* be cached and cause other types to fail even though they may
                 * not be the authority for the name. For example, if a WINS lookup
                 * for FOO fails and caches unknownAddress for FOO, a subsequent
                 * lookup for FOO using BCAST should not fail because of that
                 * name cached from WINS.
                 *

@app.put("/items/{item_id}")
async def update_item(
    *,
    item_id: int,
    item: Annotated[
        Item,
        Body(
            examples=[
                {
                    "name": "Foo",
                    "description": "A very nice Item",
                    "price": 35.4,
                    "tax": 3.2,
                },
                {
                    "name": "Bar",

            return delegate;
          }
        };
    new EqualsTester().addEqualityGroup(forward).testEquals();
  }

  public void testEqualsSymmetric() {
    Set<String> delegate = newHashSet("foo");
    ForwardingObject forward =
        new ForwardingObject() {
          @Override
          protected Object delegate() {
            return delegate;
          }
        };

@GwtCompatible
public final class Throwables {
  private Throwables() {}

  /**
   * Throws {@code throwable} if it is an instance of {@code declaredType}. Example usage:
   *
   * <pre>
   * for (Foo foo : foos) {
   *   try {
   *     foo.bar();
   *   } catch (BarException | RuntimeException | Error t) {
   *     failure = t;
   *   }
   * }
   * if (failure != null) {
   *   throwIfInstanceOf(failure, BarException.class);

  public void testIdentity_same() {
    Function<@Nullable String, @Nullable String> identity = Functions.identity();
    assertThat(identity.apply(null)).isNull();
    assertThat(identity.apply("foo")).isSameInstanceAs("foo");
  }

  public void testIdentity_notSame() {
    Function<Long, Long> identity = Functions.identity();
    assertThat(identity.apply(new Long(135135L))).isNotSameInstanceAs(new Long(135135L));
  }

public class DomUtilTest extends TestCase {

    /**
     * @throws Exception
     */
    public void testGetContentsAsStream() throws Exception {
        final String contents = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><foo/>";
        assertNotNull("1", DomUtil.getContentsAsStream(contents, "UTF-8"));
    }

    /**
     * @throws Exception
     */
    public void testToString() throws Exception {

    assertThrows(NegativeArraySizeException.class, () -> Atomics.newReferenceArray(-1));
  }

  public void testNewReferenceArray_withStringArray() throws Exception {
    String[] array = {"foo", "bar", "baz"};
    AtomicReferenceArray<String> refArray = Atomics.newReferenceArray(array);
    for (int i = 0; i < array.length; ++i) {
      assertThat(refArray.get(i)).isEqualTo(array[i]);
    }

        """.trimIndent(),
      )
    assertThat(verifier.verify("foo.com", session)).isTrue()
    assertThat(verifier.verify("a.foo.com", session)).isFalse()
    assertThat(verifier.verify("foo.com", session)).isTrue()
    assertThat(verifier.verify("a.foo.com", session)).isFalse()
  }

  @Test fun verifyMultipleCn() {
    // CN=foo.com, CN=bar.com, CN=花子.co.jp
    val session =
      session(

   *
   * <p>For example, if {@code rangeMap} had the entries {@code [1, 5] => "foo", (6, 8) => "bar",
   * (10, ∞) => "baz"} then {@code rangeMap.subRangeMap(Range.open(3, 12))} would return a range map
   * with the entries {@code (3, 5] => "foo", (6, 8) => "bar", (10, 12) => "baz"}.
   *
   * <p>The returned range map supports all optional operations that this range map supports, except

The tests:

## Code snippets { #code-snippets }

//// tab | Test

This is a code snippet: `foo`. And this is another code snippet: `bar`. And another one: `baz quux`.

////

//// tab | Info

Content of code snippets should be left as is.