// Test that putValues overwrites existing values
        ExtractData data = new ExtractData();

        data.putValue("key", "old_value");
        String[] oldValues = data.getValues("key");
        assertEquals(1, oldValues.length);
        assertEquals("old_value", oldValues[0]);

        String[] newValues = { "new_value1", "new_value2" };
        data.putValues("key", newValues);

        } else {
            final Object oldValue = dataMap.get(key);
            final Object[] oldValues;
            if (oldValue instanceof Object[]) {
                oldValues = (Object[]) oldValue;
            } else if (oldValue instanceof Collection<?>) {
                oldValues = ((Collection<?>) oldValue).toArray();
            } else {
                oldValues = new Object[] { oldValue };
            }

    segment.setWeakValueReferenceForTesting(entry, oldValueRef);

    // no entry
    assertFalse(segment.replace(key, hash, oldValue, newValue));
    assertEquals(0, segment.count);

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

    segment.setWeakValueReferenceForTesting(entry, oldValueRef);

    // no entry
    assertFalse(segment.replace(key, hash, oldValue, newValue));
    assertEquals(0, segment.count);

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

      }

      while (true) {
        int oldValue = existingCounter.get();
        if (oldValue != 0) {
          try {
            int newValue = Math.addExact(oldValue, occurrences);
            if (existingCounter.compareAndSet(oldValue, newValue)) {
              // newValue can't == 0, so no need to check & remove
              return oldValue;
            }
          } catch (ArithmeticException overflow) {

    assertThat(segment.remove(key, hash, newValue)).isFalse();
    assertThat(segment.count).isEqualTo(1);
    assertThat(segment.get(key, hash)).isSameInstanceAs(oldValue);

    // cleared
    assertThat(segment.get(key, hash)).isSameInstanceAs(oldValue);
    oldValueRef.clear();
    assertThat(segment.remove(key, hash, oldValue)).isFalse();

    assertThat(segment.remove(key, hash, newValue)).isFalse();
    assertThat(segment.count).isEqualTo(1);
    assertThat(segment.get(key, hash)).isSameInstanceAs(oldValue);

    // cleared
    assertThat(segment.get(key, hash)).isSameInstanceAs(oldValue);
    oldValueRef.clear();
    assertThat(segment.remove(key, hash, oldValue)).isFalse();

              int oldValue = multiset.setCount(key, newValue);
              deltas[keyIndex] += newValue - oldValue;
              break;
            }
          case SET_COUNT_IF:
            {
              int newValue = random.nextInt(3);
              int oldValue = multiset.count(key);
              if (multiset.setCount(key, oldValue, newValue)) {

    emptyAccumulatorByAddAllEmptyStats.addAll(Stats.of());

    oneValueAccumulator = new StatsAccumulator();
    oneValueAccumulator.add(ONE_VALUE);

    oneValueAccumulatorByAddAllEmptyStats = new StatsAccumulator();
    oneValueAccumulatorByAddAllEmptyStats.add(ONE_VALUE);
    oneValueAccumulatorByAddAllEmptyStats.addAll(Stats.of());

    twoValuesAccumulator = new StatsAccumulator();

    oneValueAccumulator = new PairedStatsAccumulator();
    oneValueAccumulator.add(ONE_VALUE, OTHER_ONE_VALUE);

    oneValueAccumulatorByAddAllEmptyPairedStats = new PairedStatsAccumulator();
    oneValueAccumulatorByAddAllEmptyPairedStats.add(ONE_VALUE, OTHER_ONE_VALUE);
    oneValueAccumulatorByAddAllEmptyPairedStats.addAll(emptyAccumulator.snapshot());