}

  // Since we can't pass a concrete SomeEnum.class directly, we need to use a raw type.
  @SuppressWarnings("unchecked")
  @Benchmark
  boolean getIfPresent(int repetitions) {
    boolean retVal = false;
    for (int i = 0; i < repetitions; ++i) {
      retVal &= Enums.getIfPresent(enumType, sampleData[i & 255]).isPresent();
    }
    return retVal;
  }

  )
  fun code(): Int = code

  /**
   * Returns true if the code is in [200..300), which means the request was successfully received,
   * understood, and accepted.
   */
  val isSuccessful: Boolean = code in 200..299

  @JvmName("-deprecated_message")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "message"),
    level = DeprecationLevel.ERROR,
  )

   * as well.
   */
  @Override
  public abstract ImmutableMap<R, Map<C, V>> rowMap();

  @Override
  public boolean contains(@Nullable Object rowKey, @Nullable Object columnKey) {
    return get(rowKey, columnKey) != null;
  }

  @Override
  public boolean containsValue(@Nullable Object value) {
    return values().contains(value);
  }

  /**

  val mappings: String,
) {
  /**
   * Returns true if the [codePoint] was applied successfully. Returns false if it was disallowed.
   */
  fun map(
    codePoint: Int,
    sink: BufferedSink,
  ): Boolean {
    val sectionsIndex = findSectionsIndex(codePoint)

    val rangesPosition = sections.read14BitInt(sectionsIndex + 2)

    val rangesLimit =
      when {

            assertEquals(0x7F, allCaps, "All capabilities combined should equal 0x7F");
        }

        private boolean isPowerOfTwo(int n) {
            return n > 0 && (n & (n - 1)) == 0;
        }
    }

    @Nested
    @DisplayName("Info Level Constants")
    class InfoLevelConstants {

        @Test

        // Given
        when(mockDelegate.hasNext()).thenReturn(true, false);
        when(mockDelegate.next()).thenReturn(mockFileEntry1);

        // Create iterator with custom adapt implementation
        final boolean[] adaptCalled = { false };
        DirFileEntryAdapterIterator iterator = new DirFileEntryAdapterIterator(mockParent, mockDelegate, null) {
            @Override
            protected SmbResource adapt(FileEntry e) {

    Iterator<Entry<E>> entryIterator() {
      Iterator<Map.Entry<E, Integer>> backingEntries = backingMap.entrySet().iterator();
      return new UnmodifiableIterator<Multiset.Entry<E>>() {
        @Override
        public boolean hasNext() {
          return backingEntries.hasNext();
        }

        @Override
        public Multiset.Entry<E> next() {
          Map.Entry<E, Integer> mapEntry = backingEntries.next();

          return null;
        },
        /* userPassedSupplier= */ false);
  }

  private static <T extends Throwable> T doAssertThrows(
      Class<T> expectedThrowable, ThrowingSupplier supplier, boolean userPassedSupplier) {
    checkNotNull(expectedThrowable);
    checkNotNull(supplier);
    Predicate<Throwable> predicate = INSTANCE_OF.get(expectedThrowable);
    if (predicate == null) {

        assertNotNull(exception.getStackTrace());
        assertTrue(exception.getStackTrace().length > 0);

        // Verify the stack trace contains this test method
        boolean foundTestMethod = false;
        for (StackTraceElement element : exception.getStackTrace()) {
            if (element.getMethodName().equals("test_stackTrace") && element.getClassName().equals(this.getClass().getName())) {

    try {
      return block()
    } finally {
      typeHintStack.removeAt(typeHintStack.size - 1)
    }
  }

  private fun sink(): BufferedSink = stack[stack.size - 1]

  fun writeBoolean(b: Boolean) {
    sink().writeByte(if (b) -1 else 0)
  }

  fun writeBigInteger(value: BigInteger) {
    sink().write(value.toByteArray())
  }

  fun writeLong(v: Long) {
    val sink = sink()