}

  @GwtIncompatible // different overflow behavior; could probably be made to work by using ~~
  public void testConcat_overflow_negative() {
    int dim1 = 1 << 16;
    int dim2 = 1 << 15;
    assertThat(dim1 * dim2).isLessThan(0);
    testConcatOverflow(dim1, dim2);
  }

  @GwtIncompatible // different overflow behavior; could probably be made to work by using ~~

    }

    @Test
    @DisplayName("Should check if can reuse")
    void testCanReuse() {
        // When same config
        assertTrue(response.canReuse(mockContext, false));

        // When different config
        Configuration otherConfig = mock(Configuration.class);
        CIFSContext otherContext = mock(CIFSContext.class);
        when(otherContext.getConfig()).thenReturn(otherConfig);

### Concurrencia y Hamburguesas { #concurrency-and-burgers }

Esta idea de código **asíncrono** descrita anteriormente a veces también se llama **"concurrencia"**. Es diferente del **"paralelismo"**.

Et Swagger UI prend en charge ce champ particulier `examples` depuis un certain temps. Vous pouvez donc l'utiliser pour **afficher** différents **exemples dans l'interface des documents**.

        assertEquals(24L, MemoryUtil.sizeOf(1.0f));
        assertEquals(24L, MemoryUtil.sizeOf(1.0d));
    }

    @Test
    public void test_sizeOf_dateTimeTypes() {
        // Test different date/time types
        assertEquals(32L, MemoryUtil.sizeOf(new Date(0)));
        assertEquals(80L, MemoryUtil.sizeOf(LocalDateTime.of(2023, 1, 1, 0, 0)));
        assertEquals(2128L, MemoryUtil.sizeOf(ZonedDateTime.now()));

        assertNull(emptyOptional.orElse(null));
    }

    @Test
    public void test_ofNullable_multipleTypesInSequence() {
        // Test multiple different types in sequence to ensure type safety
        OptionalEntity<String> stringOpt = OptionalUtil.ofNullable("string");
        OptionalEntity<Integer> intOpt = OptionalUtil.ofNullable(42);

### Locks

We have 3 different things that we synchronize on.

#### Http2Connection

              getLowerEndpoint(),
              getLowerBoundType());
      result.reverse = this;
      return this.reverse = result;
    }
    return result;
  }

  // This method helps J2KT's type inference.
  private static <T extends @Nullable Object> Comparator<T> reverseComparator(
      Comparator<T> comparator) {
    return Ordering.from(comparator).reverse();
  }

  @Override
  public String toString() {

   * the behavior described in {@link #put(Range, Object) put(range, value)}, however the ranges
   * returned from {@link #asMapOfRanges} will be different if there were existing entries which
   * connect to the given range and value.
   *
   * <p>Even if the input range is empty, if it is connected on both sides by ranges mapped to the

  @AndroidIncompatible
  public void testTaskThrowsError() throws Exception {
    class MyError extends Error {}
    CyclicBarrier barrier = new CyclicBarrier(2);
    // we need to make sure the error gets thrown on a different thread.
    ExecutorService service = newSingleThreadExecutor();
    try {
      SequentialExecutor executor = new SequentialExecutor(service);
      Runnable errorTask =
          () -> {