return value;
              }
            });
      }
      assertThat(segment.count).isEqualTo(count);
      assertThat(count).isAtMost(segment.threshold);
      assertThat(count).isAtMost((segment.table.length() * 3 / 4));
      assertThat(count).isGreaterThan(segment.table.length() * 3 / 8);
    }
  }

  @SuppressWarnings("TruthGetOrDefault") // We are testing our implementation of getOrDefault.

                return value;
              }
            });
      }
      assertThat(segment.count).isEqualTo(count);
      assertThat(count).isAtMost(segment.threshold);
      assertThat(count).isAtMost((segment.table.length() * 3 / 4));
      assertThat(count).isGreaterThan(segment.table.length() * 3 / 8);
    }
  }

  @SuppressWarnings("TruthGetOrDefault") // We are testing our implementation of getOrDefault.

    if (edge->src_output() == oper_out.index) {
      if (count < max_consumers) {
        consumers[count] = {ToOperation(edge->dst()), edge->dst_input()};
      }
      ++count;
    }
  }
  return count;
}

int TF_OperationNumControlInputs(TF_Operation* oper) {
  int count = 0;
  for (const auto* edge : oper->node.in_edges()) {
    if (edge->IsControlEdge() && !edge->src()->IsSource()) {

                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;

    /** The key of the message: by Click Count (asc) */
    public static final String LABELS_search_result_sort_click_count_asc = "{labels.search_result_sort_click_count_asc}";

    /** The key of the message: by Click Count (desc) */
    public static final String LABELS_search_result_sort_click_count_desc = "{labels.search_result_sort_click_count_desc}";

    /** The key of the message: by Favorite Count (asc) */

                    final Object count = contentMap.get("count");
                    if (count instanceof Number) {
                        return ((Number) count).longValue();
                    }
                }
            }
        } catch (final Exception e) {
            logger.debug("Failed to get document count: indexName={}", indexName, e);
        }
        return -1;
    }

                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;

	peerLocks := globalNotificationSys.GetLocks(ctx, r)

	topLocks := topLockEntries(peerLocks, stale)

	// Marshal API response upto requested count.
	if len(topLocks) > count && count > 0 {
		topLocks = topLocks[:count]
	}

	jsonBytes, err := json.Marshal(topLocks)
	if err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}

			}

			if qs.QStats.Avg.Count > 0 || qs.QStats.Curr.Count > 0 {
				qt := qs.QStats
				currInQueueBytes.Value = qt.Curr.Bytes
				currInQueueCount.Value = qt.Curr.Count
				avgQueueBytes.Value = qt.Avg.Bytes
				avgQueueCount.Value = qt.Avg.Count
				maxQueueBytes.Value = qt.Max.Bytes
				maxQueueCount.Value = qt.Max.Count
			}
			activeWorkersCount.Value = float64(qs.ActiveWorkers.Curr)

// checkOld can be set to an expected value.
// If the worker count changed
func (p *ReplicationPool) ResizeLrgWorkers(n, checkOld int) {
	p.mu.Lock()
	defer p.mu.Unlock()

	if (checkOld > 0 && len(p.lrgworkers) != checkOld) || n == len(p.lrgworkers) || n < 1 {
		// Either already satisfied or worker count changed while we waited for the lock.
		return
	}
	for len(p.lrgworkers) < n {