return (delegate != null) ? delegate.containsKey(key) : indexOf(key) != -1;
  }

  @Override
  public @Nullable V get(@Nullable Object key) {
    Map<K, V> delegate = delegateOrNull();
    if (delegate != null) {
      return delegate.get(key);
    }
    int index = indexOf(key);
    if (index == -1) {
      return null;
    }
    accessEntry(index);
    return value(index);

		t.Errorf("found invalid user, got %v", u)
	}

	name += "Update"
	rows, err := gorm.G[User](DB).Where("id = ?", u.ID).Update(ctx, "name", name)
	if rows != 1 {
		t.Fatalf("failed to get affected rows, got %d, should be %d", rows, 1)
	}

	nu, err := gorm.G[User](DB).Where("name = ?", name).First(ctx)
	if err != nil {
		t.Fatalf("failed to find user, got error: %v", err)

        validate(form, messages -> {}, this::asDictIndexHtml);
        pageNumber.ifPresent(num -> {
            charMappingPager.setCurrentPageNumber(pageNumber.get());
        }).orElse(() -> {
            charMappingPager.setCurrentPageNumber(0);
        });
        return asHtml(path_AdminDictMapping_AdminDictMappingJsp).renderWith(data -> {
            searchPaging(data, form);

	go func() {
		updateTicker := time.NewTicker(30 * time.Second)
		defer updateTicker.Stop()
		var lastUpdate time.Time

		// We need to merge since we will get the same buckets from each pool.
		// Therefore to get the exact bucket sizes we must merge before we can convert.
		var allMerged dataUsageCache

		update := func() {
			mu.Lock()
			defer mu.Unlock()

      params[1] = "";
      if (params.length > 2) {
        // fill in the rest of the array with arbitrary instances
        for (int i = 2; i < params.length; i++) {
          params[i] = ArbitraryInstances.get(sig.get(i));
        }
      }
    }
    return params;
  }

  private static final ImmutableList<Class<?>> POSSIBLE_PARAM_TYPES =
      ImmutableList.of(char.class, int.class, long.class, Object.class);

      params[1] = "";
      if (params.length > 2) {
        // fill in the rest of the array with arbitrary instances
        for (int i = 2; i < params.length; i++) {
          params[i] = ArbitraryInstances.get(sig.get(i));
        }
      }
    }
    return params;
  }

  private static final ImmutableList<Class<?>> POSSIBLE_PARAM_TYPES =
      ImmutableList.of(char.class, int.class, long.class, Object.class);

// update curr and max workers;
func (a *ActiveWorkerStat) update() {
	if a == nil {
		return
	}
	a.Curr = globalReplicationPool.Get().ActiveWorkers()
	a.hist.Update(int64(a.Curr))
	a.Avg = float32(a.hist.Mean())
	a.Max = int(a.hist.Max())
}

func (a *ActiveWorkerStat) get() ActiveWorkerStat {
	w := ActiveWorkerStat{
		Curr: a.Curr,
		Avg:  a.Avg,
		Max:  a.Max,
	}
	return w
}

        try {
            Integer result = (Integer) processMethod.invoke(null, options);
            assertNotNull(result);
            // Verify that generate was called at least once
            assertTrue(generateCallCount.get() >= 0);
        } catch (Exception e) {
            // Expected behavior when components are not fully initialized

for the Android flavor.

[Snapshot API Javadoc][guava-snapshot-api-docs] as well as
[Snapshot API Diffs][guava-snapshot-api-diffs] are also available.

Another easy way to get to the Javadoc is to open
[guava.dev/api](https://guava.dev/api). You can also jump right to a specific
class by appending the class name to guava.dev. For example,
[guava.dev/ImmutableList](https://guava.dev/ImmutableList)!

      processCalled++;
      assertEquals(ByteOrder.LITTLE_ENDIAN, bb.order());
      assertTrue(bb.remaining() >= chunkSize);
      for (int i = 0; i < chunkSize; i++) {
        out.write(bb.get());
      }
    }

    @Override
    protected void processRemaining(ByteBuffer bb) {
      assertFalse(remainingCalled);
      remainingCalled = true;