![[Jenkins]](/ecp/static/e8bbdb94/images/svgs/logo.svg){kind=logo}
Package: TreeMasterDetail_PTest$26$1
TreeMasterDetail_PTest$26$1
| name | instruction | branch | complexity | line | method | ||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| createDetailComposite(Composite) |
|
|
|
|
|
||||||||||||||||||||
| enableVerticalCopy() |
|
|
|
|
|
||||||||||||||||||||
| {...} |
|
|
|
|
|
||||||||||||||||||||
Coverage
1: /*******************************************************************************
2: * Copyright (c) 2011-2020 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: * Edgar Mueller - initial API and implementation
13: * Christian W. Damus - bugs 527686, 548592, 549565, 559116
14: ******************************************************************************/
15: package org.eclipse.emfforms.swt.treemasterdetail.test;
16:
17: import static org.eclipse.swtbot.swt.finder.matchers.WidgetMatcherFactory.widgetOfType;
18: import static org.eclipse.swtbot.swt.finder.matchers.WidgetMatcherFactory.withText;
19: import static org.eclipse.swtbot.swt.finder.waits.Conditions.waitForWidget;
20: import static org.hamcrest.CoreMatchers.both;
21: import static org.hamcrest.CoreMatchers.is;
22: import static org.hamcrest.CoreMatchers.notNullValue;
23: import static org.junit.Assert.assertEquals;
24: import static org.junit.Assert.assertSame;
25: import static org.junit.Assert.assertThat;
26: import static org.junit.Assert.assertTrue;
27: import static org.junit.Assert.fail;
28: import static org.junit.Assume.assumeThat;
29:
30: import java.math.BigInteger;
31: import java.util.Map;
32: import java.util.concurrent.atomic.AtomicBoolean;
33: import java.util.concurrent.atomic.AtomicReference;
34:
35: import org.eclipse.emf.common.command.BasicCommandStack;
36: import org.eclipse.emf.common.util.EList;
37: import org.eclipse.emf.common.util.URI;
38: import org.eclipse.emf.ecore.EObject;
39: import org.eclipse.emf.ecore.EReference;
40: import org.eclipse.emf.ecore.EcorePackage;
41: import org.eclipse.emf.ecore.resource.Resource;
42: import org.eclipse.emf.ecore.resource.ResourceSet;
43: import org.eclipse.emf.ecore.resource.impl.ResourceFactoryImpl;
44: import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
45: import org.eclipse.emf.ecp.common.spi.UniqueSetting;
46: import org.eclipse.emf.ecp.test.common.DefaultRealm;
47: import org.eclipse.emf.ecp.ui.view.swt.ECPSWTView;
48: import org.eclipse.emf.ecp.view.spi.common.callback.ViewModelPropertiesUpdateCallback;
49: import org.eclipse.emf.ecp.view.spi.context.ViewModelContext;
50: import org.eclipse.emf.ecp.view.spi.model.VViewModelProperties;
51: import org.eclipse.emf.ecp.view.spi.provider.EMFFormsViewService;
52: import org.eclipse.emf.ecp.view.spi.provider.IViewProvider;
53: import org.eclipse.emf.ecp.view.test.common.swt.SWTTestUtil;
54: import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;
55: import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
56: import org.eclipse.emf.emfstore.bowling.Area;
57: import org.eclipse.emf.emfstore.bowling.BowlingFactory;
58: import org.eclipse.emf.emfstore.bowling.BowlingPackage;
59: import org.eclipse.emf.emfstore.bowling.League;
60: import org.eclipse.emf.emfstore.bowling.Matchup;
61: import org.eclipse.emf.emfstore.bowling.Player;
62: import org.eclipse.emf.emfstore.bowling.Tournament;
63: import org.eclipse.emfforms.spi.swt.treemasterdetail.DetailCompositeBuilder;
64: import org.eclipse.emfforms.spi.swt.treemasterdetail.InitialSelectionProvider;
65: import org.eclipse.emfforms.spi.swt.treemasterdetail.TreeMasterDetailComposite;
66: import org.eclipse.emfforms.spi.swt.treemasterdetail.TreeMasterDetailSWTFactory;
67: import org.eclipse.emfforms.spi.swt.treemasterdetail.util.CreateElementCallback;
68: import org.eclipse.emfforms.spi.swt.treemasterdetail.util.DetailPanelRenderingFinishedCallback;
69: import org.eclipse.emfforms.spi.swt.treemasterdetail.util.RootObject;
70: import org.eclipse.jface.bindings.keys.IKeyLookup;
71: import org.eclipse.jface.bindings.keys.KeyStroke;
72: import org.eclipse.jface.bindings.keys.ParseException;
73: import org.eclipse.jface.layout.GridDataFactory;
74: import org.eclipse.jface.layout.GridLayoutFactory;
75: import org.eclipse.jface.viewers.ILabelDecorator;
76: import org.eclipse.jface.viewers.ILabelProviderListener;
77: import org.eclipse.swt.SWT;
78: import org.eclipse.swt.graphics.Image;
79: import org.eclipse.swt.layout.FormData;
80: import org.eclipse.swt.widgets.Composite;
81: import org.eclipse.swt.widgets.Display;
82: import org.eclipse.swt.widgets.Sash;
83: import org.eclipse.swt.widgets.Shell;
84: import org.eclipse.swt.widgets.Text;
85: import org.eclipse.swtbot.swt.finder.SWTBot;
86: import org.eclipse.swtbot.swt.finder.finders.UIThreadRunnable;
87: import org.eclipse.swtbot.swt.finder.junit.SWTBotJunit4ClassRunner;
88: import org.eclipse.swtbot.swt.finder.results.Result;
89: import org.eclipse.swtbot.swt.finder.waits.DefaultCondition;
90: import org.eclipse.swtbot.swt.finder.waits.ICondition;
91: import org.junit.After;
92: import org.junit.Before;
93: import org.junit.Test;
94: import org.junit.runner.RunWith;
95: import org.mockito.Matchers;
96: import org.mockito.Mockito;
97: import org.mockito.invocation.InvocationOnMock;
98: import org.mockito.stubbing.Answer;
99: import org.osgi.framework.BundleContext;
100: import org.osgi.framework.FrameworkUtil;
101: import org.osgi.framework.ServiceReference;
102:
103: @SuppressWarnings("restriction")
104: @RunWith(SWTBotJunit4ClassRunner.class)
105: public class TreeMasterDetail_PTest {
106:
107: private static final String ALICE = "Alice"; //$NON-NLS-1$
108: private static final String BOB = "Bob"; //$NON-NLS-1$
109: private static final String LEAGUE = "Liga"; //$NON-NLS-1$
110:
111: private Shell shell;
112: private Display display;
113: private SWTBot bot;
114: private DefaultRealm realm;
115:
116: private TreeMasterDetailComposite composite;
117:
118: @Before
119: public void setUp() {
120: realm = new DefaultRealm();
121: display = Display.getDefault();
122: shell = UIThreadRunnable.syncExec(display, new Result<Shell>() {
123: @Override
124: public Shell run() {
125: final Shell shell = new Shell(display);
126: GridLayoutFactory.fillDefaults().applyTo(shell);
127: return shell;
128: }
129: });
130: bot = new SWTBot(shell);
131: }
132:
133: private Resource createResource() {
134: final Resource.Factory.Registry registry = Resource.Factory.Registry.INSTANCE;
135: final Map<String, Object> extToFactoryMap = registry
136: .getExtensionToFactoryMap();
137: extToFactoryMap.put(Resource.Factory.Registry.DEFAULT_EXTENSION,
138: new ResourceFactoryImpl());
139: final ResourceSet resourceSet = new ResourceSetImpl();
140: resourceSet.getPackageRegistry().put(EcorePackage.eNS_URI,
141: EcorePackage.eINSTANCE);
142:
143: final AdapterFactoryEditingDomain domain = new AdapterFactoryEditingDomain(
144: new ComposedAdapterFactory(
145: ComposedAdapterFactory.Descriptor.Registry.INSTANCE),
146: new BasicCommandStack(), resourceSet);
147: resourceSet.eAdapters().add(
148: new AdapterFactoryEditingDomain.EditingDomainProvider(domain));
149: final Resource resource = resourceSet
150: .createResource(URI.createURI("VIRTUAL")); //$NON-NLS-1$
151: return resource;
152:
153: }
154:
155: @After
156: public void after() {
157: realm.dispose();
158: Display.getDefault().syncExec(new Runnable() {
159: @Override
160: public void run() {
161: if (composite != null) {
162: composite.dispose();
163: composite = null;
164: }
165: shell.close();
166: shell.dispose();
167: }
168: });
169: }
170:
171: @Test
172: public void renderInitialEObject() {
173: // arrange
174: final League league = BowlingFactory.eINSTANCE.createLeague();
175: final Player alice = BowlingFactory.eINSTANCE.createPlayer();
176: alice.setName(ALICE);
177: league.getPlayers().add(alice);
178:
179: final Object input = league;
180:
181: // act
182: Display.getDefault().syncExec(new Runnable() {
183: @Override
184: public void run() {
185: composite = TreeMasterDetailSWTFactory.createTreeMasterDetail(
186: shell,
187: SWT.NONE,
188: input);
189: GridDataFactory.fillDefaults().grab(true, true).applyTo(composite);
190: shell.open();
191: }
192: });
193: SWTTestUtil.waitForUIThread();
194:
195: // assert, league hidden, no selection
196: assertEquals(1, bot.tree().getAllItems().length);
197: assertEquals("Player Alice", bot.tree().getAllItems()[0].getText()); //$NON-NLS-1$
198: assertEquals(0, bot.tree().selection().columnCount());
199: assertEquals(0, bot.tree().selection().rowCount());
200: assertEquals("Select a node in the tree to edit it", bot.label().getText()); //$NON-NLS-1$
201: }
202:
203: @Test
204: public void renderInitialRootobject() {
205: // arrange
206: final League league = BowlingFactory.eINSTANCE.createLeague();
207: league.setName(LEAGUE);
208: final Player alice = BowlingFactory.eINSTANCE.createPlayer();
209: alice.setName(ALICE);
210: league.getPlayers().add(alice);
211:
212: final Object input = new RootObject(league);
213:
214: // act
215: Display.getDefault().syncExec(new Runnable() {
216: @Override
217: public void run() {
218: composite = TreeMasterDetailSWTFactory.createTreeMasterDetail(
219: shell,
220: SWT.NONE,
221: input);
222: GridDataFactory.fillDefaults().grab(true, true).applyTo(composite);
223: shell.open();
224: }
225: });
226: SWTTestUtil.waitForUIThread();
227:
228: // assert, league shown, no selection
229: assertEquals(1, bot.tree().getAllItems().length);
230: assertEquals("League Liga", bot.tree().getAllItems()[0].getText()); //$NON-NLS-1$
231: assertEquals(0, bot.tree().selection().columnCount());
232: assertEquals(0, bot.tree().selection().rowCount());
233: assertEquals("Select a node in the tree to edit it", bot.label().getText()); //$NON-NLS-1$
234: }
235:
236: @Test
237: public void renderInitialResource() {
238: // arrange
239: final League league = BowlingFactory.eINSTANCE.createLeague();
240: league.setName(LEAGUE);
241: final Player alice = BowlingFactory.eINSTANCE.createPlayer();
242: alice.setName(ALICE);
243: league.getPlayers().add(alice);
244:
245: final Resource resource = createResource();
246: resource.getContents().add(league);
247:
248: final Object input = resource;
249:
250: // act
251: Display.getDefault().syncExec(new Runnable() {
252: @Override
253: public void run() {
254: composite = TreeMasterDetailSWTFactory.createTreeMasterDetail(
255: shell,
256: SWT.NONE,
257: input);
258: GridDataFactory.fillDefaults().grab(true, true).applyTo(composite);
259: shell.open();
260: }
261: });
262: SWTTestUtil.waitForUIThread();
263:
264: // assert, league shown, selection on league
265: assertEquals(1, bot.tree().getAllItems().length);
266: assertEquals("League Liga", bot.tree().getAllItems()[0].getText()); //$NON-NLS-1$
267: assertEquals("League Liga", bot.tree().selection().get(0, 0)); //$NON-NLS-1$
268: assertEquals(LEAGUE, bot.text().getText());
269: }
270:
271: @Test
272: public void updateDetailBySelectingAnotherPlayer() throws InterruptedException {
273:
274: // arrange
275: final League league = BowlingFactory.eINSTANCE.createLeague();
276: final Player alice = BowlingFactory.eINSTANCE.createPlayer();
277: final Player bob = BowlingFactory.eINSTANCE.createPlayer();
278: alice.setName(ALICE);
279: bob.setName(BOB);
280: league.getPlayers().add(alice);
281: league.getPlayers().add(bob);
282:
283: Display.getDefault().syncExec(new Runnable() {
284: @Override
285: public void run() {
286: composite = TreeMasterDetailSWTFactory
287: .createTreeMasterDetail(shell, SWT.NONE, league);
288: GridDataFactory.fillDefaults().grab(true, true).applyTo(composite);
289: shell.open();
290: }
291: });
292:
293: SWTTestUtil.waitForUIThread();
294:
295: /* act */
296: Display.getDefault().syncExec(new Runnable() {
297: @Override
298: public void run() {
299: bot.tree().getTreeItem("Player Bob").doubleClick(); //$NON-NLS-1$
300: }
301: });
302:
303: SWTTestUtil.waitForUIThread();
304:
305: // assert
306: assertEquals(BOB, bot.text().getText());
307: }
308:
309: @Test
310: public void initSelection() throws InterruptedException {
311:
312: // arrange
313: final League league = BowlingFactory.eINSTANCE.createLeague();
314: final Player alice = BowlingFactory.eINSTANCE.createPlayer();
315: final Player bob = BowlingFactory.eINSTANCE.createPlayer();
316: alice.setName(ALICE);
317: bob.setName(BOB);
318: league.getPlayers().add(alice);
319: league.getPlayers().add(bob);
320:
321: Display.getDefault().syncExec(new Runnable() {
322: @Override
323: public void run() {
324: composite = TreeMasterDetailSWTFactory
325: .fillDefaults(shell, SWT.NONE, league)
326: .customizeInitialSelection(new InitialSelectionProvider() {
327: @Override
328: public EObject getInitialSelection(Object input) {
329: return bob;
330: }
331: })
332: .create();
333: GridDataFactory.fillDefaults().grab(true, true).applyTo(composite);
334:
335: // act
336: shell.open();
337: }
338: });
339:
340: SWTTestUtil.waitForUIThread();
341:
342: // assert
343: assertEquals("Player Bob", bot.tree().selection().get(0, 0)); //$NON-NLS-1$
344: assertEquals(BOB, bot.text().getText());
345: }
346:
347: @Test
348: public void renderDelaySingleClick() {
349: /* setup */
350: final League league = BowlingFactory.eINSTANCE.createLeague();
351: league.setName(LEAGUE);
352: final Player alice = BowlingFactory.eINSTANCE.createPlayer();
353: alice.setName(ALICE);
354: league.getPlayers().add(alice);
355: final Player bob = BowlingFactory.eINSTANCE.createPlayer();
356: bob.setName(BOB);
357: league.getPlayers().add(bob);
358: final Object input = league;
359: final int renderDelay = 2500;
360: Display.getDefault().syncExec(new Runnable() {
361: @Override
362: public void run() {
363: composite = TreeMasterDetailSWTFactory
364: .fillDefaults(shell, SWT.NONE, input)
365: .customizeInitialSelection(new InitialSelectionProvider() {
366: @Override
367: public EObject getInitialSelection(Object input) {
368: return alice;
369: }
370: })
371: .customizeUpdateDelay(renderDelay)
372: .create();
373: GridDataFactory.fillDefaults().grab(true, true).applyTo(composite);
374: shell.open();
375: }
376: });
377: SWTTestUtil.waitForUIThread();
378: final String text = bot.text().getText();
379: assertEquals(ALICE, text);
380:
381: /* select */
382: Display.getDefault().syncExec(new Runnable() {
383: @Override
384: public void run() {
385: bot.tree().getTreeItem("Player Bob").click(); //$NON-NLS-1$
386: }
387: });
388:
389: /* unchanged after click */
390: SWTTestUtil.waitForUIThread();
391: assertEquals(text, bot.text().getText());
392: assumeThat("Selection not changed in tree", bot.tree().selection().get(0, 0), is("Player Bob"));
393:
394: /* changed after delay */
395: bot.waitUntil(new ICondition() {
396:
397: @Override
398: public boolean test() throws Exception {
399: SWTTestUtil.waitForUIThread();
400: return BOB.equals(bot.text().getText());
401: }
402:
403: @Override
404: public void init(SWTBot bot) {
405: }
406:
407: @Override
408: public String getFailureMessage() {
409: return "Delay over but still showing first player"; //$NON-NLS-1$
410: }
411: }, renderDelay * 2);
412:
413: /* no focus change expected */
414: assertSame(bot.tree().widget, bot.getFocusedWidget());
415: }
416:
417: @Test
418: public void renderDelayDoubleClick() {
419: /* setup */
420: final League league = BowlingFactory.eINSTANCE.createLeague();
421: league.setName(LEAGUE);
422: final Player alice = BowlingFactory.eINSTANCE.createPlayer();
423: alice.setName(ALICE);
424: league.getPlayers().add(alice);
425: final Player bob = BowlingFactory.eINSTANCE.createPlayer();
426: bob.setName(BOB);
427: league.getPlayers().add(bob);
428: final Object input = league;
429: final int renderDelay = 2500;
430: Display.getDefault().syncExec(new Runnable() {
431: @Override
432: public void run() {
433: composite = TreeMasterDetailSWTFactory
434: .fillDefaults(shell, SWT.NONE, input)
435: .customizeInitialSelection(new InitialSelectionProvider() {
436: @Override
437: public EObject getInitialSelection(Object input) {
438: return alice;
439: }
440: })
441: .customizeUpdateDelay(renderDelay)
442: .create();
443: GridDataFactory.fillDefaults().grab(true, true).applyTo(composite);
444: shell.open();
445: }
446: });
447: SWTTestUtil.waitForUIThread();
448: final String text = bot.text().getText();
449: assertEquals(ALICE, text);
450:
451: /* double click */
452: Display.getDefault().syncExec(new Runnable() {
453: @Override
454: public void run() {
455: bot.tree().getTreeItem("Player Bob").doubleClick(); //$NON-NLS-1$
456: }
457: });
458:
459: /* double click should update immediately, no delay expected */
460: SWTTestUtil.waitForUIThread();
461: assertEquals(BOB, bot.text().getText());
462: /* focus change expected */
463: assertSame(bot.text().widget, bot.getFocusedWidget());
464: }
465:
466: @Test
467: public void renderDelayKeyboardEnter() {
468: /* setup */
469: final League league = BowlingFactory.eINSTANCE.createLeague();
470: league.setName(LEAGUE);
471: final Player alice = BowlingFactory.eINSTANCE.createPlayer();
472: alice.setName(ALICE);
473: league.getPlayers().add(alice);
474: final Player bob = BowlingFactory.eINSTANCE.createPlayer();
475: bob.setName(BOB);
476: league.getPlayers().add(bob);
477: final Object input = league;
478: final int renderDelay = 2500;
479: Display.getDefault().syncExec(new Runnable() {
480: @Override
481: public void run() {
482: composite = TreeMasterDetailSWTFactory
483: .fillDefaults(shell, SWT.NONE, input)
484: .customizeInitialSelection(new InitialSelectionProvider() {
485: @Override
486: public EObject getInitialSelection(Object input) {
487: return alice;
488: }
489: })
490: .customizeUpdateDelay(renderDelay)
491: .create();
492: GridDataFactory.fillDefaults().grab(true, true).applyTo(composite);
493: shell.open();
494: }
495: });
496:
497: SWTTestUtil.waitForUIThread();
498: final String text = bot.text().getText();
499: assertEquals(ALICE, text);
500: assertEquals("Player Alice", bot.tree().selection().get(0, 0)); //$NON-NLS-1$
501:
502: /* press down, selection expected to change */
503: try {
504: bot.tree().pressShortcut(KeyStroke.getInstance(IKeyLookup.ARROW_DOWN_NAME));
505: } catch (final ParseException ex) {
506: throw new RuntimeException(ex);
507: }
508:
509: /* detail unchanged after down, but selection changed already */
510: SWTTestUtil.waitForUIThread();
511: assertEquals(text, bot.text().getText());
512: assumeThat("Selection not changed in tree", bot.tree().selection().get(0, 0), is("Player Bob"));
513: bot.waitUntil(new DefaultCondition() {
514:
515: @Override
516: public boolean test() throws Exception {
517: SWTTestUtil.waitForUIThread();
518: return "Player Bob".equals(bot.tree().selection().get(0, 0));
519: }
520:
521: @Override
522: public String getFailureMessage() {
523: return "The selection did not update to Bob!";
524: }
525: }, 10000, 100);
526:
527: /* press enter */
528: try {
529: bot.tree().pressShortcut(KeyStroke.getInstance(IKeyLookup.ENTER_NAME));
530: } catch (final ParseException ex) {
531: throw new RuntimeException(ex);
532: }
533:
534: /* enter should update immediately, no delay expected */
535: bot.waitUntil(new DefaultCondition() {
536:
537: @Override
538: public boolean test() throws Exception {
539: SWTTestUtil.waitForUIThread();
540: return BOB.equals(bot.text().getText());
541: }
542:
543: @Override
544: public String getFailureMessage() {
545: return "The detail did not update to show Bob!";
546: }
547: }, 10000, 100);
548: /* focus change expected */
549: bot.waitUntil(new DefaultCondition() {
550:
551: @Override
552: public boolean test() throws Exception {
553: SWTTestUtil.waitForUIThread();
554: return bot.text().widget == bot.getFocusedWidget();
555: }
556:
557: @Override
558: public String getFailureMessage() {
559: return "The focus did not switch to Text Bob!";
560: }
561: }, 10000, 100);
562: }
563:
564: @Test
565: @SuppressWarnings("deprecation")
566: public void cacheNotCached() {
567: /* setup render */
568: final League league = BowlingFactory.eINSTANCE.createLeague();
569: final Player alice = BowlingFactory.eINSTANCE.createPlayer();
570: alice.setName(ALICE);
571: league.getPlayers().add(alice);
572: final Player bob = BowlingFactory.eINSTANCE.createPlayer();
573: bob.setName(BOB);
574: league.getPlayers().add(bob);
575:
576: final Object input = league;
577:
578: final AtomicReference<TreeMasterDetailComposite> tmdComposite = new AtomicReference<TreeMasterDetailComposite>();
579:
580: Display.getDefault().syncExec(new Runnable() {
581: @Override
582: public void run() {
583: composite = TreeMasterDetailSWTFactory
584: .fillDefaults(shell, SWT.NONE, input)
585: .create();
586: tmdComposite.set(composite);
587: GridDataFactory.fillDefaults().grab(true, true).applyTo(composite);
588: shell.open();
589: }
590: });
591: SWTTestUtil.waitForUIThread();
592:
593: /* setup cache */
594: final AtomicReference<EObject> isCachedCalledWith = new AtomicReference<EObject>();
595: tmdComposite.get().setCache(new org.eclipse.emfforms.spi.swt.treemasterdetail.TreeMasterDetailCache() {
596:
597: @Override
598: public boolean isChached(EObject selection) {
599: if (isCachedCalledWith.get() != null) {
600: /* called multiple times */
601: fail();
602: }
603: assertSame(bob, selection);
604: isCachedCalledWith.set(selection);
605: return false;
606: }
607:
608: @Override
609: public ECPSWTView getCachedView(EObject selection) {
610: fail();
611: return null;
612: }
613:
614: @Override
615: public void cache(ECPSWTView ecpView) {
616: }
617:
618: @Override
619: public void clear() {
620: // Nothing cached, nothing to clear
621: }
622: });
623:
624: /* act select something */
625: Display.getDefault().syncExec(new Runnable() {
626: @Override
627: public void run() {
628: bot.tree().getTreeItem("Player Bob").doubleClick(); //$NON-NLS-1$
629: }
630: });
631:
632: /* assert */
633: assertSame(bob, isCachedCalledWith.get());
634: }
635:
636: @Test
637: @SuppressWarnings("deprecation")
638: public void cacheCacheAndRerender() {
639: /* setup render and select something */
640: final League league = BowlingFactory.eINSTANCE.createLeague();
641: final Player alice = BowlingFactory.eINSTANCE.createPlayer();
642: alice.setName(ALICE);
643: league.getPlayers().add(alice);
644: final Player bob = BowlingFactory.eINSTANCE.createPlayer();
645: bob.setName(BOB);
646: league.getPlayers().add(bob);
647:
648: final Object input = league;
649:
650: final AtomicReference<TreeMasterDetailComposite> tmdComposite = new AtomicReference<TreeMasterDetailComposite>();
651:
652: Display.getDefault().syncExec(new Runnable() {
653: @Override
654: public void run() {
655: composite = TreeMasterDetailSWTFactory
656: .fillDefaults(shell, SWT.NONE, input)
657: .create();
658: tmdComposite.set(composite);
659: GridDataFactory.fillDefaults().grab(true, true).applyTo(composite);
660: shell.open();
661: }
662: });
663: SWTTestUtil.waitForUIThread();
664:
665: Display.getDefault().syncExec(new Runnable() {
666: @Override
667: public void run() {
668: bot.tree().getTreeItem("Player Bob").doubleClick(); //$NON-NLS-1$
669: }
670: });
671: SWTTestUtil.waitForUIThread();
672: assertEquals(BOB, bot.text().getText());
673: final Text nameWidget = bot.text().widget;
674:
675: /* setup cache */
676: tmdComposite.get().setCache(new org.eclipse.emfforms.spi.swt.treemasterdetail.TreeMasterDetailCache() {
677:
678: private ECPSWTView ecpView;
679:
680: @Override
681: public boolean isChached(EObject selection) {
682: assertSame(alice.eClass(), selection.eClass());
683: return true;
684: }
685:
686: @Override
687: public ECPSWTView getCachedView(EObject selection) {
688: assertSame(alice.eClass(), selection.eClass());
689: return ecpView;
690: }
691:
692: @Override
693: public void cache(ECPSWTView ecpView) {
694: assertSame(bob, ecpView.getViewModelContext().getDomainModel());
695: if (this.ecpView != null) {
696: fail();
697: }
698: this.ecpView = ecpView;
699: }
700:
701: @Override
702: public void clear() {
703: ecpView = null;
704: }
705: });
706:
707: /* act select something else */
708: Display.getDefault().syncExec(new Runnable() {
709: @Override
710: public void run() {
711: bot.tree().getTreeItem("Player Alice").doubleClick(); //$NON-NLS-1$
712: }
713: });
714:
715: /* assert updated text, same widget in use */
716: SWTTestUtil.waitForUIThread();
717: assertEquals(ALICE, bot.text().getText());
718: assertSame(nameWidget, bot.text().widget);
719: }
720:
721: @Test
722: public void initialTreeWidth() {
723: /* setup domain */
724: final League league = BowlingFactory.eINSTANCE.createLeague();
725: final Player alice = BowlingFactory.eINSTANCE.createPlayer();
726: alice.setName(ALICE);
727: league.getPlayers().add(alice);
728: final Player bob = BowlingFactory.eINSTANCE.createPlayer();
729: bob.setName(BOB);
730: league.getPlayers().add(bob);
731:
732: /* act render */
733: final int initialTreeWidth = 123;
734: final Object input = league;
735: final AtomicReference<TreeMasterDetailComposite> tmdComposite = new AtomicReference<TreeMasterDetailComposite>();
736: Display.getDefault().syncExec(new Runnable() {
737: @Override
738: public void run() {
739: composite = TreeMasterDetailSWTFactory
740: .fillDefaults(shell, SWT.NONE, input)
741: .customizeInitialTreeWidth(initialTreeWidth)
742: .create();
743: tmdComposite.set(composite);
744: GridDataFactory.fillDefaults().grab(true, true).applyTo(composite);
745: shell.open();
746: }
747: });
748: SWTTestUtil.waitForUIThread();
749:
750: /* assert */
751: final TreeMasterDetailComposite treeMasterDetailComposite = tmdComposite.get();
752: final Sash sash = (Sash) treeMasterDetailComposite.getChildren()[0];
753: final FormData formData = (FormData) sash.getLayoutData();
754: assertEquals(initialTreeWidth, formData.left.offset);
755: }
756:
757: @Test
758: public void detailComposite() {
759: /* setup domain */
760: final League league = BowlingFactory.eINSTANCE.createLeague();
761: final Player alice = BowlingFactory.eINSTANCE.createPlayer();
762: alice.setName(ALICE);
763: league.getPlayers().add(alice);
764: final Player bob = BowlingFactory.eINSTANCE.createPlayer();
765: bob.setName(BOB);
766: league.getPlayers().add(bob);
767:
768: /* act render */
769: final Object input = league;
770: final AtomicReference<TreeMasterDetailComposite> tmdComposite = new AtomicReference<TreeMasterDetailComposite>();
771: Display.getDefault().syncExec(new Runnable() {
772: @Override
773: public void run() {
774: composite = TreeMasterDetailSWTFactory
775: .fillDefaults(shell, SWT.NONE, input)
776: .customizeDetailComposite(new DetailCompositeBuilder() {
777:
778: @Override
779: public boolean enableVerticalCopy() {
780: return false;
781: }
782:
783: @Override
784: public Composite createDetailComposite(Composite parent) {
785: final Composite comp = new Composite(parent, SWT.NONE);
786: comp.setData(TreeMasterDetail_PTest.class.getName(),
787: TreeMasterDetail_PTest.class.getName());
788: return comp;
789: }
790: })
791: .create();
792: tmdComposite.set(composite);
793: GridDataFactory.fillDefaults().grab(true, true).applyTo(composite);
794: shell.open();
795: }
796: });
797: SWTTestUtil.waitForUIThread();
798:
799: final TreeMasterDetailComposite treeMasterDetailComposite = tmdComposite.get();
800: final Composite comp = (Composite) treeMasterDetailComposite.getChildren()[2];
801: assertEquals(TreeMasterDetail_PTest.class.getName(), comp.getData(TreeMasterDetail_PTest.class.getName()));
802: }
803:
804: @Test
805: public void setInput() {
806: /* setup */
807: final League league = BowlingFactory.eINSTANCE.createLeague();
808: final Player alice = BowlingFactory.eINSTANCE.createPlayer();
809: alice.setName(ALICE);
810: league.getPlayers().add(alice);
811:
812: final Object input = league;
813: final AtomicReference<TreeMasterDetailComposite> tmdComposite = new AtomicReference<TreeMasterDetailComposite>();
814:
815: Display.getDefault().syncExec(new Runnable() {
816: @Override
817: public void run() {
818: composite = TreeMasterDetailSWTFactory.createTreeMasterDetail(
819: shell,
820: SWT.NONE,
821: input);
822: tmdComposite.set(composite);
823: GridDataFactory.fillDefaults().grab(true, true).applyTo(composite);
824: shell.open();
825: }
826: });
827: SWTTestUtil.waitForUIThread();
828:
829: /* act */
830: final League league2 = BowlingFactory.eINSTANCE.createLeague();
831: final Player bob = BowlingFactory.eINSTANCE.createPlayer();
832: bob.setName(BOB);
833: league2.getPlayers().add(bob);
834: tmdComposite.get().setInput(league2);
835: SWTTestUtil.waitForUIThread();
836:
837: // assert, league hidden, no selection
838: assertEquals(1, bot.tree().getAllItems().length);
839: assertEquals("Player Bob", bot.tree().getAllItems()[0].getText()); //$NON-NLS-1$
840: assertEquals(0, bot.tree().selection().columnCount());
841: assertEquals(0, bot.tree().selection().rowCount());
842: assertEquals("Select a node in the tree to edit it", bot.label().getText()); //$NON-NLS-1$
843:
844: }
845:
846: @Test
847: public void testUpdateViewModelProperties() {
848: /* setup */
849: final BundleContext bundleContext = FrameworkUtil.getBundle(EMFFormsViewService.class).getBundleContext();
850: final ServiceReference<EMFFormsViewService> serviceReference = bundleContext
851: .getServiceReference(EMFFormsViewService.class);
852: final EMFFormsViewService viewService = bundleContext.getService(serviceReference);
853:
854: final String myPropertyKey = "IAmPropertyKey"; //$NON-NLS-1$
855:
856: final AtomicBoolean called = new AtomicBoolean(false);
857:
858: final IViewProvider viewProvider = Mockito.mock(IViewProvider.class);
859: Mockito.doAnswer(new Answer<Double>() {
860:
861: @Override
862: public Double answer(InvocationOnMock invocation) throws Throwable {
863: final VViewModelProperties viewModelProperties = VViewModelProperties.class
864: .cast(invocation.getArguments()[1]);
865: assertTrue(viewModelProperties.containsKey(myPropertyKey));
866: called.set(true);
867: return IViewProvider.NOT_APPLICABLE;
868: }
869: }).when(viewProvider).canProvideViewModel(
870: Matchers.any(EObject.class),
871: Matchers.any(VViewModelProperties.class));
872:
873: try {
874: viewService.addProvider(viewProvider);
875:
876: final League league = BowlingFactory.eINSTANCE.createLeague();
877: final Player alice = BowlingFactory.eINSTANCE.createPlayer();
878: final Player bob = BowlingFactory.eINSTANCE.createPlayer();
879: alice.setName(ALICE);
880: bob.setName(BOB);
881: league.getPlayers().add(alice);
882: league.getPlayers().add(bob);
883:
884: Display.getDefault().syncExec(new Runnable() {
885: @Override
886: public void run() {
887: composite = TreeMasterDetailSWTFactory
888: .createTreeMasterDetail(shell, SWT.NONE, league);
889: GridDataFactory.fillDefaults().grab(true, true).applyTo(composite);
890: composite.addViewModelPropertiesUpdateCallback(new ViewModelPropertiesUpdateCallback() {
891: @Override
892: public void updateViewModelProperties(VViewModelProperties properties) {
893: properties.addInheritableProperty(myPropertyKey, "IAmValue"); //$NON-NLS-1$
894: }
895: });
896: shell.open();
897: }
898: });
899:
900: SWTTestUtil.waitForUIThread();
901:
902: /* act */
903: Display.getDefault().syncExec(new Runnable() {
904: @Override
905: public void run() {
906: bot.tree().getTreeItem("Player Bob").doubleClick(); //$NON-NLS-1$
907: }
908: });
909:
910: /* assert */
911: assertTrue(called.get());
912: }
913:
914: /* cleanup */
915: finally {
916: viewService.removeProvider(viewProvider);
917: bundleContext.ungetService(serviceReference);
918: }
919: }
920:
921: @Test
922: public void testDispose() {
923: final int shellsBefore = Display.getCurrent().getShells().length;
924:
925: /* setup */
926: final League league = BowlingFactory.eINSTANCE.createLeague();
927: final Player alice = BowlingFactory.eINSTANCE.createPlayer();
928: alice.setName(ALICE);
929: league.getPlayers().add(alice);
930:
931: final Object input = league;
932:
933: Display.getDefault().syncExec(new Runnable() {
934: @Override
935: public void run() {
936: composite = TreeMasterDetailSWTFactory.createTreeMasterDetail(
937: shell,
938: SWT.NONE,
939: input);
940: GridDataFactory.fillDefaults().grab(true, true).applyTo(composite);
941: shell.open();
942: }
943: });
944: SWTTestUtil.waitForUIThread();
945:
946: /* act */
947: Display.getDefault().syncExec(new Runnable() {
948: @Override
949: public void run() {
950: composite.dispose();
951: }
952: });
953: SWTTestUtil.waitForUIThread();
954:
955: /* assert */
956: assertEquals(0, shell.getChildren().length);
957: // limbo shell is diposed -> no increase in
958: // count of shells
959: assertEquals(shellsBefore, Display.getCurrent().getShells().length);
960: }
961:
962: @Test
963: public void selectAndReveal() throws InterruptedException {
964:
965: // arrange
966: final League league = BowlingFactory.eINSTANCE.createLeague();
967: final Player alice = BowlingFactory.eINSTANCE.createPlayer();
968: final Player bob = BowlingFactory.eINSTANCE.createPlayer();
969: alice.setName(ALICE);
970: bob.setName(BOB);
971: league.getPlayers().add(alice);
972: league.getPlayers().add(bob);
973:
974: Display.getDefault().syncExec(() -> {
975: composite = TreeMasterDetailSWTFactory
976: .fillDefaults(shell, SWT.NONE, league)
977: .customizeInitialSelection(new InitialSelectionProvider() {
978: @Override
979: public EObject getInitialSelection(Object input) {
980: return alice;
981: }
982: })
983: // Display.timerExec doesn't work in the tests on some platforms
984: .customizeUpdateDelay(0)
985: .create();
986: GridDataFactory.fillDefaults().grab(true, true).applyTo(composite);
987: shell.open();
988: });
989:
990: SWTTestUtil.waitForUIThread();
991:
992: /* act */
993: Display.getDefault().syncExec(() -> {
994: composite
995: .selectAndReveal(UniqueSetting.createSetting(bob, BowlingPackage.Literals.PLAYER__IS_PROFESSIONAL));
996: });
997:
998: SWTTestUtil.waitForUIThread();
999:
1000: // wait for the selection change
1001: bot.waitUntil(waitForWidget(both(widgetOfType(Text.class)).and(withText(BOB))));
1002:
1003: // assert the reveal part
1004: assertThat("Feature not revealed", bot.checkBox().isActive(), is(true));
1005: }
1006:
1007: @Test
1008: public void detailRenderingCallback() throws InterruptedException {
1009: // Set up the test data
1010: final League league = BowlingFactory.eINSTANCE.createLeague();
1011: final Player alice = BowlingFactory.eINSTANCE.createPlayer();
1012: final Player bob = BowlingFactory.eINSTANCE.createPlayer();
1013: alice.setName(ALICE);
1014: bob.setName(BOB);
1015: league.getPlayers().add(alice);
1016: league.getPlayers().add(bob);
1017:
1018: // Create the test fixture
1019: Display.getDefault().syncExec(() -> {
1020: composite = TreeMasterDetailSWTFactory
1021: .fillDefaults(shell, SWT.NONE, league)
1022: .customizeInitialSelection(new InitialSelectionProvider() {
1023: @Override
1024: public EObject getInitialSelection(Object input) {
1025: return alice;
1026: }
1027: })
1028: // Display.timerExec doesn't work in the tests on some platforms
1029: .customizeUpdateDelay(0)
1030: .create();
1031: GridDataFactory.fillDefaults().grab(true, true).applyTo(composite);
1032: shell.open();
1033: });
1034:
1035: SWTTestUtil.waitForUIThread();
1036:
1037: // Add a listener
1038: final AtomicReference<Object> rendered = new AtomicReference<>();
1039: composite.registerDetailPanelRenderingFinishedCallback(rendered::set);
1040:
1041: // Select another object
1042: Display.getDefault().syncExec(() -> composite.selectAndReveal(bob));
1043:
1044: SWTTestUtil.waitForUIThread();
1045:
1046: // Wait for the selection change
1047: bot.waitUntil(waitForWidget(both(widgetOfType(Text.class)).and(withText(BOB))));
1048:
1049: // Assert that our listener was called
1050: assertThat("Rendering call-back not invoked", rendered.get(), is(bob));
1051: }
1052:
1053: @Test
1054: public void detailRenderingCallback_withContext() throws InterruptedException {
1055: // Set up the test data
1056: final League league = BowlingFactory.eINSTANCE.createLeague();
1057: final Player alice = BowlingFactory.eINSTANCE.createPlayer();
1058: final Player bob = BowlingFactory.eINSTANCE.createPlayer();
1059: alice.setName(ALICE);
1060: bob.setName(BOB);
1061: league.getPlayers().add(alice);
1062: league.getPlayers().add(bob);
1063:
1064: // Create the test fixture
1065: Display.getDefault().syncExec(() -> {
1066: composite = TreeMasterDetailSWTFactory
1067: .fillDefaults(shell, SWT.NONE, league)
1068: .customizeInitialSelection(new InitialSelectionProvider() {
1069: @Override
1070: public EObject getInitialSelection(Object input) {
1071: return alice;
1072: }
1073: })
1074: // Display.timerExec doesn't work in the tests on some platforms
1075: .customizeUpdateDelay(0)
1076: .create();
1077: GridDataFactory.fillDefaults().grab(true, true).applyTo(composite);
1078: shell.open();
1079: });
1080:
1081: SWTTestUtil.waitForUIThread();
1082:
1083: // Add a listener
1084: final AtomicReference<ViewModelContext> detailContext = new AtomicReference<>();
1085: final AtomicReference<Object> rendered = new AtomicReference<>();
1086: composite
1087: .registerDetailPanelRenderingFinishedCallback(DetailPanelRenderingFinishedCallback.adapt((ctx, obj) -> {
1088: detailContext.set(ctx);
1089: rendered.set(obj);
1090: }));
1091:
1092: // Select another object
1093: Display.getDefault().syncExec(() -> composite.selectAndReveal(bob));
1094:
1095: SWTTestUtil.waitForUIThread();
1096:
1097: // Wait for the selection change
1098: bot.waitUntil(waitForWidget(both(widgetOfType(Text.class)).and(withText(BOB))));
1099:
1100: // Assert that our listener was called
1101: assertThat("Rendering call-back not invoked", rendered.get(), is(bob));
1102: assertThat("Rendering call-back not invoked for context", detailContext.get(), notNullValue());
1103: assertThat("Wrong view model context", detailContext.get().getDomainModel(), is(bob));
1104: }
1105:
1106: // TODO test set selection programmatically
1107: // TODO test get editing domain
1108:
1109: ///////////////////////////////////////////////////////////////////////////////////////////////////////////
1110:
1111: @Test
1112: public void createElement() throws InterruptedException {
1113:
1114: // arrange
1115: // create an area as it already has child descriptors
1116: final Area area = BowlingFactory.eINSTANCE.createArea();
1117: final Tournament t1 = BowlingFactory.eINSTANCE.createTournament();
1118: final Tournament t2 = BowlingFactory.eINSTANCE.createTournament();
1119:
1120: area.getTournaments().add(t1);
1121: area.getTournaments().add(t2);
1122:
1123: // necessary in order to generate menu items of child descriptors
1124: final Resource resource = createResource();
1125: resource.getContents().add(area);
1126:
1127: Display.getDefault().syncExec(new Runnable() {
1128: @Override
1129: public void run() {
1130: composite = TreeMasterDetailSWTFactory
1131: .fillDefaults(shell, SWT.NONE, area)
1132: .customizeCildCreation(new CreateElementCallback() {
1133:
1134: @Override
1135: public void initElement(EObject parent, EReference reference, EObject newObject) {
1136: }
1137:
1138: @Override
1139: public boolean beforeCreateElement(Object newElement) {
1140: return true;
1141: }
1142:
1143: @Override
1144: public void afterCreateElement(Object newElement) {
1145: Matchup.class.cast(newElement).setNrSpectators(BigInteger.TEN);
1146: }
1147: })
1148: .create();
1149: GridDataFactory.fillDefaults().grab(true, true).applyTo(composite);
1150: shell.open();
1151: }
1152: });
1153:
1154: SWTTestUtil.waitForUIThread();
1155:
1156: /* act */
1157: Display.getDefault().syncExec(new Runnable() {
1158: @Override
1159: public void run() {
1160: bot.tree().select(0).contextMenu("Matchup").click(); //$NON-NLS-1$
1161: }
1162: });
1163:
1164: SWTTestUtil.waitForUIThread();
1165:
1166: // assert
1167: final EList<Matchup> matchups = area.getTournaments().get(0).getMatchups();
1168: assertEquals(1, matchups.size());
1169: assertEquals(BigInteger.TEN, matchups.get(0).getNrSpectators());
1170: }
1171:
1172: @Test
1173: public void labelDecorator() throws InterruptedException {
1174:
1175: final League league = BowlingFactory.eINSTANCE.createLeague();
1176: final Player alice = BowlingFactory.eINSTANCE.createPlayer();
1177: final Player bob = BowlingFactory.eINSTANCE.createPlayer();
1178: alice.setName(ALICE);
1179: bob.setName(BOB);
1180: league.getPlayers().add(alice);
1181: league.getPlayers().add(bob);
1182:
1183: Display.getDefault().syncExec(new Runnable() {
1184: @Override
1185: public void run() {
1186: composite = TreeMasterDetailSWTFactory
1187: .fillDefaults(shell, SWT.NONE, league)
1188: .customizeLabelDecorator(new MyLabelDecorator())
1189: .create();
1190: shell.open();
1191: }
1192: });
1193:
1194: // act
1195: bot.tree().getTreeItem(ALICE);
1196: }
1197:
1198: class MyLabelDecorator implements ILabelDecorator {
1199:
1200: @Override
1201: public void removeListener(ILabelProviderListener listener) {
1202: }
1203:
1204: @Override
1205: public boolean isLabelProperty(Object element, String property) {
1206: return false;
1207: }
1208:
1209: @Override
1210: public void dispose() {
1211: }
1212:
1213: @Override
1214: public void addListener(ILabelProviderListener listener) {
1215: }
1216:
1217: @Override
1218: public String decorateText(String text, Object element) {
1219: return text.replace("Player", "").trim(); //$NON-NLS-1$ //$NON-NLS-2$
1220: }
1221:
1222: @Override
1223: public Image decorateImage(Image image, Object element) {
1224: return null;
1225: }
1226: }
1227:
1228: }