java类com.google.common.collect.ImmutableMultiset的实例源码

/**
 * Asserts that the given diagnostics contain errors with a message containing "[CheckerName]"
 * on the given lines of the given file. If there should be multiple errors on a line, the line
 * number must appear multiple times. There may not be any errors in any other file.
 */
public void assertErrorsOnLines(String file,
    List<Diagnostic<? extends JavaFileObject>> diagnostics, long... lines) {
  ListMultimap<String, Long> actualErrors = ArrayListMultimap.create();
  for (Diagnostic<? extends JavaFileObject> diagnostic : diagnostics) {
    String message = diagnostic.getMessage(Locale.US);

    // The source may be null, e.g. for diagnostics about command-line flags
    assertNotNull(message, diagnostic.getSource());
    String sourceName = diagnostic.getSource().getName();

    assertEquals(
        "unexpected error in source file " + sourceName + ": " + message,
        file, sourceName);

    actualErrors.put(diagnostic.getSource().getName(), diagnostic.getLineNumber());

    // any errors from the compiler that are not related to this checker should fail
    assertThat(message).contains("[" + checker.getAnnotation(BugPattern.class).name() + "]");
  }

  assertEquals(
      ImmutableMultiset.copyOf(Longs.asList(lines)),
      ImmutableMultiset.copyOf(actualErrors.get(file)));
}

@Test
public void should_stop_success_demo_first() throws Throwable {
    cleanFolder("flowCliE");

    CountDownLatch countDownLatch = new CountDownLatch(1);
    applicationEventMulticaster.addApplicationListener((ApplicationListener<PluginStatusChangeEvent>) event -> {
        if (ImmutableMultiset.of(PluginStatus.INSTALLING).contains(event.getPluginStatus())) {
            countDownLatch.countDown();
        }
    });

    pluginService.install("flowCliE");
    countDownLatch.await(30, TimeUnit.SECONDS);
    pluginService.stop("flowCliE");

    Plugin plugin = pluginDao.get("flowCliE");
    Assert.assertEquals(PluginStatus.PENDING, plugin.getStatus());
    Assert.assertEquals(false, plugin.getStopped());
}

private void identifyDuplicates(List<ModContainer> mods)
{
    TreeMultimap<ModContainer, File> dupsearch = TreeMultimap.create(new ModIdComparator(), Ordering.arbitrary());
    for (ModContainer mc : mods)
    {
        if (mc.getSource() != null)
        {
            dupsearch.put(mc, mc.getSource());
        }
    }

    ImmutableMultiset<ModContainer> duplist = Multisets.copyHighestCountFirst(dupsearch.keys());
    SetMultimap<ModContainer, File> dupes = LinkedHashMultimap.create();
    for (Entry<ModContainer> e : duplist.entrySet())
    {
        if (e.getCount() > 1)
        {
            FMLLog.severe("Found a duplicate mod %s at %s", e.getElement().getModId(), dupsearch.get(e.getElement()));
            dupes.putAll(e.getElement(),dupsearch.get(e.getElement()));
        }
    }
    if (!dupes.isEmpty())
    {
        throw new DuplicateModsFoundException(dupes);
    }
}

@VisibleForTesting
static AttributeAggregate create(Supplier<Iterable<IAttribute>> attributes) {
  Supplier<Multiset<Pair<String, String>>> aggregator = Suppliers.compose(
      attributes1 -> {
        ImmutableMultiset.Builder<Pair<String, String>> builder = ImmutableMultiset.builder();
        for (IAttribute attribute : attributes1) {
          for (String value : attribute.getValues()) {
            builder.add(Pair.of(attribute.getName(), value));
          }
        }

        return builder.build();
      },
      attributes
  );

  return new AttributeAggregate(aggregator);
}

private void identifyDuplicates(List<ModContainer> mods)
{
    TreeMultimap<ModContainer, File> dupsearch = TreeMultimap.create(new ModIdComparator(), Ordering.arbitrary());
    for (ModContainer mc : mods)
    {
        if (mc.getSource() != null)
        {
            dupsearch.put(mc, mc.getSource());
        }
    }

    ImmutableMultiset<ModContainer> duplist = Multisets.copyHighestCountFirst(dupsearch.keys());
    SetMultimap<ModContainer, File> dupes = LinkedHashMultimap.create();
    for (Entry<ModContainer> e : duplist.entrySet())
    {
        if (e.getCount() > 1)
        {
            FMLLog.severe("Found a duplicate mod %s at %s", e.getElement().getModId(), dupsearch.get(e.getElement()));
            dupes.putAll(e.getElement(),dupsearch.get(e.getElement()));
        }
    }
    if (!dupes.isEmpty())
    {
        throw new DuplicateModsFoundException(dupes);
    }
}

@Test
public void testLotsOfRandomInserts() {
    int lots = 50000;
    final FibonacciQueue<Integer> queue = FibonacciQueue.create();
    // Insert lots of random numbers.
    final ImmutableMultiset.Builder<Integer> insertedBuilder = ImmutableMultiset.builder();
    final Random random = new Random();
    for (int i = 0; i < lots; i++) {
        int r = random.nextInt();
        insertedBuilder.add(r);
        queue.add(r);
    }
    final Multiset<Integer> inserted = insertedBuilder.build();
    assertEquals(lots, queue.size());
    // Ensure it contains the same multiset of values that we put in
    assertEquals(inserted, ImmutableMultiset.copyOf(queue));
    // Ensure the numbers come out in increasing order.
    final List<Integer> polled = Lists.newLinkedList();
    while (!queue.isEmpty()) {
        polled.add(queue.poll());
    }
    assertTrue(Ordering.<Integer>natural().isOrdered(polled));
    // Ensure the same multiset of values came out that we put in
    assertEquals(inserted, ImmutableMultiset.copyOf(polled));
    assertEquals(0, queue.size());
}

/**
 * Returns true iff the other object is an instance of {@code TagContext} and contains the same
 * key-value pairs. Implementations are free to override this method to provide better
 * performance.
 */
@Override
public boolean equals(@Nullable Object other) {
  if (!(other instanceof TagContext)) {
    return false;
  }
  TagContext otherTags = (TagContext) other;
  Iterator<Tag> iter1 = getIterator();
  Iterator<Tag> iter2 = otherTags.getIterator();
  Multiset<Tag> tags1 =
      iter1 == null
          ? ImmutableMultiset.<Tag>of()
          : HashMultiset.create(Lists.<Tag>newArrayList(iter1));
  Multiset<Tag> tags2 =
      iter2 == null
          ? ImmutableMultiset.<Tag>of()
          : HashMultiset.create(Lists.<Tag>newArrayList(iter2));
  return tags1.equals(tags2);
}

@Override
public Optional<MultisetProperty> create(Config config) {
  DeclaredType type = maybeDeclared(config.getProperty().getType()).orNull();
  if (type == null || !erasesToAnyOf(type, Multiset.class, ImmutableMultiset.class)) {
    return Optional.absent();
  }

  TypeMirror elementType = upperBound(config.getElements(), type.getTypeArguments().get(0));
  Optional<TypeMirror> unboxedType = maybeUnbox(elementType, config.getTypes());
  boolean needsSafeVarargs = needsSafeVarargs(unboxedType.or(elementType));
  boolean overridesSetCountMethod =
      hasSetCountMethodOverride(config, unboxedType.or(elementType));
  boolean overridesVarargsAddMethod =
      hasVarargsAddMethodOverride(config, unboxedType.or(elementType));
  return Optional.of(new MultisetProperty(
      config.getMetadata(),
      config.getProperty(),
      needsSafeVarargs,
      overridesSetCountMethod,
      overridesVarargsAddMethod,
      elementType,
      unboxedType));
}

@Test
public void testImmutableSetProperty() {
  behaviorTester
      .with(new Processor(features))
      .with(new SourceBuilder()
          .addLine("package com.example;")
          .addLine("@%s", FreeBuilder.class)
          .addLine("public abstract class DataType {")
          .addLine("  public abstract %s<%s> items();", ImmutableMultiset.class, String.class)
          .addLine("")
          .addLine("  public static class Builder extends DataType_Builder {}")
          .addLine("  public static Builder builder() {")
          .addLine("    return new Builder();")
          .addLine("  }")
          .addLine("}")
          .build())
      .with(testBuilder()
          .addLine("DataType value = new DataType.Builder()")
          .addLine("    .addItems(\"one\")")
          .addLine("    .addItems(\"two\")")
          .addLine("    .build();")
          .addLine("assertThat(value.items()).iteratesAs(\"one\", \"two\");")
          .build())
      .runTest();
}

@Test
public void testImmutableSetProperty() {
  behaviorTester
      .with(new Processor(features))
      .with(new SourceBuilder()
          .addLine("package com.example;")
          .addLine("@%s", FreeBuilder.class)
          .addLine("public abstract class DataType {")
          .addLine("  public abstract %s<%s> getItems();", ImmutableMultiset.class, String.class)
          .addLine("")
          .addLine("  public static class Builder extends DataType_Builder {}")
          .addLine("  public static Builder builder() {")
          .addLine("    return new Builder();")
          .addLine("  }")
          .addLine("}")
          .build())
      .with(new TestBuilder()
          .addLine("com.example.DataType value = new com.example.DataType.Builder()")
          .addLine("    .addItems(\"one\")")
          .addLine("    .addItems(\"two\")")
          .addLine("    .build();")
          .addLine("assertThat(value.getItems()).iteratesAs(\"one\", \"two\");")
          .build())
      .runTest();
}

private void identifyDuplicates(List<ModContainer> mods)
{
    TreeMultimap<ModContainer, File> dupsearch = TreeMultimap.create(new ModIdComparator(), Ordering.arbitrary());
    for (ModContainer mc : mods)
    {
        if (mc.getSource() != null)
        {
            dupsearch.put(mc, mc.getSource());
        }
    }

    ImmutableMultiset<ModContainer> duplist = Multisets.copyHighestCountFirst(dupsearch.keys());
    SetMultimap<ModContainer, File> dupes = LinkedHashMultimap.create();
    for (Entry<ModContainer> e : duplist.entrySet())
    {
        if (e.getCount() > 1)
        {
            FMLLog.severe("Found a duplicate mod %s at %s", e.getElement().getModId(), dupsearch.get(e.getElement()));
            dupes.putAll(e.getElement(),dupsearch.get(e.getElement()));
        }
    }
    if (!dupes.isEmpty())
    {
        throw new DuplicateModsFoundException(dupes);
    }
}

@Test
public void testGetIdentifier() throws Exception {
    MathTag tagX = new MathTag(1, "<math xmlns=\"http://www.w3.org/1998/Math/MathML\"><mrow><mi>x</mi></mrow></math>", WikiTextUtils.MathMarkUpType.MATHML);
    assertEquals(ImmutableSet.of("x"), tagX.getIdentifier(true, true).elementSet());
    assertEquals(ImmutableSet.of("x"), tagX.getIdentifier(false, true).elementSet());
    MathTag schrödinger = new MathTag(1, getTestResource("com/formulasearchengine/mathosphere/mlp/schrödinger_eq.xml"), WikiTextUtils.MathMarkUpType.MATHML);
    //MathTag schrödingerTex = new MathTag(1,"i\\hbar\\frac{\\partial}{\\partial t}\\Psi(\\mathbb{r},\\,t)=-\\frac{\\hbar^{2}}{2m}" +
    //  "\\nabla^{2}\\Psi(\\mathbb{r},\\,t)+V(\\mathbb{r})\\Psi(\\mathbb{r},\\,t).", WikiTextUtils.MathMarkUpType.LATEX);
    ImmutableMultiset<String> lIds = ImmutableMultiset.of("i",
            "\\hbar", "\\hbar",
            "t", "t", "t", "t",
            "\\Psi", "\\Psi", "\\Psi",
            "\\mathbb{r}", "\\mathbb{r}", "\\mathbb{r}", "\\mathbb{r}",
            "V",
            "m");
    assertEquals(lIds, schrödinger.getIdentifier(true, false));
}

final void check() {
  runTester()
      .assertNonNullValues(
          Gender.MALE,
          Integer.valueOf(0),
          0,
          "",
          "",
          ImmutableList.of(),
          ImmutableList.of(),
          ImmutableMap.of(),
          ImmutableMap.of(),
          ImmutableSet.of(),
          ImmutableSet.of(),
          ImmutableSortedSet.of(),
          ImmutableSortedSet.of(),
          ImmutableMultiset.of(),
          ImmutableMultiset.of(),
          ImmutableMultimap.of(),
          ImmutableMultimap.of(),
          ImmutableTable.of(),
          ImmutableTable.of());
}

final void check() {
  runTester()
      .assertNonNullValues(
          Gender.MALE,
          Integer.valueOf(0),
          0,
          "",
          "",
          ImmutableList.of(),
          ImmutableList.of(),
          ImmutableMap.of(),
          ImmutableMap.of(),
          ImmutableSet.of(),
          ImmutableSet.of(),
          ImmutableSortedSet.of(),
          ImmutableSortedSet.of(),
          ImmutableMultiset.of(),
          ImmutableMultiset.of(),
          ImmutableMultimap.of(),
          ImmutableMultimap.of(),
          ImmutableTable.of(),
          ImmutableTable.of());
}

@Parameters(name = "{index}:immutable={1}")
public static Collection<Object[]> data() {
  return ImmutableList.of(
      //Mutable collections
      new Object[]{Lists.newArrayList(1, 2, 3), false},
      new Object[]{Sets.newHashSet("1", "2"), false},
      new Object[]{Collection.class.cast(Lists.newArrayList(true, false)), false},
      //Immutable collections
      new Object[]{ImmutableList.of(1, 2, 3), true},
      new Object[]{ImmutableSet.of("1", "2"), true},
      new Object[]{ImmutableSortedSet.of(1, 2, 3), true},
      new Object[]{ImmutableMultiset.of(1, 2, 3), true},
      new Object[]{Collection.class.cast(ImmutableList.of(true, false)), true},
      new Object[]{Collections.unmodifiableList(Lists.newArrayList(1, 2, 3)), true},
      new Object[]{Collections.unmodifiableSet(Sets.newHashSet("1", "2")), true},
      new Object[]{Collections.unmodifiableCollection(Lists.newArrayList(true, false)), true}
      );
}

private void identifyDuplicates(List<ModContainer> mods)
{
    TreeMultimap<ModContainer, File> dupsearch = TreeMultimap.create(new ModIdComparator(), Ordering.arbitrary());
    for (ModContainer mc : mods)
    {
        if (mc.getSource() != null)
        {
            dupsearch.put(mc, mc.getSource());
        }
    }

    ImmutableMultiset<ModContainer> duplist = Multisets.copyHighestCountFirst(dupsearch.keys());
    SetMultimap<ModContainer, File> dupes = LinkedHashMultimap.create();
    for (Entry<ModContainer> e : duplist.entrySet())
    {
        if (e.getCount() > 1)
        {
            FMLLog.severe("Found a duplicate mod %s at %s", e.getElement().getModId(), dupsearch.get(e.getElement()));
            dupes.putAll(e.getElement(),dupsearch.get(e.getElement()));
        }
    }
    if (!dupes.isEmpty())
    {
        throw new DuplicateModsFoundException(dupes);
    }
}

private void identifyDuplicates(List<ModContainer> mods)
{
    TreeMultimap<ModContainer, File> dupsearch = TreeMultimap.create(new ModIdComparator(), Ordering.arbitrary());
    for (ModContainer mc : mods)
    {
        if (mc.getSource() != null)
        {
            dupsearch.put(mc, mc.getSource());
        }
    }

    ImmutableMultiset<ModContainer> duplist = Multisets.copyHighestCountFirst(dupsearch.keys());
    SetMultimap<ModContainer, File> dupes = LinkedHashMultimap.create();
    for (Entry<ModContainer> e : duplist.entrySet())
    {
        if (e.getCount() > 1)
        {
            FMLLog.severe("Found a duplicate mod %s at %s", e.getElement().getModId(), dupsearch.get(e.getElement()));
            dupes.putAll(e.getElement(),dupsearch.get(e.getElement()));
        }
    }
    if (!dupes.isEmpty())
    {
        throw new DuplicateModsFoundException(dupes);
    }
}

private void identifyDuplicates(List<ModContainer> mods)
{
    TreeMultimap<ModContainer, File> dupsearch = TreeMultimap.create(new ModIdComparator(), Ordering.arbitrary());
    for (ModContainer mc : mods)
    {
        if (mc.getSource() != null)
        {
            dupsearch.put(mc, mc.getSource());
        }
    }

    ImmutableMultiset<ModContainer> duplist = Multisets.copyHighestCountFirst(dupsearch.keys());
    SetMultimap<ModContainer, File> dupes = LinkedHashMultimap.create();
    for (Entry<ModContainer> e : duplist.entrySet())
    {
        if (e.getCount() > 1)
        {
            FMLLog.severe("Found a duplicate mod %s at %s", e.getElement().getModId(), dupsearch.get(e.getElement()));
            dupes.putAll(e.getElement(),dupsearch.get(e.getElement()));
        }
    }
    if (!dupes.isEmpty())
    {
        throw new DuplicateModsFoundException(dupes);
    }
}

@Override
public Map<String, Double> count(final List<List<String>> sentences) {
    if (sentences == null || sentences.size() == 0) {
        return Collections.emptyMap();
    }
    final List<String> words = new ArrayList<>();
    for (final List<String> sentence : sentences) {
        words.addAll(sentence);
    }
    final ImmutableMultiset<String> multiset = ImmutableMultiset
            .copyOf(words);
    final Map<String, Double> result = new HashMap<>();
    for (final String word : multiset.elementSet()) {
        result.put(word, (double) multiset.count(word));
    }
    return result;
}

private void identifyDuplicates(List<ModContainer> mods)
{
    TreeMultimap<ModContainer, File> dupsearch = TreeMultimap.create(new ModIdComparator(), Ordering.arbitrary());
    for (ModContainer mc : mods)
    {
        if (mc.getSource() != null)
        {
            dupsearch.put(mc, mc.getSource());
        }
    }

    ImmutableMultiset<ModContainer> duplist = Multisets.copyHighestCountFirst(dupsearch.keys());
    SetMultimap<ModContainer, File> dupes = LinkedHashMultimap.create();
    for (Entry<ModContainer> e : duplist.entrySet())
    {
        if (e.getCount() > 1)
        {
            FMLLog.severe("Found a duplicate mod %s at %s", e.getElement().getModId(), dupsearch.get(e.getElement()));
            dupes.putAll(e.getElement(),dupsearch.get(e.getElement()));
        }
    }
    if (!dupes.isEmpty())
    {
        throw new DuplicateModsFoundException(dupes);
    }
}

private void identifyDuplicates(List<ModContainer> mods)
{
    TreeMultimap<ModContainer, File> dupsearch = TreeMultimap.create(new ModIdComparator(), Ordering.arbitrary());
    for (ModContainer mc : mods)
    {
        if (mc.getSource() != null)
        {
            dupsearch.put(mc, mc.getSource());
        }
    }

    ImmutableMultiset<ModContainer> duplist = Multisets.copyHighestCountFirst(dupsearch.keys());
    SetMultimap<ModContainer, File> dupes = LinkedHashMultimap.create();
    for (Entry<ModContainer> e : duplist.entrySet())
    {
        if (e.getCount() > 1)
        {
            FMLLog.severe("Found a duplicate mod %s at %s", e.getElement().getModId(), dupsearch.get(e.getElement()));
            dupes.putAll(e.getElement(),dupsearch.get(e.getElement()));
        }
    }
    if (!dupes.isEmpty())
    {
        throw new DuplicateModsFoundException(dupes);
    }
}

private void identifyDuplicates(List<ModContainer> mods)
{
    TreeMultimap<ModContainer, File> dupsearch = TreeMultimap.create(new ModIdComparator(), Ordering.arbitrary());
    for (ModContainer mc : mods)
    {
        if (mc.getSource() != null)
        {
            dupsearch.put(mc, mc.getSource());
        }
    }

    ImmutableMultiset<ModContainer> duplist = Multisets.copyHighestCountFirst(dupsearch.keys());
    SetMultimap<ModContainer, File> dupes = LinkedHashMultimap.create();
    for (Entry<ModContainer> e : duplist.entrySet())
    {
        if (e.getCount() > 1)
        {
            FMLLog.severe("Found a duplicate mod %s at %s", e.getElement().getModId(), dupsearch.get(e.getElement()));
            dupes.putAll(e.getElement(),dupsearch.get(e.getElement()));
        }
    }
    if (!dupes.isEmpty())
    {
        throw new DuplicateModsFoundException(dupes);
    }
}

@Test
public void testTransform()
{
    List<String> lines = Arrays.asList("#Comment line", "#Another comment line",
            "11\t47359281\t.\tC\tG\t.\t.\tCADD_SCALED=33.0", "11\t47359281\tC\tCC\t2.3\t33.0",
            "11\t47359281\t.\tC\tCG\t.\t.\tCADD_SCALED=33.0", "11\t47359281\t.\tCG\tC\t.\t.\tCADD_SCALED=33.0");

    Multiset<LineType> expected = ImmutableMultiset.of(COMMENT, COMMENT, VCF, CADD, INDEL_NOCADD, INDEL_NOCADD);
    Assert.assertEquals(lineParser.transformLines(lines.stream(), output, error), expected);

    verify(output).accept("##fileformat=VCFv4.0");
    verify(output).accept("#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO");
    verify(output).accept("11\t47359281\t.\tC\tG\t.\t.\t.");
    verify(output).accept("11\t47359281\t.\tC\tCC\t.\t.\tCADD=2.3;CADD_SCALED=33.0");
    verify(error).accept("Line 5:\t11\t47359281\t.\tC\tCG\t.\t.\tCADD_SCALED=33.0");
    verify(error).accept("Line 6:\t11\t47359281\t.\tCG\tC\t.\t.\tCADD_SCALED=33.0");
}

public void testSerialization() {
    BeanWithMultisetTypes bean = new BeanWithMultisetTypes();

    List<String> list = Arrays.asList( "foo", "abc", null, "abc" );
    List<String> listWithNonNull = Arrays.asList( "foo", "abc", "bar", "abc" );

    bean.multiset = LinkedHashMultiset.create( list );
    bean.hashMultiset = HashMultiset.create( Arrays.asList( "abc", "abc" ) );
    bean.linkedHashMultiset = LinkedHashMultiset.create( list );
    bean.sortedMultiset = TreeMultiset.create( listWithNonNull );
    bean.treeMultiset = TreeMultiset.create( listWithNonNull );
    bean.immutableMultiset = ImmutableMultiset.copyOf( listWithNonNull );
    bean.enumMultiset = EnumMultiset.create( Arrays.asList( AlphaEnum.B, AlphaEnum.A, AlphaEnum.D, AlphaEnum.A ) );

    String expected = "{" +
            "\"multiset\":[\"foo\",\"abc\",\"abc\",null]," +
            "\"hashMultiset\":[\"abc\",\"abc\"]," +
            "\"linkedHashMultiset\":[\"foo\",\"abc\",\"abc\",null]," +
            "\"sortedMultiset\":[\"abc\",\"abc\",\"bar\",\"foo\"]," +
            "\"treeMultiset\":[\"abc\",\"abc\",\"bar\",\"foo\"]," +
            "\"immutableMultiset\":[\"foo\",\"abc\",\"abc\",\"bar\"]," +
            "\"enumMultiset\":[\"A\",\"A\",\"B\",\"D\"]" +
            "}";

    assertEquals( expected, BeanWithMultisetTypesMapper.INSTANCE.write( bean ) );
}

public void testDeserialization() {
    String input = "{" +
            "\"multiset\":[\"foo\",\"abc\",\"abc\",null]," +
            "\"hashMultiset\":[\"abc\",\"abc\"]," +
            "\"linkedHashMultiset\":[\"foo\",\"abc\",\"abc\",null]," +
            "\"sortedMultiset\":[\"foo\",\"abc\",\"bar\",\"abc\",null]," +
            "\"treeMultiset\":[\"bar\",\"abc\",\"abc\",\"foo\",null]," +
            "\"immutableMultiset\":[\"foo\",\"abc\",\"abc\",\"bar\",null]," +
            "\"enumMultiset\":[\"B\",\"A\",\"A\",\"D\",null]" +
            "}";

    BeanWithMultisetTypes result = BeanWithMultisetTypesMapper.INSTANCE.read( input );
    assertNotNull( result );

    List<String> expectedList = Arrays.asList( "foo", "abc", null, "abc" );
    List<String> expectedListWithNonNull = Arrays.asList( "foo", "abc", "bar", "abc" );

    assertEquals( LinkedHashMultiset.create( expectedList ), result.multiset );
    assertEquals( HashMultiset.create( Arrays.asList( "abc", "abc" ) ), result.hashMultiset );
    assertEquals( LinkedHashMultiset.create( expectedList ), result.linkedHashMultiset );
    assertEquals( TreeMultiset.create( expectedListWithNonNull ), result.sortedMultiset );
    assertEquals( TreeMultiset.create( expectedListWithNonNull ), result.treeMultiset );
    assertEquals( ImmutableMultiset.copyOf( expectedListWithNonNull ), result.immutableMultiset );
    assertEquals( EnumMultiset.create( Arrays.asList( AlphaEnum.B, AlphaEnum.A, AlphaEnum.D, AlphaEnum.A ) ), result.enumMultiset );
}

private Set<Multiset<TriplesMapBuilder>> detectCycles(List<TriplesMapBuilder> triplesMapBuilders,
                                                      Map<String, TriplesMapBuilder> lookup) {
  Set<Multiset<TriplesMapBuilder>> cycles = new HashSet<>();
  topologicalSort(
    triplesMapBuilders,
    lookup,
    ((currentChain, current, dependency) -> {
      ImmutableMultiset.Builder<TriplesMapBuilder> cycleChain = ImmutableMultiset.builder();
      cycleChain.addAll(currentChain);
      if (current == dependency) {
        //self reference
        cycleChain.add(dependency);//make sure the self referencing item is counted twice
      }
      cycles.add(cycleChain.build());
    }),
    e -> {
      //errors are handled in the actual sort and ignored for now
    }
  );
  return cycles;
}

/**
 * Method should return the number of times an occurrence of a reel
 * 
 * @param reels
 * @return
 */
static int determinePayOutPercentage(List<String> reels) {

    Multiset<String> reelCount = HashMultiset.create();
    reelCount.addAll(reels);

    // order the number of elements by the higest
    ImmutableMultiset<String> highestCountFirst = Multisets.copyHighestCountFirst(reelCount);

    int count = 0;
    for (Entry<String> entry : highestCountFirst.entrySet()) {
        count = entry.getCount();
        break;
    }
    return count;
}

@Test
public void structFromConstructorSerializeDeserialize() throws Exception {
  ImmutableStructFromConstructor structFromConstructor =
      ImmutableStructFromConstructor.of(
          2,
          Arrays.asList(1, 2),
          Optional.of("OPT"),
          ImmutableMultiset.of("list", "list"),
          ImmutableMultimap.of(1, "1"),
          ImmutableListMultimap.of(2, "2"),
          ImmutableBiMap.of(1, "2"))
          .withIndexSet(ImmutableListMultimap.of(3, "3"));

  check(deserialize(serialize(structFromConstructor))).is(structFromConstructor);
}

static void writeTsv(ImmutableMultiset<String> data, File file) throws IOException {
  try (Writer out = Files.asCharSink(file, Charsets.UTF_8).openBufferedStream()) {
    for (Entry<String> e : Multisets.copyHighestCountFirst(data).entrySet()) {
      out.write(e.getElement() + "\t" + e.getCount() + "\n");
    }
  }
}

private ImmutableSetMultimap<RoleAndID, DocAndHopper> indexArgsToEventHopper(final Symbol docID,
    final EREDocument ereDoc, final ImmutableMultiset.Builder<String> allEREEventTypes) {
  final ImmutableSetMultimap.Builder<RoleAndID, DocAndHopper> argsToDocEventsB =
      ImmutableSetMultimap.builder();

  for (final EREEvent ereEvent : ereDoc.getEvents()) {
    boolean loggedType = false;

    for (final EREEventMention ereEventMention : ereEvent.getEventMentions()) {
      for (final EREArgument ereEventArg : ereEventMention.getArguments()) {
        if (ereEventArg instanceof EREEntityArgument) {
          final Optional<EREEntity> entityFiller = ((EREEntityArgument) ereEventArg).ereEntity();
          if (entityFiller.isPresent()) {
            final Optional<Symbol> mappedEventType =
                ScoringUtils.mapERETypesToDotSeparated(ontologyMapper, ereEventMention);
            final Optional<Symbol> mappedEventRole =
                ontologyMapper.eventRole(Symbol.from(ereEventArg.getRole()));

            if (mappedEventType.isPresent() && mappedEventRole.isPresent()) {
              if (!loggedType) {
                // we only want to log events which meet the criteria above, but we only
                // want to count each document event once
                allEREEventTypes.add(mappedEventType.get().asString());
                loggedType = true;
              }
              argsToDocEventsB.put(
                  RoleAndID.of(
                      mappedEventType.get().asString(),
                      mappedEventRole.get().asString(), entityFiller.get().getID()),
                  DocAndHopper.of(docID.asString(), ereEvent.getID(),
                      mappedEventType.get().asString()));
            }
          }
        }
      }
    }
  }

  return argsToDocEventsB.build();
}