use of com.google.inject.multibindings.MapBinderBinding in project guice by google.
the class SpiUtils method mapModuleTest.
@SuppressWarnings("unchecked")
private static <T> void mapModuleTest(Key<T> mapKey, TypeLiteral<?> keyType, TypeLiteral<?> valueType, Iterable<? extends Module> modules, boolean allowDuplicates, int expectedMapBindings, MapResult<?, ?>... results) {
Set<Element> elements = ImmutableSet.copyOf(Elements.getElements(modules));
Visitor<T> visitor = new Visitor<>();
MapBinderBinding<T> mapbinder = null;
Map<Key<?>, Binding<?>> keyMap = Maps.newHashMap();
for (Element element : elements) {
if (element instanceof Binding) {
Binding<?> binding = (Binding<?>) element;
keyMap.put(binding.getKey(), binding);
if (binding.getKey().equals(mapKey)) {
mapbinder = (MapBinderBinding<T>) ((Binding<T>) binding).acceptTargetVisitor(visitor);
}
}
}
assertNotNull(mapbinder);
List<MapResult<?, ?>> mapResults = Lists.newArrayList(results);
// Make sure the entries returned from getEntries(elements) are correct.
// Because getEntries() can return duplicates, make sure to continue searching, even
// after we find one match.
List<Map.Entry<?, Binding<?>>> entries = Lists.newArrayList(mapbinder.getEntries(elements));
for (MapResult<?, ?> result : mapResults) {
List<Map.Entry<?, Binding<?>>> foundEntries = Lists.newArrayList();
for (Map.Entry<?, Binding<?>> entry : entries) {
Object key = entry.getKey();
Binding<?> value = entry.getValue();
if (key.equals(result.k) && matches(value, result.v)) {
assertTrue("mapBinder doesn't contain: " + entry.getValue(), mapbinder.containsElement(entry.getValue()));
foundEntries.add(entry);
}
}
assertTrue("Could not find entry: " + result + " in remaining entries: " + entries, !foundEntries.isEmpty());
entries.removeAll(foundEntries);
}
assertTrue("Found all entries of: " + mapResults + ", but more were left over: " + entries, entries.isEmpty());
assertEquals(mapKey, mapbinder.getMapKey());
assertEquals(keyType, mapbinder.getKeyTypeLiteral());
assertEquals(valueType, mapbinder.getValueTypeLiteral());
Key<?> mapOfProvider = mapKey.ofType(mapOfProviderOf(keyType, valueType));
Key<?> mapOfJavaxProvider = mapKey.ofType(mapOfJavaxProviderOf(keyType, valueType));
Key<?> mapOfSetOfProvider = mapKey.ofType(mapOfSetOfProviderOf(keyType, valueType));
Key<?> mapOfSetOfJavaxProvider = mapKey.ofType(mapOfSetOfJavaxProviderOf(keyType, valueType));
Key<?> mapOfCollectionOfProvider = mapKey.ofType(mapOfCollectionOfProviderOf(keyType, valueType));
Key<?> mapOfCollectionOfJavaxProvider = mapKey.ofType(mapOfCollectionOfJavaxProviderOf(keyType, valueType));
Key<?> mapOfSet = mapKey.ofType(mapOf(keyType, setOf(valueType)));
Key<?> setOfEntry = mapKey.ofType(setOf(entryOfProviderOf(keyType, valueType)));
Key<?> setOfJavaxEntry = mapKey.ofType(setOf(entryOfJavaxProviderOf(keyType, valueType)));
Key<?> collectionOfProvidersOfEntryOfProvider = mapKey.ofType(collectionOfProvidersOf(entryOfProviderOf(keyType, valueType)));
Key<?> collectionOfJavaxProvidersOfEntryOfProvider = mapKey.ofType(collectionOfJavaxProvidersOf(entryOfProviderOf(keyType, valueType)));
Key<?> setOfExtendsOfEntryOfProvider = mapKey.ofType(setOfExtendsOf(entryOfProviderOf(keyType, valueType)));
Key<?> mapOfKeyExtendsValueKey = mapKey.ofType(mapOf(keyType, TypeLiteral.get(Types.subtypeOf(valueType.getType()))));
assertEquals(ImmutableSet.of(mapOfProvider, mapOfJavaxProvider, mapOfSetOfProvider, mapOfSetOfJavaxProvider, mapOfCollectionOfProvider, mapOfCollectionOfJavaxProvider, mapOfSet, mapOfKeyExtendsValueKey), mapbinder.getAlternateMapKeys());
boolean entrySetMatch = false;
boolean entrySetJavaxMatch = false;
boolean mapProviderMatch = false;
boolean mapJavaxProviderMatch = false;
boolean mapSetMatch = false;
boolean mapSetProviderMatch = false;
boolean mapSetJavaxProviderMatch = false;
boolean mapCollectionProviderMatch = false;
boolean mapCollectionJavaxProviderMatch = false;
boolean collectionOfProvidersOfEntryOfProviderMatch = false;
boolean collectionOfJavaxProvidersOfEntryOfProviderMatch = false;
boolean setOfExtendsOfEntryOfProviderMatch = false;
boolean mapOfKeyExtendsValueKeyMatch = false;
List<Object> otherMapBindings = Lists.newArrayList();
List<Element> otherMatches = Lists.newArrayList();
List<Element> otherElements = Lists.newArrayList();
Indexer indexer = new Indexer(null);
Multimap<Object, IndexedBinding> indexedEntries = MultimapBuilder.hashKeys().hashSetValues().build();
int duplicates = 0;
for (Element element : elements) {
boolean contains = mapbinder.containsElement(element);
if (!contains) {
otherElements.add(element);
}
boolean matched = false;
Key<T> key = null;
Binding<T> b = null;
if (element instanceof Binding) {
b = (Binding) element;
if (b instanceof ProviderInstanceBinding) {
ProviderInstanceBinding<?> pb = (ProviderInstanceBinding<?>) b;
if (pb.getUserSuppliedProvider() instanceof ProviderMapEntry) {
// weird casting required to workaround jdk6 compilation problems
ProviderMapEntry<?, ?> pme = (ProviderMapEntry<?, ?>) (Provider) pb.getUserSuppliedProvider();
Binding<?> valueBinding = keyMap.get(pme.getValueKey());
if (indexer.isIndexable(valueBinding) && !indexedEntries.put(pme.getKey(), valueBinding.acceptTargetVisitor(indexer))) {
duplicates++;
}
}
}
key = b.getKey();
Object visited = b.acceptTargetVisitor(visitor);
if (visited instanceof MapBinderBinding) {
matched = true;
if (visited.equals(mapbinder)) {
assertTrue(contains);
} else {
otherMapBindings.add(visited);
}
}
} else if (element instanceof ProviderLookup) {
key = ((ProviderLookup) element).getKey();
}
if (!matched && key != null) {
if (key.equals(mapOfProvider)) {
matched = true;
assertTrue(contains);
mapProviderMatch = true;
} else if (key.equals(mapOfJavaxProvider)) {
matched = true;
assertTrue(contains);
mapJavaxProviderMatch = true;
} else if (key.equals(mapOfSet)) {
matched = true;
assertTrue(contains);
mapSetMatch = true;
} else if (key.equals(mapOfSetOfProvider)) {
matched = true;
assertTrue(contains);
mapSetProviderMatch = true;
} else if (key.equals(mapOfSetOfJavaxProvider)) {
matched = true;
assertTrue(contains);
mapSetJavaxProviderMatch = true;
} else if (key.equals(mapOfCollectionOfProvider)) {
matched = true;
assertTrue(contains);
mapCollectionProviderMatch = true;
} else if (key.equals(mapOfCollectionOfJavaxProvider)) {
matched = true;
assertTrue(contains);
mapCollectionJavaxProviderMatch = true;
} else if (key.equals(setOfEntry)) {
matched = true;
assertTrue(contains);
entrySetMatch = true;
// Validate that this binding is also a MultibinderBinding.
if (b != null) {
assertTrue(b.acceptTargetVisitor(visitor) instanceof MultibinderBinding);
}
} else if (key.equals(setOfJavaxEntry)) {
matched = true;
assertTrue(contains);
entrySetJavaxMatch = true;
} else if (key.equals(collectionOfProvidersOfEntryOfProvider)) {
matched = true;
assertTrue(contains);
collectionOfProvidersOfEntryOfProviderMatch = true;
} else if (key.equals(collectionOfJavaxProvidersOfEntryOfProvider)) {
matched = true;
assertTrue(contains);
collectionOfJavaxProvidersOfEntryOfProviderMatch = true;
} else if (key.equals(setOfExtendsOfEntryOfProvider)) {
matched = true;
assertTrue(contains);
setOfExtendsOfEntryOfProviderMatch = true;
} else if (key.equals(mapOfKeyExtendsValueKey)) {
matched = true;
assertTrue(contains);
mapOfKeyExtendsValueKeyMatch = true;
}
}
if (!matched && contains) {
otherMatches.add(element);
}
}
int otherMatchesSize = otherMatches.size();
if (allowDuplicates) {
// allow for 1 duplicate binding
otherMatchesSize--;
}
// Multiply by 2 because each has a value, and Map.Entry
int expectedSize = (mapResults.size() + duplicates) * 2;
assertEquals("incorrect number of contains, leftover matches:\n" + Joiner.on("\n\t").join(otherMatches), expectedSize, otherMatchesSize);
assertTrue(entrySetMatch);
assertTrue(entrySetJavaxMatch);
assertTrue(mapProviderMatch);
assertTrue(mapJavaxProviderMatch);
assertTrue(collectionOfProvidersOfEntryOfProviderMatch);
assertTrue(collectionOfJavaxProvidersOfEntryOfProviderMatch);
assertTrue(setOfExtendsOfEntryOfProviderMatch);
assertTrue(mapOfKeyExtendsValueKeyMatch);
assertEquals(allowDuplicates, mapSetMatch);
assertEquals(allowDuplicates, mapSetProviderMatch);
assertEquals(allowDuplicates, mapSetJavaxProviderMatch);
assertEquals(allowDuplicates, mapCollectionProviderMatch);
assertEquals(allowDuplicates, mapCollectionJavaxProviderMatch);
assertEquals("other MapBindings found: " + otherMapBindings, expectedMapBindings, otherMapBindings.size());
// Validate that we can construct an injector out of the remaining bindings.
Guice.createInjector(Elements.getModule(otherElements));
}
Aggregations