assertEquals(0, segment.count);

    // same value
    segment.setTableEntryForTesting(index, entry);
    segment.count++;
    assertEquals(1, segment.count);
    assertSame(oldValue, segment.get(key, hash));
    assertTrue(segment.replace(key, hash, oldValue, newValue));
    assertEquals(1, segment.count);
    assertSame(newValue, segment.get(key, hash));

    assertEquals(0, segment.count);

    // same value
    segment.setTableEntryForTesting(index, entry);
    segment.count++;
    assertEquals(1, segment.count);
    assertSame(oldValue, segment.get(key, hash));
    assertTrue(segment.replace(key, hash, oldValue, newValue));
    assertEquals(1, segment.count);
    assertSame(newValue, segment.get(key, hash));

    assertThat(segment.get(key, hash)).isNull();

    // cleared
    table.set(index, entry);
    segment.count++;
    assertThat(segment.count).isEqualTo(1);
    assertThat(segment.get(key, hash)).isSameInstanceAs(oldValue);
    oldValueRef.clear();
    assertThat(segment.remove(key, hash)).isNull();
    assertThat(segment.count).isEqualTo(0);
    assertThat(segment.get(key, hash)).isNull();

    assertThat(segment.get(key, hash)).isNull();

    // cleared
    table.set(index, entry);
    segment.count++;
    assertThat(segment.count).isEqualTo(1);
    assertThat(segment.get(key, hash)).isSameInstanceAs(oldValue);
    oldValueRef.clear();
    assertThat(segment.remove(key, hash)).isNull();
    assertThat(segment.count).isEqualTo(0);
    assertThat(segment.get(key, hash)).isNull();

     */
    long sum = 0L;
    Segment<K, V, E, S>[] segments = this.segments;
    for (int i = 0; i < segments.length; ++i) {
      if (segments[i].count != 0) {
        return false;
      }
      sum += segments[i].modCount;
    }

    if (sum != 0L) { // recheck unless no modifications
      for (int i = 0; i < segments.length; ++i) {
        if (segments[i].count != 0) {
          return false;

      for (Segment<K, V> segment : segments) {
        if (segment.count != 0) {
          return false;
        }
        sum -= segment.modCount;
      }
      return sum == 0L;
    }
    return true;
  }

  long longSize() {
    Segment<K, V>[] segments = this.segments;
    long sum = 0;
    for (Segment<K, V> segment : segments) {
      sum += segment.count;
    }

        TaskSegment segment = createTaskSegment();
        projectBuilds.add(createProjectBuild(A, session, segment));
        projectBuilds.add(createProjectBuild(B, session, segment));
        projectBuilds.add(createProjectBuild(C, session, segment));
        projectBuilds.add(createProjectBuild(X, session, segment));
        projectBuilds.add(createProjectBuild(Y, session, segment));

    Segment<Object, Object> segment = cache.localCache.segments[0];
    ConcurrentMap<Object, Object> map = cache.asMap();

    Object one = new Object();
    assertThat(cache.getUnchecked(one)).isSameInstanceAs(one);
    assertThat(segment.recencyQueue.isEmpty()).isTrue();
    assertThat(map.get(one)).isSameInstanceAs(one);
    assertThat(segment.recencyQueue.peek().getKey()).isSameInstanceAs(one);

 * "/square/okhttp/issues/1486" and decompose into a list of segments like `["square", "okhttp",
 * "issues", "1486"]`.
 *
 * This class offers methods to compose and decompose paths by segment. It composes each path
 * from a list of segments by alternating between "/" and the encoded segment. For example the
 * segments `["a", "b"]` build "/a/b" and the segments `["a", "b", ""]` build "/a/b/".
 *

                    // don't stop processing in case a future segment explicitly excludes this repo
                }
                // check for external:http:*
                else if (EXTERNAL_HTTP_WILDCARD.equals(repo) && isExternalHttpRepo(originalRepository)) {
                    result = true;
                    // don't stop processing in case a future segment explicitly excludes this repo