public void testToString() {
final Key<String> key1 = Key.get(String.class, Names.named("KEY"));
final Key<String> key2 = Key.get(String.class, Names.named("BAD"));
final Injector injector =
Guice.createInjector(
new AbstractModule() {
@Override
protected void configure() {
bind(key1).toProvider(new ToStringProvider());
bind(key2).toProvider(new BadToStringProvider());
}
});
final Entry<Named, String> entry1 =
new LazyBeanEntry<Named, String>(
(Named) key1.getAnnotation(), injector.getBinding(key1), 0);
final Entry<Named, String> entry2 =
new LazyBeanEntry<Named, String>(
(Named) key2.getAnnotation(), injector.getBinding(key2), 0);
Exception error = null;
try {
injector.getInstance(key2);
} catch (final Exception e) {
error = e;
}
assertEquals('@' + javax.inject.Named.class.getName() + "(value=KEY)=VALUE", entry1.toString());
assertEquals(
'@' + javax.inject.Named.class.getName() + "(value=BAD)=" + error, entry2.toString());
}
public void testDetails() {
final Key<Bean> key1 = Key.get(Bean.class, Names.named("1"));
final Key<Bean> key2 = Key.get(Bean.class, Names.named("2"));
final Key<Bean> key3 = Key.get(Bean.class, Names.named("3"));
final Key<Bean> key4 = Key.get(Bean.class, Names.named("4"));
final Injector injector =
Guice.createInjector(
new AbstractModule() {
@Override
protected void configure() {
bind(key1).to(DescribedBean.class).in(Scopes.SINGLETON);
binder()
.withSource(
new BeanDescription() {
public String getDescription() {
return "Another test";
}
})
.bind(key2)
.toInstance(new BeanImpl());
binder().withSource("where?").bind(key3).to(BeanImpl.class);
bind(key4).toProvider(Providers.of(new BeanImpl()));
}
});
final LazyBeanEntry<Annotation, Bean> bean1 =
new LazyBeanEntry<Annotation, Bean>(key1.getAnnotation(), injector.getBinding(key1), 42);
final LazyBeanEntry<Annotation, Bean> bean2 =
new LazyBeanEntry<Annotation, Bean>(key2.getAnnotation(), injector.getBinding(key2), -24);
final LazyBeanEntry<Annotation, Bean> bean3 =
new LazyBeanEntry<Annotation, Bean>(key3.getAnnotation(), injector.getBinding(key3), 0);
final LazyBeanEntry<Annotation, Bean> bean4 =
new LazyBeanEntry<Annotation, Bean>(key4.getAnnotation(), injector.getBinding(key4), -1);
assertEquals("This is a test", bean1.getDescription());
assertTrue(bean1.getSource() instanceof StackTraceElement);
assertEquals(DescribedBean.class, bean1.getImplementationClass());
assertEquals(42, bean1.getRank());
assertEquals("Another test", bean2.getDescription());
assertTrue(bean2.getSource() instanceof BeanDescription);
assertEquals(BeanImpl.class, bean2.getImplementationClass());
assertEquals(-24, bean2.getRank());
assertNull(bean3.getDescription());
assertTrue(bean3.getSource() instanceof String);
assertEquals(BeanImpl.class, bean3.getImplementationClass());
assertEquals(0, bean3.getRank());
assertNull(bean4.getDescription());
assertTrue(bean4.getSource() instanceof StackTraceElement);
assertEquals(null, bean4.getImplementationClass());
assertEquals(-1, bean4.getRank());
}
/**
* Computes a canonical {@link Qualifier} annotation for the given binding {@link Key}.
*
* @param key The key to qualify
* @return Qualifier for the key
*/
static final Annotation qualify(final Key<?> key) {
if (key instanceof WildcardKey) {
final Annotation qualifier = ((WildcardKey) key).getQualifier();
return null != qualifier ? qualifier : DEFAULT_QUALIFIER;
}
return null != key.getAnnotationType() ? key.getAnnotation() : DEFAULT_QUALIFIER;
}
@Nonnull
@Override
public <T> Collection<Qualified<T>> getQualifiedInstances(@Nonnull Class<T> type)
throws InstanceNotFoundException {
requireNonNull(type, ERROR_TYPE_NULL);
if (isClosed()) {
throw new InstanceNotFoundException(type, new ClosedInjectorException(this));
}
List<Qualified<T>> instances = new ArrayList<>();
List<com.google.inject.Binding<T>> bindings;
try {
bindings = delegate.findBindingsByType(TypeLiteral.get(type));
} catch (RuntimeException e) {
throw new InstanceNotFoundException(type, e);
}
if (bindings == null) {
throw new InstanceNotFoundException(type);
}
for (com.google.inject.Binding<T> binding : bindings) {
try {
Key<T> key = binding.getKey();
final T instance = delegate.getInstance(key);
instances.add(new Qualified<>(instance, translate(key.getAnnotation())));
} catch (RuntimeException e) {
throw new InstanceNotFoundException(type, e);
}
}
return instances;
}
// TODO: Remove method parameter, which is unused
protected SortedMap<Key<?>, Binding<?>> getPolymorphicAdapterMapBindings(
final Class<?> adaptableType, final Method method, final AdapterMap methodAnnotation) {
// find available keys
final Map<Key<?>, Binding<?>> allBindings = injector.getAllBindings();
// IMPORTANT: use a sorted map, where keys are sorted according to
// hierarchy of annotation types (so we have polymorphic injection)
final SortedMap<Key<?>, Binding<?>> polymorphicBindings =
new TreeMap<Key<?>, Binding<?>>(
new Comparator<Key<?>>() {
@Override
public int compare(final Key<?> o1, final Key<?> o2) {
if (!AdapterMap.class.equals(o1.getAnnotationType())
|| !AdapterMap.class.equals(o2.getAnnotationType())) {
throw new IllegalArgumentException(
"Can only compare keys with AdapterMap annotations");
}
final AdapterMap a1 = (AdapterMap) o1.getAnnotation();
final AdapterMap a2 = (AdapterMap) o2.getAnnotation();
if (a1.adaptableType().equals(a2.adaptableType())) {
return 0;
} else if (a1.adaptableType().isAssignableFrom(a2.adaptableType())) {
return -1;
} else {
return 1;
}
}
});
for (final Key<?> key : allBindings.keySet()) {
if ((key.getAnnotationType() != null) && AdapterMap.class.equals(key.getAnnotationType())) {
final AdapterMap keyAnnotation = (AdapterMap) key.getAnnotation();
// Guice will already have injected all bindings where the
// adaptableType used in the method annotation is the same as
// the one used in the key annotation.
if (!methodAnnotation.adaptableType().equals(keyAnnotation.adaptableType())
/*
* The annotation in the binding refers to a true
* super-type of instance runtime type (check, because
* if the type is the same, the default injector will
* already inject the values) IMPORTANT: we use
* 'adaptableType' instead of 'methodAnnotation
* .adaptableType()' here, because the runtime type of
* the to be injected IAdaptable is relevant
*/
&& keyAnnotation.adaptableType().isAssignableFrom(adaptableType)) {
// System.out.println("Applying binding for " +
// keyAnnotation.value() + " to " + type +
// " as subtype of " + methodAnnotation.value());
polymorphicBindings.put(key, allBindings.get(key));
}
}
}
return polymorphicBindings;
}
private static void bindHierarchy(final Binder binder, final Key rootKey) {
final Class root = rootKey.getTypeLiteral().getRawType();
Annotation qualifier = rootKey.getAnnotation();
if (null == qualifier) {
qualifier = Names.named(root.getName());
}
for (Class clazz = root; clazz != Object.class; clazz = clazz.getSuperclass()) {
if (clazz != root && ExtensionPoint.class.isAssignableFrom(clazz)) {
binder.bind(clazz).annotatedWith(qualifier).to(rootKey);
}
if (Descriptor.class.isAssignableFrom(clazz)) {
binder.bind(Descriptor.class).annotatedWith(qualifier).to(rootKey);
}
for (final Class<?> iface : clazz.getInterfaces()) {
if (ExtensionPoint.class.isAssignableFrom(iface)) {
binder.bind(iface).annotatedWith(qualifier).to(rootKey);
}
}
}
}
@Override
final Annotation qualifies(final Key<?> requirement, final Binding<?> binding) {
final Annotation qualifier = MARKED.qualifies(requirement, binding);
return requirement.getAnnotation().equals(qualifier) ? qualifier : null;
}
@Override
final Annotation qualifies(final Key<?> requirement, final Binding<?> binding) {
final Annotation qualifier = qualify(binding.getKey());
return requirement.getAnnotation().equals(qualifier) ? qualifier : null;
}
