Datei: NdoDllUnitTests/NDOContainerTests.cs

Last Commit (a366466)
1 using NDO.Configuration;
2 using NUnit.Framework;
3 using System;
4 using System.Collections.Concurrent;
5 using System.Collections.Generic;
6 using System.Linq;
7 using System.Text;
8 using System.Threading.Tasks;
9
10 namespace NdoDllUnitTests
11 {
12 ····[TestFixture]
13 ····public class NDOContainerTests
14 ····{
15 ········[Test]
16 ········public void SimpleRegistration()
17 ········{
18 ············INDOContainer container = new NDOContainer();
19
20 ············container.RegisterType<ICar, BMW>();
21 ············container.RegisterType<Driver>();
22
23 ············//Resolves dependencies and returns the Driver object
24 ············Driver drv = container.Resolve<Driver>();
25 ············Assert.AreEqual( "Running BMW - 1 mile", drv.RunCar() );
26 ········}
27
28 ········[Test]
29 ········public void SimpleRegistrationWithOneType()
30 ········{
31 ············INDOContainer container = new NDOContainer();
32
33 ············container.RegisterType<BMW>();
34
35 ············var car = container.Resolve<BMW>();
36 ············Assert.AreEqual( typeof( BMW ), car.GetType() );
37 ········}
38
39 ········[Test]
40 ········public void SimpleRegistrationWithOverride()
41 ········{
42 ············INDOContainer container = new NDOContainer();
43
44 ············container.RegisterType<Driver>();
45
46 ············//Resolves dependencies and returns the Driver object
47 ············Driver drv = container.Resolve<Driver>(null, new ParameterOverride("car", new BMW()));
48 ············Assert.AreEqual( "Running BMW - 1 mile", drv.RunCar() );
49 ········}
50
51 ········[Test]
52 ········public void RegistrationWithAnonymousOverride()
53 ········{
54 ············INDOContainer container = new NDOContainer();
55
56 ············container.RegisterType<Driver>();
57
58 ············//Resolves dependencies and returns the Driver object
59 ············Driver drv = container.Resolve<Driver>(null, new ParameterOverride(new BMW()));
60 ············Assert.AreEqual( "Running BMW - 1 mile", drv.RunCar() );
61 ········}
62
63 ········[Test]
64 ········public void DoubleResolve()
65 ········{
66 ············INDOContainer container = new NDOContainer();
67
68 ············container.RegisterType<ICar, BMW>(new ContainerControlledLifetimeManager());
69
70 ············var car1 = container.Resolve<ICar>();
71 ············var car2 = container.Resolve<ICar>();
72
73 ············Assert.AreSame( car1, car2 );
74 ········}
75
76 ········[Test]
77 ········public void DoubleResolveWithName()
78 ········{
79 ············INDOContainer container = new NDOContainer();
80
81 ············container.RegisterType<ICar, BMW>(new ContainerControlledLifetimeManager());
82
83 ············var car1 = container.Resolve<ICar>("car1");
84 ············var car2 = container.Resolve<ICar>("car1");
85 ············var car3 = container.Resolve<ICar>("car2");
86
87 ············Assert.AreSame( car1, car2 );
88 ············Assert.AreNotSame( car1, car3 );
89 ········}
90
91 ········[Test]
92 ········public void DoubleRegisterTypeWithName()
93 ········{
94 ············INDOContainer container = new NDOContainer();
95
96 ············container.RegisterType<ICar, BMW>( new ContainerControlledLifetimeManager() );
97 ············container.RegisterType<ICar, Audi>( new ContainerControlledLifetimeManager() );
98
99 ············var car1 = container.Resolve<ICar>( "bmw" );
100 ············var car2 = container.Resolve<ICar>( "bmw" );
101 ············var car3 = container.Resolve<ICar>( "audi" );
102
103 ············Assert.AreSame( car1, car2 );
104 ············Assert.AreNotSame( car1, car3 );
105 ········}
106
107 ········[Test]
108 ········public void DoubleRegisterTypeWithNameTransient()
109 ········{
110 ············INDOContainer container = new NDOContainer();
111
112 ············container.RegisterType<ICar, BMW>();
113 ············container.RegisterType<ICar, Audi>();
114
115 ············var car1 = container.Resolve<ICar>( "bmw" );
116 ············var car2 = container.Resolve<ICar>( "bmw" );
117 ············var car3 = container.Resolve<ICar>( "audi" );
118
119 ············Assert.AreNotSame( car1, car2 );
120 ············Assert.AreNotSame( car1, car3 );
121 ········}
122
123 ········[Test]
124 ········public void ResolveOrRegisterTypeWithOverride()
125 ········{
126 ············INDOContainer container = new NDOContainer();
127
128 ············var drv1 = container.ResolveOrRegisterType<Driver>(new ContainerControlledLifetimeManager(), "bmw", new ParameterOverride("car", new BMW()));
129 ············var drv2 = container.ResolveOrRegisterType<Driver>(new ContainerControlledLifetimeManager(), "audi", new ParameterOverride("car", new Audi()));
130 ············Assert.AreEqual( "Running BMW - 1 mile", drv1.RunCar() );
131 ············Assert.AreEqual( "Running Audi - 1 mile", drv2.RunCar() );
132 ············drv1 = container.ResolveOrRegisterType<Driver>( new ContainerControlledLifetimeManager(), "bmw", new ParameterOverride( "car", new BMW() ) );
133 ············drv2 = container.ResolveOrRegisterType<Driver>( new ContainerControlledLifetimeManager(), "audi", new ParameterOverride( "car", new Audi() ) );
134 ············Assert.AreEqual( "Running BMW - 2 mile", drv1.RunCar() );
135 ············Assert.AreEqual( "Running Audi - 2 mile", drv2.RunCar() );
136 ········}
137
138 ········[Test]
139 ········public void RegisterInstance()
140 ········{
141 ············INDOContainer container = new NDOContainer();
142
143 ············var car1 = new BMW();
144 ············container.RegisterInstance<ICar>( car1 );
145
146 ············var car2 = container.Resolve<ICar>();
147 ············Assert.AreSame( car1, car2 );
148 ········}
149
150 ········[Test]
151 ········public void RegisterInstanceWithName()
152 ········{
153 ············INDOContainer container = new NDOContainer();
154
155 ············var bmw1 = new BMW();
156 ············container.RegisterInstance<ICar>( bmw1, "bmw" );
157 ············var audi1 = new Audi();
158 ············container.RegisterInstance<ICar>( audi1, "audi" );
159
160 ············var bmw2 = container.Resolve<ICar>("bmw");
161 ············Assert.AreSame( bmw1, bmw2 );
162 ············var audi2 = container.Resolve<ICar>("audi");
163 ············Assert.AreSame( audi1, audi2 );
164 ········}
165
166 ········[Test]
167 ········public void ResolveAndRegisterInstance()
168 ········{
169 ············INDOContainer container = new NDOContainer();
170 ············var car1 = container.ResolveOrRegisterInstance<ICar>("bmw", _=>new BMW());
171 ············var car2 = container.ResolveOrRegisterInstance<ICar>("bmw", _=>new BMW());
172 ············Assert.AreSame( car1, car2 );
173
174 ············var car3 = container.ResolveOrRegisterInstance<ICar>("ford", _=>new Ford());
175 ············Assert.AreNotSame( car1, car3 );
176
177 ············var car4 = container.ResolveOrRegisterInstance<ICar>("bmw2", _=>new BMW());
178 ············Assert.AreNotSame( car1, car4 );
179 ········}
180
181 ········[Test]
 
 
 
 
 
 
 
 
 
 
 
 
 
182 ········public void ResolveWithChildContainer()
183 ········{
184 ············INDOContainer container1 = new NDOContainer();
185
186 ············container1.RegisterType<ICar, BMW>( new ContainerControlledLifetimeManager() );
187
188 ············var car1 = container1.Resolve<ICar>();
189
190
191 ············var container2 = container1.CreateChildContainer();
192 ············var car2 = container2.Resolve<ICar>();
193
194 ············Assert.AreSame( car1, car2 );
195
196 ············container2.RegisterType<ICar, BMW>( new ContainerControlledLifetimeManager() );
197 ············car2 = container2.Resolve<ICar>();
198
199 ············Assert.AreNotSame( car1, car2 );
200
201 ············container2.Dispose();
202
203 ············car2 = container1.Resolve<ICar>();
204 ············Assert.AreSame( car1, car2 );
205 ········}
206
207 ········[Test]
208 ········public void ResolveWithChildContainer2()
209 ········{
210 ············INDOContainer container1 = new NDOContainer();
211
212 ············container1.RegisterType<ICar, BMW>( new ContainerControlledLifetimeManager() );
213
214 ············var car1 = container1.Resolve<ICar>();
215
216
217 ············var container2 = container1.CreateChildContainer();
218 ············var car2 = container2.Resolve<ICar>();
219
220 ············Assert.AreSame( car1, car2 );
221
222 ············container2.RegisterType<ICar, BMW>(/* Transient */);
223 ············car2 = container2.Resolve<ICar>();
224
225 ············Assert.AreNotSame( car1, car2 );
226
227 ············container2.Dispose();
228
229 ············car2 = container1.Resolve<ICar>();
230 ············Assert.AreSame( car1, car2 );
231 ········}
232
233 ········[Test]
234 ········public void ResolveInstanceWithChildContainer()
235 ········{
236 ············INDOContainer container1 = new NDOContainer();
237
238 ············container1.RegisterInstance<ICar>( new BMW() );
239
240 ············var car1 = container1.Resolve<ICar>();
241
242
243 ············var container2 = container1.CreateChildContainer();
244 ············var car2 = container2.Resolve<ICar>();
245
246 ············Assert.AreSame( car1, car2 );
247
248 ············container2.RegisterInstance<ICar>( new BMW() );
249 ············car2 = container2.Resolve<ICar>();
250
251 ············Assert.AreNotSame( car1, car2 );
252
253 ············container2.Dispose();
254
255 ············car2 = container1.Resolve<ICar>();
256 ············Assert.AreSame( car1, car2 );
257 ········}
258
259 ········[Test]
260 ········public void ResolveWithParameterInParentContainer()
261 ········{
262 ············var container1 = new NDOContainer();
263 ············container1.RegisterType<Driver>();
264 ············var container2 = container1.CreateChildContainer();
265 ············container2.RegisterInstance<ICar>( new BMW() );
266 ············var drv = container2.Resolve<Driver>();
267 ············Assert.NotNull( drv );
268 ············Assert.AreEqual( "Running BMW - 1 mile", drv.RunCar() );
269
270 ············container1 = new NDOContainer();
271 ············container1.RegisterInstance<ICar>( new BMW() );
272 ············container2 = container1.CreateChildContainer();
273 ············container2.RegisterType<Driver>();
274 ············drv = container2.Resolve<Driver>();
275 ············Assert.NotNull( drv );
276 ············Assert.AreEqual( "Running BMW - 1 mile", drv.RunCar() );
277 ········}
278
279 ········[Test]
280 ········public void RegisterWithTransientLifetime()
281 ········{
282 ············var container = new NDOContainer();
283 ············container.RegisterType<ICar, BMW>( new TransientLifetimeManager() );
284
285 ············var driver1 = container.Resolve<Driver>();
286
287 ············Assert.AreEqual( "Running BMW - 1 mile", driver1.RunCar() );
288
289 ············var driver2 = container.Resolve<Driver>();
290
291 ············Assert.AreEqual( "Running BMW - 1 mile", driver2.RunCar() );
292 ········}
293
294 ········[Test]
295 ········public void RegisterWithContainerLifetime()
296 ········{
297 ············var container = new NDOContainer();
298 ············container.RegisterType<ICar, BMW>( new ContainerControlledLifetimeManager() );
299
300 ············var driver1 = container.Resolve<Driver>();
301 ············Assert.AreEqual( "Running BMW - 1 mile", driver1.RunCar() );
302
303 ············var driver2 = container.Resolve<Driver>();
304
305 ············Assert.AreEqual( "Running BMW - 2 mile", driver2.RunCar() );
306 ········}
307
308 ········[Test]
309 ········public void TestNullInstance()
310 ········{
311 ············var container = new NDOContainer();
312 ············container.RegisterInstance<ICar>( null );
313 ············Assert.IsNull( container.Resolve<ICar>() );
314 ········}
315
316 ········[Test]
317 ········public void IsRegisteredWorks()
318 ········{
319 ············var container = new NDOContainer();
320 ············Assert.AreEqual( false, container.IsRegistered<ICar>() );
321 ············container.RegisterInstance<ICar>( null );
322 ············Assert.AreEqual( true, container.IsRegistered<ICar>() );
323 ········}
324
325
326 ········[Test]
327 ········public void OverwriteTypeRegWithInstanceReg()
328 ········{
329 ············var container = new NDOContainer();
330 ············container.RegisterType<ICar, BMW>();
331 ············container.RegisterInstance<ICar>( new Ford() );
332 ············Assert.IsTrue( container.Resolve<ICar>() is Ford );
333 ········}
334
335 ········[Test]
336 ········public void OverwriteInstanceRegWithTypeReg()
337 ········{
338 ············var container = new NDOContainer();
339 ············container.RegisterInstance<ICar>( new Ford() );
340 ············container.RegisterType<ICar, BMW>();
341 ············Assert.IsTrue( container.Resolve<ICar>() is BMW );
342 ········}
343
344 ········[Test]
345 ········public void ResolveWithoutRegistration()
346 ········{
347 ············var container = new NDOContainer();
348 ············Assert.IsTrue( container.Resolve<BMW>() is BMW );
349 ········}
350
351 ········[Test]
352 ········public void ResolveInterfaceWithoutRegistrationIsNull()
353 ········{
354 ············var container = new NDOContainer();
355 ············Assert.IsNull( container.Resolve<ICar>() );
356 ········}
357
358 ········[Test]
359 ········public void ResolveTypeWithInstanceDependency()
360 ········{
361 ············var container = new NDOContainer();
362 ············container.RegisterInstance<ICar>( new BMW() );
363 ············var drv = container.Resolve<Driver>();
364 ············Assert.NotNull( drv );
365 ········}
366
367 ········class TestDisposable : IDisposable
368 ········{
369 ············public void Dispose()
370 ············{
371 ············}
372 ········}
373
374 ········[Test]
375 ········public void DisposeTest()
376 ········{
377 ············ConcurrentDictionary<string, object> dict = new ConcurrentDictionary<string, object>();
378 ············var o1 = new object();
379 ············var o2 = new TestDisposable();
380 ············dict.TryAdd( "o1", o1 );
381 ············dict.TryAdd( "o2", o2 );
382 ············int count = 0;
383 ············foreach (IDisposable d in dict.Values.Where( o => o is IDisposable ))
384 ············{
385 ················count++;
386 ············}
387 ············Assert.AreEqual( 1, count );
388 ········}
389 ····}
390 }
391
New Commit (9de9fa9)
1 using NDO.Configuration;
2 using NUnit.Framework;
3 using System;
4 using System.Collections.Concurrent;
5 using System.Collections.Generic;
6 using System.Linq;
7 using System.Text;
8 using System.Threading.Tasks;
9
10 namespace NdoDllUnitTests
11 {
12 ····[TestFixture]
13 ····public class NDOContainerTests
14 ····{
15 ········[Test]
16 ········public void SimpleRegistration()
17 ········{
18 ············INDOContainer container = new NDOContainer();
19
20 ············container.RegisterType<ICar, BMW>();
21 ············container.RegisterType<Driver>();
22
23 ············//Resolves dependencies and returns the Driver object
24 ············Driver drv = container.Resolve<Driver>();
25 ············Assert.AreEqual( "Running BMW - 1 mile", drv.RunCar() );
26 ········}
27
28 ········[Test]
29 ········public void SimpleRegistrationWithOneType()
30 ········{
31 ············INDOContainer container = new NDOContainer();
32
33 ············container.RegisterType<BMW>();
34
35 ············var car = container.Resolve<BMW>();
36 ············Assert.AreEqual( typeof( BMW ), car.GetType() );
37 ········}
38
39 ········[Test]
40 ········public void SimpleRegistrationWithOverride()
41 ········{
42 ············INDOContainer container = new NDOContainer();
43
44 ············container.RegisterType<Driver>();
45
46 ············//Resolves dependencies and returns the Driver object
47 ············Driver drv = container.Resolve<Driver>(null, new ParameterOverride("car", new BMW()));
48 ············Assert.AreEqual( "Running BMW - 1 mile", drv.RunCar() );
49 ········}
50
51 ········[Test]
52 ········public void RegistrationWithAnonymousOverride()
53 ········{
54 ············INDOContainer container = new NDOContainer();
55
56 ············container.RegisterType<Driver>();
57
58 ············//Resolves dependencies and returns the Driver object
59 ············Driver drv = container.Resolve<Driver>(null, new ParameterOverride(new BMW()));
60 ············Assert.AreEqual( "Running BMW - 1 mile", drv.RunCar() );
61 ········}
62
63 ········[Test]
64 ········public void DoubleResolve()
65 ········{
66 ············INDOContainer container = new NDOContainer();
67
68 ············container.RegisterType<ICar, BMW>(new ContainerControlledLifetimeManager());
69
70 ············var car1 = container.Resolve<ICar>();
71 ············var car2 = container.Resolve<ICar>();
72
73 ············Assert.AreSame( car1, car2 );
74 ········}
75
76 ········[Test]
77 ········public void DoubleResolveWithName()
78 ········{
79 ············INDOContainer container = new NDOContainer();
80
81 ············container.RegisterType<ICar, BMW>(new ContainerControlledLifetimeManager());
82
83 ············var car1 = container.Resolve<ICar>("car1");
84 ············var car2 = container.Resolve<ICar>("car1");
85 ············var car3 = container.Resolve<ICar>("car2");
86
87 ············Assert.AreSame( car1, car2 );
88 ············Assert.AreNotSame( car1, car3 );
89 ········}
90
91 ········[Test]
92 ········public void DoubleRegisterTypeWithName()
93 ········{
94 ············INDOContainer container = new NDOContainer();
95
96 ············container.RegisterType<ICar, BMW>( new ContainerControlledLifetimeManager() );
97 ············container.RegisterType<ICar, Audi>( new ContainerControlledLifetimeManager() );
98
99 ············var car1 = container.Resolve<ICar>( "bmw" );
100 ············var car2 = container.Resolve<ICar>( "bmw" );
101 ············var car3 = container.Resolve<ICar>( "audi" );
102
103 ············Assert.AreSame( car1, car2 );
104 ············Assert.AreNotSame( car1, car3 );
105 ········}
106
107 ········[Test]
108 ········public void DoubleRegisterTypeWithNameTransient()
109 ········{
110 ············INDOContainer container = new NDOContainer();
111
112 ············container.RegisterType<ICar, BMW>();
113 ············container.RegisterType<ICar, Audi>();
114
115 ············var car1 = container.Resolve<ICar>( "bmw" );
116 ············var car2 = container.Resolve<ICar>( "bmw" );
117 ············var car3 = container.Resolve<ICar>( "audi" );
118
119 ············Assert.AreNotSame( car1, car2 );
120 ············Assert.AreNotSame( car1, car3 );
121 ········}
122
123 ········[Test]
124 ········public void ResolveOrRegisterTypeWithOverride()
125 ········{
126 ············INDOContainer container = new NDOContainer();
127
128 ············var drv1 = container.ResolveOrRegisterType<Driver>(new ContainerControlledLifetimeManager(), "bmw", new ParameterOverride("car", new BMW()));
129 ············var drv2 = container.ResolveOrRegisterType<Driver>(new ContainerControlledLifetimeManager(), "audi", new ParameterOverride("car", new Audi()));
130 ············Assert.AreEqual( "Running BMW - 1 mile", drv1.RunCar() );
131 ············Assert.AreEqual( "Running Audi - 1 mile", drv2.RunCar() );
132 ············drv1 = container.ResolveOrRegisterType<Driver>( new ContainerControlledLifetimeManager(), "bmw", new ParameterOverride( "car", new BMW() ) );
133 ············drv2 = container.ResolveOrRegisterType<Driver>( new ContainerControlledLifetimeManager(), "audi", new ParameterOverride( "car", new Audi() ) );
134 ············Assert.AreEqual( "Running BMW - 2 mile", drv1.RunCar() );
135 ············Assert.AreEqual( "Running Audi - 2 mile", drv2.RunCar() );
136 ········}
137
138 ········[Test]
139 ········public void RegisterInstance()
140 ········{
141 ············INDOContainer container = new NDOContainer();
142
143 ············var car1 = new BMW();
144 ············container.RegisterInstance<ICar>( car1 );
145
146 ············var car2 = container.Resolve<ICar>();
147 ············Assert.AreSame( car1, car2 );
148 ········}
149
150 ········[Test]
151 ········public void RegisterInstanceWithName()
152 ········{
153 ············INDOContainer container = new NDOContainer();
154
155 ············var bmw1 = new BMW();
156 ············container.RegisterInstance<ICar>( bmw1, "bmw" );
157 ············var audi1 = new Audi();
158 ············container.RegisterInstance<ICar>( audi1, "audi" );
159
160 ············var bmw2 = container.Resolve<ICar>("bmw");
161 ············Assert.AreSame( bmw1, bmw2 );
162 ············var audi2 = container.Resolve<ICar>("audi");
163 ············Assert.AreSame( audi1, audi2 );
164 ········}
165
166 ········[Test]
167 ········public void ResolveAndRegisterInstance()
168 ········{
169 ············INDOContainer container = new NDOContainer();
170 ············var car1 = container.ResolveOrRegisterInstance<ICar>("bmw", _=>new BMW());
171 ············var car2 = container.ResolveOrRegisterInstance<ICar>("bmw", _=>new BMW());
172 ············Assert.AreSame( car1, car2 );
173
174 ············var car3 = container.ResolveOrRegisterInstance<ICar>("ford", _=>new Ford());
175 ············Assert.AreNotSame( car1, car3 );
176
177 ············var car4 = container.ResolveOrRegisterInstance<ICar>("bmw2", _=>new BMW());
178 ············Assert.AreNotSame( car1, car4 );
179 ········}
180
181 ········[Test]
182 ········public void ResolveAndRegisterInstanceWithFactory()
183 ········{
184 ············INDOContainer container = new NDOContainer();
185 ············container.ResolveOrRegisterInstance( "bmw", _ => new BMW() );
186 ············var bmw = container.Resolve( typeof( BMW ), "bmw" );
187 ············Assert.IsNotNull( bmw );
188 ············Assert.AreEqual( typeof( BMW ), bmw.GetType() );
189 ············var bmw2 = container.Resolve( typeof( BMW ), "bmw" );
190 ············Assert.AreSame( bmw, bmw2 );
191 ········}
192
193
194 ········[Test]
195 ········public void ResolveWithChildContainer()
196 ········{
197 ············INDOContainer container1 = new NDOContainer();
198
199 ············container1.RegisterType<ICar, BMW>( new ContainerControlledLifetimeManager() );
200
201 ············var car1 = container1.Resolve<ICar>();
202
203
204 ············var container2 = container1.CreateChildContainer();
205 ············var car2 = container2.Resolve<ICar>();
206
207 ············Assert.AreSame( car1, car2 );
208
209 ············container2.RegisterType<ICar, BMW>( new ContainerControlledLifetimeManager() );
210 ············car2 = container2.Resolve<ICar>();
211
212 ············Assert.AreNotSame( car1, car2 );
213
214 ············container2.Dispose();
215
216 ············car2 = container1.Resolve<ICar>();
217 ············Assert.AreSame( car1, car2 );
218 ········}
219
220 ········[Test]
221 ········public void ResolveWithChildContainer2()
222 ········{
223 ············INDOContainer container1 = new NDOContainer();
224
225 ············container1.RegisterType<ICar, BMW>( new ContainerControlledLifetimeManager() );
226
227 ············var car1 = container1.Resolve<ICar>();
228
229
230 ············var container2 = container1.CreateChildContainer();
231 ············var car2 = container2.Resolve<ICar>();
232
233 ············Assert.AreSame( car1, car2 );
234
235 ············container2.RegisterType<ICar, BMW>(/* Transient */);
236 ············car2 = container2.Resolve<ICar>();
237
238 ············Assert.AreNotSame( car1, car2 );
239
240 ············container2.Dispose();
241
242 ············car2 = container1.Resolve<ICar>();
243 ············Assert.AreSame( car1, car2 );
244 ········}
245
246 ········[Test]
247 ········public void ResolveInstanceWithChildContainer()
248 ········{
249 ············INDOContainer container1 = new NDOContainer();
250
251 ············container1.RegisterInstance<ICar>( new BMW() );
252
253 ············var car1 = container1.Resolve<ICar>();
254
255
256 ············var container2 = container1.CreateChildContainer();
257 ············var car2 = container2.Resolve<ICar>();
258
259 ············Assert.AreSame( car1, car2 );
260
261 ············container2.RegisterInstance<ICar>( new BMW() );
262 ············car2 = container2.Resolve<ICar>();
263
264 ············Assert.AreNotSame( car1, car2 );
265
266 ············container2.Dispose();
267
268 ············car2 = container1.Resolve<ICar>();
269 ············Assert.AreSame( car1, car2 );
270 ········}
271
272 ········[Test]
273 ········public void ResolveWithParameterInParentContainer()
274 ········{
275 ············var container1 = new NDOContainer();
276 ············container1.RegisterType<Driver>();
277 ············var container2 = container1.CreateChildContainer();
278 ············container2.RegisterInstance<ICar>( new BMW() );
279 ············var drv = container2.Resolve<Driver>();
280 ············Assert.NotNull( drv );
281 ············Assert.AreEqual( "Running BMW - 1 mile", drv.RunCar() );
282
283 ············container1 = new NDOContainer();
284 ············container1.RegisterInstance<ICar>( new BMW() );
285 ············container2 = container1.CreateChildContainer();
286 ············container2.RegisterType<Driver>();
287 ············drv = container2.Resolve<Driver>();
288 ············Assert.NotNull( drv );
289 ············Assert.AreEqual( "Running BMW - 1 mile", drv.RunCar() );
290 ········}
291
292 ········[Test]
293 ········public void RegisterWithTransientLifetime()
294 ········{
295 ············var container = new NDOContainer();
296 ············container.RegisterType<ICar, BMW>( new TransientLifetimeManager() );
297
298 ············var driver1 = container.Resolve<Driver>();
299
300 ············Assert.AreEqual( "Running BMW - 1 mile", driver1.RunCar() );
301
302 ············var driver2 = container.Resolve<Driver>();
303
304 ············Assert.AreEqual( "Running BMW - 1 mile", driver2.RunCar() );
305 ········}
306
307 ········[Test]
308 ········public void RegisterWithContainerLifetime()
309 ········{
310 ············var container = new NDOContainer();
311 ············container.RegisterType<ICar, BMW>( new ContainerControlledLifetimeManager() );
312
313 ············var driver1 = container.Resolve<Driver>();
314 ············Assert.AreEqual( "Running BMW - 1 mile", driver1.RunCar() );
315
316 ············var driver2 = container.Resolve<Driver>();
317
318 ············Assert.AreEqual( "Running BMW - 2 mile", driver2.RunCar() );
319 ········}
320
321 ········[Test]
322 ········public void TestNullInstance()
323 ········{
324 ············var container = new NDOContainer();
325 ············container.RegisterInstance<ICar>( null );
326 ············Assert.IsNull( container.Resolve<ICar>() );
327 ········}
328
329 ········[Test]
330 ········public void IsRegisteredWorks()
331 ········{
332 ············var container = new NDOContainer();
333 ············Assert.AreEqual( false, container.IsRegistered<ICar>() );
334 ············container.RegisterInstance<ICar>( null );
335 ············Assert.AreEqual( true, container.IsRegistered<ICar>() );
336 ········}
337
338
339 ········[Test]
340 ········public void OverwriteTypeRegWithInstanceReg()
341 ········{
342 ············var container = new NDOContainer();
343 ············container.RegisterType<ICar, BMW>();
344 ············container.RegisterInstance<ICar>( new Ford() );
345 ············Assert.IsTrue( container.Resolve<ICar>() is Ford );
346 ········}
347
348 ········[Test]
349 ········public void OverwriteInstanceRegWithTypeReg()
350 ········{
351 ············var container = new NDOContainer();
352 ············container.RegisterInstance<ICar>( new Ford() );
353 ············container.RegisterType<ICar, BMW>();
354 ············Assert.IsTrue( container.Resolve<ICar>() is BMW );
355 ········}
356
357 ········[Test]
358 ········public void ResolveWithoutRegistration()
359 ········{
360 ············var container = new NDOContainer();
361 ············Assert.IsTrue( container.Resolve<BMW>() is BMW );
362 ········}
363
364 ········[Test]
365 ········public void ResolveInterfaceWithoutRegistrationIsNull()
366 ········{
367 ············var container = new NDOContainer();
368 ············Assert.IsNull( container.Resolve<ICar>() );
369 ········}
370
371 ········[Test]
372 ········public void ResolveTypeWithInstanceDependency()
373 ········{
374 ············var container = new NDOContainer();
375 ············container.RegisterInstance<ICar>( new BMW() );
376 ············var drv = container.Resolve<Driver>();
377 ············Assert.NotNull( drv );
378 ········}
379
380 ········class TestDisposable : IDisposable
381 ········{
382 ············public void Dispose()
383 ············{
384 ············}
385 ········}
386
387 ········[Test]
388 ········public void DisposeTest()
389 ········{
390 ············ConcurrentDictionary<string, object> dict = new ConcurrentDictionary<string, object>();
391 ············var o1 = new object();
392 ············var o2 = new TestDisposable();
393 ············dict.TryAdd( "o1", o1 );
394 ············dict.TryAdd( "o2", o2 );
395 ············int count = 0;
396 ············foreach (IDisposable d in dict.Values.Where( o => o is IDisposable ))
397 ············{
398 ················count++;
399 ············}
400 ············Assert.AreEqual( 1, count );
401 ········}
402 ····}
403 }
404