map.put("Null", null);
    Function<String, @Nullable Integer> function = Functions.forMap(map, 42);

    assertEquals(1, function.apply("One").intValue());
    assertEquals(42, function.apply("Two").intValue());
    assertEquals(3, function.apply("Three").intValue());
    assertThat(function.apply("Null")).isNull();

    new EqualsTester()
        .addEqualityGroup(function, Functions.forMap(map, 42))

		maxInt64Plus1Ptr = &maxInt64Plus1
	)
	tests := []struct {
		name    string
		value   interface{}
		want    interface{}
		wantErr bool
	}{
		{
			name:    "int",
			value:   intValue,
			want:    time.Unix(int64(intValue), 0).UTC(),
			wantErr: false,
		},
		{
			name:    "int8",
			value:   int8Value,
			want:    time.Unix(int64(int8Value), 0).UTC(),
			wantErr: false,
		},
		{
			name:    "int16",

      int j = i & ARRAY_MASK;
      tmp += oldSlowFactorial(slowFactorials[j]).intValue();
    }
    return tmp;
  }

  @Benchmark
  int factorial(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;
      tmp += BigIntegerMath.factorial(factorials[j]).intValue();
    }
    return tmp;
  }

  @Benchmark
  int binomial(int reps) {

        }

        value = props.getProperty("jcifs.smb.client.maxChannels");
        if (value != null) {
            try {
                int intValue = Integer.parseInt(value);
                if (intValue > 0) {
                    this.maxChannels = intValue;
                }
            } catch (NumberFormatException e) {
                // Invalid values ignored
            }
        }

    EquivalenceTester.of(Equivalence.equals().onResultOf(Functions.toStringFunction()))
        .addEquivalenceGroup(new IntValue(1), new IntValue(1))
        .addEquivalenceGroup(new IntValue(2))
        .test();
  }

  public void testOnResultOf_equals() {
    new EqualsTester()
        .addEqualityGroup(
            Equivalence.identity().onResultOf(Functions.toStringFunction()),

    map.put("Null", null);
    Function<String, @Nullable Integer> function = Functions.forMap(map, 42);

    assertEquals(1, function.apply("One").intValue());
    assertEquals(42, function.apply("Two").intValue());
    assertEquals(3, function.apply("Three").intValue());
    assertThat(function.apply("Null")).isNull();

    new EqualsTester()
        .addEqualityGroup(function, Functions.forMap(map, 42))

import okhttp3.internal.http2.Http2
import okhttp3.internal.platform.android.AndroidLog.androidLog

private val LogRecord.androidLevel: Int
  get() =
    when {
      level.intValue() > Level.INFO.intValue() -> Log.WARN
      level.intValue() == Level.INFO.intValue() -> Log.INFO
      else -> Log.DEBUG
    }

object AndroidLogHandler : Handler() {
  override fun publish(record: LogRecord) {

    assertEquals(1, ContiguousSet.create(Range.open(0, 4), integers()).first().intValue());
    assertEquals(
        Integer.MIN_VALUE,
        ContiguousSet.create(Range.<Integer>all(), integers()).first().intValue());
  }

  public void testLast() {
    assertEquals(3, ContiguousSet.create(Range.closed(1, 3), integers()).last().intValue());

  }

  public void testIntValue() {
    for (long a : TEST_LONGS) {
      UnsignedLong aUnsigned = UnsignedLong.fromLongBits(a);
      int intValue = aUnsigned.bigIntegerValue().intValue();
      assertThat(aUnsigned.intValue()).isEqualTo(intValue);
    }
  }

  @GwtIncompatible
  @J2ktIncompatible
    public void testSerialization() {
    for (long a : TEST_LONGS) {

    for (int x : POSITIVE_INTEGER_CANDIDATES) {
      BigInteger expectedResult = BigIntegerMath.ceilingPowerOfTwo(BigInteger.valueOf(x));
      if (fitsInInt(expectedResult)) {
        assertEquals(expectedResult.intValue(), IntMath.ceilingPowerOfTwo(x));
      } else {
        assertThrows(ArithmeticException.class, () -> IntMath.ceilingPowerOfTwo(x));
      }
    }
  }

  public void testFloorPowerOfTwo() {