Java SortedMultiset类代码示例

import com.google.common.collect.SortedMultiset; //导入依赖的package包/类
private TestSuite createReserializedSuite(
    SortedMultisetTestSuiteBuilder<E> parentBuilder) {
  final TestMultisetGenerator<E> delegate =
      (TestMultisetGenerator<E>) parentBuilder.getSubjectGenerator();

  Set<Feature<?>> features = new HashSet<Feature<?>>();
  features.addAll(parentBuilder.getFeatures());
  features.remove(CollectionFeature.SERIALIZABLE);
  features.remove(CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS);

  return SortedMultisetTestSuiteBuilder
      .using(new ForwardingTestMultisetGenerator<E>(delegate) {
        @Override
        public SortedMultiset<E> create(Object... entries) {
          return SerializableTester.reserialize(((SortedMultiset<E>) super.create(entries)));
        }
      })
      .named(parentBuilder.getName() + " reserialized")
      .withFeatures(features)
      .suppressing(parentBuilder.getSuppressedTests())
      .createTestSuite();
}
 

import com.google.common.collect.SortedMultiset; //导入依赖的package包/类
/**
 * Print statistics on stdout.
 */
protected void printStats() {
	final SortedMultiset<Integer> sizeDistribution = sampleGrammar
			.computeGrammarTreeSizeStats();
	System.out.println("Size Stats: 1-5:"
			+ sizeDistribution.subMultiset(0, BoundType.CLOSED, 5,
					BoundType.CLOSED).size()
					+ " 6-15:"
					+ sizeDistribution.subMultiset(6, BoundType.CLOSED, 15,
							BoundType.CLOSED).size()
							+ " 16-30:"
							+ sizeDistribution.subMultiset(16, BoundType.CLOSED, 30,
									BoundType.CLOSED).size()
									+ " >30:"
									+ sizeDistribution.subMultiset(31, BoundType.CLOSED,
											Integer.MAX_VALUE, BoundType.CLOSED).size());

	int sumOfSizes = 0;
	for (final com.google.common.collect.Multiset.Entry<Integer> sizeEntry : sizeDistribution
			.entrySet()) {
		sumOfSizes += sizeEntry.getCount() * sizeEntry.getElement();
	}

	final double avgSize = (((double) sumOfSizes) / sizeDistribution.size());
	System.out.println("Avg Tree Size: " + String.format("%.2f", avgSize));
}
 

import com.google.common.collect.SortedMultiset; //导入依赖的package包/类
private TestSuite createReserializedSuite(SortedMultisetTestSuiteBuilder<E> parentBuilder) {
  final TestMultisetGenerator<E> delegate =
      (TestMultisetGenerator<E>) parentBuilder.getSubjectGenerator();

  Set<Feature<?>> features = new HashSet<Feature<?>>();
  features.addAll(parentBuilder.getFeatures());
  features.remove(SERIALIZABLE);
  features.remove(SERIALIZABLE_INCLUDING_VIEWS);

  return SortedMultisetTestSuiteBuilder.using(
          new ForwardingTestMultisetGenerator<E>(delegate) {
            @Override
            public SortedMultiset<E> create(Object... entries) {
              return SerializableTester.reserialize(((SortedMultiset<E>) super.create(entries)));
            }
          })
      .named(parentBuilder.getName() + " reserialized")
      .withFeatures(features)
      .suppressing(parentBuilder.getSuppressedTests())
      .createTestSuite();
}
 

import com.google.common.collect.SortedMultiset; //导入依赖的package包/类
/**
 * Return the threshold for the given number of elements.
 * 
 * @param elements
 * @param proportion
 * @return
 */
private double getThreshold(final SortedMultiset<Double> elements,
		final int nElements) {
	checkArgument(elements.size() >= nElements);
	double threshold = elements.firstEntry().getElement();
	int nSeen = 0;
	for (final Entry<Double> elementEntry : elements.entrySet()) {
		if (nSeen > nElements) {
			break;
		}
		nSeen += elementEntry.getCount();
		threshold = elementEntry.getElement();
	}
	checkArgument(threshold <= elements.firstEntry().getElement(),
			"Threshold is %s but first element is %s", threshold,
			elements.firstEntry().getElement());
	return threshold;
}
 

import com.google.common.collect.SortedMultiset; //导入依赖的package包/类
/**
 * Prune the list to the given threshold.
 */
private List<Pair<SortedMultiset<Double>, SortedMultiset<Double>>> pruneToThreshold(
		final double threshold) {
	final List<Pair<SortedMultiset<Double>, SortedMultiset<Double>>> filtered = Lists
			.newArrayList();

	for (final Pair<SortedMultiset<Double>, SortedMultiset<Double>> suggestion : suggestionPrecision) {
		final SortedMultiset<Double> allFilteredSuggestions = suggestion.first
				.tailMultiset(threshold, BoundType.CLOSED);
		final SortedMultiset<Double> correctFilteredSuggestions = suggestion.second
				.tailMultiset(threshold, BoundType.CLOSED);
		final Pair<SortedMultiset<Double>, SortedMultiset<Double>> filteredPair = Pair
				.create(allFilteredSuggestions,
						correctFilteredSuggestions);
		filtered.add(filteredPair);
	}

	return filtered;
}
 

import com.google.common.collect.SortedMultiset; //导入依赖的package包/类
private TestSuite createReserializedSuite(SortedMultisetTestSuiteBuilder<E> parentBuilder) {
  final TestMultisetGenerator<E> delegate =
      (TestMultisetGenerator<E>) parentBuilder.getSubjectGenerator();

  Set<Feature<?>> features = new HashSet<>();
  features.addAll(parentBuilder.getFeatures());
  features.remove(SERIALIZABLE);
  features.remove(SERIALIZABLE_INCLUDING_VIEWS);

  return SortedMultisetTestSuiteBuilder.using(
          new ForwardingTestMultisetGenerator<E>(delegate) {
            @Override
            public SortedMultiset<E> create(Object... entries) {
              return SerializableTester.reserialize(((SortedMultiset<E>) super.create(entries)));
            }
          })
      .named(parentBuilder.getName() + " reserialized")
      .withFeatures(features)
      .suppressing(parentBuilder.getSuppressedTests())
      .createTestSuite();
}
 

import com.google.common.collect.SortedMultiset; //导入依赖的package包/类
/**
 * Resets the contents of sortedMultiset to have entries a, c, for the navigation tests.
 */
@SuppressWarnings("unchecked")
// Needed to stop Eclipse whining
private void resetWithHole() {
  List<E> container = new ArrayList<E>();
  container.addAll(Collections.nCopies(a.getCount(), a.getElement()));
  container.addAll(Collections.nCopies(c.getCount(), c.getElement()));
  super.resetContainer(getSubjectGenerator().create(container.toArray()));
  sortedMultiset = (SortedMultiset<E>) getMultiset();
}
 

import com.google.common.collect.SortedMultiset; //导入依赖的package包/类
void expectSetCountFailure(SortedMultiset<E> multiset, Entry<E> entry) {
  try {
    multiset.setCount(entry.getElement(), multiset.count(entry.getElement()));
  } catch (IllegalArgumentException acceptable) {
  }
  try {
    multiset.setCount(entry.getElement(), multiset.count(entry.getElement()) + 1);
    fail("Expected IllegalArgumentException");
  } catch (IllegalArgumentException expected) {
  }
}
 

import com.google.common.collect.SortedMultiset; //导入依赖的package包/类
public void testEmptyRangeSubMultiset(SortedMultiset<E> multiset) {
  assertTrue(multiset.isEmpty());
  assertEquals(0, multiset.size());
  assertEquals(0, multiset.toArray().length);
  assertTrue(multiset.entrySet().isEmpty());
  assertFalse(multiset.iterator().hasNext());
  assertEquals(0, multiset.entrySet().size());
  assertEquals(0, multiset.entrySet().toArray().length);
  assertFalse(multiset.entrySet().iterator().hasNext());
}
 

import com.google.common.collect.SortedMultiset; //导入依赖的package包/类
private void testSubMultisetEntrySet(SubMultisetSpec spec) {
  List<Entry<E>> entries = copyToList(sortedMultiset.entrySet());
  for (int i = 0; i < entries.size(); i++) {
    List<Entry<E>> expected = spec.expectedEntries(i, entries);
    SortedMultiset<E> subMultiset = spec.subMultiset(sortedMultiset, entries, i);
    assertEquals(expected, copyToList(subMultiset.entrySet()));
  }
}
 

import com.google.common.collect.SortedMultiset; //导入依赖的package包/类
private void testSubMultisetSize(SubMultisetSpec spec) {
  List<Entry<E>> entries = copyToList(sortedMultiset.entrySet());
  for (int i = 0; i < entries.size(); i++) {
    List<Entry<E>> expected = spec.expectedEntries(i, entries);
    SortedMultiset<E> subMultiset = spec.subMultiset(sortedMultiset, entries, i);
    assertEquals(totalSize(expected), subMultiset.size());
  }
}
 

import com.google.common.collect.SortedMultiset; //导入依赖的package包/类
private void testSubMultisetDistinctElements(SubMultisetSpec spec) {
  List<Entry<E>> entries = copyToList(sortedMultiset.entrySet());
  for (int i = 0; i < entries.size(); i++) {
    List<Entry<E>> expected = spec.expectedEntries(i, entries);
    SortedMultiset<E> subMultiset = spec.subMultiset(sortedMultiset, entries, i);
    assertEquals(expected.size(), subMultiset.entrySet().size());
    assertEquals(expected.size(), subMultiset.elementSet().size());
  }
}
 

import com.google.common.collect.SortedMultiset; //导入依赖的package包/类
private TestSuite createDescendingSuite(SortedMultisetTestSuiteBuilder<E> parentBuilder) {
  final TestMultisetGenerator<E> delegate =
      (TestMultisetGenerator<E>) parentBuilder.getSubjectGenerator();

  Set<Feature<?>> features = new HashSet<Feature<?>>();
  features.add(NoRecurse.DESCENDING);
  features.addAll(parentBuilder.getFeatures());
  if (!features.remove(SERIALIZABLE_INCLUDING_VIEWS)) {
    features.remove(SERIALIZABLE);
  }

  return SortedMultisetTestSuiteBuilder.using(
          new ForwardingTestMultisetGenerator<E>(delegate) {
            @Override
            public SortedMultiset<E> create(Object... entries) {
              return ((SortedMultiset<E>) super.create(entries)).descendingMultiset();
            }

            @Override
            public Iterable<E> order(List<E> insertionOrder) {
              return ImmutableList.copyOf(super.order(insertionOrder)).reverse();
            }
          })
      .named(parentBuilder.getName() + " descending")
      .withFeatures(features)
      .suppressing(parentBuilder.getSuppressedTests())
      .createTestSuite();
}
 

import com.google.common.collect.SortedMultiset; //导入依赖的package包/类
void expectSetCountFailure(SortedMultiset<E> multiset, Entry<E> entry) {
  try {
    multiset.setCount(entry.getElement(), multiset.count(entry.getElement()));
  } catch (IllegalArgumentException acceptable) {}
  try {
    multiset.setCount(entry.getElement(), multiset.count(entry.getElement()) + 1);
    fail("Expected IllegalArgumentException");
  } catch (IllegalArgumentException expected) {}
}
 

import com.google.common.collect.SortedMultiset; //导入依赖的package包/类
private TestSuite createDescendingSuite(
    SortedMultisetTestSuiteBuilder<E> parentBuilder) {
  final TestMultisetGenerator<E> delegate =
      (TestMultisetGenerator<E>) parentBuilder.getSubjectGenerator();

  Set<Feature<?>> features = new HashSet<Feature<?>>();
  features.add(NoRecurse.DESCENDING);
  features.addAll(parentBuilder.getFeatures());
  if (!features.remove(CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS)) {
    features.remove(CollectionFeature.SERIALIZABLE);
  }

  return SortedMultisetTestSuiteBuilder
      .using(new ForwardingTestMultisetGenerator<E>(delegate) {
        @Override
        public SortedMultiset<E> create(Object... entries) {
          return ((SortedMultiset<E>) super.create(entries))
              .descendingMultiset();
        }

        @Override
        public Iterable<E> order(List<E> insertionOrder) {
          return ImmutableList.copyOf(super.order(insertionOrder)).reverse();
        }
      })
      .named(parentBuilder.getName() + " descending")
      .withFeatures(features)
      .suppressing(parentBuilder.getSuppressedTests())
      .createTestSuite();
}