1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
|
package com.google.inject.spi;
import java.util.Map;
import com.google.inject.AbstractModule;
import com.google.inject.Binding;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.Key;
import com.google.inject.Provider;
import com.google.inject.TypeLiteral;
import junit.framework.TestCase;
/**
* @author sberlin@gmail.com (Sam Berlin)
*/
public class InjectorSpiTest extends TestCase {
public void testExistingBinding() {
Injector injector = Guice.createInjector(new AbstractModule() {
@Override
protected void configure() {
bind(Foo.class);
bind(Baz.class);
}
});
// Sanity check -- ensure we return the proper binding for all existing bindings.
for(Map.Entry<Key<?>, Binding<?>> entry : injector.getAllBindings().entrySet()) {
assertSame(entry.getValue(), injector.getExistingBinding(entry.getKey()));
}
// Now run through specifics...
Binding<?> binding;
// 1) non-Provider Foo.class
binding = injector.getExistingBinding(Key.get(Foo.class));
assertNotNull(binding);
assertEquals(Foo.class, binding.getKey().getTypeLiteral().getRawType());
// 2) Provider<Foo> class (should already exist, because Baz @Injects it).
// the assertTrue is a bit stricter than necessary, but makes sure this works for pre-existing Provider bindings
assertTrue(injector.getAllBindings().containsKey(Key.get(new TypeLiteral<Provider<Foo>>() {})));
binding = injector.getExistingBinding(Key.get(new TypeLiteral<Provider<Foo>>() {}));
assertNotNull(binding);
assertEquals(Provider.class, binding.getKey().getTypeLiteral().getRawType());
assertEquals(Foo.class, ((Provider)binding.getProvider().get()).get().getClass());
// 3) non-Provider Baz.class
binding = injector.getExistingBinding(Key.get(Baz.class));
assertNotNull(binding);
assertEquals(Baz.class, binding.getKey().getTypeLiteral().getRawType());
// 4) Provider<Baz> class (should not already exist, because nothing used it yet).
// the assertFalse is a bit stricter than necessary, but makes sure this works for non-pre-existing Provider bindings
assertFalse(injector.getAllBindings().containsKey(Key.get(new TypeLiteral<Provider<Baz>>() {})));
binding = injector.getExistingBinding(Key.get(new TypeLiteral<Provider<Baz>>() {}));
assertNotNull(binding);
assertEquals(Provider.class, binding.getKey().getTypeLiteral().getRawType());
assertEquals(Baz.class, ((Provider)binding.getProvider().get()).get().getClass());
// 5) non-Provider Bar, doesn't exist.
assertNull(injector.getExistingBinding(Key.get(Bar.class)));
// 6) Provider Bar, doesn't exist.
assertNull(injector.getExistingBinding(Key.get(new TypeLiteral<Provider<Bar>>() {})));
}
private static class Foo {}
private static class Bar {}
private static class Baz { @SuppressWarnings("unused") @Inject Provider<Foo> fooP; }
}
|
