/**
 * Test for {@link WrappingExecutorService}
 *
 * @author Chris Nokleberg
 */
@NullUnmarked
public class WrappingExecutorServiceTest extends TestCase {
  private static final String RESULT_VALUE = "ran";

  // Uninteresting delegations
  public void testDelegations() throws InterruptedException {
    MockExecutor mock = new MockExecutor();
    TestExecutor testExecutor = new TestExecutor(mock);

you doing out here?  Run home this moment, and fetch me a pair of
gloves and a fan!  Quick, now!'  And Alice was so much frightened
that she ran off at once in the direction it pointed to, without
trying to explain the mistake it had made.

  `He took me for his housemaid,' she said to herself as she ran.
`How surprised he'll be when he finds out who I am!  But I'd
better take him his fan and gloves--that is, if I can find them.'

Por lo tanto, el ladrón no podrá intentar usar esa contraseña en otro sistema (como muchos usuarios usan la misma contraseña en todas partes, esto sería peligroso).

## Instalar `passlib`

PassLib es un gran paquete de Python para manejar hashes de contraseñas.

Soporta muchos algoritmos de hashing seguros y utilidades para trabajar con ellos.

El algoritmo recomendado es "Bcrypt".

            currentThread.name = task.name
            val delayNanos =
              logger.logElapsed(task, task.queue!!) {
                task.runOnce()
              }

            // A task ran successfully. Update the execution state and take the next task.
            task = withLock {
              afterRun(task, delayNanos, true)
              awaitTaskToRun()
            } ?: return
          }

/// tip | Consejo

Al añadir `standard`, Uvicorn instalará y usará algunas dependencias adicionales recomendadas.

Eso incluye `uvloop`, el reemplazo de alto rendimiento para `asyncio`, que proporciona un gran impulso de rendimiento en concurrencia.

Cuando instalas FastAPI con algo como `pip install "fastapi[standard]"` ya obtienes `uvicorn[standard]` también.

///

## Ejecuta el Programa del Servidor

Pero `open()` no usa `async` y `await`.

Por eso, declaramos la función manejadora del evento con `def` estándar en vez de `async def`.

///

### `startup` y `shutdown` juntos

Hay una gran posibilidad de que la lógica para tu *startup* y *shutdown* esté conectada, podrías querer iniciar algo y luego finalizarlo, adquirir un recurso y luego liberarlo, etc.

                return;
              } else {
                // Increment the run counter to avoid the ABA problem of a submitter marking the
                // thread as QUEUED after it already ran and exhausted the queue before returning
                // from execute().
                workerRunCount++;
                workerRunningState = RUNNING;
                hasSetRunning = true;
              }

        boundaryIndex != -1L -> boundaryIndex // We found the boundary.
        source.buffer.size >= toIndex -> minOf(toIndex, maxByteCount) // No boundary before toIndex.
        else -> throw EOFException() // We ran out of data before we found the required boundary.
      }
    }

    @Throws(IOException::class)
    override fun close() {
      if (closed) return
      closed = true
      currentPart = null

				break
			}
			runeCount++
			got, _ := utf8.DecodeRune(s.Bytes())
			if got != expect {
				t.Errorf("#%d: %d: expected %q got %q", n, i, expect, got)
			}
		}
		if s.Scan() {
			t.Errorf("#%d: scan ran too long, got %q", n, s.Text())
		}
		testRuneCount := utf8.RuneCountInString(test)
		if runeCount != testRuneCount {
			t.Errorf("#%d: termination expected at %d; got %d", n, testRuneCount, runeCount)
		}
		err := s.Err()

Esto será especialmente útil cuando lo uses en una **gran base de código** donde uses **las mismas dependencias** una y otra vez en **muchas *path operations***.

## Usar `async` o no usar `async`