}

	if ch, size, err := (&Reader{}).ReadRune(); ch != 0 || size != 0 || err != io.EOF {
		t.Errorf("ReadRune: got %d, %d, %v; want 0, 0, io.EOF", ch, size, err)
	}

	if offset, err := (&Reader{}).Seek(11, io.SeekStart); offset != 11 || err != nil {
		t.Errorf("Seek: got %d, %v; want 11, nil", offset, err)
	}

	if s := (&Reader{}).Size(); s != 0 {
		t.Errorf("Size: got %d, want 0", s)
	}

      if (ancestor != null) {
        ancestor.addToMap();
      } else {
        map.put(key, delegate);
      }
    }

    @Override
    public int size() {
      refreshIfEmpty();
      return delegate.size();
    }

    @Override
    /*
     * Most Multimap implementations use a List or Set (or even Multiset) for their values, in which

    try {
      block(content)
      constructedBit = if (constructed) 0b0010_0000 else 0
      constructed = true // The enclosing object is constructed.
    } finally {
      stack.removeAt(stack.size - 1)
      path.removeAt(path.size - 1)
    }

    val sink = sink()

    // Write the tagClass, tag, and constructed bit. This takes 1 byte if tag is less than 31.
    if (tag < 31) {

        final Set<String> set = new HashSet<String>();
        traverser.forEach((ClassHandler) (packageName, shortClassName) -> set.add(ClassUtil.concatName(packageName, shortClassName)));
        assertThat(set.size() > 0, is(true));
        assertThat(set.contains(DummyTest.class.getName()), is(true));
        assertThat(set.contains(TraverserUtilTest.class.getName()), is(true));

        assertEquals(0, list.size());
        assertTrue(list.isEmpty());
    }

    @Test
    public void test_selectList_negativeOffset() {
        // Load data first
        protwordsFile.reload(null);

        // Test with negative offset
        PagingList<ProtwordsItem> list = protwordsFile.selectList(-1, 10);
        assertEquals(0, list.size());
    }

    @Test

    // no equals and hashCode; it would break the contract!
  }

  /** Returns the number of elements in {@code iterable}. */
  public static int size(Iterable<?> iterable) {
    return (iterable instanceof Collection)
        ? ((Collection<?>) iterable).size()
        : Iterators.size(iterable.iterator());
  }

  /**
   * Returns {@code true} if {@code iterable} contains any element {@code o} for which {@code

  }

  @Override
  public boolean isEmpty() {
    return backingMap.isEmpty();
  }

  @Override
  public int size() {
    int size = 0;
    for (Map<C, V> map : backingMap.values()) {
      size += map.size();
    }
    return size;
  }

  // Mutators

  @Override
  public void clear() {
    backingMap.clear();
  }

accessModes: [ {{ $accessMode | quote }} ] {{- if $storageClass }} storageClassName: {{ $storageClass }} {{- end }} resources: requests: storage: {{ $psize }} {{- end }} {{- else }} - metadata: name: export spec: accessModes: [ {{ $accessMode | quote }} ] {{- if $storageClass }} storageClassName: {{ $storageClass }} {{- end }} resources: requests: storage: {{ $psize }} {{- end }} {{- end }} {{- end }} minio/.helmignore # Patterns to ignore when building packages. # This supports shell glob matching, relative...

accessModes: [ {{ $accessMode | quote }} ] {{- if $storageClass }} storageClassName: {{ $storageClass }} {{- end }} resources: requests: storage: {{ $psize }} {{- end }} {{- else }} - metadata: name: export spec: accessModes: [ {{ $accessMode | quote }} ] {{- if $storageClass }} storageClassName: {{ $storageClass }} {{- end }} resources: requests: storage: {{ $psize }} {{- end }} {{- end }} {{- end }} minio/.helmignore # Patterns to ignore when building packages. # This supports shell glob matching, relative...

accessModes: [ {{ $accessMode | quote }} ] {{- if $storageClass }} storageClassName: {{ $storageClass }} {{- end }} resources: requests: storage: {{ $psize }} {{- end }} {{- else }} - metadata: name: export spec: accessModes: [ {{ $accessMode | quote }} ] {{- if $storageClass }} storageClassName: {{ $storageClass }} {{- end }} resources: requests: storage: {{ $psize }} {{- end }} {{- end }} {{- end }} minio/.helmignore # Patterns to ignore when building packages. # This supports shell glob matching, relative...