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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
|
package com.google.inject;
import static com.google.inject.Asserts.assertContains;
import com.google.inject.internal.Nullable;
import junit.framework.TestCase;
/**
* @author jessewilson@google.com (Jesse Wilson)
*/
public class NullableInjectionPointTest extends TestCase {
public void testInjectNullIntoNotNullableConstructor() {
try {
createInjector().getInstance(FooConstructor.class);
fail("Injecting null should fail with an error");
}
catch (ProvisionException expected) {
assertContains(expected.getMessage(),
"null returned by binding at " + getClass().getName(),
"parameter 0 of " + FooConstructor.class.getName() + ".<init>() is not @Nullable");
}
}
public void testInjectNullIntoNotNullableMethod() {
try {
createInjector().getInstance(FooMethod.class);
fail("Injecting null should fail with an error");
}
catch (ProvisionException expected) {
assertContains(expected.getMessage(),
"null returned by binding at " + getClass().getName(),
"parameter 0 of " + FooMethod.class.getName() + ".setFoo() is not @Nullable");
}
}
public void testInjectNullIntoNotNullableField() {
try {
createInjector().getInstance(FooField.class);
fail("Injecting null should fail with an error");
}
catch (ProvisionException expected) {
assertContains(expected.getMessage(),
"null returned by binding at " + getClass().getName(),
" but " + FooField.class.getName() + ".foo is not @Nullable");
}
}
/**
* Provider.getInstance() is allowed to return null via direct calls to
* getInstance().
*/
public void testGetInstanceOfNull() {
assertNull(createInjector().getInstance(Foo.class));
}
public void testInjectNullIntoNullableConstructor() {
NullableFooConstructor nfc
= createInjector().getInstance(NullableFooConstructor.class);
assertNull(nfc.foo);
}
public void testInjectNullIntoNullableMethod() {
NullableFooMethod nfm
= createInjector().getInstance(NullableFooMethod.class);
assertNull(nfm.foo);
}
public void testInjectNullIntoNullableField() {
NullableFooField nff
= createInjector().getInstance(NullableFooField.class);
assertNull(nff.foo);
}
private Injector createInjector() {
return Guice.createInjector(
new AbstractModule() {
protected void configure() {
bind(Foo.class).toProvider(new Provider<Foo>() {
public Foo get() {
return null;
}
});
}
});
}
/**
* We haven't decided on what the desired behaviour of this test should be...
*/
public void testBindNullToInstance() {
try {
Guice.createInjector(new AbstractModule() {
protected void configure() {
bind(Foo.class).toInstance(null);
}
});
fail();
} catch (CreationException expected) {
assertContains(expected.getMessage(),
"Binding to null instances is not allowed.",
"at " + getClass().getName(), ".configure(NullableInjectionPointTest.java:");
}
}
public void testBindNullToProvider() {
Injector injector = Guice.createInjector(new AbstractModule() {
protected void configure() {
bind(Foo.class).toProvider(new Provider<Foo>() {
public Foo get() {
return null;
}
});
}
});
assertNull(injector.getInstance(NullableFooField.class).foo);
try {
injector.getInstance(FooField.class);
}
catch(ProvisionException expected) {
assertContains(expected.getMessage(), "null returned by binding at");
}
}
public void testBindScopedNull() {
Injector injector = Guice.createInjector(new AbstractModule() {
protected void configure() {
bind(Foo.class).toProvider(new Provider<Foo>() {
public Foo get() {
return null;
}
}).in(Scopes.SINGLETON);
}
});
assertNull(injector.getInstance(NullableFooField.class).foo);
try {
injector.getInstance(FooField.class);
}
catch(ProvisionException expected) {
assertContains(expected.getMessage(), "null returned by binding at");
}
}
public void testBindNullAsEagerSingleton() {
Injector injector = Guice.createInjector(new AbstractModule() {
protected void configure() {
bind(Foo.class).toProvider(new Provider<Foo>() {
public Foo get() {
return null;
}
}).asEagerSingleton();
}
});
assertNull(injector.getInstance(NullableFooField.class).foo);
try {
injector.getInstance(FooField.class);
fail();
} catch(ProvisionException expected) {
assertContains(expected.getMessage(), "null returned by binding "
+ "at com.google.inject.NullableInjectionPointTest");
}
}
static class Foo { }
static class FooConstructor {
@Inject FooConstructor(Foo foo) { }
}
static class FooField {
@Inject Foo foo;
}
static class FooMethod {
@Inject
void setFoo(Foo foo) { }
}
static class NullableFooConstructor {
Foo foo;
@Inject NullableFooConstructor(@Nullable Foo foo) {
this.foo = foo;
}
}
static class NullableFooField {
@Inject @Nullable Foo foo;
}
static class NullableFooMethod {
Foo foo;
@Inject void setFoo(@Nullable Foo foo) {
this.foo = foo;
}
}
}
|
