protected @Nullable Object handleInvocation(
        Object p, Method calledMethod, @Nullable Object[] args) throws Throwable {
      assertEquals(method, calledMethod);
      assertEquals(method + " invoked more than once.", 0, called.get());
      for (int i = 0; i < passedArgs.length; i++) {
        assertEquals(
            "Parameter #" + i + " of " + method + " not forwarded", passedArgs[i], args[i]);
      }

* `seek(offset)`: Переміщується до позиції `offset` (`int`) у файлі.
    * Наприклад, `await myfile.seek(0)` поверне курсор на початок файлу.
    * This is especially useful if you run `await myfile.read()` once and then need to read the contents again. Це особливо корисно, якщо Ви виконуєте await `await myfile.read()` один раз, а потім потрібно знову прочитати вміст.
* `close()`: Закриває файл.

graph TB

common_parameters(["common_parameters"])
read_items["/items/"]
read_users["/users/"]

common_parameters --> read_items
common_parameters --> read_users
```

This way you write shared code once and **FastAPI** takes care of calling it for your *path operations*.

/// check

Notice that you don't have to create a special class and pass it somewhere to **FastAPI** to "register" it or anything similar.

* Data "<abbr title="converting the string that comes from an HTTP request into Python data">parsing</abbr>"
* Data validation
* API annotation and automatic documentation

And you only have to declare them once.

      auto& indices = iter->second;
      if (std::find(indices.begin(), indices.end(), idx) != indices.end()) {
        return InvalidArgument("TF_Output ", node->name(), ":", idx,
                               " appears more than once in the input list");
      }
      indices.push_back(idx);
    }
  }
  return absl::OkStatus();
}

// Converts `noutputs` and `outputs` into `outputs_tensors` and does various
// checks while doing so.

   * specified is included. To create a copy of a {@code SortedSet} that preserves the comparator,
   * call {@link #copyOfSorted} instead. This method iterates over {@code elements} at most once.
   *
   * <p>Note that if {@code s} is a {@code Set<String>}, then {@code ImmutableSortedSet.copyOf(s)}
   * returns an {@code ImmutableSortedSet<String>} containing each of the strings in {@code s},

    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 =

   * 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.

    @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);
        }

        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