PairedStats stats = accumulator.snapshot();
    accumulator.add(99.99, 9999.9999); // should do nothing to the snapshot
    return stats;
  }

  private static PairedStats buildHorizontalValuesPairedStats() {
    PairedStatsAccumulator accumulator = new PairedStatsAccumulator();
    for (double x : MANY_VALUES) {
      accumulator.add(x, OTHER_ONE_VALUE);
    }
    return accumulator.snapshot();
  }

        kuromojiFile = new KuromojiFile("1", "dummy", new Date());
        List<KuromojiItem> itemList = new ArrayList<>();
        itemList.add(new KuromojiItem(1, "token1", "seg1", "reading1", "pos1"));
        itemList.add(new KuromojiItem(2, "token2", "seg2", "reading2", "pos2"));
        itemList.add(new KuromojiItem(3, "token3", "seg3", "reading3", "pos3"));
        kuromojiFile.kuromojiItemList = itemList;
    }

    @Test

            projectIds.add(key);
        }
        return projectIds;
    }

    private Set<String> getIgnorableArtifacts(Iterable<Artifact> artifactIterable) {
        Set<String> projectIds = new HashSet<>();

        for (Artifact artifact : artifactIterable) {
            String key = ArtifactUtils.key(artifact);
            projectIds.add(key);
        }
        return projectIds;

    assertTrue(result.remove(v0()));

    assertFalse(multimap().containsKey(k0()));
    assertFalse(multimap().containsEntry(k0(), v0()));
    assertEmpty(result);

    assertTrue(result.add(v1()));
    assertTrue(result.add(v2()));

    assertContentsAnyOrder(result, v1(), v2());
    assertContentsAnyOrder(multimap().get(k0()), v1(), v2());
    assertTrue(multimap().containsKey(k0()));

                final Set<String> permissionSet = new HashSet<>();
                permissionSet.add(systemHelper.getSearchRoleByUser(name));
                stream(groups).of(stream -> stream.forEach(s -> permissionSet.add(systemHelper.getSearchRoleByGroup(s))));
                stream(roles).of(stream -> stream.forEach(s -> permissionSet.add(systemHelper.getSearchRoleByRole(s))));

    }

    public void blackList(MavenProject project) {
        if (blackListedProjects.add(BuilderCommon.getKey(project)) && projectDependencyGraph != null) {
            for (MavenProject downstreamProject : projectDependencyGraph.getDownstreamProjects(project, true)) {
                blackListedProjects.add(BuilderCommon.getKey(downstreamProject));
            }
        }
    }

    public void halt() {

                realArgs.add('/C')
                realArgs.add('"') // quote the entire command
            } else {
                realExecutable = 'sh'
            }
        } else {
            realExecutable = executable
            realArgs.addAll(arguments)
        }
        if (spawn) {
            writeWrapperScript(executable)
            realArgs.add(wrapperScript)

        resetContainer();

        List<V> values = multimap().get(key);
        List<V> expectedValues = copyToList(values);

        assertTrue(multimap().put(key, value));
        expectedValues.add(value);

        assertGet(key, expectedValues);
        assertEquals(value, values.get(values.size() - 1));
      }
    }
  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)

  override fun onFailure(
    call: Call,
    e: IOException,
  ) {
    responses.add(RecordedResponse(call.request(), null, null, null, e))
    (this as Object).notifyAll()
  }

  @Synchronized
  override fun onResponse(
    call: Call,
    response: Response,
  ) {
    val body = response.body.string()
    responses.add(RecordedResponse(call.request(), response, null, body, null))
    (this as Object).notifyAll()
  }

          i.remove()

          asyncCall.callsPerHost.incrementAndGet()
          callsToExecute.add(asyncCall)
          runningAsyncCalls.add(asyncCall)
        }

        return@synchronized Effects(
          callsToExecute = callsToExecute,
          idleCallbackToRun = idleCallbackToRun,
        )
      }