* <p>By default this method does nothing.
   */
  protected void shutDown() throws Exception {}

  /**
   * Returns the {@link Scheduler} object used to configure this service. This method will only be
   * called once.
   */
  // TODO(cpovirk): @ForOverride
  protected abstract Scheduler scheduler();

  /**
   * Returns the {@link ScheduledExecutorService} that will be used to execute the {@link #startUp},

   * each appears first in the source iterable. This method iterates over {@code elements} only
   * once.
   *
   * <p><b>Performance note:</b> This method will sometimes recognize that the actual copy operation
   * is unnecessary; for example, {@code copyOf(copyOf(anArrayList))} should copy the data only
   * once. This reduces the expense of habitually making defensive copies at API boundaries.

      if (orderedNodeConnections != null) {
        orderedNodeConnections.remove(new NodeConnection.Succ<>((N) node));
      }
    }

    /*
     * TODO(cpovirk): `return (V) removedValue` once our checker permits that.
     *
     * (We promoted a class of warnings into errors because sometimes they indicate real problems.
     * But now we need to "undo" some instance of spurious errors, as discussed in

That same information from the models that is included in OpenAPI is what can be used to **generate the client code**.

### Hey API { #hey-api }

Once we have a FastAPI app with the models, we can use Hey API to generate a TypeScript client. The fastest way to do that is via npx.

```sh
npx @hey-api/openapi-ts -i http://localhost:8000/openapi.json -o src/client
```

    assertFailsWith<IllegalStateException> {
      client.newCall(request).execute()
    }.also { expected ->
      assertThat(expected.message).isEqualTo(
        "network interceptor $interceptor must call proceed() exactly once",
      )
    }
  }

  @Test
  fun networkInterceptorsCannotCallProceedMultipleTimes() {
    server.enqueue(MockResponse())
    server.enqueue(MockResponse())
    val interceptor =

          }
        });

    // Run those tasks together.
    fakePool.runAll();

    // Check that the interruption of a SequentialExecutor's task is restored to the thread once
    // it is yielded. Clear the bit while checking so that the test doesn't hose JUnit or some other
    // test case.
    assertThat(Thread.interrupted()).isTrue();
  }

            this.provider = Crypto.getProvider();
            break;
        default:
            throw new IllegalArgumentException("Unknown dialect");
        }

        // Initialize the digest once to validate configuration
        this.digest = createMacInstance();
    }

    /**
     * Create a new Mac instance for thread-safe operations
     * @return initialized Mac instance

        lenient().when(fileEntry.getName()).thenReturn("test");
    }

    @Test
    @DisplayName("Iterator without filter - simple case")
    void iteratorWithoutFilter() {
        // Setup: constructor calls advance() once
        when(delegate.hasNext()).thenReturn(true, false);
        when(delegate.next()).thenReturn(fileEntry);

        TestIterator iterator = new TestIterator(null);

        // Verify iteration

                    fail("Thread failed: " + e.getMessage());
                } finally {
                    doneLatch.countDown();
                }
            });
        }

        // Start all threads at once
        startLatch.countDown();

        // Wait for completion
        assertTrue(doneLatch.await(5, TimeUnit.SECONDS), "Threads did not complete in time");
        executor.shutdown();

    @Test
    void testMultipleUpdates() {
        // Test multiple update calls
        HMACT64 hmac1 = new HMACT64(TEST_KEY);
        HMACT64 hmac2 = new HMACT64(TEST_KEY);

        // Update hmac1 all at once
        hmac1.engineUpdate(TEST_DATA, 0, TEST_DATA.length);

        // Update hmac2 byte by byte
        for (byte b : TEST_DATA) {
            hmac2.engineUpdate(b);
        }