}

    @Override
    public boolean addAll(int index, Collection<? extends T> elements) {
      return standardAddAll(index, elements);
    }

    @Override
    public void clear() {
      standardClear();
    }

    @Override
    public boolean contains(Object object) {
      return standardContains(object);
    }

    @Override

      return standardAdd(element);
    }

    @Override
    public boolean addAll(Collection<? extends E> collection) {
      return standardAddAll(collection);
    }

    @Override
    public void clear() {
      standardClear();
    }

    @Override
    public boolean contains(@Nullable Object object) {
      return standardContains(object);
    }

    @Override

    }

    @Override
    public boolean addAll(int index, Collection<? extends T> elements) {
      return standardAddAll(index, elements);
    }

    @Override
    public void clear() {
      standardClear();
    }

    @Override
    public boolean contains(Object object) {
      return standardContains(object);
    }

    @Override

    final Map<E, Integer> backingMap = Maps.newHashMap();

    @Override
    public int size() {
      return Multisets.linearTimeSizeImpl(this);
    }

    @Override
    public void clear() {
      throw new UnsupportedOperationException();
    }

    @Override
    public int count(@Nullable Object element) {
      for (Entry<E> entry : entrySet()) {

  }

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testPropagatesClearToMultimap() {
    Collection<V> result = multimap().asMap().get(k0());
    result.clear();
    assertGet(k0());
    assertEmpty(result);
  }

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_VALUES})
  public void testAddNullValue() {

                File f = new File( FILENAME );
                long lm;

                if(( lm = f.lastModified() ) > lastModified ) {
                    lastModified = lm;
                    TAB.clear();
                    alt = 0;
                    populate( new FileReader( f ));
                }
                result = (NbtAddress)TAB.get( name );
            }
        } catch( FileNotFoundException fnfe ) {

cat <<EOF
IMPORTANT: These tests ran under docker. This script does not clean up the
container for you! You can delete the container with:

$ docker rm -f tf

You can also execute more commands within the container with e.g.:

$ docker exec tf bazel clean
$ docker exec -it tf bash
EOF

			unlocked = true
		}
	} else {
		if !lm.isWriteLock {
			if lm.ref > 0 {
				lm.ref--
				unlocked = true
			}
		}
	}

	return unlocked
}

// ForceUnlock will forcefully clear a write or read lock.
func (lm *LRWMutex) ForceUnlock() {
	lm.mu.Lock()
	defer lm.mu.Unlock()

	lm.ref = 0
	lm.isWriteLock = false
}

// DRLocker returns a sync.Locker interface that implements

func (l *lastMinuteLatency) forwardTo(t int64) {
	if l.LastSec >= t {
		return
	}
	if t-l.LastSec >= 60 {
		l.Totals = [60]AccElem{}
		return
	}
	for l.LastSec != t {
		// Clear next element.
		idx := (l.LastSec + 1) % 60
		l.Totals[idx] = AccElem{}
		l.LastSec++
	}
}

// LastMinuteHistogram keeps track of last minute sizes added.

            addDocumentToQueue();
        }

        return queue.poll();
    }

    @Override
    public void close() {
        isFinished.set(true);
        queue.clear();
    }

    public void setScrollSize(final int scrollSize) {
        this.scrollSize = scrollSize;
    }

    public void setLimitOfDocumentSize(final long limitOfDocumentSize) {