if err != nil {
			return err
		}
	} else {
		// Evaluate the (only) argument
		val, err = e.SFunc.ArgsList[0].evalNode(r, tableAlias)
		if err != nil {
			return err
		}
	}

	if val.IsNull() {
		// E.g. the column or field does not exist in the
		// record - in all such cases the aggregation is not
		// updated.
		return nil
	}

	argVal := val
	if funcName != aggFnCount {

    rangeSet.add(Range.closed(3, 10));
    assertEquals(Range.closed(3, 10), rangeSet.rangeContaining(5));
    assertTrue(rangeSet.contains(5));
    assertThat(rangeSet.rangeContaining(1)).isNull();
    assertFalse(rangeSet.contains(1));
  }

  public void testRangeContaining2() {
    RangeSet<Integer> rangeSet = TreeRangeSet.create();
    rangeSet.add(Range.closed(3, 10));

import assertk.assertions.contains
import assertk.assertions.hasMessage
import assertk.assertions.isCloseTo
import assertk.assertions.isEqualTo
import assertk.assertions.isFalse
import assertk.assertions.isNull
import assertk.assertions.isTrue
import assertk.fail
import java.io.IOException
import java.net.HttpURLConnection
import java.net.SocketTimeoutException
import java.time.Duration
import java.util.Arrays

      assertEquals(Integer.valueOf(0), defaultConverter.convert("anything"));
      assertEquals("", defaultConverter.reverse().convert(123));
      assertThat(defaultConverter.convert(null)).isNull();
      assertThat(defaultConverter.reverse().convert(null)).isNull();
    }
  }

  public void testConverterDefaultValue() {
    new ConverterDefaultValueChecker().check();
  }

  private static class VisibilityMethods {

    BiMap<Integer, Integer> bimap = HashBiMap.create(N);
    BiMap<Integer, Integer> inverse = bimap.inverse();

    for (int i = 0; i < N; i++) {
      assertThat(bimap.put(2 * i, 2 * i + 1)).isNull();
    }
    for (int i = 0; i < N; i++) {
      assertEquals(2 * i + 1, (int) bimap.get(2 * i));
    }
    for (int i = 0; i < N; i++) {
      assertEquals(2 * i, (int) inverse.get(2 * i + 1));
    }

  }

  public void testOfInstanceSuppliesNull() {
    Supplier<@Nullable Integer> nullSupplier = Suppliers.ofInstance(null);
    assertThat(nullSupplier.get()).isNull();
  }

  @J2ktIncompatible
  @GwtIncompatible // Thread
  @SuppressWarnings("DoNotCall")
  public void testExpiringMemoizedSupplierThreadSafe() throws Throwable {

  }

  public void testOfInstanceSuppliesNull() {
    Supplier<@Nullable Integer> nullSupplier = Suppliers.ofInstance(null);
    assertThat(nullSupplier.get()).isNull();
  }

  @J2ktIncompatible
  @GwtIncompatible // Thread
  @SuppressWarnings("DoNotCall")
  public void testExpiringMemoizedSupplierThreadSafe() throws Throwable {

    underlying.put("a", 1);
    Map<String, String> map = transformValues(underlying, Functions.toStringFunction());
    assertEquals("1", map.remove("a"));
    assertThat(map.remove("b")).isNull();
  }

  public void testTransformEqualityOfMapsWithNullValues() {
    Map<String, @Nullable String> underlying = new HashMap<>();
    underlying.put("a", null);
    underlying.put("b", "");

  }

  public void testStandardLastEntry() {
    NavigableMap<String, Integer> forwarding =
        new StandardLastEntryForwardingNavigableMap<>(new SafeTreeMap<String, Integer>());
    assertThat(forwarding.lastEntry()).isNull();
    forwarding.put("b", 2);
    assertEquals(immutableEntry("b", 2), forwarding.lastEntry());
    forwarding.put("c", 3);
    assertEquals(immutableEntry("c", 3), forwarding.lastEntry());
    forwarding.put("a", 1);

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;