}

  /** Returns the number of bytes written. */
  public long getCount() {
    return count;
  }

  @Override
  public void write(byte[] b, int off, int len) throws IOException {
    out.write(b, off, len);
    count += len;
  }

  @Override
  public void write(int b) throws IOException {
    out.write(b);
    count++;
  }

                setValue(e, key, value, now);
                newCount = this.count; // count remains unchanged
              } else {
                setValue(e, key, value, now);
                newCount = this.count + 1;
              }
              this.count = newCount; // write-volatile
              evictEntries(e);
              return null;

     * @return the integer value of the hex digits
     */
    public static int hex_to_bin(final char[] arr, final int offset, final int length) {
        int value = 0;
        int ai, count;

        count = 0;
        for (ai = offset; ai < arr.length && count < length; ai++) {
            value <<= 4;
            switch (arr[ai]) {
            case '0':
            case '1':
            case '2':
            case '3':

	handle, err := syscall.FindFirstFile(globAllP, data)
	if err != nil {
		return nil, syscallErrToFileErr(dirPath, err)
	}

	defer syscall.FindClose(handle)

	count := opts.count
	for ; count != 0; err = syscall.FindNextFile(handle, data) {
		if err != nil {
			if err == syscall.ERROR_NO_MORE_FILES {
				break
			}
			return nil, osErrToFileErr(&os.PathError{
				Op:   "FindNextFile",

	defer direntNamePool.Put(nameTmp)
	tmp := *nameTmp

	boff := 0 // starting read position in buf
	nbuf := 0 // end valid data in buf

	count := opts.count

	for count != 0 {
		if boff >= nbuf {
			boff = 0
			stop := globalOSMetrics.time(osMetricReadDirent)
			nbuf, err = syscall.ReadDirent(fd, buf)
			stop()
			if err != nil {
				if isSysErrNotDir(err) {
					return nil, errFileNotFound

    ms.add(Color.RED);
    assertEquals(0, ms.count(Color.BLUE));
    assertEquals(1, ms.count(Color.YELLOW));
    assertEquals(2, ms.count(Color.RED));
  }

  public void testCollectionCreate() {
    Multiset<Color> ms = EnumMultiset.create(asList(Color.RED, Color.YELLOW, Color.RED));
    assertEquals(0, ms.count(Color.BLUE));
    assertEquals(1, ms.count(Color.YELLOW));
    assertEquals(2, ms.count(Color.RED));
  }

        // Process multiple elements
        int count = 1;
        while (transaction.hasMoreElements() && count < 10) {
            transaction.nextElement();
            count++;
        }

        assertTrue(count > 1, "Large data should require multiple elements");
    }

    @Test
    @DisplayName("Test transaction name handling")

     */
    public SearchBody() {
        super();
    }

    /** The URL that failed during crawling */
    public String url;

    /** Minimum error count filter */
    public Integer errorCountMin;

    /** Maximum error count filter */
    public Integer errorCountMax;

    /** Name or type of the error */
    public String errorName;

    multiset.add("bar");
    assertEquals(3, multiset.size());
    assertEquals(2, multiset.count("foo"));
  }

  public void testCreateWithSize() {
    Multiset<String> multiset = HashMultiset.create(50);
    multiset.add("foo", 2);
    multiset.add("bar");
    assertEquals(3, multiset.size());
    assertEquals(2, multiset.count("foo"));
  }

  public void testCreateFromIterable() {

	m.Set(replicationAverageQueuedCount, float64(qt.Avg.Count))
	m.Set(replicationMaxQueuedBytes, float64(qt.Max.Bytes))
	m.Set(replicationMaxQueuedCount, float64(qt.Max.Count))
	m.Set(replicationLastMinuteQueuedBytes, float64(qt.Curr.Bytes))
	m.Set(replicationLastMinuteQueuedCount, float64(qt.Curr.Count))

	qa := qs.ActiveWorkers
	m.Set(replicationAverageActiveWorkers, float64(qa.Avg))