Skip to contentPackage: ViewModelContextImpl_ITest$4
ViewModelContextImpl_ITest$4
Coverage
1: /*******************************************************************************
2: * Copyright (c) 2011-2019 EclipseSource Muenchen GmbH and others.
3: *
4: * All rights reserved. This program and the accompanying materials
5: * are made available under the terms of the Eclipse Public License 2.0
6: * which accompanies this distribution, and is available at
7: * https://www.eclipse.org/legal/epl-2.0/
8: *
9: * SPDX-License-Identifier: EPL-2.0
10: *
11: * Contributors:
12: * Eugen Neufeld - initial API and implementation
13: * Christian W. Damus - bugs 527740, 545686, 527686
14: ******************************************************************************/
15: package org.eclipse.emf.ecp.view.internal.context;
16:
17: import static org.hamcrest.CoreMatchers.anything;
18: import static org.hamcrest.CoreMatchers.hasItem;
19: import static org.hamcrest.CoreMatchers.hasItems;
20: import static org.hamcrest.CoreMatchers.is;
21: import static org.hamcrest.CoreMatchers.not;
22: import static org.hamcrest.CoreMatchers.notNullValue;
23: import static org.hamcrest.CoreMatchers.nullValue;
24: import static org.hamcrest.CoreMatchers.sameInstance;
25: import static org.hamcrest.MatcherAssert.assertThat;
26: import static org.junit.Assert.assertNotNull;
27: import static org.junit.Assert.assertNull;
28: import static org.junit.Assert.assertSame;
29: import static org.junit.Assume.assumeThat;
30: import static org.mockito.Matchers.any;
31: import static org.mockito.Matchers.argThat;
32: import static org.mockito.Mockito.doReturn;
33: import static org.mockito.Mockito.inOrder;
34: import static org.mockito.Mockito.mock;
35: import static org.mockito.Mockito.never;
36: import static org.mockito.Mockito.spy;
37: import static org.mockito.Mockito.times;
38: import static org.mockito.Mockito.verify;
39: import static org.mockito.Mockito.when;
40:
41: import java.util.Arrays;
42: import java.util.Collection;
43: import java.util.Collections;
44: import java.util.Dictionary;
45: import java.util.HashMap;
46: import java.util.Hashtable;
47: import java.util.List;
48: import java.util.Map;
49:
50: import org.eclipse.emf.common.notify.Adapter;
51: import org.eclipse.emf.ecore.EAttribute;
52: import org.eclipse.emf.ecore.EClass;
53: import org.eclipse.emf.ecore.EObject;
54: import org.eclipse.emf.ecore.EPackage;
55: import org.eclipse.emf.ecore.EcoreFactory;
56: import org.eclipse.emf.ecp.view.spi.context.EMFFormsLegacyServicesManager;
57: import org.eclipse.emf.ecp.view.spi.context.ViewModelContext;
58: import org.eclipse.emf.ecp.view.spi.context.ViewModelContextDisposeListener;
59: import org.eclipse.emf.ecp.view.spi.context.ViewModelContextFactory;
60: import org.eclipse.emf.ecp.view.spi.context.ViewModelService;
61: import org.eclipse.emf.ecp.view.spi.context.ViewModelServiceProvider;
62: import org.eclipse.emf.ecp.view.spi.model.ModelChangeAddRemoveListener;
63: import org.eclipse.emf.ecp.view.spi.model.ModelChangeNotification;
64: import org.eclipse.emf.ecp.view.spi.model.VElement;
65: import org.eclipse.emf.ecp.view.spi.model.VView;
66: import org.eclipse.emf.ecp.view.spi.model.VViewFactory;
67: import org.eclipse.emfforms.spi.core.services.databinding.DatabindingFailedException;
68: import org.eclipse.emfforms.spi.core.services.view.EMFFormsContextListener;
69: import org.eclipse.emfforms.spi.core.services.view.EMFFormsViewContext;
70: import org.eclipse.emfforms.spi.core.services.view.EMFFormsViewServiceFactory;
71: import org.eclipse.emfforms.spi.core.services.view.EMFFormsViewServicePolicy;
72: import org.eclipse.emfforms.spi.core.services.view.EMFFormsViewServiceScope;
73: import org.eclipse.emfforms.spi.core.services.view.RootDomainModelChangeListener;
74: import org.hamcrest.FeatureMatcher;
75: import org.hamcrest.Matcher;
76: import org.junit.After;
77: import org.junit.Before;
78: import org.junit.BeforeClass;
79: import org.junit.Test;
80: import org.mockito.InOrder;
81: import org.mockito.Mockito;
82: import org.mockito.invocation.InvocationOnMock;
83: import org.mockito.stubbing.Answer;
84: import org.osgi.framework.BundleContext;
85: import org.osgi.framework.FrameworkUtil;
86: import org.osgi.framework.ServiceRegistration;
87:
88: @SuppressWarnings({ "rawtypes", "deprecation" })
89: public class ViewModelContextImpl_ITest {
90:
91: private static BundleContext bundleContext;
92: private EMFFormsViewServiceFactory<?> scopedServiceProvider;
93: private ServiceRegistration<EMFFormsViewServiceFactory> registerService;
94:
95: @BeforeClass
96: public static void setUpBeforeClass() {
97: bundleContext = FrameworkUtil.getBundle(ViewModelContextImpl_ITest.class)
98: .getBundleContext();
99: }
100:
101: @Before
102: public void setUp() throws DatabindingFailedException {
103:
104: }
105:
106: @After
107: public void tearDown() {
108: if (registerService != null) {
109: registerService.unregister();
110: }
111: }
112:
113: @Test
114: public void testGlobalImmediateServiceProviderCalled() {
115: final Dictionary<String, Object> dictionary = new Hashtable<String, Object>();
116: dictionary.put("service.ranking", 50); //$NON-NLS-1$
117: scopedServiceProvider = mock(EMFFormsViewServiceFactory.class);
118: doReturn(Object.class).when(scopedServiceProvider).getType();
119: final Object mockedService = mock(Object.class);
120: doReturn(mockedService).when(scopedServiceProvider).createService(any(EMFFormsViewContext.class));
121: when(scopedServiceProvider.getPolicy()).thenReturn(EMFFormsViewServicePolicy.IMMEDIATE);
122: when(scopedServiceProvider.getScope()).thenReturn(EMFFormsViewServiceScope.GLOBAL);
123: when(scopedServiceProvider.getPriority()).thenReturn(1d);
124:
125: registerService = bundleContext.registerService(EMFFormsViewServiceFactory.class, scopedServiceProvider,
126: dictionary);
127:
128: final ViewModelContext vmc = spy(new ViewModelContextImpl(VViewFactory.eINSTANCE.createView(),
129: EcoreFactory.eINSTANCE.createEObject()));
130: verify(scopedServiceProvider).createService(any(EMFFormsViewContext.class));
131: final Object object = vmc.getService(Object.class);
132: assertNotNull(object);
133: assertSame(mockedService, object);
134:
135: final Object object2 = vmc.getService(Object.class);
136: assertNotNull(object2);
137: assertSame(mockedService, object2);
138:
139: final InOrder inOrder = inOrder(vmc, scopedServiceProvider);
140: inOrder.verify(scopedServiceProvider).createService(any(EMFFormsViewContext.class));
141: inOrder.verify(vmc, times(2)).getService(Object.class);
142: }
143:
144: @Test
145: public void testGlobalImmediateServiceProviderNotCalledFromChild() {
146: final Dictionary<String, Object> dictionary = new Hashtable<String, Object>();
147: dictionary.put("service.ranking", 50); //$NON-NLS-1$
148: scopedServiceProvider = mock(EMFFormsViewServiceFactory.class);
149: doReturn(Object.class).when(scopedServiceProvider).getType();
150: final Object mockedService = mock(Object.class);
151: doReturn(mockedService).when(scopedServiceProvider).createService(any(EMFFormsViewContext.class));
152: when(scopedServiceProvider.getPolicy()).thenReturn(EMFFormsViewServicePolicy.IMMEDIATE);
153: when(scopedServiceProvider.getScope()).thenReturn(EMFFormsViewServiceScope.GLOBAL);
154: when(scopedServiceProvider.getPriority()).thenReturn(1d);
155:
156: registerService = bundleContext.registerService(EMFFormsViewServiceFactory.class, scopedServiceProvider,
157: dictionary);
158:
159: final VView parentView = VViewFactory.eINSTANCE.createView();
160: final ViewModelContext vmc = spy(new ViewModelContextImpl(parentView, EcoreFactory.eINSTANCE.createEObject()));
161:
162: final ViewModelContext vmcChild = spy(vmc.getChildContext(EcoreFactory.eINSTANCE.createEObject(), parentView,
163: VViewFactory.eINSTANCE.createView()));
164:
165: final Object object = vmcChild.getService(Object.class);
166: assertSame(mockedService, object);
167:
168: final InOrder inOrder = inOrder(vmc, scopedServiceProvider, vmcChild);
169: inOrder.verify(scopedServiceProvider, times(1)).createService(any(EMFFormsViewContext.class));
170: inOrder.verify(vmcChild, times(1)).getService(Object.class);
171: inOrder.verify(vmc, times(1)).hasService(Object.class);
172: inOrder.verify(vmc, times(1)).getService(Object.class);
173: }
174:
175: @Test
176: public void testLocalImmediateServiceProviderCalled() {
177: final Dictionary<String, Object> dictionary = new Hashtable<String, Object>();
178: dictionary.put("service.ranking", 50); //$NON-NLS-1$
179: scopedServiceProvider = mock(EMFFormsViewServiceFactory.class);
180: doReturn(Object.class).when(scopedServiceProvider).getType();
181: final Object mockedService = mock(Object.class);
182: doReturn(mockedService).when(scopedServiceProvider).createService(any(EMFFormsViewContext.class));
183: when(scopedServiceProvider.getPolicy()).thenReturn(EMFFormsViewServicePolicy.IMMEDIATE);
184: when(scopedServiceProvider.getScope()).thenReturn(EMFFormsViewServiceScope.LOCAL);
185: when(scopedServiceProvider.getPriority()).thenReturn(1d);
186:
187: registerService = bundleContext.registerService(EMFFormsViewServiceFactory.class, scopedServiceProvider,
188: dictionary);
189:
190: final ViewModelContext vmc = spy(new ViewModelContextImpl(VViewFactory.eINSTANCE.createView(),
191: EcoreFactory.eINSTANCE.createEObject()));
192: verify(scopedServiceProvider).createService(any(EMFFormsViewContext.class));
193: final Object object = vmc.getService(Object.class);
194: assertNotNull(object);
195: assertSame(mockedService, object);
196:
197: final Object object2 = vmc.getService(Object.class);
198: assertNotNull(object2);
199: assertSame(mockedService, object2);
200:
201: final InOrder inOrder = inOrder(vmc, scopedServiceProvider);
202: inOrder.verify(scopedServiceProvider).createService(any(EMFFormsViewContext.class));
203: inOrder.verify(vmc, times(2)).getService(Object.class);
204: }
205:
206: @Test
207: public void testLocalImmediateServiceProviderCalledFromChild() {
208: final Dictionary<String, Object> dictionary = new Hashtable<String, Object>();
209: dictionary.put("service.ranking", 50); //$NON-NLS-1$
210: scopedServiceProvider = mock(EMFFormsViewServiceFactory.class);
211: doReturn(Object.class).when(scopedServiceProvider).getType();
212: final Object mockedService = mock(Object.class);
213: final Object mockedService2 = mock(Object.class);
214: doReturn(mockedService).doReturn(mockedService2).when(scopedServiceProvider)
215: .createService(any(EMFFormsViewContext.class));
216: when(scopedServiceProvider.getPolicy()).thenReturn(EMFFormsViewServicePolicy.IMMEDIATE);
217: when(scopedServiceProvider.getScope()).thenReturn(EMFFormsViewServiceScope.LOCAL);
218: when(scopedServiceProvider.getPriority()).thenReturn(1d);
219:
220: registerService = bundleContext.registerService(EMFFormsViewServiceFactory.class, scopedServiceProvider,
221: dictionary);
222:
223: final VView parentView = VViewFactory.eINSTANCE.createView();
224: final ViewModelContext vmc = spy(new ViewModelContextImpl(parentView, EcoreFactory.eINSTANCE.createEObject()));
225:
226: final ViewModelContext vmcChild = spy(vmc.getChildContext(EcoreFactory.eINSTANCE.createEObject(), parentView,
227: VViewFactory.eINSTANCE.createView()));
228: final Object object2 = vmcChild.getService(Object.class);
229: assertSame(mockedService2, object2);
230: final Object object = vmc.getService(Object.class);
231: assertSame(mockedService, object);
232:
233: final InOrder inOrder = inOrder(vmc, scopedServiceProvider, vmcChild);
234: inOrder.verify(scopedServiceProvider, times(1)).createService(any(EMFFormsViewContext.class));
235: inOrder.verify(scopedServiceProvider, times(1)).createService(any(EMFFormsViewContext.class));
236: inOrder.verify(vmcChild, times(1)).getService(Object.class);
237: inOrder.verify(vmc, times(1)).getService(Object.class);
238: }
239:
240: @Test
241: public void testLocalLazyServiceProviderCalled() {
242: final Dictionary<String, Object> dictionary = new Hashtable<String, Object>();
243: dictionary.put("service.ranking", 50); //$NON-NLS-1$
244: scopedServiceProvider = mock(EMFFormsViewServiceFactory.class);
245: doReturn(Object.class).when(scopedServiceProvider).getType();
246: final Object mockedService = mock(Object.class);
247: doReturn(mockedService).when(scopedServiceProvider).createService(any(EMFFormsViewContext.class));
248: when(scopedServiceProvider.getPolicy()).thenReturn(EMFFormsViewServicePolicy.LAZY);
249: when(scopedServiceProvider.getScope()).thenReturn(EMFFormsViewServiceScope.LOCAL);
250: when(scopedServiceProvider.getPriority()).thenReturn(1d);
251:
252: registerService = bundleContext.registerService(EMFFormsViewServiceFactory.class, scopedServiceProvider,
253: dictionary);
254:
255: final ViewModelContext vmc = spy(new ViewModelContextImpl(VViewFactory.eINSTANCE.createView(),
256: EcoreFactory.eINSTANCE.createEObject()));
257: final Object object = vmc.getService(Object.class);
258: assertNotNull(object);
259: assertSame(mockedService, object);
260:
261: final Object object2 = vmc.getService(Object.class);
262: assertNotNull(object2);
263: assertSame(mockedService, object2);
264:
265: final InOrder inOrder = inOrder(vmc, scopedServiceProvider);
266: inOrder.verify(vmc, times(1)).getService(Object.class);
267: inOrder.verify(scopedServiceProvider, times(1)).createService(any(EMFFormsViewContext.class));
268: inOrder.verify(vmc, times(1)).getService(Object.class);
269: }
270:
271: @Test
272: public void testLocalLazyServiceProviderCalledFromChild() {
273: final Dictionary<String, Object> dictionary = new Hashtable<String, Object>();
274: dictionary.put("service.ranking", 50); //$NON-NLS-1$
275: scopedServiceProvider = mock(EMFFormsViewServiceFactory.class);
276: doReturn(Object.class).when(scopedServiceProvider).getType();
277: final Object mockedService = mock(Object.class);
278: final Object mockedService2 = mock(Object.class);
279: doReturn(mockedService).doReturn(mockedService2).when(scopedServiceProvider)
280: .createService(any(EMFFormsViewContext.class));
281: when(scopedServiceProvider.getPolicy()).thenReturn(EMFFormsViewServicePolicy.LAZY);
282: when(scopedServiceProvider.getScope()).thenReturn(EMFFormsViewServiceScope.LOCAL);
283: when(scopedServiceProvider.getPriority()).thenReturn(1d);
284:
285: registerService = bundleContext.registerService(EMFFormsViewServiceFactory.class, scopedServiceProvider,
286: dictionary);
287:
288: final VView parentView = VViewFactory.eINSTANCE.createView();
289: final ViewModelContext vmc = spy(new ViewModelContextImpl(parentView, EcoreFactory.eINSTANCE.createEObject()));
290:
291: final ViewModelContext vmcChild = spy(vmc.getChildContext(EcoreFactory.eINSTANCE.createEObject(), parentView,
292: VViewFactory.eINSTANCE.createView()));
293: final Object object2 = vmcChild.getService(Object.class);
294: assertSame(mockedService, object2);
295: final Object object = vmc.getService(Object.class);
296: assertSame(mockedService2, object);
297:
298: final InOrder inOrder = inOrder(vmc, scopedServiceProvider, vmcChild);
299: inOrder.verify(vmcChild, times(1)).getService(Object.class);
300: inOrder.verify(scopedServiceProvider, times(1)).createService(any(EMFFormsViewContext.class));
301: inOrder.verify(vmc, times(1)).getService(Object.class);
302: inOrder.verify(scopedServiceProvider, times(1)).createService(any(EMFFormsViewContext.class));
303: }
304:
305: @Test
306: public void testGlobalLazyServiceProviderCalled() {
307: final Dictionary<String, Object> dictionary = new Hashtable<String, Object>();
308: dictionary.put("service.ranking", 50); //$NON-NLS-1$
309: scopedServiceProvider = mock(EMFFormsViewServiceFactory.class);
310: doReturn(Object.class).when(scopedServiceProvider).getType();
311: final Object mockedService = mock(Object.class);
312: doReturn(mockedService).when(scopedServiceProvider).createService(any(EMFFormsViewContext.class));
313: when(scopedServiceProvider.getPolicy()).thenReturn(EMFFormsViewServicePolicy.LAZY);
314: when(scopedServiceProvider.getScope()).thenReturn(EMFFormsViewServiceScope.GLOBAL);
315: when(scopedServiceProvider.getPriority()).thenReturn(1d);
316:
317: registerService = bundleContext.registerService(EMFFormsViewServiceFactory.class, scopedServiceProvider,
318: dictionary);
319:
320: final ViewModelContext vmc = spy(new ViewModelContextImpl(VViewFactory.eINSTANCE.createView(),
321: EcoreFactory.eINSTANCE.createEObject()));
322: final Object object = vmc.getService(Object.class);
323: assertNotNull(object);
324: assertSame(mockedService, object);
325:
326: final Object object2 = vmc.getService(Object.class);
327: assertNotNull(object2);
328: assertSame(mockedService, object2);
329:
330: final InOrder inOrder = inOrder(vmc, scopedServiceProvider);
331: inOrder.verify(vmc, times(1)).getService(Object.class);
332: inOrder.verify(scopedServiceProvider, times(1)).createService(any(EMFFormsViewContext.class));
333: inOrder.verify(vmc, times(1)).getService(Object.class);
334: }
335:
336: @Test
337: public void testGlobalLazyServiceProviderCalledFromChild() {
338: final Dictionary<String, Object> dictionary = new Hashtable<String, Object>();
339: dictionary.put("service.ranking", 50); //$NON-NLS-1$
340: scopedServiceProvider = mock(EMFFormsViewServiceFactory.class);
341: doReturn(Object.class).when(scopedServiceProvider).getType();
342: final Object mockedService = mock(Object.class);
343: doReturn(mockedService).when(scopedServiceProvider).createService(any(EMFFormsViewContext.class));
344: when(scopedServiceProvider.getPolicy()).thenReturn(EMFFormsViewServicePolicy.LAZY);
345: when(scopedServiceProvider.getScope()).thenReturn(EMFFormsViewServiceScope.GLOBAL);
346: when(scopedServiceProvider.getPriority()).thenReturn(1d);
347:
348: registerService = bundleContext.registerService(EMFFormsViewServiceFactory.class, scopedServiceProvider,
349: dictionary);
350:
351: final VView parentView = VViewFactory.eINSTANCE.createView();
352: final ViewModelContext vmc = spy(new ViewModelContextImpl(parentView, EcoreFactory.eINSTANCE.createEObject()));
353:
354: final ViewModelContext vmcChild = spy(vmc.getChildContext(EcoreFactory.eINSTANCE.createEObject(), parentView,
355: VViewFactory.eINSTANCE.createView()));
356: final Object object2 = vmcChild.getService(Object.class);
357: assertSame(mockedService, object2);
358:
359: final Object object = vmc.getService(Object.class);
360: assertSame(mockedService, object);
361:
362: final InOrder inOrder = inOrder(vmc, scopedServiceProvider, vmcChild);
363: inOrder.verify(vmcChild, times(1)).getService(Object.class);
364: inOrder.verify(vmc, times(1)).hasService(Object.class);
365: inOrder.verify(scopedServiceProvider, times(1)).createService(any(EMFFormsViewContext.class));
366: inOrder.verify(vmc, times(1)).getService(Object.class);
367: inOrder.verify(vmc, times(1)).getService(Object.class);
368: }
369:
370: @Test
371: public void testLegacyServiceFactoryCalled() {
372:
373: final Dictionary<String, Object> dictionary = new Hashtable<String, Object>();
374: dictionary.put("service.ranking", 50); //$NON-NLS-1$
375: final EMFFormsLegacyServicesManager emfFormsLegacyServices = mock(EMFFormsLegacyServicesManager.class);
376:
377: final ServiceRegistration<EMFFormsLegacyServicesManager> serviceRegistration = bundleContext.registerService(
378: EMFFormsLegacyServicesManager.class, emfFormsLegacyServices,
379: dictionary);
380:
381: new ViewModelContextImpl(VViewFactory.eINSTANCE.createView(),
382: EcoreFactory.eINSTANCE.createEObject());
383: verify(emfFormsLegacyServices).instantiate();
384: serviceRegistration.unregister();
385: }
386:
387: @Test
388: public void testLegacyServiceFactoryCalledBeforeImmediateServices() {
389:
390: final Dictionary<String, Object> dictionary = new Hashtable<String, Object>();
391: dictionary.put("service.ranking", 50); //$NON-NLS-1$
392: final EMFFormsLegacyServicesManager emfFormsLegacyServices = mock(EMFFormsLegacyServicesManager.class);
393:
394: final ServiceRegistration<EMFFormsLegacyServicesManager> serviceRegistration = bundleContext.registerService(
395: EMFFormsLegacyServicesManager.class, emfFormsLegacyServices,
396: dictionary);
397: final EMFFormsViewServiceFactory<?> scopedServiceProvider = mock(EMFFormsViewServiceFactory.class);
398: when(scopedServiceProvider.getPolicy()).thenReturn(EMFFormsViewServicePolicy.IMMEDIATE);
399: when(scopedServiceProvider.getScope()).thenReturn(EMFFormsViewServiceScope.GLOBAL);
400: when(scopedServiceProvider.getPriority()).thenReturn(1d);
401: final Object mockedService = mock(Object.class);
402: doReturn(mockedService).when(scopedServiceProvider).createService(any(EMFFormsViewContext.class));
403: doReturn(Object.class).when(scopedServiceProvider).getType();
404: Mockito.doAnswer(new Answer<Void>() {
405:
406: // BEGIN SUPRESS CATCH EXCEPTION
407: @Override
408: public Void answer(InvocationOnMock invocation) throws Throwable {
409: registerService = bundleContext.registerService(EMFFormsViewServiceFactory.class,
410: scopedServiceProvider,
411: dictionary);
412: return null;
413: }
414: // END SUPRESS CATCH EXCEPTION
415: }).when(emfFormsLegacyServices).instantiate();
416:
417: final ViewModelContext vmc = new ViewModelContextImpl(VViewFactory.eINSTANCE.createView(),
418: EcoreFactory.eINSTANCE.createEObject());
419: verify(emfFormsLegacyServices).instantiate();
420: assertSame(mockedService, vmc.getService(Object.class));
421: serviceRegistration.unregister();
422: }
423:
424: @Test
425: public void testOSGiServiceCalled() {
426: final ViewModelContext vmc = new ViewModelContextImpl(VViewFactory.eINSTANCE.createView(),
427: EcoreFactory.eINSTANCE.createEObject());
428:
429: final Dictionary<String, Object> dictionary = new Hashtable<String, Object>();
430: dictionary.put("service.ranking", 50); //$NON-NLS-1$
431: final Object objectService = mock(Object.class);
432: final ServiceRegistration<Object> serviceRegistration = bundleContext.registerService(
433: Object.class, objectService, dictionary);
434:
435: final Object object = vmc.getService(Object.class);
436: assertSame(objectService, object);
437:
438: serviceRegistration.unregister();
439: }
440:
441: @Test
442: public void testOSGiServiceCalledAfterUnregister() {
443: final Dictionary<String, Object> dictionary = new Hashtable<String, Object>();
444: dictionary.put("service.ranking", 50); //$NON-NLS-1$
445: final Object objectService = mock(Object.class);
446:
447: final ServiceRegistration<Object> serviceRegistration = bundleContext.registerService(
448: Object.class, objectService, dictionary);
449:
450: final ViewModelContext vmc = new ViewModelContextImpl(VViewFactory.eINSTANCE.createView(),
451: EcoreFactory.eINSTANCE.createEObject());
452: final Object object = vmc.getService(Object.class);
453: assertSame(objectService, object);
454:
455: serviceRegistration.unregister();
456:
457: final Object objectService2 = mock(Object.class);
458: final ServiceRegistration<Object> serviceRegistration2 = bundleContext.registerService(
459: Object.class, objectService2, dictionary);
460:
461: final Object object2 = vmc.getService(Object.class);
462: assertSame(objectService2, object2);
463:
464: serviceRegistration2.unregister();
465: }
466:
467: @Test
468: public void testOSGiServiceUnregisteredOnDispose() {
469: final ViewModelContext vmc = new ViewModelContextImpl(VViewFactory.eINSTANCE.createView(),
470: EcoreFactory.eINSTANCE.createEObject());
471:
472: final Dictionary<String, Object> dictionary = new Hashtable<String, Object>();
473: dictionary.put("service.ranking", 50); //$NON-NLS-1$
474: final Object objectService = mock(Object.class);
475: final ServiceRegistration<Object> serviceRegistration = bundleContext.registerService(
476: Object.class, objectService, dictionary);
477:
478: final Object object = vmc.getService(Object.class);
479: assertSame(objectService, object);
480:
481: vmc.dispose();
482:
483: try {
484: assertNull(serviceRegistration.getReference().getUsingBundles());
485: } finally {
486: serviceRegistration.unregister();
487: }
488: }
489:
490: @Test
491: public void testNoAvailableServiceReturnsNull() {
492: final Dictionary<String, Object> dictionary = new Hashtable<String, Object>();
493: dictionary.put("service.ranking", 50); //$NON-NLS-1$
494:
495: final ViewModelContext vmc = new ViewModelContextImpl(VViewFactory.eINSTANCE.createView(),
496: EcoreFactory.eINSTANCE.createEObject());
497: final Object object = vmc.getService(Object.class);
498: assertNull(object);
499: }
500:
501: @Test
502: public void testConstructorServiceBeforeLocalImmediateParentContext() {
503: final Dictionary<String, Object> dictionary = new Hashtable<String, Object>();
504: dictionary.put("service.ranking", 50); //$NON-NLS-1$
505:
506: final EMFFormsViewServiceFactory<?> scopedServiceProviderLI = mock(EMFFormsViewServiceFactory.class);
507: doReturn(ViewModelService.class).when(scopedServiceProviderLI).getType();
508: final Object mockedServiceLI = mock(ViewModelService.class);
509: doReturn(mockedServiceLI).when(scopedServiceProviderLI).createService(any(EMFFormsViewContext.class));
510: when(scopedServiceProviderLI.getPolicy()).thenReturn(EMFFormsViewServicePolicy.IMMEDIATE);
511: when(scopedServiceProviderLI.getScope()).thenReturn(EMFFormsViewServiceScope.LOCAL);
512: when(scopedServiceProviderLI.getPriority()).thenReturn(1d);
513: final ServiceRegistration<EMFFormsViewServiceFactory> serviceRegistrationLI = bundleContext.registerService(
514: EMFFormsViewServiceFactory.class, scopedServiceProviderLI, dictionary);
515:
516: final ViewModelService constructorService = mock(ViewModelService.class);
517: final ViewModelContext vmc = new ViewModelContextImpl(VViewFactory.eINSTANCE.createView(),
518: EcoreFactory.eINSTANCE.createEObject(), constructorService);
519: final ViewModelService service = vmc.getService(ViewModelService.class);
520: assertSame(constructorService, service);
521:
522: serviceRegistrationLI.unregister();
523: }
524:
525: @Test
526: public void testConstructorServiceBeforeLocalImmediateChildContext() {
527: final Dictionary<String, Object> dictionary = new Hashtable<String, Object>();
528: dictionary.put("service.ranking", 50); //$NON-NLS-1$
529:
530: final EMFFormsViewServiceFactory<?> scopedServiceProviderLI = mock(EMFFormsViewServiceFactory.class);
531: doReturn(ViewModelService.class).when(scopedServiceProviderLI).getType();
532: final Object mockedServiceLI = mock(ViewModelService.class);
533: doReturn(mockedServiceLI).when(scopedServiceProviderLI).createService(any(EMFFormsViewContext.class));
534: when(scopedServiceProviderLI.getPolicy()).thenReturn(EMFFormsViewServicePolicy.IMMEDIATE);
535: when(scopedServiceProviderLI.getScope()).thenReturn(EMFFormsViewServiceScope.LOCAL);
536: when(scopedServiceProviderLI.getPriority()).thenReturn(1d);
537: final ServiceRegistration<EMFFormsViewServiceFactory> serviceRegistrationLI = bundleContext.registerService(
538: EMFFormsViewServiceFactory.class, scopedServiceProviderLI, dictionary);
539:
540: final ViewModelService constructorService = mock(ViewModelService.class);
541:
542: final VView parentView = VViewFactory.eINSTANCE.createView();
543: final ViewModelContext vmc = new ViewModelContextImpl(parentView, EcoreFactory.eINSTANCE.createEObject());
544:
545: final ViewModelContext vmcChild = vmc.getChildContext(EcoreFactory.eINSTANCE.createEObject(), parentView,
546: VViewFactory.eINSTANCE.createView(), constructorService);
547:
548: final ViewModelService service = vmcChild.getService(ViewModelService.class);
549: assertSame(constructorService, service);
550:
551: serviceRegistrationLI.unregister();
552: }
553:
554: @Test
555: public void testLocalImmediateBeforeLocalLazyParentContext() {
556: final Dictionary<String, Object> dictionary = new Hashtable<String, Object>();
557: dictionary.put("service.ranking", 50); //$NON-NLS-1$
558:
559: final EMFFormsViewServiceFactory<?> scopedServiceProviderLI = mock(EMFFormsViewServiceFactory.class);
560: doReturn(Object.class).when(scopedServiceProviderLI).getType();
561: final Object mockedServiceLI = mock(Object.class);
562: doReturn(mockedServiceLI).when(scopedServiceProviderLI).createService(any(EMFFormsViewContext.class));
563: when(scopedServiceProviderLI.getPolicy()).thenReturn(EMFFormsViewServicePolicy.IMMEDIATE);
564: when(scopedServiceProviderLI.getScope()).thenReturn(EMFFormsViewServiceScope.LOCAL);
565: when(scopedServiceProviderLI.getPriority()).thenReturn(1d);
566: final ServiceRegistration<EMFFormsViewServiceFactory> serviceRegistrationLI = bundleContext.registerService(
567: EMFFormsViewServiceFactory.class, scopedServiceProviderLI, dictionary);
568:
569: final EMFFormsViewServiceFactory<?> scopedServiceProviderLL = mock(EMFFormsViewServiceFactory.class);
570: doReturn(Object.class).when(scopedServiceProviderLL).getType();
571: final Object mockedServiceLL = mock(Object.class);
572: doReturn(mockedServiceLL).when(scopedServiceProviderLL).createService(any(EMFFormsViewContext.class));
573: when(scopedServiceProviderLL.getPolicy()).thenReturn(EMFFormsViewServicePolicy.LAZY);
574: when(scopedServiceProviderLL.getScope()).thenReturn(EMFFormsViewServiceScope.LOCAL);
575: when(scopedServiceProviderLL.getPriority()).thenReturn(1d);
576: final ServiceRegistration<EMFFormsViewServiceFactory> serviceRegistrationLL = bundleContext.registerService(
577: EMFFormsViewServiceFactory.class, scopedServiceProviderLL, dictionary);
578:
579: final ViewModelContext vmc = new ViewModelContextImpl(VViewFactory.eINSTANCE.createView(),
580: EcoreFactory.eINSTANCE.createEObject());
581: final Object service = vmc.getService(Object.class);
582: assertSame(mockedServiceLI, service);
583:
584: serviceRegistrationLI.unregister();
585: serviceRegistrationLL.unregister();
586: }
587:
588: @Test
589: public void testLocalImmediateBeforeLocalLazyChildContext() {
590: final Dictionary<String, Object> dictionary = new Hashtable<String, Object>();
591: dictionary.put("service.ranking", 50); //$NON-NLS-1$
592:
593: final EMFFormsViewServiceFactory<?> scopedServiceProviderLI = mock(EMFFormsViewServiceFactory.class);
594: doReturn(Object.class).when(scopedServiceProviderLI).getType();
595: final Object mockedServiceLI = mock(Object.class);
596: doReturn(mockedServiceLI).when(scopedServiceProviderLI).createService(any(EMFFormsViewContext.class));
597: when(scopedServiceProviderLI.getPolicy()).thenReturn(EMFFormsViewServicePolicy.IMMEDIATE);
598: when(scopedServiceProviderLI.getScope()).thenReturn(EMFFormsViewServiceScope.LOCAL);
599: when(scopedServiceProviderLI.getPriority()).thenReturn(1d);
600: final ServiceRegistration<EMFFormsViewServiceFactory> serviceRegistrationLI = bundleContext.registerService(
601: EMFFormsViewServiceFactory.class, scopedServiceProviderLI, dictionary);
602:
603: final EMFFormsViewServiceFactory<?> scopedServiceProviderLL = mock(EMFFormsViewServiceFactory.class);
604: doReturn(Object.class).when(scopedServiceProviderLL).getType();
605: final Object mockedServiceLL = mock(Object.class);
606: doReturn(mockedServiceLL).when(scopedServiceProviderLL).createService(any(EMFFormsViewContext.class));
607: when(scopedServiceProviderLL.getPolicy()).thenReturn(EMFFormsViewServicePolicy.LAZY);
608: when(scopedServiceProviderLL.getScope()).thenReturn(EMFFormsViewServiceScope.LOCAL);
609: when(scopedServiceProviderLL.getPriority()).thenReturn(1d);
610: final ServiceRegistration<EMFFormsViewServiceFactory> serviceRegistrationLL = bundleContext.registerService(
611: EMFFormsViewServiceFactory.class, scopedServiceProviderLL, dictionary);
612:
613: final VView parentView = VViewFactory.eINSTANCE.createView();
614: final ViewModelContext vmc = new ViewModelContextImpl(parentView, EcoreFactory.eINSTANCE.createEObject());
615:
616: final ViewModelContext vmcChild = vmc.getChildContext(EcoreFactory.eINSTANCE.createEObject(), parentView,
617: VViewFactory.eINSTANCE.createView());
618:
619: final Object service = vmcChild.getService(Object.class);
620: assertSame(mockedServiceLI, service);
621:
622: serviceRegistrationLI.unregister();
623: serviceRegistrationLL.unregister();
624: }
625:
626: @Test
627: public void testLocalLazyBeforeGlobalImmediateParentContext() {
628: final Dictionary<String, Object> dictionary = new Hashtable<String, Object>();
629: dictionary.put("service.ranking", 50); //$NON-NLS-1$
630:
631: final EMFFormsViewServiceFactory<?> scopedServiceProviderLL = mock(EMFFormsViewServiceFactory.class);
632: doReturn(Object.class).when(scopedServiceProviderLL).getType();
633: final Object mockedServiceLL = mock(Object.class);
634: doReturn(mockedServiceLL).when(scopedServiceProviderLL).createService(any(EMFFormsViewContext.class));
635: when(scopedServiceProviderLL.getPolicy()).thenReturn(EMFFormsViewServicePolicy.LAZY);
636: when(scopedServiceProviderLL.getScope()).thenReturn(EMFFormsViewServiceScope.LOCAL);
637: when(scopedServiceProviderLL.getPriority()).thenReturn(1d);
638: final ServiceRegistration<EMFFormsViewServiceFactory> serviceRegistrationLL = bundleContext.registerService(
639: EMFFormsViewServiceFactory.class, scopedServiceProviderLL, dictionary);
640:
641: final EMFFormsViewServiceFactory<?> scopedServiceProviderGI = mock(EMFFormsViewServiceFactory.class);
642: doReturn(Object.class).when(scopedServiceProviderGI).getType();
643: final Object mockedServiceGI = mock(Object.class);
644: doReturn(mockedServiceGI).when(scopedServiceProviderGI).createService(any(EMFFormsViewContext.class));
645: when(scopedServiceProviderGI.getPolicy()).thenReturn(EMFFormsViewServicePolicy.IMMEDIATE);
646: when(scopedServiceProviderGI.getScope()).thenReturn(EMFFormsViewServiceScope.GLOBAL);
647: when(scopedServiceProviderGI.getPriority()).thenReturn(1d);
648: final ServiceRegistration<EMFFormsViewServiceFactory> serviceRegistrationGI = bundleContext.registerService(
649: EMFFormsViewServiceFactory.class, scopedServiceProviderGI, dictionary);
650:
651: final ViewModelContext vmc = new ViewModelContextImpl(VViewFactory.eINSTANCE.createView(),
652: EcoreFactory.eINSTANCE.createEObject());
653: final Object service = vmc.getService(Object.class);
654: assertSame(mockedServiceGI, service);
655:
656: serviceRegistrationGI.unregister();
657: serviceRegistrationLL.unregister();
658: }
659:
660: @Test
661: public void testLocalLazyBeforeGlobalImmediateChildContext() {
662: final Dictionary<String, Object> dictionary = new Hashtable<String, Object>();
663: dictionary.put("service.ranking", 50); //$NON-NLS-1$
664:
665: final EMFFormsViewServiceFactory<?> scopedServiceProviderLL = mock(EMFFormsViewServiceFactory.class);
666: doReturn(Object.class).when(scopedServiceProviderLL).getType();
667: final Object mockedServiceLL = mock(Object.class);
668: doReturn(mockedServiceLL).when(scopedServiceProviderLL).createService(any(EMFFormsViewContext.class));
669: when(scopedServiceProviderLL.getPolicy()).thenReturn(EMFFormsViewServicePolicy.LAZY);
670: when(scopedServiceProviderLL.getScope()).thenReturn(EMFFormsViewServiceScope.LOCAL);
671: when(scopedServiceProviderLL.getPriority()).thenReturn(1d);
672: final ServiceRegistration<EMFFormsViewServiceFactory> serviceRegistrationLL = bundleContext.registerService(
673: EMFFormsViewServiceFactory.class, scopedServiceProviderLL, dictionary);
674:
675: final EMFFormsViewServiceFactory<?> scopedServiceProviderGI = mock(EMFFormsViewServiceFactory.class);
676: doReturn(Object.class).when(scopedServiceProviderGI).getType();
677: final Object mockedServiceGI = mock(Object.class);
678: doReturn(mockedServiceGI).when(scopedServiceProviderGI).createService(any(EMFFormsViewContext.class));
679: when(scopedServiceProviderGI.getPolicy()).thenReturn(EMFFormsViewServicePolicy.IMMEDIATE);
680: when(scopedServiceProviderGI.getScope()).thenReturn(EMFFormsViewServiceScope.GLOBAL);
681: when(scopedServiceProviderGI.getPriority()).thenReturn(1d);
682: final ServiceRegistration<EMFFormsViewServiceFactory> serviceRegistrationGI = bundleContext.registerService(
683: EMFFormsViewServiceFactory.class, scopedServiceProviderGI, dictionary);
684:
685: final VView parentView = VViewFactory.eINSTANCE.createView();
686: final ViewModelContext vmc = new ViewModelContextImpl(parentView, EcoreFactory.eINSTANCE.createEObject());
687:
688: final ViewModelContext vmcChild = vmc.getChildContext(EcoreFactory.eINSTANCE.createEObject(), parentView,
689: VViewFactory.eINSTANCE.createView());
690:
691: final Object service = vmcChild.getService(Object.class);
692: assertSame(mockedServiceLL, service);
693:
694: serviceRegistrationGI.unregister();
695: serviceRegistrationLL.unregister();
696: }
697:
698: @Test
699: public void testGlobalImmediateBeforeGlobalLazyParentContext() {
700: final Dictionary<String, Object> dictionary = new Hashtable<String, Object>();
701: dictionary.put("service.ranking", 50); //$NON-NLS-1$
702:
703: final EMFFormsViewServiceFactory<?> scopedServiceProviderGI = mock(EMFFormsViewServiceFactory.class);
704: doReturn(Object.class).when(scopedServiceProviderGI).getType();
705: final Object mockedServiceGI = mock(Object.class);
706: doReturn(mockedServiceGI).when(scopedServiceProviderGI).createService(any(EMFFormsViewContext.class));
707: when(scopedServiceProviderGI.getPolicy()).thenReturn(EMFFormsViewServicePolicy.IMMEDIATE);
708: when(scopedServiceProviderGI.getScope()).thenReturn(EMFFormsViewServiceScope.GLOBAL);
709: when(scopedServiceProviderGI.getPriority()).thenReturn(1d);
710: final ServiceRegistration<EMFFormsViewServiceFactory> serviceRegistrationGI = bundleContext.registerService(
711: EMFFormsViewServiceFactory.class, scopedServiceProviderGI, dictionary);
712:
713: final EMFFormsViewServiceFactory<?> scopedServiceProviderGL = mock(EMFFormsViewServiceFactory.class);
714: doReturn(Object.class).when(scopedServiceProviderGL).getType();
715: final Object mockedServiceGL = mock(Object.class);
716: doReturn(mockedServiceGL).when(scopedServiceProviderGL).createService(any(EMFFormsViewContext.class));
717: when(scopedServiceProviderGL.getPolicy()).thenReturn(EMFFormsViewServicePolicy.LAZY);
718: when(scopedServiceProviderGL.getScope()).thenReturn(EMFFormsViewServiceScope.GLOBAL);
719: when(scopedServiceProviderGL.getPriority()).thenReturn(1d);
720: final ServiceRegistration<EMFFormsViewServiceFactory> serviceRegistrationGL = bundleContext.registerService(
721: EMFFormsViewServiceFactory.class, scopedServiceProviderGL, dictionary);
722:
723: final ViewModelContext vmc = new ViewModelContextImpl(VViewFactory.eINSTANCE.createView(),
724: EcoreFactory.eINSTANCE.createEObject());
725: final Object service = vmc.getService(Object.class);
726: assertSame(mockedServiceGI, service);
727:
728: serviceRegistrationGI.unregister();
729: serviceRegistrationGL.unregister();
730: }
731:
732: @Test
733: public void testGlobalImmediateBeforeGlobalLazyChildContext() {
734: final Dictionary<String, Object> dictionary = new Hashtable<String, Object>();
735: dictionary.put("service.ranking", 50); //$NON-NLS-1$
736:
737: final EMFFormsViewServiceFactory<?> scopedServiceProviderGI = mock(EMFFormsViewServiceFactory.class);
738: doReturn(Object.class).when(scopedServiceProviderGI).getType();
739: final Object mockedServiceGI = mock(Object.class);
740: doReturn(mockedServiceGI).when(scopedServiceProviderGI).createService(any(EMFFormsViewContext.class));
741: when(scopedServiceProviderGI.getPolicy()).thenReturn(EMFFormsViewServicePolicy.IMMEDIATE);
742: when(scopedServiceProviderGI.getScope()).thenReturn(EMFFormsViewServiceScope.GLOBAL);
743: when(scopedServiceProviderGI.getPriority()).thenReturn(1d);
744: final ServiceRegistration<EMFFormsViewServiceFactory> serviceRegistrationGI = bundleContext.registerService(
745: EMFFormsViewServiceFactory.class, scopedServiceProviderGI, dictionary);
746:
747: final EMFFormsViewServiceFactory<?> scopedServiceProviderGL = mock(EMFFormsViewServiceFactory.class);
748: doReturn(Object.class).when(scopedServiceProviderGL).getType();
749: final Object mockedServiceGL = mock(Object.class);
750: doReturn(mockedServiceGL).when(scopedServiceProviderGL).createService(any(EMFFormsViewContext.class));
751: when(scopedServiceProviderGL.getPolicy()).thenReturn(EMFFormsViewServicePolicy.LAZY);
752: when(scopedServiceProviderGL.getScope()).thenReturn(EMFFormsViewServiceScope.GLOBAL);
753: when(scopedServiceProviderGL.getPriority()).thenReturn(1d);
754: final ServiceRegistration<EMFFormsViewServiceFactory> serviceRegistrationGL = bundleContext.registerService(
755: EMFFormsViewServiceFactory.class, scopedServiceProviderGL, dictionary);
756:
757: final VView parentView = VViewFactory.eINSTANCE.createView();
758: final ViewModelContext vmc = new ViewModelContextImpl(parentView, EcoreFactory.eINSTANCE.createEObject());
759:
760: final ViewModelContext vmcChild = vmc.getChildContext(EcoreFactory.eINSTANCE.createEObject(), parentView,
761: VViewFactory.eINSTANCE.createView());
762:
763: final Object service = vmcChild.getService(Object.class);
764: assertSame(mockedServiceGI, service);
765:
766: serviceRegistrationGI.unregister();
767: serviceRegistrationGL.unregister();
768: }
769:
770: /**
771: * Test the inheritance of provided view-model services from the parent context in a child,
772: * and overriding of the same by services additionally injected in the child.
773: */
774: // BEGIN COMPLEX CODE
775: @Test
776: public void testChildContextWithProvider() {
777: final EObject parentModel = EcoreFactory.eINSTANCE.createEObject();
778: final VElement parentView = VViewFactory.eINSTANCE.createView();
779: final EObject childModel = EcoreFactory.eINSTANCE.createEObject();
780: final VElement childView = VViewFactory.eINSTANCE.createView();
781:
782: class Service implements ViewModelService {
783: ViewModelContext context;
784: boolean disposed;
785:
786: @Override
787: public void instantiate(ViewModelContext context) {
788: this.context = context;
789: }
790:
791: @Override
792: public void dispose() {
793: context = null;
794: disposed = true;
795: }
796:
797: @Override
798: public int getPriority() {
799: return 1;
800: }
801: }
802: class Service2 extends Service {
803: // Pass
804: }
805: class Service3 extends Service {
806: // Pass
807: }
808:
809: abstract class ServiceProvider implements ViewModelServiceProvider {
810: VElement view;
811: EObject model;
812: Service service1;
813: Service service2;
814: Service service3;
815: }
816:
817: final ServiceProvider provider1 = new ServiceProvider() {
818: @Override
819: public Collection<? extends ViewModelService> getViewModelServices(VElement view, EObject eObject) {
820: this.view = view;
821: model = eObject;
822:
823: service1 = new Service();
824: service2 = new Service2();
825: // No Service3
826: return Arrays.asList(service1, service2);
827: }
828: };
829: final ServiceProvider provider2 = new ServiceProvider() {
830: @Override
831: public Collection<? extends ViewModelService> getViewModelServices(VElement view, EObject eObject) {
832: this.view = view;
833: model = eObject;
834:
835: service1 = new Service();
836: // No Service2
837: service3 = new Service3();
838: return Arrays.asList(service1, service3);
839: }
840: };
841:
842: final ViewModelContext parentCtx = new ViewModelContextImpl(parentView, parentModel, provider1);
843: assertThat(provider1.view, is(parentView));
844: assertThat(provider1.model, is(parentModel));
845: assertThat(provider1.service1, notNullValue());
846: assertThat(provider1.service1.context, is(parentCtx));
847: assertThat(provider1.service1.disposed, is(false));
848: assertThat(provider1.service2, notNullValue());
849: assertThat(provider1.service2.context, is(parentCtx));
850: assertThat(provider1.service2.disposed, is(false));
851:
852: final ViewModelContext childCtx = parentCtx.getChildContext(childModel, parentView,
853: (VView) childView, provider2);
854:
855: // Check that provider1 provided for this child context, but only the unique service
856: assertThat(provider1.view, is(childView));
857: assertThat(provider1.model, is(childModel));
858: assertThat(provider1.service1, notNullValue());
859: assertThat(provider1.service1.context, nullValue());
860: assertThat(provider1.service1.disposed, is(true));
861: assertThat(provider1.service2, notNullValue());
862: assertThat(provider1.service2.context, is(childCtx));
863: assertThat(provider1.service2.disposed, is(false));
864:
865: // The provider2's services took priority
866: assertThat(provider2.view, is(childView));
867: assertThat(provider2.model, is(childModel));
868: assertThat(provider2.service1, notNullValue());
869: assertThat(provider2.service1.context, is(childCtx));
870: assertThat(provider2.service1.disposed, is(false));
871: assertThat(provider2.service3, notNullValue());
872: assertThat(provider2.service3.context, is(childCtx));
873: assertThat(provider2.service3.disposed, is(false));
874:
875: childCtx.dispose();
876:
877: // As usual
878: assertThat(provider1.service1.context, nullValue());
879: assertThat(provider1.service1.disposed, is(true));
880: assertThat(provider1.service2.context, nullValue());
881: assertThat(provider1.service2.disposed, is(true));
882: assertThat(provider2.service3, notNullValue());
883: assertThat(provider2.service3.context, nullValue());
884: assertThat(provider2.service3.disposed, is(true));
885: }
886: // END COMPLEX CODE
887:
888: /**
889: * Test that it's okay to create contexts with null service-override providers.
890: */
891: @Test
892: public void testContextWithNullServiceProvider() {
893: final EObject model = EcoreFactory.eINSTANCE.createEObject();
894: final VElement view = VViewFactory.eINSTANCE.createView();
895:
896: final ViewModelContext context = ViewModelContextFactory.INSTANCE.createViewModelContext(
897: view, model, (ViewModelServiceProvider) null);
898: assertThat(context, notNullValue());
899: context.dispose();
900: }
901:
902: @SuppressWarnings("nls")
903: @Test
904: public void testContextDispose() {
905: final EObject model = EcoreFactory.eINSTANCE.createEObject();
906: final VElement view = VViewFactory.eINSTANCE.createView();
907: final ViewModelContext context = ViewModelContextFactory.INSTANCE.createViewModelContext(
908: view, model, (ViewModelServiceProvider) null);
909: final EObject child = EcoreFactory.eINSTANCE.createEObject();
910: final VView childView1 = VViewFactory.eINSTANCE.createView();
911: final VView childView2 = VViewFactory.eINSTANCE.createView();
912: final VElement parent1 = VViewFactory.eINSTANCE.createView();
913: final VElement parent2 = VViewFactory.eINSTANCE.createView();
914: final Object user = new Object();
915: final ViewModelContext childContext1 = context.getChildContext(child, parent1, childView1);
916: childContext1.addContextUser(user);
917: final ViewModelContext childContext2 = context.getChildContext(child, parent2, childView2);
918: childContext2.addContextUser(user);
919:
920: final ViewModelContext childContextToRemove1 = context.getChildContext(child, parent1, childView1);
921: childContextToRemove1.removeContextUser(user);
922: final ViewModelContext childContextToRemove2 = context.getChildContext(child, parent2, childView2);
923: childContextToRemove2.removeContextUser(user);
924:
925: assertSame(childContext1, childContextToRemove1);
926: assertSame(childContext2, childContextToRemove2);
927:
928: context.dispose();
929:
930: assertThat("Context not disposed", view.eAdapters(), not(hasItem(anything())));
931: assertThat("Child context not disposed", childView1.eAdapters(), not(hasItem(anything())));
932: assertThat("Second child context not disposed", childView2.eAdapters(), not(hasItem(anything())));
933: }
934:
935: /**
936: * Test that service-override providers are invoked again on re-initialization of the
937: * context following domain-model change.
938: */
939: @SuppressWarnings("nls")
940: @Test
941: public void testChangeDomainModelWithServiceProvider() {
942: final EObject model = EcoreFactory.eINSTANCE.createEObject();
943: final VElement view = VViewFactory.eINSTANCE.createView();
944:
945: final ViewModelService canary = mock(MyService.class);
946: final ViewModelServiceProvider provider = mock(ViewModelServiceProvider.class);
947: when(provider.getViewModelServices(any(VElement.class), any(EObject.class)))
948: .then(new Answer<Collection<ViewModelService>>() {
949: @Override
950: public Collection<ViewModelService> answer(InvocationOnMock invocation) throws Throwable {
951: return Collections.singleton(canary);
952: }
953: });
954: final ViewModelContext context = ViewModelContextFactory.INSTANCE.createViewModelContext(
955: view, model, provider);
956:
957: try {
958: assertThat("Service not provided", context.hasService(MyService.class), is(true));
959: verify(provider).getViewModelServices(view, model);
960:
961: // Now, change the domain model
962: final EObject newModel = EcoreFactory.eINSTANCE.createEObject();
963: context.changeDomainModel(newModel);
964:
965: assertThat("Service not restored", context.hasService(MyService.class), is(true));
966: verify(provider).getViewModelServices(view, newModel);
967: } finally {
968: context.dispose();
969: }
970: }
971:
972: /**
973: * Test initialization of the root context's map of values.
974: */
975: @SuppressWarnings("nls")
976: @Test
977: public void testRootContextInitialValues() {
978: final EObject model = EcoreFactory.eINSTANCE.createEObject();
979: final VElement view = VViewFactory.eINSTANCE.createView();
980:
981: final Map<String, Object> values = new HashMap<>();
982: values.put("foo", "bar");
983: values.put("baz", 42);
984:
985: final ViewModelContext context = ViewModelContextFactory.INSTANCE.createViewModelContext(
986: view, model, values);
987: try {
988: assertThat(context, notNullValue());
989: assertThat(context.getContextValue("foo"), is("bar"));
990: assertThat(context.getContextValue("baz"), is(42));
991: } finally {
992: context.dispose();
993: }
994: }
995:
996: /**
997: * Test initialization of the root context's map of values with a service provider.
998: */
999: @SuppressWarnings("nls")
1000: @Test
1001: public void testRootContextInitialValuesWithServiceProvider() {
1002: final EObject model = EcoreFactory.eINSTANCE.createEObject();
1003: final VElement view = VViewFactory.eINSTANCE.createView();
1004:
1005: final Map<String, Object> found = new HashMap<>();
1006:
1007: final ViewModelService canary = mock(MyService.class);
1008: final ViewModelServiceProvider provider = mock(ViewModelServiceProvider.class);
1009: when(provider.getViewModelServices(any(VElement.class), any(EObject.class)))
1010: .then(invocation -> Collections.singleton(canary));
1011: Mockito.doAnswer(invocation -> {
1012: // The context should already have the values at this point
1013: final ViewModelContext ctx = (ViewModelContext) invocation.getArguments()[0];
1014: found.put("foo", ctx.getContextValue("foo"));
1015: found.put("baz", ctx.getContextValue("baz"));
1016: return null;
1017: }).when(canary).instantiate(any(ViewModelContext.class));
1018:
1019: final Map<String, Object> values = new HashMap<>();
1020: values.put("foo", "bar");
1021: values.put("baz", 42);
1022:
1023: final ViewModelContext context = ViewModelContextFactory.INSTANCE.createViewModelContext(
1024: view, model, provider, values);
1025:
1026: try {
1027: assertThat("Service not provided", context.hasService(MyService.class), is(true));
1028: assertThat("Service initialization did not find the 'foo' context value", found.get("foo"), is("bar"));
1029: assertThat("Service initialization did not find the 'baz' context value", found.get("baz"), is(42));
1030: } finally {
1031: context.dispose();
1032: }
1033: }
1034:
1035: /**
1036: * Verify that we can change the domain model of a child context and not lose track of it.
1037: */
1038: @SuppressWarnings("nls")
1039: @Test
1040: public void testChangeDomainModelOfChildContext() {
1041: final EMFFormsContextListener rootListener = mock(EMFFormsContextListener.class);
1042: final EMFFormsContextListener childListener = mock(EMFFormsContextListener.class);
1043: final ViewModelContextDisposeListener disposeListener = mock(ViewModelContextDisposeListener.class);
1044: final RootDomainModelChangeListener changeListener = mock(RootDomainModelChangeListener.class);
1045:
1046: final EObject root = EcoreFactory.eINSTANCE.createEObject();
1047: final EObject object1 = EcoreFactory.eINSTANCE.createEObject();
1048: final EObject object2 = EcoreFactory.eINSTANCE.createEObject();
1049: final VView rootView = VViewFactory.eINSTANCE.createView();
1050: final VElement parentView = VViewFactory.eINSTANCE.createControl();
1051: final VView view = VViewFactory.eINSTANCE.createView();
1052:
1053: final ViewModelContext context = ViewModelContextFactory.INSTANCE.createViewModelContext(
1054: rootView, root);
1055: context.registerEMFFormsContextListener(rootListener);
1056:
1057: final ViewModelContext child = context.getChildContext(object1, parentView, view);
1058: child.registerEMFFormsContextListener(childListener);
1059: child.registerRootDomainModelChangeListener(changeListener);
1060: child.registerDisposeListener(disposeListener);
1061:
1062: assumeThat("Wrong domain model", child.getDomainModel(), is(object1));
1063:
1064: final List<Adapter> viewAdapters = view.eAdapters();
1065: final List<Adapter> domainAdapters = object1.eAdapters();
1066:
1067: child.changeDomainModel(object2);
1068:
1069: assertThat("Wrong domain model", child.getDomainModel(), is(object2));
1070:
1071: // We don't actually ViewModelContext-ly dispose and drop the child context,
1072: // but only EMFFormsViewContext-ly
1073: verify(rootListener).childContextDisposed(child);
1074: verify(disposeListener, never()).contextDisposed(any());
1075:
1076: final InOrder inOrder = inOrder(rootListener, childListener, changeListener);
1077: inOrder.verify(rootListener).childContextAdded(parentView, child);
1078: inOrder.verify(childListener).contextDispose();
1079: inOrder.verify(rootListener).childContextDisposed(child);
1080: inOrder.verify(rootListener).childContextAdded(parentView, child);
1081: inOrder.verify(childListener).contextInitialised();
1082: inOrder.verify(changeListener).notifyChange();
1083:
1084: assertThat("Parent created new child context", context.getChildContext(object2, parentView, view),
1085: sameInstance(child));
1086: assertThat("View model adapters changed", view.eAdapters(), is(viewAdapters));
1087: assertThat("Wrong domain model adapters", object2.eAdapters(),
1088: hasItems(domainAdapters.toArray(new Adapter[0])));
1089: }
1090:
1091: /**
1092: * Verify that we can change the domain model of a child context and not lose track of it.
1093: */
1094: @SuppressWarnings("nls")
1095: @Test
1096: public void testChildContextDomainModelListeners() {
1097: final EPackage ePackage = EcoreFactory.eINSTANCE.createEPackage();
1098: ePackage.setName("foo");
1099: final EClass eClass = EcoreFactory.eINSTANCE.createEClass();
1100: eClass.setName("Foo");
1101: final EAttribute eAttribute = EcoreFactory.eINSTANCE.createEAttribute();
1102: eAttribute.setName("a");
1103: eClass.getEStructuralFeatures().add(eAttribute);
1104: ePackage.getEClassifiers().add(eClass);
1105:
1106: final VView rootView = VViewFactory.eINSTANCE.createView();
1107: final VElement parentView = VViewFactory.eINSTANCE.createControl();
1108: final VView view = VViewFactory.eINSTANCE.createView();
1109:
1110: final ViewModelContext context = ViewModelContextFactory.INSTANCE.createViewModelContext(
1111: rootView, ePackage);
1112: final ViewModelContext childContext = context.getChildContext(eAttribute, parentView, view);
1113:
1114: final ModelChangeAddRemoveListener domainListener = mock(ModelChangeAddRemoveListener.class);
1115: childContext.registerDomainChangeListener(domainListener);
1116:
1117: // This is the correct usage pattern, and necessary for removal of the listener
1118: childContext.registerDisposeListener(ctx -> ctx.unregisterDomainChangeListener(domainListener));
1119:
1120: verify(domainListener).notifyAdd(eAttribute);
1121: verify(domainListener).notifyAdd(ePackage);
1122:
1123: childContext.dispose();
1124:
1125: verify(domainListener).notifyRemove(eAttribute);
1126: verify(domainListener).notifyRemove(ePackage);
1127:
1128: ePackage.setName("bar");
1129:
1130: verify(domainListener, never()).notifyChange(argThat(notificationFrom(ePackage)));
1131: }
1132:
1133: //
1134: // Test framework
1135: //
1136:
1137: Matcher<ModelChangeNotification> notificationFrom(EObject notifier) {
1138: return new FeatureMatcher<ModelChangeNotification, EObject>(is(notifier), "notifier", "notifier") { //$NON-NLS-1$//$NON-NLS-2$
1139:
1140: @Override
1141: protected EObject featureValueOf(ModelChangeNotification actual) {
1142: return actual.getNotifier();
1143: }
1144: };
1145: }
1146:
1147: //
1148: // Nested types
1149: //
1150:
1151: /**
1152: * Dummy view-model service interface for testing.
1153: */
1154: public interface MyService extends ViewModelService {
1155: // Empty (just for testing via mocks)
1156: }
1157: }
![[Jenkins]](/ecp/static/e8bbdb94/images/svgs/logo.svg){kind=logo}
