use of com.google.inject.spi.ProviderInstanceBinding in project guice by google.
the class SpiUtils method mapInjectorTest.
@SuppressWarnings("unchecked")
private static <T> void mapInjectorTest(Key<T> mapKey, TypeLiteral<?> keyType, TypeLiteral<?> valueType, Iterable<? extends Module> modules, boolean allowDuplicates, int expectedMapBindings, MapResult<?, ?>... results) {
Injector injector = Guice.createInjector(modules);
Visitor<T> visitor = new Visitor<>();
Binding<T> mapBinding = injector.getBinding(mapKey);
MapBinderBinding<T> mapbinder = (MapBinderBinding<T>) mapBinding.acceptTargetVisitor(visitor);
assertNotNull(mapbinder);
assertEquals(mapKey, mapbinder.getMapKey());
assertEquals(keyType, mapbinder.getKeyTypeLiteral());
assertEquals(valueType, mapbinder.getValueTypeLiteral());
assertEquals(allowDuplicates, mapbinder.permitsDuplicates());
List<Map.Entry<?, Binding<?>>> entries = Lists.newArrayList(mapbinder.getEntries());
List<MapResult<?, ?>> mapResults = Lists.newArrayList(results);
assertEquals("wrong entries, expected: " + mapResults + ", but was: " + entries, mapResults.size(), entries.size());
for (MapResult<?, ?> result : mapResults) {
Map.Entry<?, Binding<?>> found = null;
for (Map.Entry<?, Binding<?>> entry : entries) {
Object key = entry.getKey();
Binding<?> value = entry.getValue();
if (key.equals(result.k) && matches(value, result.v)) {
found = entry;
break;
}
}
if (found == null) {
fail("Could not find entry: " + result + " in remaining entries: " + entries);
} else {
assertTrue("mapBinder doesn't contain: " + found.getValue(), mapbinder.containsElement(found.getValue()));
entries.remove(found);
}
}
if (!entries.isEmpty()) {
fail("Found all entries of: " + mapResults + ", but more were left over: " + entries);
}
Key<?> mapOfJavaxProvider = mapKey.ofType(mapOfJavaxProviderOf(keyType, valueType));
Key<?> mapOfProvider = mapKey.ofType(mapOfProviderOf(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(mapOfJavaxProvider, mapOfProvider, mapOfSetOfProvider, mapOfSetOfJavaxProvider, mapOfCollectionOfProvider, mapOfCollectionOfJavaxProvider, mapOfSet, mapOfKeyExtendsValueKey), mapbinder.getAlternateMapKeys());
boolean entrySetMatch = false;
boolean javaxEntrySetMatch = false;
boolean mapJavaxProviderMatch = false;
boolean mapProviderMatch = 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<Binding<?>> otherMatches = Lists.newArrayList();
Multimap<Object, IndexedBinding> indexedEntries = MultimapBuilder.hashKeys().hashSetValues().build();
Indexer indexer = new Indexer(injector);
int duplicates = 0;
for (Binding<?> b : injector.getAllBindings().values()) {
boolean contains = mapbinder.containsElement(b);
Object visited = ((Binding<T>) b).acceptTargetVisitor(visitor);
if (visited instanceof MapBinderBinding) {
if (visited.equals(mapbinder)) {
assertTrue(contains);
} else {
otherMapBindings.add(visited);
}
} else if (b.getKey().equals(mapOfProvider)) {
assertTrue(contains);
mapProviderMatch = true;
} else if (b.getKey().equals(mapOfJavaxProvider)) {
assertTrue(contains);
mapJavaxProviderMatch = true;
} else if (b.getKey().equals(mapOfSet)) {
assertTrue(contains);
mapSetMatch = true;
} else if (b.getKey().equals(mapOfSetOfProvider)) {
assertTrue(contains);
mapSetProviderMatch = true;
} else if (b.getKey().equals(mapOfSetOfJavaxProvider)) {
assertTrue(contains);
mapSetJavaxProviderMatch = true;
} else if (b.getKey().equals(mapOfCollectionOfProvider)) {
assertTrue(contains);
mapCollectionProviderMatch = true;
} else if (b.getKey().equals(mapOfCollectionOfJavaxProvider)) {
assertTrue(contains);
mapCollectionJavaxProviderMatch = true;
} else if (b.getKey().equals(setOfEntry)) {
assertTrue(contains);
entrySetMatch = true;
// Validate that this binding is also a MultibinderBinding.
assertThat(((Binding<T>) b).acceptTargetVisitor(visitor)).isInstanceOf(MultibinderBinding.class);
} else if (b.getKey().equals(setOfJavaxEntry)) {
assertTrue(contains);
javaxEntrySetMatch = true;
} else if (b.getKey().equals(collectionOfProvidersOfEntryOfProvider)) {
assertTrue(contains);
collectionOfProvidersOfEntryOfProviderMatch = true;
} else if (b.getKey().equals(collectionOfJavaxProvidersOfEntryOfProvider)) {
assertTrue(contains);
collectionOfJavaxProvidersOfEntryOfProviderMatch = true;
} else if (b.getKey().equals(setOfExtendsOfEntryOfProvider)) {
assertTrue(contains);
setOfExtendsOfEntryOfProviderMatch = true;
} else if (b.getKey().equals(mapOfKeyExtendsValueKey)) {
assertTrue(contains);
mapOfKeyExtendsValueKeyMatch = true;
} else if (contains) {
if (b instanceof ProviderInstanceBinding) {
ProviderInstanceBinding<?> pib = (ProviderInstanceBinding<?>) b;
if (pib.getUserSuppliedProvider() instanceof ProviderMapEntry) {
// weird casting required to workaround compilation issues with jdk6
ProviderMapEntry<?, ?> pme = (ProviderMapEntry<?, ?>) (Provider) pib.getUserSuppliedProvider();
Binding<?> valueBinding = injector.getBinding(pme.getValueKey());
if (indexer.isIndexable(valueBinding) && !indexedEntries.put(pme.getKey(), valueBinding.acceptTargetVisitor(indexer))) {
duplicates++;
}
}
}
otherMatches.add(b);
}
}
int sizeOfOther = otherMatches.size();
if (allowDuplicates) {
// account for 1 duplicate binding
sizeOfOther--;
}
// Multiply by two because each has a value and Map.Entry.
int expectedSize = 2 * (mapResults.size() + duplicates);
assertEquals("Incorrect other matches:\n\t" + Joiner.on("\n\t").join(otherMatches), expectedSize, sizeOfOther);
assertTrue(entrySetMatch);
assertTrue(javaxEntrySetMatch);
assertTrue(mapProviderMatch);
assertTrue(mapJavaxProviderMatch);
assertTrue(collectionOfProvidersOfEntryOfProviderMatch);
assertTrue(collectionOfJavaxProvidersOfEntryOfProviderMatch);
assertTrue(setOfExtendsOfEntryOfProviderMatch);
assertTrue(mapOfKeyExtendsValueKeyMatch);
assertEquals(allowDuplicates, mapSetMatch);
assertEquals(allowDuplicates, mapSetProviderMatch);
assertEquals(allowDuplicates, mapSetJavaxProviderMatch);
assertEquals(allowDuplicates, mapCollectionJavaxProviderMatch);
assertEquals(allowDuplicates, mapCollectionProviderMatch);
assertEquals("other MapBindings found: " + otherMapBindings, expectedMapBindings, otherMapBindings.size());
}
use of com.google.inject.spi.ProviderInstanceBinding in project roboguice by roboguice.
the class SpiUtils method mapInjectorTest.
@SuppressWarnings("unchecked")
private static <T> void mapInjectorTest(Key<T> mapKey, TypeLiteral<?> keyType, TypeLiteral<?> valueType, Iterable<? extends Module> modules, boolean allowDuplicates, int expectedMapBindings, MapResult... results) {
Injector injector = Guice.createInjector(modules);
Visitor<T> visitor = new Visitor<T>();
Binding<T> mapBinding = injector.getBinding(mapKey);
MapBinderBinding<T> mapbinder = (MapBinderBinding<T>) mapBinding.acceptTargetVisitor(visitor);
assertNotNull(mapbinder);
assertEquals(keyType, mapbinder.getKeyTypeLiteral());
assertEquals(valueType, mapbinder.getValueTypeLiteral());
assertEquals(allowDuplicates, mapbinder.permitsDuplicates());
List<Map.Entry<?, Binding<?>>> entries = Lists.newArrayList(mapbinder.getEntries());
List<MapResult> mapResults = Lists.newArrayList(results);
assertEquals("wrong entries, expected: " + mapResults + ", but was: " + entries, mapResults.size(), entries.size());
for (MapResult result : mapResults) {
Map.Entry<?, Binding<?>> found = null;
for (Map.Entry<?, Binding<?>> entry : entries) {
Object key = entry.getKey();
Binding<?> value = entry.getValue();
if (key.equals(result.k) && matches(value, result.v)) {
found = entry;
break;
}
}
if (found == null) {
fail("Could not find entry: " + result + " in remaining entries: " + entries);
} else {
assertTrue("mapBinder doesn't contain: " + found.getValue(), mapbinder.containsElement(found.getValue()));
entries.remove(found);
}
}
if (!entries.isEmpty()) {
fail("Found all entries of: " + mapResults + ", but more were left over: " + entries);
}
Key<?> mapOfJavaxProvider = mapKey.ofType(mapOfJavaxProviderOf(keyType, valueType));
Key<?> mapOfProvider = mapKey.ofType(mapOfProviderOf(keyType, valueType));
Key<?> mapOfSetOfProvider = mapKey.ofType(mapOfSetOfProviderOf(keyType, valueType));
Key<?> mapOfSet = mapKey.ofType(mapOf(keyType, setOf(valueType)));
Key<?> setOfEntry = mapKey.ofType(setOf(entryOfProviderOf(keyType, valueType)));
boolean entrySetMatch = false;
boolean mapJavaxProviderMatch = false;
boolean mapProviderMatch = false;
boolean mapSetMatch = false;
boolean mapSetProviderMatch = false;
List<Object> otherMapBindings = Lists.newArrayList();
List<Binding> otherMatches = Lists.newArrayList();
Multimap<Object, IndexedBinding> indexedEntries = MultimapBuilder.hashKeys().hashSetValues().build();
Indexer indexer = new Indexer(injector);
int duplicates = 0;
for (Binding b : injector.getAllBindings().values()) {
boolean contains = mapbinder.containsElement(b);
Object visited = b.acceptTargetVisitor(visitor);
if (visited instanceof MapBinderBinding) {
if (visited.equals(mapbinder)) {
assertTrue(contains);
} else {
otherMapBindings.add(visited);
}
} else if (b.getKey().equals(mapOfProvider)) {
assertTrue(contains);
mapProviderMatch = true;
} else if (b.getKey().equals(mapOfJavaxProvider)) {
assertTrue(contains);
mapJavaxProviderMatch = true;
} else if (b.getKey().equals(mapOfSet)) {
assertTrue(contains);
mapSetMatch = true;
} else if (b.getKey().equals(mapOfSetOfProvider)) {
assertTrue(contains);
mapSetProviderMatch = true;
} else if (b.getKey().equals(setOfEntry)) {
assertTrue(contains);
entrySetMatch = true;
// Validate that this binding is also a MultibinderBinding.
assertTrue(b.acceptTargetVisitor(visitor) instanceof MultibinderBinding);
} else if (contains) {
if (b instanceof ProviderInstanceBinding) {
ProviderInstanceBinding<?> pib = (ProviderInstanceBinding<?>) b;
if (pib.getUserSuppliedProvider() instanceof ProviderMapEntry) {
// weird casting required to workaround compilation issues with jdk6
ProviderMapEntry<?, ?> pme = (ProviderMapEntry<?, ?>) (Provider) pib.getUserSuppliedProvider();
Binding<?> valueBinding = injector.getBinding(pme.getValueKey());
if (indexer.isIndexable(valueBinding) && !indexedEntries.put(pme.getKey(), valueBinding.acceptTargetVisitor(indexer))) {
duplicates++;
}
}
}
otherMatches.add(b);
}
}
int sizeOfOther = otherMatches.size();
if (allowDuplicates) {
// account for 1 duplicate binding
sizeOfOther--;
}
// account for 1 value & 1 Map.Entry of each expected binding.
sizeOfOther = sizeOfOther / 2;
assertEquals("Incorrect other matches: " + otherMatches, mapResults.size() + duplicates, sizeOfOther);
assertTrue(entrySetMatch);
assertTrue(mapProviderMatch);
assertTrue(mapJavaxProviderMatch);
assertEquals(allowDuplicates, mapSetMatch);
assertEquals(allowDuplicates, mapSetProviderMatch);
assertEquals("other MapBindings found: " + otherMapBindings, expectedMapBindings, otherMapBindings.size());
}
use of com.google.inject.spi.ProviderInstanceBinding in project guice by google.
the class SpiUtils method mapInjectorTest.
@SuppressWarnings("unchecked")
private static <T> void mapInjectorTest(Key<T> mapKey, TypeLiteral<?> keyType, TypeLiteral<?> valueType, Iterable<? extends Module> modules, boolean allowDuplicates, int expectedMapBindings, MapResult... results) {
Injector injector = Guice.createInjector(modules);
Visitor<T> visitor = new Visitor<T>();
Binding<T> mapBinding = injector.getBinding(mapKey);
MapBinderBinding<T> mapbinder = (MapBinderBinding<T>) mapBinding.acceptTargetVisitor(visitor);
assertNotNull(mapbinder);
assertEquals(keyType, mapbinder.getKeyTypeLiteral());
assertEquals(valueType, mapbinder.getValueTypeLiteral());
assertEquals(allowDuplicates, mapbinder.permitsDuplicates());
List<Map.Entry<?, Binding<?>>> entries = Lists.newArrayList(mapbinder.getEntries());
List<MapResult> mapResults = Lists.newArrayList(results);
assertEquals("wrong entries, expected: " + mapResults + ", but was: " + entries, mapResults.size(), entries.size());
for (MapResult result : mapResults) {
Map.Entry<?, Binding<?>> found = null;
for (Map.Entry<?, Binding<?>> entry : entries) {
Object key = entry.getKey();
Binding<?> value = entry.getValue();
if (key.equals(result.k) && matches(value, result.v)) {
found = entry;
break;
}
}
if (found == null) {
fail("Could not find entry: " + result + " in remaining entries: " + entries);
} else {
assertTrue("mapBinder doesn't contain: " + found.getValue(), mapbinder.containsElement(found.getValue()));
entries.remove(found);
}
}
if (!entries.isEmpty()) {
fail("Found all entries of: " + mapResults + ", but more were left over: " + entries);
}
Key<?> mapOfJavaxProvider = mapKey.ofType(mapOfJavaxProviderOf(keyType, valueType));
Key<?> mapOfProvider = mapKey.ofType(mapOfProviderOf(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)));
boolean entrySetMatch = false;
boolean javaxEntrySetMatch = false;
boolean mapJavaxProviderMatch = false;
boolean mapProviderMatch = false;
boolean mapSetMatch = false;
boolean mapSetProviderMatch = false;
boolean mapSetJavaxProviderMatch = false;
boolean mapCollectionProviderMatch = false;
boolean mapCollectionJavaxProviderMatch = false;
boolean collectionOfProvidersOfEntryOfProviderMatch = false;
boolean collectionOfJavaxProvidersOfEntryOfProviderMatch = false;
List<Object> otherMapBindings = Lists.newArrayList();
List<Binding> otherMatches = Lists.newArrayList();
Multimap<Object, IndexedBinding> indexedEntries = MultimapBuilder.hashKeys().hashSetValues().build();
Indexer indexer = new Indexer(injector);
int duplicates = 0;
for (Binding b : injector.getAllBindings().values()) {
boolean contains = mapbinder.containsElement(b);
Object visited = b.acceptTargetVisitor(visitor);
if (visited instanceof MapBinderBinding) {
if (visited.equals(mapbinder)) {
assertTrue(contains);
} else {
otherMapBindings.add(visited);
}
} else if (b.getKey().equals(mapOfProvider)) {
assertTrue(contains);
mapProviderMatch = true;
} else if (b.getKey().equals(mapOfJavaxProvider)) {
assertTrue(contains);
mapJavaxProviderMatch = true;
} else if (b.getKey().equals(mapOfSet)) {
assertTrue(contains);
mapSetMatch = true;
} else if (b.getKey().equals(mapOfSetOfProvider)) {
assertTrue(contains);
mapSetProviderMatch = true;
} else if (b.getKey().equals(mapOfSetOfJavaxProvider)) {
assertTrue(contains);
mapSetJavaxProviderMatch = true;
} else if (b.getKey().equals(mapOfCollectionOfProvider)) {
assertTrue(contains);
mapCollectionProviderMatch = true;
} else if (b.getKey().equals(mapOfCollectionOfJavaxProvider)) {
assertTrue(contains);
mapCollectionJavaxProviderMatch = true;
} else if (b.getKey().equals(setOfEntry)) {
assertTrue(contains);
entrySetMatch = true;
// Validate that this binding is also a MultibinderBinding.
assertTrue(b.acceptTargetVisitor(visitor) instanceof MultibinderBinding);
} else if (b.getKey().equals(setOfJavaxEntry)) {
assertTrue(contains);
javaxEntrySetMatch = true;
} else if (b.getKey().equals(collectionOfProvidersOfEntryOfProvider)) {
assertTrue(contains);
collectionOfProvidersOfEntryOfProviderMatch = true;
} else if (b.getKey().equals(collectionOfJavaxProvidersOfEntryOfProvider)) {
assertTrue(contains);
collectionOfJavaxProvidersOfEntryOfProviderMatch = true;
} else if (contains) {
if (b instanceof ProviderInstanceBinding) {
ProviderInstanceBinding<?> pib = (ProviderInstanceBinding<?>) b;
if (pib.getUserSuppliedProvider() instanceof ProviderMapEntry) {
// weird casting required to workaround compilation issues with jdk6
ProviderMapEntry<?, ?> pme = (ProviderMapEntry<?, ?>) (Provider) pib.getUserSuppliedProvider();
Binding<?> valueBinding = injector.getBinding(pme.getValueKey());
if (indexer.isIndexable(valueBinding) && !indexedEntries.put(pme.getKey(), valueBinding.acceptTargetVisitor(indexer))) {
duplicates++;
}
}
}
otherMatches.add(b);
}
}
int sizeOfOther = otherMatches.size();
if (allowDuplicates) {
// account for 1 duplicate binding
sizeOfOther--;
}
// Multiply by two because each has a value and Map.Entry.
int expectedSize = 2 * (mapResults.size() + duplicates);
assertEquals("Incorrect other matches:\n\t" + Joiner.on("\n\t").join(otherMatches), expectedSize, sizeOfOther);
assertTrue(entrySetMatch);
assertTrue(javaxEntrySetMatch);
assertTrue(mapProviderMatch);
assertTrue(mapJavaxProviderMatch);
assertTrue(collectionOfProvidersOfEntryOfProviderMatch);
assertTrue(collectionOfJavaxProvidersOfEntryOfProviderMatch);
assertEquals(allowDuplicates, mapSetMatch);
assertEquals(allowDuplicates, mapSetProviderMatch);
assertEquals(allowDuplicates, mapSetJavaxProviderMatch);
assertEquals(allowDuplicates, mapCollectionJavaxProviderMatch);
assertEquals(allowDuplicates, mapCollectionProviderMatch);
assertEquals("other MapBindings found: " + otherMapBindings, expectedMapBindings, otherMapBindings.size());
}
use of com.google.inject.spi.ProviderInstanceBinding 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));
}
use of com.google.inject.spi.ProviderInstanceBinding in project ninja by ninjaframework.
the class LifecycleServiceImpl method start.
@Override
public void start() {
startTime = System.currentTimeMillis();
log.info("Starting Ninja application...");
state = State.STARTING;
// until they are instantiated that LifecycleSupport has an opportunity to register them.
for (final Binding binding : injector.getBindings().values()) {
binding.acceptScopingVisitor(new DefaultBindingScopingVisitor() {
@Override
public Object visitEagerSingleton() {
injector.getInstance(binding.getKey());
return null;
}
@Override
public Object visitScope(Scope scope) {
if (scope.equals(Scopes.SINGLETON)) {
Object target = injector.getInstance(binding.getKey());
if (binding instanceof ProviderInstanceBinding) {
Provider providerInstance = ((ProviderInstanceBinding) binding).getProviderInstance();
if (providerInstance instanceof ProviderMethod) {
// @Provides methods don't get picked up by TypeListeners, so we need to manually register them
if (lifecycleSupport.hasLifecycleMethod(target.getClass())) {
lifecycleSupport.registerLifecycle(target);
}
}
}
}
return null;
}
});
}
lifecycleRegister.start();
long time = System.currentTimeMillis() - startTime;
log.info("Ninja application started in {}ms", time);
state = lifecycleRegister.isStarted() ? State.STARTED : State.STOPPED;
}
Aggregations