from pydantic.v1 import BaseModel


class Item(BaseModel):
    name: str
    description: str | None = None

      }

      @Override
      public Iterator<Entry<E>> iterator() {
        return entryIterator();
      }

      @Override
      public int size() {
        return forwardMultiset().entrySet().size();
      }
    }
    return new EntrySetImpl();
  }

  @Override
  public Iterator<E> iterator() {
    return Multisets.iteratorImpl(this);
  }

  @Override

        int offset = 10;
        int size = 100;
        when(response.verifySignature(buffer, offset, size)).thenReturn(true);

        // When
        boolean verified = response.verifySignature(buffer, offset, size);

        // Then
        assertTrue(verified);
        verify(response).verifySignature(buffer, offset, size);
    }

    @Test

    IndexOutOfBoundsException expected =
        assertThrows(IndexOutOfBoundsException.class, () -> checkElementIndex(1, 1));
    assertThat(expected).hasMessageThat().isEqualTo("index (1) must be less than size (1)");
  }

  public void testCheckElementIndex_withDesc_negative() {
    IndexOutOfBoundsException expected =
        assertThrows(IndexOutOfBoundsException.class, () -> checkElementIndex(-1, 1, "foo"));

        }
        load();
    }

    /**
     * Retrieves a list of all available related query entities from the data store.
     * The results are ordered by term and limited by the configured maximum fetch size.
     *
     * @return a list of RelatedQuery entities containing all available related queries
     */
    public List<RelatedQuery> getAvailableRelatedQueryList() {

    Collection<V> result = multimap().asMap().get(k0());
    assertTrue(result.remove(v0()));
    assertFalse(multimap().containsEntry(k0(), v0()));
    assertEquals(2, multimap().size());
  }

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testPropagatesRemoveLastElementToMultimap() {
    Collection<V> result = multimap().asMap().get(k0());

    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & SAMPLE_MASK;
      int x = xInts[j];
      int y = yInts[j];
      int z = constant[j];
      tmp += z + ((x - y) >>> (Integer.SIZE - 1));
    }
    return tmp;
  }

  @Benchmark
  int branchFreeLtInt(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & SAMPLE_MASK;
      int x = xInts[j];

  @BeforeExperiment
  void setUp() {
    for (int i = 0; i < ARRAY_SIZE; i++) {
      positive[i] = randomPositiveBigInteger(Long.SIZE - 2).longValue();
      nonzero[i] = randomNonZeroBigInteger(Long.SIZE - 2).longValue();
      longs[i] = RANDOM_SOURCE.nextLong();
    }
  }

  @Benchmark
  int log2(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {

                versionsByMinor.entries.forEachIndexed { idx, entry ->
                    val versionsOfMinor = entry.value.sortedByDescending { VersionNumber.parse(it) }
                    if (idx < versionsByMinor.size - 1) {
                        // Latest of the previous minor
                        add(versionsOfMinor.first())
                    } else {
                        // Current minor

 *
 * @author higa
 */
public abstract class InputStreamUtil {

    /**
     * Do not instantiate.
     */
    protected InputStreamUtil() {
    }

    /** Default buffer size. */
    private static final int BUF_SIZE = 4096;

    /**
     * Creates a {@link FileInputStream}.
     *
     * @param file the file (must not be {@literal null})