assertThat(asMap.get(2)).isEqualTo(20);
    assertThat(cache.getIfPresent(10)).isEqualTo(50);
    assertThat(asMap.get(10)).isEqualTo(50);
  }

  @Test
  public void removalListener() {
    int[] stats = new int[4];

    RemovalListener<Integer, Integer> countingListener =
        notification -> {
          switch (notification.getCause()) {
            case EXPIRED:
              stats[0]++;

            String target = "TARGET";
            String combined = prefix + target;
            byte[] combinedBytes = combined.getBytes(StandardCharsets.UTF_16LE);
            int prefixBytes = prefix.getBytes(StandardCharsets.UTF_16LE).length;
            int targetBytes = target.getBytes(StandardCharsets.UTF_16LE).length;

            // When
            String result = Strings.fromUNIBytes(combinedBytes, prefixBytes, targetBytes);

	Logger                   logger.Interface
	NowFunc                  func() time.Time
	CreateBatchSize          int
}

// Open initialize db session based on dialector
func Open(dialector Dialector, opts ...Option) (db *DB, err error) {
	config := &Config{}

	sort.Slice(opts, func(i, j int) bool {
		_, isConfig := opts[i].(*Config)
		_, isConfig2 := opts[j].(*Config)
		return isConfig && !isConfig2
	})

    final Integer value;

    Foo(int value) {
      this.value = value;
    }

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

    @Override
    public boolean equals(@Nullable Object o) {
      return (o instanceof Foo) && ((Foo) o).value.equals(value);
    }

    @Override
    public int compareTo(Foo other) {

  }

  /** Enum values can override for performance reasons. */
  String convert(CaseFormat format, String s) {
    // deal with camel conversion
    StringBuilder out = null;
    int i = 0;
    int j = -1;
    while ((j = wordBoundary.indexIn(s, ++j)) != -1) {
      if (i == 0) {
        // include some extra space for separators
        out = new StringBuilder(s.length() + 4 * format.wordSeparator.length());

      return this;
    }

    /**
     * Sets the concurrency level that will be used by the to-be-built {@link Interner}.
     *
     * @see MapMaker#concurrencyLevel(int)
     */
    @CanIgnoreReturnValue
    public InternerBuilder concurrencyLevel(int concurrencyLevel) {
      this.mapMaker.concurrencyLevel(concurrencyLevel);
      return this;
    }

    public <E> Interner<E> build() {
      if (!strong) {

    public void clear() {
      AbstractTable.this.clear();
    }

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

  @Override
  public boolean equals(@Nullable Object obj) {
    return Tables.equalsImpl(this, obj);
  }

  @Override
  public int hashCode() {
    return cellSet().hashCode();
  }

    String expected = charSequence.toString();

    // read char by char
    CharSequenceReader reader = new CharSequenceReader(charSequence);
    for (int i = 0; i < expected.length(); i++) {
      assertEquals(expected.charAt(i), reader.read());
    }
    assertFullyRead(reader);

    // read all to one array
    reader = new CharSequenceReader(charSequence);

        int result = NtlmMessage.readULong(a, 0);
        assertEquals(0x04030201, result, "ULong should be little‑endian");
    }

    @Test
    @DisplayName("readUShort correctly interprets little endian")
    void testReadUShort() {
        byte[] a = new byte[] { (byte) 0xAA, (byte) 0xBB };
        int result = NtlmMessage.readUShort(a, 0);

namespace internal {
namespace {

using tensorflow::TF_StatusPtr;

void CompareNumericalAndManualGradients(
    Model model, AbstractContext* ctx,
    absl::Span<AbstractTensorHandle* const> inputs, int input_index,
    float* expected_grad, int num_grad, bool use_function,
    double abs_error = 1e-2) {
  absl::Status s;
  AbstractTensorHandlePtr numerical_grad;
  {
    AbstractTensorHandle* numerical_grad_raw;