*/
package org.codelibs.core.beans.factory;

import static org.codelibs.core.collection.CollectionsUtil.newConcurrentHashMap;
import static org.codelibs.core.collection.CollectionsUtil.putIfAbsent;
import static org.codelibs.core.misc.AssertionUtil.assertArgumentNotNull;

import java.util.concurrent.ConcurrentMap;

import org.codelibs.core.beans.BeanDesc;
import org.codelibs.core.beans.impl.BeanDescImpl;

            sessionIdList.add(sid);

            final String urlsStr = webConfig.getUrls();
            if (StringUtil.isBlank(urlsStr)) {
                logger.warn("No target urls. Skipped");
                break;
            }

            // interval time
            final int intervalTime =
                    webConfig.getIntervalTime() != null ? webConfig.getIntervalTime() : Constants.DEFAULT_INTERVAL_TIME_FOR_WEB;

import static org.junit.Assert.assertThat;

import java.util.List;
import java.util.Map;

import org.codelibs.core.beans.BeanDesc;
import org.codelibs.core.beans.FieldDesc;
import org.codelibs.core.beans.ParameterizedClassDesc;
import org.codelibs.core.exception.FieldNotStaticRuntimeException;
import org.junit.Test;

/**
 * @author koichik
 */
public class FieldDescImplTest {

    /**

import java.util.List;
import java.util.Map;
import java.util.Set;

import org.codelibs.core.beans.BeanDesc;
import org.codelibs.core.beans.FieldDesc;
import org.codelibs.core.beans.MethodDesc;
import org.codelibs.core.beans.ParameterizedClassDesc;
import org.codelibs.core.beans.PropertyDesc;
import org.codelibs.core.beans.factory.BeanDescFactory;
import org.codelibs.core.exception.MethodNotFoundRuntimeException;
import org.junit.Test;

 */
package org.codelibs.core.beans.impl;

import static org.codelibs.core.misc.AssertionUtil.assertArgumentArrayIndex;
import static org.codelibs.core.misc.AssertionUtil.assertArgumentNotNull;

import java.lang.reflect.Method;
import java.util.Collection;
import java.util.Map;

import org.codelibs.core.beans.BeanDesc;
import org.codelibs.core.beans.MethodDesc;

    return FutureTask<Void> {
      socket.source.use {
        socket.sink.use {
          while (true) {
            val action = actions.poll() ?: break
            action(socket)
          }
        }
      }
      return@FutureTask null
    }
  }

  /** Returns once all stream actions complete successfully. */
  fun awaitSuccess() {

import java.util.logging.Level;
import org.jspecify.annotations.Nullable;

/** Implementation of {@link Futures#immediateFuture}. */
@GwtCompatible
// TODO(cpovirk): Make this final (but that may break Mockito spy calls).
class ImmediateFuture<V extends @Nullable Object> implements ListenableFuture<V> {
  static final ListenableFuture<?> NULL = new ImmediateFuture<@Nullable Object>(null);

    file.read()
```

En versiones recientes de Python, también hay un **async context manager**. Lo usarías con `async with`:

```Python
async with lifespan(app):
    await do_stuff()
```

Cuando creas un context manager o un async context manager como arriba, lo que hace es que, antes de entrar al bloque `with`, ejecutará el código antes del `yield`, y al salir del bloque `with`, ejecutará el código después del `yield`.

            if (element.getMethodName().equals("test_stackTrace") && element.getClassName().equals(this.getClass().getName())) {
                foundTestMethod = true;
                break;
            }
        }
        assertTrue(foundTestMethod);
    }

    public void test_serialVersionUID() {
        // Test that serialVersionUID is defined (by checking serializability)

import jcifs.internal.util.SMBUtil;

/**
 * SMB1 COM_LOCKING_ANDX command implementation.
 *
 * This command locks or unlocks byte ranges within a file. It can also
 * be used to break oplocks and change oplock levels.
 *
 * @author mbechler
 */
public class SmbComLockingAndX extends AndXServerMessageBlock {

    private int fid;
    private byte typeOfLock;
    private byte newOpLockLevel;