com.google.common.collect.testing.features.CollectionFeature Java Examples

public Test testsForPatriciaTrie() {
  return MapTestSuiteBuilder
      .using(new TestStringMapGenerator() {
        @Override
        protected Map<String, String> create(
            final Entry<String, String>[] entries) {
          return populate(new PatriciaTrie<String>(), entries);
        }
      })
      .named("PatriciaTrie")
      .withFeatures(
          MapFeature.GENERAL_PURPOSE,
          MapFeature.ALLOWS_NULL_ENTRY_QUERIES,
          MapFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION,
          CollectionFeature.SUPPORTS_ITERATOR_REMOVE,
          // Assumes Insertion Order if you don't implement SortedMap
          // CollectionFeature.KNOWN_ORDER,
          CollectionFeature.SERIALIZABLE,
          CollectionSize.ANY)
      .suppressing(suppressForPatriciaTrie())
      .createTestSuite();
}
 

public Test testForOneToWayUseMySet() {
    return QueueTestSuiteBuilder
            .using(new QueueXGenerator())
            .named("QueueX test")
            .withFeatures(
                    CollectionSize.ANY,
                    CollectionFeature.ALLOWS_NULL_VALUES,
                    CollectionFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION,
                    CollectionFeature.SUPPORTS_ADD,

                    CollectionFeature.SUPPORTS_REMOVE,
                    CollectionFeature.SUPPORTS_ITERATOR_REMOVE,
                    CollectionFeature.SUPPORTS_REMOVE
            )
            .createTestSuite();
}
 

private static <T> TestSuite mapTestSuite(TestMapGenerator<T, T> testMapGenerator, String name)
{
    return new MapTestSuiteBuilder<T, T>()
    {
        {
            usingGenerator(testMapGenerator);
        }

        @Override
        protected List<Class<? extends AbstractTester>> getTesters()
        {
            List<Class<? extends AbstractTester>> testers = new ArrayList<>(super.getTesters());
            // NonBlockingHashMap doesn't support null in putIfAbsent and provides putIfAbsentAllowsNull instead
            testers.remove(MapReplaceEntryTester.class);
            testers.remove(MapReplaceTester.class);
            return testers;
        }
    }.withFeatures(
        MapFeature.GENERAL_PURPOSE,
        CollectionSize.ANY,
        CollectionFeature.SUPPORTS_ITERATOR_REMOVE)
        .named(name)
        .createTestSuite();
}
 

public Test testsForPauselessHashMap() {
    return MapTestSuiteBuilder
            .using(new TestStringMapGenerator() {
                @Override
                protected Map<String, String> create(
                        Map.Entry<String, String>[] entries) {
                    return toHashMap(entries);
                }
            })
            .named("HashMap")
            .withFeatures(
                    MapFeature.GENERAL_PURPOSE,
                    MapFeature.ALLOWS_NULL_KEYS,
                    MapFeature.ALLOWS_NULL_VALUES,
                    MapFeature.ALLOWS_ANY_NULL_QUERIES,
                    MapFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION,
                    CollectionFeature.SUPPORTS_ITERATOR_REMOVE,
                    CollectionFeature.SERIALIZABLE,
                    CollectionSize.ANY)
            .suppressing(suppressForHashMap())
            .createTestSuite();
}
 

public Test testForOneToWayUseMySet() {
    return ListTestSuiteBuilder
            .using(new ListXGenerator())
            .named("listX test")
            .withFeatures(
                    CollectionSize.ANY,
                    CollectionFeature.ALLOWS_NULL_VALUES,
                    CollectionFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION,
                    CollectionFeature.SUPPORTS_ADD,
                    ListFeature.SUPPORTS_SET,
                    CollectionFeature.SUPPORTS_REMOVE,
                    CollectionFeature.SUPPORTS_ITERATOR_REMOVE,
                    CollectionFeature.SUPPORTS_REMOVE
            )
            .createTestSuite();
}
 

public Test testForOneToWayUseMySet() {
    return QueueTestSuiteBuilder
            .using(new DequeXGenerator())
            .named("DequeX test")
            .withFeatures(
                    CollectionSize.ANY,
                    CollectionFeature.ALLOWS_NULL_VALUES,
                    CollectionFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION,
                    CollectionFeature.SUPPORTS_ADD,

                    CollectionFeature.SUPPORTS_REMOVE,
                    CollectionFeature.SUPPORTS_ITERATOR_REMOVE,
                    CollectionFeature.SUPPORTS_REMOVE
            )
            .createTestSuite();
}
 

private static TestSuite queueTest(boolean optimistic) {
  return QueueTestSuiteBuilder
      .using(new TestStringQueueGenerator() {
          @Override public Queue<String> create(String[] elements) {
            Queue<String> queue = optimistic
                ? SingleConsumerQueue.optimistic()
                : SingleConsumerQueue.linearizable();
            queue.addAll(MinimalCollection.of(elements));
            return queue;
          }
        })
      .named(SingleConsumerQueue.class.getSimpleName())
      .withFeatures(
          CollectionFeature.ALLOWS_NULL_QUERIES,
          CollectionFeature.GENERAL_PURPOSE,
          CollectionFeature.SERIALIZABLE,
          CollectionFeature.KNOWN_ORDER,
          CollectionSize.ANY)
      .createTestSuite();
}
 

static Test suite(String name, Supplier<LinkedDeque<LinkedValue>> supplier) {
  return QueueTestSuiteBuilder
      .using(new TestLinkedValueGenerator() {
        @Override public Queue<LinkedValue> create(LinkedValue[] elements) {
          Deque<LinkedValue> deque = useTarget ? supplier.get() : new ArrayDeque<>();
          deque.addAll(MinimalCollection.of(elements));
          useTarget = false;
          return deque;
        }
      })
      .named(name)
      .withFeatures(
          CollectionFeature.ALLOWS_NULL_QUERIES,
          CollectionFeature.GENERAL_PURPOSE,
          CollectionFeature.KNOWN_ORDER,
          CollectionSize.ANY)
      .withSetUp(() -> useTarget = true)
      .withTearDown(() -> {
        Arrays.asList(a, b, c, d, e).forEach(value -> {
          value.setNextInAccessOrder(null);
          value.setPreviousInAccessOrder(null);
        });
      })
      .createTestSuite();
}
 

public Test testModelImpl(String name, ModelFactory factory) {
	try {
		return SetTestSuiteBuilder.using(new TestModelGenerator(factory))
				.named(name)
				.withFeatures(CollectionSize.ANY, CollectionFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION,
						CollectionFeature.SERIALIZABLE, CollectionFeature.SUPPORTS_ADD,
						CollectionFeature.SUPPORTS_ITERATOR_REMOVE, CollectionFeature.SUPPORTS_REMOVE,
						CollectionFeature.NON_STANDARD_TOSTRING)
				// FIXME suppressing test on iterator element remove behavior
				.suppressing(CollectionIteratorTester.class
						.getDeclaredMethod("testIterator_unknownOrderRemoveSupported"))
				.createTestSuite();
	} catch (NoSuchMethodException | SecurityException e) {
		throw new RuntimeException(e);
	}
}
 

private static <T> TestSuite mapTestSuite(final TestMapGenerator<T, T> testMapGenerator, final String name)
{
    return new MapTestSuiteBuilder<T, T>()
    {
        {
            usingGenerator(testMapGenerator);
        }
    }.withFeatures(
        MapFeature.GENERAL_PURPOSE,
        CollectionSize.ANY,
        CollectionFeature.SUPPORTS_ITERATOR_REMOVE)
        .named(name)
        .createTestSuite();
}
 

public static Test suite() throws Exception {
    return SetTestSuiteBuilder.using(new TestStringSetGenerator() {
        @Override
        protected Set<String> create(String[] elements) {
            Set<String> set = new SingleWriterHashSet<>(elements.length);
            Collections.addAll(set, elements);
            return set;
        }
    }).withFeatures(
            SetFeature.GENERAL_PURPOSE,
            CollectionSize.ANY,
            CollectionFeature.NON_STANDARD_TOSTRING)
      .named(SingleWriterHashSet.class.getSimpleName())
      .createTestSuite();
}
 

private static <T> TestSuite mapTestSuite(final TestMapGenerator<T, T> testMapGenerator, final String name)
{
    return new MapTestSuiteBuilder<T, T>()
    {
        {
            usingGenerator(testMapGenerator);
        }
    }.withFeatures(
        MapFeature.GENERAL_PURPOSE,
        MapFeature.ALLOWS_NULL_VALUES,
        CollectionSize.ANY,
        CollectionFeature.SUPPORTS_ITERATOR_REMOVE)
        .named(name)
        .createTestSuite();
}
 

private static <T> TestSuite mapTestSuite(final TestMapGenerator<T, T> testMapGenerator, final String name)
{
    return new MapTestSuiteBuilder<T, T>()
    {
        {
            usingGenerator(testMapGenerator);
        }
    }.withFeatures(
        MapFeature.GENERAL_PURPOSE,
        MapFeature.ALLOWS_NULL_VALUES,
        CollectionSize.ANY,
        CollectionFeature.SUPPORTS_ITERATOR_REMOVE)
        .named(name)
        .createTestSuite();
}
 

public static TestSuite suite()
{
    return SetTestSuiteBuilder.using(new Generator())
        .named("ObjectHashSet Tests")
        .withFeatures(CollectionSize.ANY,
            CollectionFeature.NON_STANDARD_TOSTRING,
            CollectionFeature.SUPPORTS_ADD,
            CollectionFeature.SUPPORTS_REMOVE,
            CollectionFeature.SUPPORTS_ITERATOR_REMOVE,
            CollectionFeature.REMOVE_OPERATIONS)
        .createTestSuite();
}
 

private static <T> TestSuite mapTestSuite(final TestMapGenerator<T, T> testMapGenerator, final String name)
{
    return new MapTestSuiteBuilder<T, T>()
    {
        {
            usingGenerator(testMapGenerator);
        }
    }.withFeatures(
        MapFeature.GENERAL_PURPOSE,
        CollectionSize.ANY,
        CollectionFeature.SUPPORTS_ITERATOR_REMOVE)
        .named(name)
        .createTestSuite();
}
 

private static <T> TestSuite mapTestSuite(final TestMapGenerator<T, T> testMapGenerator, final String name)
{
    return new MapTestSuiteBuilder<T, T>()
    {
        {
            usingGenerator(testMapGenerator);
        }
    }.withFeatures(
        MapFeature.GENERAL_PURPOSE,
        MapFeature.ALLOWS_NULL_VALUES,
        CollectionSize.ANY,
        CollectionFeature.SUPPORTS_ITERATOR_REMOVE)
        .named(name)
        .createTestSuite();
}
 

private static <T> TestSuite mapTestSuite(final TestMapGenerator<T, T> testMapGenerator, final String name)
{
    return new MapTestSuiteBuilder<T, T>()
    {
        {
            usingGenerator(testMapGenerator);
        }
    }.withFeatures(
        MapFeature.GENERAL_PURPOSE,
        CollectionSize.ANY,
        CollectionFeature.SUPPORTS_ITERATOR_REMOVE)
        .named(name)
        .createTestSuite();
}
 

private static <T> TestSuite mapTestSuite(final TestMapGenerator<T, T> testMapGenerator, final String name)
{
    return new MapTestSuiteBuilder<T, T>()
    {
        {
            usingGenerator(testMapGenerator);
        }
    }.withFeatures(
        MapFeature.GENERAL_PURPOSE,
        CollectionSize.ANY,
        CollectionFeature.SUPPORTS_ITERATOR_REMOVE)
        .named(name)
        .createTestSuite();
}
 

private static <T> TestSuite mapTestSuite(final TestMapGenerator<T, T> testMapGenerator, final String name)
{
    return new MapTestSuiteBuilder<T, T>()
    {
        {
            usingGenerator(testMapGenerator);
        }
    }.withFeatures(
        MapFeature.GENERAL_PURPOSE,
        CollectionSize.ANY,
        CollectionFeature.SUPPORTS_ITERATOR_REMOVE)
        .named(name)
        .createTestSuite();
}
 

private static <T> TestSuite mapTestSuite(final TestMapGenerator<T, T> testMapGenerator, final String name)
{
    return new MapTestSuiteBuilder<T, T>()
    {
        {
            usingGenerator(testMapGenerator);
        }
    }.withFeatures(
        MapFeature.GENERAL_PURPOSE,
        CollectionSize.ANY,
        CollectionFeature.SUPPORTS_ITERATOR_REMOVE)
        .named(name)
        .createTestSuite();
}
 

private static <T> TestSuite mapTestSuite(final TestMapGenerator<T, T> testMapGenerator, final String name)
{
    return new MapTestSuiteBuilder<T, T>()
    {
        {
            usingGenerator(testMapGenerator);
        }
    }.withFeatures(
        MapFeature.GENERAL_PURPOSE,
        CollectionSize.ANY,
        CollectionFeature.SUPPORTS_ITERATOR_REMOVE)
        .named(name)
        .createTestSuite();
}
 

/**
 * Returns a test suite.
 *
 * @param name the name of the cache type under test
 * @param generator the map generator
 * @return a suite of tests
 */
public static Test suite(String name, TestMapGenerator<?, ?> generator) {
  return ConcurrentMapTestSuiteBuilder
      .using(generator)
      .named(name)
      .withFeatures(
          MapFeature.GENERAL_PURPOSE,
          MapFeature.ALLOWS_NULL_ENTRY_QUERIES,
          CollectionFeature.SUPPORTS_ITERATOR_REMOVE,
          CollectionSize.ANY)
      .createTestSuite();
}
 

public Test testForOneToWayUseMySet() {
    return SetTestSuiteBuilder
            .using(new SetXGenerator())
            .named("setX test")
            .withFeatures(
                    CollectionSize.ANY,
                    CollectionFeature.ALLOWS_NULL_VALUES,
                    CollectionFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION,
                    CollectionFeature.SUPPORTS_ADD,
                    CollectionFeature.SUPPORTS_ITERATOR_REMOVE,
                    CollectionFeature.SUPPORTS_REMOVE
            )
            .createTestSuite();
}
 

public Test testForOneToWayUseMySet() {
    return SetTestSuiteBuilder
            .using(new SetXGenerator())
            .named("setX test")
            .withFeatures(
                    CollectionSize.ANY,
                    CollectionFeature.ALLOWS_NULL_VALUES,
                    CollectionFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION,
                    CollectionFeature.SUPPORTS_ADD,
                    CollectionFeature.SUPPORTS_ITERATOR_REMOVE,
                    CollectionFeature.SUPPORTS_REMOVE
            )
            .createTestSuite();
}
 

public static TestSuite suite() {
	return MapTestSuiteBuilder
			// The create method is called with an array of elements
			// that should populate the collection.
			.using(new TestStringMapGenerator() {
				@Override
				protected Map<String, String> create(Entry<String, String>[] source) {
					Map<String, String> left = Maps.newHashMap();
					Map<String, String> right = Maps.newHashMap();
					for(int i = 0; i < source.length; i++) {
						Entry<String, String> entry = source[i];
						if (right.containsKey(entry.getKey())) {
							left.put(entry.getKey(), right.get(entry.getKey()));
							right.put(entry.getKey(), entry.getValue());
						} else if (i % 2 != 0) {
							left.put(entry.getKey(), entry.getValue());	
						} else {
							right.put(entry.getKey(), entry.getValue());
							if (i % 4 != 0) {
								left.put(entry.getKey(), "will be ignored");
							}
						}
					}
					return new UnmodifiableMergingMapView(left, right);
				}
			}).named("Guava-based UnmodifiableMergingMapView tests")
			.withFeatures(
					MapFeature.ALLOWS_NULL_KEYS,
					MapFeature.ALLOWS_NULL_VALUES,
					MapFeature.ALLOWS_ANY_NULL_QUERIES,
					MapFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION,
					CollectionFeature.ALLOWS_NULL_QUERIES,
					CollectionFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION,
					CollectionSize.ANY)
			.createTestSuite();
}
 

private static void configureSuite(MapTestSuiteBuilder<String, String> suite) {
    suite.withFeatures(GENERAL_PURPOSE)
            .withFeatures(CollectionSize.ANY)
            .withFeatures(CollectionFeature.REMOVE_OPERATIONS)
            .withFeatures(RESTRICTS_KEYS, RESTRICTS_VALUES);
}