final int count = searchLogHelper.getClickCount(url);
        doc.put(clickCountField, count);
        if (logger.isDebugEnabled()) {
            logger.debug("Updated click count: count={}, url={}", count, url);
        }
    }

    /**
     * Adds favorite count information to the document.
     *
     * @param doc the document to update

    teststring = newTestString(new Random(1), bitSet, percentMatching);
  }

  @Benchmark
  public int countIn(int reps) {
    int result = 0;
    CharMatcher matcher = this.matcher;
    String teststring = this.teststring;
    for (int i = 0; i < reps; i++) {
      result += matcher.countIn(teststring);
    }
    return result;
  }

  @Benchmark
  public int collapseFrom(int reps) {
    int result = 0;

        assertEquals(buffer, getFieldValue(write, "b"), "Buffer reference should be set");
        assertEquals(off, getFieldValue(write, "off"), "Off should match constructor arg");
        assertEquals(len, getFieldValue(write, "count"), "Count should equal len");
    }

    /**
     * Test setParam method updates the write parameters
     */
    @Test
    public void testSetParam() {
        // Arrange

      // The JVM will return interned values for small ints.
      Integer value = random.nextInt(1000) + 128;
      int count = min(random.nextInt(10) + 1, sizeRemaining);
      sizeRemaining -= count;
      hashMultiset.add(value, count);
      linkedHashMultiset.add(value, count);
      treeMultiset.add(value, count);
    }

    // TODO(kevinb): convert to assert once benchmark tests enable asserts by default

                windowStart = now;
            }

            recentAttempts.incrementAndGet();
            lastAttempt = now;
        }

        void recordSuccess() {
            // Reduce counter on success to allow recovery
            recentAttempts.updateAndGet(val -> Math.max(0, val - 1));
        }

        void reset() {
            recentAttempts.set(0);
            blocked.set(false);

)

var (
	healthDrivesOfflineCountMD = NewGaugeMD(healthDrivesOfflineCount,
		"Count of offline drives in the cluster")
	healthDrivesOnlineCountMD = NewGaugeMD(healthDrivesOnlineCount,
		"Count of online drives in the cluster")
	healthDrivesCountMD = NewGaugeMD(healthDrivesCount,
		"Count of all drives in the cluster")
)

// loadClusterHealthDriveMetrics - `MetricsLoaderFn` for cluster storage drive metrics

//
//msgp:tuple VolInfo
type VolInfo struct {
	// Name of the volume.
	Name string

	// Date and time when the volume was created.
	Created time.Time

	// total VolInfo counts
	count int

	// Date and time when the volume was deleted, if Deleted
	Deleted time.Time
}

// FilesInfo represent a list of files, additionally
// indicates if the list is last.
//

license to downstream recipients.  "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.

  If, pursuant to or in connection with a single transaction or

	}

	count := 3

	var languages []Language
	for i := 0; i < count; i++ {
		language := Language{Code: fmt.Sprintf("consurrent %d", i)}
		db.Create(&language)
		languages = append(languages, language)
	}

	user := User{}
	db.Create(&user)
	db.Preload("Languages").FirstOrCreate(&user)

	var wg sync.WaitGroup
	for i := 0; i < count; i++ {
		wg.Add(1)

    assertEquals(0, multimap().keys().count(null));
  }

  @CollectionSize.Require(SEVERAL)
  @MapFeature.Require(ALLOWS_NULL_KEYS)
  public void testKeysWithNullKey() {
    resetContainer(mapEntry((K) null, v0()), mapEntry((K) null, v1()), mapEntry(k1(), v0()));
    Multiset<K> keys = multimap().keys();
    assertEquals(2, keys.count(null));
    assertEquals(1, keys.count(k1()));
    assertEquals(3, keys.size());