use of com.google.inject.Key in project roboguice by roboguice.
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<T>();
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);
assertEquals(keyType, mapbinder.getKeyTypeLiteral());
assertEquals(valueType, mapbinder.getValueTypeLiteral());
List<MapResult> mapResults = Lists.newArrayList(results);
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)));
Key<?> collectionOfProvidersOfEntry = mapKey.ofType(collectionOfProvidersOf(entryOfProviderOf(keyType, valueType)));
boolean entrySetMatch = false;
boolean entryProviderCollectionMatch = false;
boolean mapProviderMatch = false;
boolean mapSetMatch = false;
boolean mapSetProviderMatch = 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 key = null;
Binding 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(mapOfSet)) {
matched = true;
assertTrue(contains);
mapSetMatch = true;
} else if (key.equals(mapOfSetOfProvider)) {
matched = true;
assertTrue(contains);
mapSetProviderMatch = 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(collectionOfProvidersOfEntry)) {
matched = true;
assertTrue(contains);
entryProviderCollectionMatch = true;
}
}
if (!matched && contains) {
otherMatches.add(element);
}
}
int otherMatchesSize = otherMatches.size();
if (allowDuplicates) {
// allow for 1 duplicate binding
otherMatchesSize--;
}
// value, ProviderLookup per value, Map.Entry per value
otherMatchesSize = otherMatchesSize / 3;
assertEquals("incorrect number of contains, leftover matches: " + otherMatches, mapResults.size() + duplicates, otherMatchesSize);
assertTrue(entrySetMatch);
assertTrue(entryProviderCollectionMatch);
assertTrue(mapProviderMatch);
assertEquals(allowDuplicates, mapSetMatch);
assertEquals(allowDuplicates, mapSetProviderMatch);
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.Key in project roboguice by roboguice.
the class ScopeRequestIntegrationTest method testNullReplacement.
public final void testNullReplacement() throws Exception {
Injector injector = Guice.createInjector(new ServletModule() {
@Override
protected void configureServlets() {
bindConstant().annotatedWith(Names.named(SomeObject.INVALID)).to(SHOULDNEVERBESEEN);
bind(SomeObject.class).in(RequestScoped.class);
}
});
Callable<SomeObject> callable = injector.getInstance(Caller.class);
try {
assertNotNull(callable.call());
fail();
} catch (ProvisionException pe) {
assertTrue(pe.getCause() instanceof OutOfScopeException);
}
// Validate that an actual null entry in the map results in a null injected object.
Map<Key<?>, Object> map = Maps.newHashMap();
map.put(Key.get(SomeObject.class), null);
callable = ServletScopes.scopeRequest(injector.getInstance(Caller.class), map);
assertNull(callable.call());
}
use of com.google.inject.Key in project roboguice by roboguice.
the class ServletScopesTest method testIsRequestScopedPositive.
public void testIsRequestScopedPositive() {
final Key<String> a = Key.get(String.class, named("A"));
final Key<String> b = Key.get(String.class, named("B"));
final Key<String> c = Key.get(String.class, named("C"));
final Key<String> d = Key.get(String.class, named("D"));
final Key<Object> e = Key.get(Object.class, named("E"));
final Key<String> f = Key.get(String.class, named("F"));
final Key<String> g = Key.get(String.class, named("G"));
Module requestScopedBindings = new AbstractModule() {
@Override
protected void configure() {
bind(a).to(b);
bind(b).to(c);
bind(c).toProvider(Providers.of("c")).in(ServletScopes.REQUEST);
bind(d).toProvider(Providers.of("d")).in(RequestScoped.class);
bind(e).to(AnnotatedRequestScopedClass.class);
install(new PrivateModule() {
@Override
protected void configure() {
bind(f).toProvider(Providers.of("f")).in(RequestScoped.class);
expose(f);
}
});
}
@Provides
@Named("G")
@RequestScoped
String provideG() {
return "g";
}
};
// we know the module contains only bindings
@SuppressWarnings("unchecked") List<Element> moduleBindings = Elements.getElements(requestScopedBindings);
ImmutableMap<Key<?>, Binding<?>> map = indexBindings(moduleBindings);
// linked bindings are not followed by modules
assertFalse(ServletScopes.isRequestScoped(map.get(a)));
assertFalse(ServletScopes.isRequestScoped(map.get(b)));
assertTrue(ServletScopes.isRequestScoped(map.get(c)));
assertTrue(ServletScopes.isRequestScoped(map.get(d)));
// annotated classes are not followed by modules
assertFalse(ServletScopes.isRequestScoped(map.get(e)));
assertTrue(ServletScopes.isRequestScoped(map.get(f)));
assertTrue(ServletScopes.isRequestScoped(map.get(g)));
Injector injector = Guice.createInjector(requestScopedBindings, new ServletModule());
assertTrue(ServletScopes.isRequestScoped(injector.getBinding(a)));
assertTrue(ServletScopes.isRequestScoped(injector.getBinding(b)));
assertTrue(ServletScopes.isRequestScoped(injector.getBinding(c)));
assertTrue(ServletScopes.isRequestScoped(injector.getBinding(d)));
assertTrue(ServletScopes.isRequestScoped(injector.getBinding(e)));
assertTrue(ServletScopes.isRequestScoped(injector.getBinding(f)));
assertTrue(ServletScopes.isRequestScoped(injector.getBinding(g)));
}
use of com.google.inject.Key in project roboguice by roboguice.
the class TransferRequestIntegrationTest method testTransferNonHttpRequest.
public void testTransferNonHttpRequest() throws Exception {
final Injector injector = Guice.createInjector(new AbstractModule() {
@Override
protected void configure() {
bindScope(RequestScoped.class, ServletScopes.REQUEST);
}
@Provides
@RequestScoped
Object provideObject() {
return new Object();
}
});
Callable<Callable<Boolean>> callable = new Callable<Callable<Boolean>>() {
@Override
public Callable<Boolean> call() {
final Object original = injector.getInstance(Object.class);
return ServletScopes.transferRequest(new Callable<Boolean>() {
@Override
public Boolean call() {
return original == injector.getInstance(Object.class);
}
});
}
};
ImmutableMap<Key<?>, Object> seedMap = ImmutableMap.of();
Callable<Boolean> transfer = ServletScopes.scopeRequest(callable, seedMap).call();
ExecutorService executor = Executors.newSingleThreadExecutor();
assertTrue(executor.submit(transfer).get());
executor.shutdownNow();
}
use of com.google.inject.Key in project roboguice by roboguice.
the class CheckedProviderTest method testDependencies_Cxtor.
public void testDependencies_Cxtor() {
cxtorInjector = Guice.createInjector(new AbstractModule() {
@Override
protected void configure() {
bind(String.class).toInstance("Foo");
bind(Integer.class).toInstance(5);
bind(Double.class).toInstance(5d);
bind(Long.class).toInstance(5L);
ThrowingProviderBinder.create(binder()).bind(RemoteProvider.class, Foo.class).providing(DependentMockFoo.class);
}
});
Key<?> key = Key.get(remoteProviderOfFoo);
// RemoteProvider<String> is dependent on Result.
HasDependencies hasDependencies = (HasDependencies) cxtorInjector.getBinding(key);
key = Iterables.getOnlyElement(hasDependencies.getDependencies()).getKey();
assertEquals(Result.class, key.getTypeLiteral().getRawType());
// Result is dependent on the fake CheckedProvider impl
hasDependencies = (HasDependencies) cxtorInjector.getBinding(key);
key = Iterables.getOnlyElement(hasDependencies.getDependencies()).getKey();
assertTrue(CheckedProvider.class.isAssignableFrom(key.getTypeLiteral().getRawType()));
// And the CheckedProvider is dependent on DependentMockFoo...
hasDependencies = (HasDependencies) cxtorInjector.getBinding(key);
key = Iterables.getOnlyElement(hasDependencies.getDependencies()).getKey();
assertEquals(DependentMockFoo.class, key.getTypeLiteral().getRawType());
// And DependentMockFoo is dependent on the goods.
hasDependencies = (HasDependencies) cxtorInjector.getBinding(key);
Set<Key<?>> dependencyKeys = ImmutableSet.copyOf(Iterables.transform(hasDependencies.getDependencies(), DEPENDENCY_TO_KEY));
assertEquals(ImmutableSet.<Key<?>>of(Key.get(String.class), Key.get(Integer.class), Key.get(Long.class), Key.get(Double.class)), dependencyKeys);
}
Aggregations