![[Jenkins]](/ecp/static/e8bbdb94/images/svgs/logo.svg){kind=logo}
Package: CompoundControlSWTRenderer_ITest$DummyRenderer
CompoundControlSWTRenderer_ITest$DummyRenderer
| name | instruction | branch | complexity | line | method | ||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| CompoundControlSWTRenderer_ITest.DummyRenderer(VControl, ViewModelContext, ReportService, boolean) |
|
|
|
|
|
||||||||||||||||||||
| createLabel(String, Composite) |
|
|
|
|
|
||||||||||||||||||||
| getGridDescription(SWTGridDescription) |
|
|
|
|
|
||||||||||||||||||||
| renderControl(SWTGridCell, Composite) |
|
|
|
|
|
||||||||||||||||||||
Coverage
1: /**
2: * Copyright (c) 2011-2015 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: * Johannes Faltermeier - initial API and implementation
13: */
14: package org.eclipse.emf.ecp.view.spi.compoundcontrol.swt;
15:
16: import static org.junit.Assert.assertEquals;
17: import static org.junit.Assert.assertFalse;
18: import static org.junit.Assert.assertNotEquals;
19: import static org.junit.Assert.assertSame;
20: import static org.junit.Assert.assertTrue;
21: import static org.mockito.Matchers.any;
22: import static org.mockito.Mockito.doReturn;
23: import static org.mockito.Mockito.mock;
24: import static org.mockito.Mockito.spy;
25: import static org.mockito.Mockito.times;
26: import static org.mockito.Mockito.verify;
27: import static org.mockito.Mockito.when;
28:
29: import java.util.Collections;
30: import java.util.Set;
31:
32: import org.eclipse.core.databinding.observable.Observables;
33: import org.eclipse.emf.common.util.ECollections;
34: import org.eclipse.emf.databinding.IEMFValueProperty;
35: import org.eclipse.emf.ecore.EObject;
36: import org.eclipse.emf.ecore.EStructuralFeature;
37: import org.eclipse.emf.ecp.test.common.DefaultRealm;
38: import org.eclipse.emf.ecp.view.spi.compoundcontrol.model.VCompoundControl;
39: import org.eclipse.emf.ecp.view.spi.context.ViewModelContext;
40: import org.eclipse.emf.ecp.view.spi.model.LabelAlignment;
41: import org.eclipse.emf.ecp.view.spi.model.VContainedElement;
42: import org.eclipse.emf.ecp.view.spi.model.VControl;
43: import org.eclipse.emf.ecp.view.spi.model.VElement;
44: import org.eclipse.emf.ecp.view.spi.model.VFeaturePathDomainModelReference;
45: import org.eclipse.emf.ecp.view.spi.renderer.NoPropertyDescriptorFoundExeption;
46: import org.eclipse.emf.ecp.view.spi.renderer.NoRendererFoundException;
47: import org.eclipse.emf.ecp.view.template.model.VTStyleProperty;
48: import org.eclipse.emf.ecp.view.template.model.VTViewTemplateProvider;
49: import org.eclipse.emf.ecp.view.template.style.alignment.model.AlignmentType;
50: import org.eclipse.emf.ecp.view.template.style.alignment.model.VTAlignmentFactory;
51: import org.eclipse.emf.ecp.view.template.style.alignment.model.VTControlLabelAlignmentStyleProperty;
52: import org.eclipse.emf.ecp.view.template.style.labelwidth.model.VTLabelWidthStyleProperty;
53: import org.eclipse.emf.ecp.view.template.style.labelwidth.model.VTLabelwidthFactory;
54: import org.eclipse.emf.ecp.view.template.style.wrap.model.VTLabelWrapStyleProperty;
55: import org.eclipse.emf.ecp.view.template.style.wrap.model.VTWrapFactory;
56: import org.eclipse.emfforms.spi.common.report.ReportService;
57: import org.eclipse.emfforms.spi.core.services.databinding.DatabindingFailedException;
58: import org.eclipse.emfforms.spi.core.services.databinding.emf.EMFFormsDatabindingEMF;
59: import org.eclipse.emfforms.spi.core.services.label.EMFFormsLabelProvider;
60: import org.eclipse.emfforms.spi.core.services.label.NoLabelFoundException;
61: import org.eclipse.emfforms.spi.swt.core.AbstractSWTRenderer;
62: import org.eclipse.emfforms.spi.swt.core.EMFFormsNoRendererException;
63: import org.eclipse.emfforms.spi.swt.core.EMFFormsRendererFactory;
64: import org.eclipse.emfforms.spi.swt.core.layout.GridDescriptionFactory;
65: import org.eclipse.emfforms.spi.swt.core.layout.SWTGridCell;
66: import org.eclipse.emfforms.spi.swt.core.layout.SWTGridDescription;
67: import org.eclipse.jface.layout.GridDataFactory;
68: import org.eclipse.jface.layout.GridLayoutFactory;
69: import org.eclipse.swt.SWT;
70: import org.eclipse.swt.widgets.Composite;
71: import org.eclipse.swt.widgets.Control;
72: import org.eclipse.swt.widgets.Display;
73: import org.eclipse.swt.widgets.Label;
74: import org.eclipse.swt.widgets.Shell;
75: import org.junit.After;
76: import org.junit.Before;
77: import org.junit.Test;
78: import org.mockito.Mockito;
79:
80: public class CompoundControlSWTRenderer_ITest {
81:
82: private static final String LABEL1 = "label1"; //$NON-NLS-1$
83: private static final String LABEL2 = "label2"; //$NON-NLS-1$
84:
85: private static final String TOOLTIP1 = "tooltip1"; //$NON-NLS-1$
86: private static final String TOOLTIP2 = "tooltip2"; //$NON-NLS-1$
87:
88: private static final String C_CONTROL = "CControl"; //$NON-NLS-1$
89: private static final String C_VALIDATION = "CValidation"; //$NON-NLS-1$
90:
91: private VCompoundControl compoundControl;
92: private ViewModelContext viewModelContext;
93: private ReportService reportService;
94: private EMFFormsLabelProvider emfFormsLabelProvider;
95: private EMFFormsRendererFactory emfFormsRendererFactory;
96: private VTViewTemplateProvider viewTemplateProvider;
97: private Shell shell;
98: private DefaultRealm realm;
99: private EMFFormsDatabindingEMF emfFormsDatabindingEMF;
100:
101: @Before
102: public void before() {
103: realm = new DefaultRealm();
104: shell = new Shell(Display.getDefault());
105: compoundControl = mock(VCompoundControl.class);
106: viewModelContext = mock(ViewModelContext.class);
107: reportService = mock(ReportService.class);
108: emfFormsLabelProvider = mock(EMFFormsLabelProvider.class);
109: emfFormsRendererFactory = mock(EMFFormsRendererFactory.class);
110: viewTemplateProvider = Mockito.mock(VTViewTemplateProvider.class);
111: emfFormsDatabindingEMF = Mockito.mock(EMFFormsDatabindingEMF.class);
112: }
113:
114: @After
115: public void after() {
116: shell.dispose();
117: realm.dispose();
118: }
119:
120: private CompoundControlSWTRenderer createRenderer() {
121: return new CompoundControlSWTRenderer(compoundControl, viewModelContext, reportService, emfFormsLabelProvider,
122: emfFormsRendererFactory, viewTemplateProvider, emfFormsDatabindingEMF);
123: }
124:
125: @Test
126: public void testGetLabelProvider() {
127: final CompoundControlSWTRenderer renderer = createRenderer();
128: assertSame(emfFormsLabelProvider, renderer.getLabelProvider());
129: }
130:
131: @Test
132: public void testGetRendererFactory() {
133: final CompoundControlSWTRenderer renderer = createRenderer();
134: assertSame(emfFormsRendererFactory, renderer.getRendererFactory());
135: }
136:
137: @Test
138: public void testGetGridDescription() {
139: when(compoundControl.getLabelAlignment()).thenReturn(LabelAlignment.DEFAULT);
140:
141: final CompoundControlSWTRenderer renderer = createRenderer();
142: final SWTGridDescription gridDescription = renderer.getGridDescription(mock(SWTGridDescription.class));
143: assertEquals(3, gridDescription.getColumns());
144: assertEquals(1, gridDescription.getRows());
145: assertEquals(3, gridDescription.getGrid().size());
146:
147: final SWTGridCell label = gridDescription.getGrid().get(0);
148: assertEquals(0, label.getColumn());
149: assertEquals(1, label.getHorizontalSpan());
150: assertEquals(0, label.getRow());
151: assertSame(renderer, label.getRenderer());
152: assertFalse(label.isHorizontalFill());
153: assertFalse(label.isHorizontalGrab());
154: assertFalse(label.isVerticalFill());
155: assertFalse(label.isVerticalGrab());
156:
157: final SWTGridCell validation = gridDescription.getGrid().get(1);
158: assertEquals(1, validation.getColumn());
159: assertEquals(1, validation.getHorizontalSpan());
160: assertEquals(0, validation.getRow());
161: assertSame(renderer, validation.getRenderer());
162: assertFalse(validation.isHorizontalFill());
163: assertFalse(validation.isHorizontalGrab());
164: assertFalse(validation.isVerticalFill());
165: assertFalse(validation.isVerticalGrab());
166:
167: final SWTGridCell controls = gridDescription.getGrid().get(2);
168: assertEquals(2, controls.getColumn());
169: assertEquals(1, controls.getHorizontalSpan());
170: assertEquals(0, controls.getRow());
171: assertSame(renderer, controls.getRenderer());
172: assertTrue(controls.isHorizontalFill());
173: assertTrue(controls.isHorizontalGrab());
174: assertTrue(controls.isVerticalFill());
175: assertFalse(controls.isVerticalGrab());
176: }
177:
178: @Test
179: public void testGetGridDescriptionWithWidth() {
180: when(compoundControl.getLabelAlignment()).thenReturn(LabelAlignment.DEFAULT);
181:
182: final VTLabelWidthStyleProperty property = VTLabelwidthFactory.eINSTANCE.createLabelWidthStyleProperty();
183: property.setWidth(11);
184: final Set<VTStyleProperty> properties = Collections.<VTStyleProperty> singleton(property);
185: Mockito.when(viewTemplateProvider.getStyleProperties(compoundControl, viewModelContext)).thenReturn(properties);
186:
187: final CompoundControlSWTRenderer renderer = createRenderer();
188: final SWTGridDescription gridDescription = renderer.getGridDescription(mock(SWTGridDescription.class));
189: assertEquals(3, gridDescription.getColumns());
190: assertEquals(1, gridDescription.getRows());
191: assertEquals(3, gridDescription.getGrid().size());
192:
193: final SWTGridCell label = gridDescription.getGrid().get(0);
194: assertEquals(0, label.getColumn());
195: assertEquals(1, label.getHorizontalSpan());
196: assertEquals(0, label.getRow());
197: assertSame(renderer, label.getRenderer());
198: assertFalse(label.isHorizontalFill());
199: assertFalse(label.isHorizontalGrab());
200: assertFalse(label.isVerticalFill());
201: assertFalse(label.isVerticalGrab());
202: assertEquals(11, label.getPreferredSize().x);
203: assertEquals(SWT.DEFAULT, label.getPreferredSize().y);
204:
205: final SWTGridCell validation = gridDescription.getGrid().get(1);
206: assertEquals(1, validation.getColumn());
207: assertEquals(1, validation.getHorizontalSpan());
208: assertEquals(0, validation.getRow());
209: assertSame(renderer, validation.getRenderer());
210: assertFalse(validation.isHorizontalFill());
211: assertFalse(validation.isHorizontalGrab());
212: assertFalse(validation.isVerticalFill());
213: assertFalse(validation.isVerticalGrab());
214:
215: final SWTGridCell controls = gridDescription.getGrid().get(2);
216: assertEquals(2, controls.getColumn());
217: assertEquals(1, controls.getHorizontalSpan());
218: assertEquals(0, controls.getRow());
219: assertSame(renderer, controls.getRenderer());
220: assertTrue(controls.isHorizontalFill());
221: assertTrue(controls.isHorizontalGrab());
222: assertTrue(controls.isVerticalFill());
223: assertFalse(controls.isVerticalGrab());
224: }
225:
226: @Test
227: public void testGetGridDescriptionControlLabelAlignmentLeft() {
228: when(compoundControl.getLabelAlignment()).thenReturn(LabelAlignment.LEFT);
229:
230: final CompoundControlSWTRenderer renderer = createRenderer();
231: final SWTGridDescription gridDescription = renderer.getGridDescription(mock(SWTGridDescription.class));
232: assertEquals(3, gridDescription.getColumns());
233: assertEquals(1, gridDescription.getRows());
234: assertEquals(3, gridDescription.getGrid().size());
235:
236: final SWTGridCell label = gridDescription.getGrid().get(0);
237: assertEquals(0, label.getColumn());
238: assertEquals(1, label.getHorizontalSpan());
239: assertEquals(0, label.getRow());
240: assertSame(renderer, label.getRenderer());
241: assertFalse(label.isHorizontalFill());
242: assertFalse(label.isHorizontalGrab());
243: assertFalse(label.isVerticalFill());
244: assertFalse(label.isVerticalGrab());
245:
246: final SWTGridCell validation = gridDescription.getGrid().get(1);
247: assertEquals(1, validation.getColumn());
248: assertEquals(1, validation.getHorizontalSpan());
249: assertEquals(0, validation.getRow());
250: assertSame(renderer, validation.getRenderer());
251: assertFalse(validation.isHorizontalFill());
252: assertFalse(validation.isHorizontalGrab());
253: assertFalse(validation.isVerticalFill());
254: assertFalse(validation.isVerticalGrab());
255:
256: final SWTGridCell controls = gridDescription.getGrid().get(2);
257: assertEquals(2, controls.getColumn());
258: assertEquals(1, controls.getHorizontalSpan());
259: assertEquals(0, controls.getRow());
260: assertSame(renderer, controls.getRenderer());
261: assertTrue(controls.isHorizontalFill());
262: assertTrue(controls.isHorizontalGrab());
263: assertTrue(controls.isVerticalFill());
264: assertFalse(controls.isVerticalGrab());
265: }
266:
267: @Test
268: public void testGetGridDescriptionControlLabelAlignmentTop() {
269: when(compoundControl.getLabelAlignment()).thenReturn(LabelAlignment.TOP);
270:
271: final CompoundControlSWTRenderer renderer = createRenderer();
272: final SWTGridDescription gridDescription = renderer.getGridDescription(mock(SWTGridDescription.class));
273: assertEquals(3, gridDescription.getColumns());
274: assertEquals(1, gridDescription.getRows());
275: assertEquals(3, gridDescription.getGrid().size());
276:
277: final SWTGridCell label = gridDescription.getGrid().get(0);
278: assertEquals(0, label.getColumn());
279: assertEquals(1, label.getHorizontalSpan());
280: assertEquals(0, label.getRow());
281: assertSame(renderer, label.getRenderer());
282: assertFalse(label.isHorizontalFill());
283: assertFalse(label.isHorizontalGrab());
284: assertFalse(label.isVerticalFill());
285: assertFalse(label.isVerticalGrab());
286:
287: final SWTGridCell validation = gridDescription.getGrid().get(1);
288: assertEquals(1, validation.getColumn());
289: assertEquals(1, validation.getHorizontalSpan());
290: assertEquals(0, validation.getRow());
291: assertSame(renderer, validation.getRenderer());
292: assertFalse(validation.isHorizontalFill());
293: assertFalse(validation.isHorizontalGrab());
294: assertFalse(validation.isVerticalFill());
295: assertFalse(validation.isVerticalGrab());
296:
297: final SWTGridCell controls = gridDescription.getGrid().get(2);
298: assertEquals(2, controls.getColumn());
299: assertEquals(1, controls.getHorizontalSpan());
300: assertEquals(0, controls.getRow());
301: assertSame(renderer, controls.getRenderer());
302: assertTrue(controls.isHorizontalFill());
303: assertTrue(controls.isHorizontalGrab());
304: assertTrue(controls.isVerticalFill());
305: assertFalse(controls.isVerticalGrab());
306:
307: /* assert that top was set to default because not supported */
308: verify(compoundControl, times(1)).setLabelAlignment(LabelAlignment.DEFAULT);
309: }
310:
311: @Test
312: public void testGetGridDescriptionControlLabelAlignmentNone() {
313: when(compoundControl.getLabelAlignment()).thenReturn(LabelAlignment.NONE);
314:
315: final CompoundControlSWTRenderer renderer = createRenderer();
316: final SWTGridDescription gridDescription = renderer.getGridDescription(mock(SWTGridDescription.class));
317: assertEquals(2, gridDescription.getColumns());
318: assertEquals(1, gridDescription.getRows());
319: assertEquals(2, gridDescription.getGrid().size());
320:
321: final SWTGridCell validation = gridDescription.getGrid().get(0);
322: assertEquals(0, validation.getColumn());
323: assertEquals(1, validation.getHorizontalSpan());
324: assertEquals(0, validation.getRow());
325: assertSame(renderer, validation.getRenderer());
326: assertFalse(validation.isHorizontalFill());
327: assertFalse(validation.isHorizontalGrab());
328: assertFalse(validation.isVerticalFill());
329: assertFalse(validation.isVerticalGrab());
330:
331: final SWTGridCell controls = gridDescription.getGrid().get(1);
332: assertEquals(1, controls.getColumn());
333: assertEquals(1, controls.getHorizontalSpan());
334: assertEquals(0, controls.getRow());
335: assertSame(renderer, controls.getRenderer());
336: assertTrue(controls.isHorizontalFill());
337: assertTrue(controls.isHorizontalGrab());
338: assertTrue(controls.isVerticalFill());
339: assertFalse(controls.isVerticalGrab());
340: }
341:
342: @Test
343: public void testCreateLabel() throws NoLabelFoundException, DatabindingFailedException {
344: /* setup */
345: final VControl control1 = mock(VControl.class);
346: final VFeaturePathDomainModelReference dmr1 = mock(VFeaturePathDomainModelReference.class);
347: when(control1.getDomainModelReference()).thenReturn(dmr1);
348:
349: final VControl control2 = mock(VControl.class);
350: final VFeaturePathDomainModelReference dmr2 = mock(VFeaturePathDomainModelReference.class);
351: when(control2.getDomainModelReference()).thenReturn(dmr2);
352:
353: when(compoundControl.getControls()).thenReturn(ECollections.asEList(control1, control2));
354:
355: final EObject domainModel = mock(EObject.class);
356: when(viewModelContext.getDomainModel()).thenReturn(domainModel);
357:
358: when(emfFormsLabelProvider.getDisplayName(dmr1, domainModel))
359: .thenReturn(Observables.constantObservableValue(LABEL1, String.class));
360:
361: when(emfFormsLabelProvider.getDisplayName(dmr2, domainModel))
362: .thenReturn(Observables.constantObservableValue(LABEL2, String.class));
363:
364: when(emfFormsLabelProvider.getDescription(dmr1, domainModel))
365: .thenReturn(Observables.constantObservableValue(TOOLTIP1, String.class));
366:
367: when(emfFormsLabelProvider.getDescription(dmr2, domainModel))
368: .thenReturn(Observables.constantObservableValue(TOOLTIP2, String.class));
369:
370: final IEMFValueProperty valueProperty1 = mock(IEMFValueProperty.class);
371: when(emfFormsDatabindingEMF.getValueProperty(dmr1, domainModel)).thenReturn(valueProperty1);
372: final EStructuralFeature structuralFeature1 = mock(EStructuralFeature.class);
373: when(valueProperty1.getStructuralFeature()).thenReturn(structuralFeature1);
374:
375: final IEMFValueProperty valueProperty2 = mock(IEMFValueProperty.class);
376: when(emfFormsDatabindingEMF.getValueProperty(dmr2, domainModel)).thenReturn(valueProperty2);
377: final EStructuralFeature structuralFeature2 = mock(EStructuralFeature.class);
378: when(valueProperty2.getStructuralFeature()).thenReturn(structuralFeature2);
379:
380: final CompoundControlSWTRenderer renderer = createRenderer();
381:
382: /* act */
383: final Control label = renderer.createLabel(shell);
384:
385: /* assert */
386: assertTrue(Label.class.isInstance(label));
387: final Label labelComposite = Label.class.cast(label);
388: assertEquals(LABEL1 + " / " + LABEL2, labelComposite.getText()); //$NON-NLS-1$
389: assertEquals(TOOLTIP1 + "\n" + TOOLTIP2, labelComposite.getToolTipText()); //$NON-NLS-1$
390: }
391:
392: @Test
393: public void testCreateLabelAlignmentDefault() throws NoLabelFoundException, DatabindingFailedException {
394: /* setup */
395: final VControl control1 = mock(VControl.class);
396: final VFeaturePathDomainModelReference dmr1 = mock(VFeaturePathDomainModelReference.class);
397: when(control1.getDomainModelReference()).thenReturn(dmr1);
398:
399: final VControl control2 = mock(VControl.class);
400: final VFeaturePathDomainModelReference dmr2 = mock(VFeaturePathDomainModelReference.class);
401: when(control2.getDomainModelReference()).thenReturn(dmr2);
402:
403: when(compoundControl.getControls()).thenReturn(ECollections.asEList(control1, control2));
404:
405: final EObject domainModel = mock(EObject.class);
406: when(viewModelContext.getDomainModel()).thenReturn(domainModel);
407:
408: when(emfFormsLabelProvider.getDisplayName(dmr1, domainModel))
409: .thenReturn(Observables.constantObservableValue(LABEL1, String.class));
410:
411: when(emfFormsLabelProvider.getDisplayName(dmr2, domainModel))
412: .thenReturn(Observables.constantObservableValue(LABEL2, String.class));
413:
414: when(emfFormsLabelProvider.getDescription(dmr1, domainModel))
415: .thenReturn(Observables.constantObservableValue(TOOLTIP1, String.class));
416:
417: when(emfFormsLabelProvider.getDescription(dmr2, domainModel))
418: .thenReturn(Observables.constantObservableValue(TOOLTIP2, String.class));
419:
420: final IEMFValueProperty valueProperty1 = mock(IEMFValueProperty.class);
421: when(emfFormsDatabindingEMF.getValueProperty(dmr1, domainModel)).thenReturn(valueProperty1);
422: final EStructuralFeature structuralFeature1 = mock(EStructuralFeature.class);
423: when(valueProperty1.getStructuralFeature()).thenReturn(structuralFeature1);
424:
425: final IEMFValueProperty valueProperty2 = mock(IEMFValueProperty.class);
426: when(emfFormsDatabindingEMF.getValueProperty(dmr2, domainModel)).thenReturn(valueProperty2);
427: final EStructuralFeature structuralFeature2 = mock(EStructuralFeature.class);
428: when(valueProperty2.getStructuralFeature()).thenReturn(structuralFeature2);
429:
430: final CompoundControlSWTRenderer renderer = createRenderer();
431:
432: /* act */
433: final Control label = renderer.createLabel(shell);
434:
435: /* assert */
436: final Label swtLabel = Label.class.cast(label);
437: assertEquals(SWT.LEFT, swtLabel.getAlignment());
438: }
439:
440: @Test
441: public void testCreateLabelAlignmentLeft() throws NoLabelFoundException, DatabindingFailedException {
442: /* setup */
443: final VControl control1 = mock(VControl.class);
444: final VFeaturePathDomainModelReference dmr1 = mock(VFeaturePathDomainModelReference.class);
445: when(control1.getDomainModelReference()).thenReturn(dmr1);
446:
447: final VControl control2 = mock(VControl.class);
448: final VFeaturePathDomainModelReference dmr2 = mock(VFeaturePathDomainModelReference.class);
449: when(control2.getDomainModelReference()).thenReturn(dmr2);
450:
451: when(compoundControl.getControls()).thenReturn(ECollections.asEList(control1, control2));
452:
453: final EObject domainModel = mock(EObject.class);
454: when(viewModelContext.getDomainModel()).thenReturn(domainModel);
455:
456: when(emfFormsLabelProvider.getDisplayName(dmr1, domainModel))
457: .thenReturn(Observables.constantObservableValue(LABEL1, String.class));
458:
459: when(emfFormsLabelProvider.getDisplayName(dmr2, domainModel))
460: .thenReturn(Observables.constantObservableValue(LABEL2, String.class));
461:
462: when(emfFormsLabelProvider.getDescription(dmr1, domainModel))
463: .thenReturn(Observables.constantObservableValue(TOOLTIP1, String.class));
464:
465: when(emfFormsLabelProvider.getDescription(dmr2, domainModel))
466: .thenReturn(Observables.constantObservableValue(TOOLTIP2, String.class));
467:
468: final IEMFValueProperty valueProperty1 = mock(IEMFValueProperty.class);
469: when(emfFormsDatabindingEMF.getValueProperty(dmr1, domainModel)).thenReturn(valueProperty1);
470: final EStructuralFeature structuralFeature1 = mock(EStructuralFeature.class);
471: when(valueProperty1.getStructuralFeature()).thenReturn(structuralFeature1);
472:
473: final IEMFValueProperty valueProperty2 = mock(IEMFValueProperty.class);
474: when(emfFormsDatabindingEMF.getValueProperty(dmr2, domainModel)).thenReturn(valueProperty2);
475: final EStructuralFeature structuralFeature2 = mock(EStructuralFeature.class);
476:
477: final CompoundControlSWTRenderer renderer = createRenderer();
478:
479: final VTControlLabelAlignmentStyleProperty property = VTAlignmentFactory.eINSTANCE
480: .createControlLabelAlignmentStyleProperty();
481: property.setType(AlignmentType.LEFT);
482: final Set<VTStyleProperty> properties = Collections.<VTStyleProperty> singleton(property);
483: Mockito.when(viewTemplateProvider.getStyleProperties(compoundControl, viewModelContext)).thenReturn(properties);
484: when(valueProperty2.getStructuralFeature()).thenReturn(structuralFeature2);
485:
486: /* act */
487: final Control label = renderer.createLabel(shell);
488:
489: /* assert */
490: final Label swtLabel = Label.class.cast(label);
491: assertEquals(SWT.LEFT, swtLabel.getAlignment());
492: }
493:
494: @Test
495: public void testCreateLabelAlignmentRight() throws NoLabelFoundException, DatabindingFailedException {
496: /* setup */
497: final VControl control1 = mock(VControl.class);
498: final VFeaturePathDomainModelReference dmr1 = mock(VFeaturePathDomainModelReference.class);
499: when(control1.getDomainModelReference()).thenReturn(dmr1);
500:
501: final VControl control2 = mock(VControl.class);
502: final VFeaturePathDomainModelReference dmr2 = mock(VFeaturePathDomainModelReference.class);
503: when(control2.getDomainModelReference()).thenReturn(dmr2);
504:
505: when(compoundControl.getControls()).thenReturn(ECollections.asEList(control1, control2));
506:
507: final EObject domainModel = mock(EObject.class);
508: when(viewModelContext.getDomainModel()).thenReturn(domainModel);
509:
510: when(emfFormsLabelProvider.getDisplayName(dmr1, domainModel))
511: .thenReturn(Observables.constantObservableValue(LABEL1, String.class));
512:
513: when(emfFormsLabelProvider.getDisplayName(dmr2, domainModel))
514: .thenReturn(Observables.constantObservableValue(LABEL2, String.class));
515:
516: when(emfFormsLabelProvider.getDescription(dmr1, domainModel))
517: .thenReturn(Observables.constantObservableValue(TOOLTIP1, String.class));
518:
519: when(emfFormsLabelProvider.getDescription(dmr2, domainModel))
520: .thenReturn(Observables.constantObservableValue(TOOLTIP2, String.class));
521:
522: final IEMFValueProperty valueProperty1 = mock(IEMFValueProperty.class);
523: when(emfFormsDatabindingEMF.getValueProperty(dmr1, domainModel)).thenReturn(valueProperty1);
524: final EStructuralFeature structuralFeature1 = mock(EStructuralFeature.class);
525: when(valueProperty1.getStructuralFeature()).thenReturn(structuralFeature1);
526:
527: final IEMFValueProperty valueProperty2 = mock(IEMFValueProperty.class);
528: when(emfFormsDatabindingEMF.getValueProperty(dmr2, domainModel)).thenReturn(valueProperty2);
529: final EStructuralFeature structuralFeature2 = mock(EStructuralFeature.class);
530: when(valueProperty2.getStructuralFeature()).thenReturn(structuralFeature2);
531:
532: final CompoundControlSWTRenderer renderer = createRenderer();
533:
534: final VTControlLabelAlignmentStyleProperty property = VTAlignmentFactory.eINSTANCE
535: .createControlLabelAlignmentStyleProperty();
536: property.setType(AlignmentType.RIGHT);
537: final Set<VTStyleProperty> properties = Collections.<VTStyleProperty> singleton(property);
538: Mockito.when(viewTemplateProvider.getStyleProperties(compoundControl, viewModelContext)).thenReturn(properties);
539:
540: /* act */
541: final Control label = renderer.createLabel(shell);
542:
543: /* assert */
544: final Label swtLabel = Label.class.cast(label);
545: assertEquals(SWT.RIGHT, swtLabel.getAlignment());
546: }
547:
548: // TODO
549: @Test
550: public void testCreateLabelWrapDefault() throws NoLabelFoundException, DatabindingFailedException {
551: /* setup */
552: final VControl control1 = mock(VControl.class);
553: final VFeaturePathDomainModelReference dmr1 = mock(VFeaturePathDomainModelReference.class);
554: when(control1.getDomainModelReference()).thenReturn(dmr1);
555:
556: final VControl control2 = mock(VControl.class);
557: final VFeaturePathDomainModelReference dmr2 = mock(VFeaturePathDomainModelReference.class);
558: when(control2.getDomainModelReference()).thenReturn(dmr2);
559:
560: when(compoundControl.getControls()).thenReturn(ECollections.asEList(control1, control2));
561:
562: final EObject domainModel = mock(EObject.class);
563: when(viewModelContext.getDomainModel()).thenReturn(domainModel);
564:
565: when(emfFormsLabelProvider.getDisplayName(dmr1, domainModel))
566: .thenReturn(Observables.constantObservableValue(LABEL1, String.class));
567:
568: when(emfFormsLabelProvider.getDisplayName(dmr2, domainModel))
569: .thenReturn(Observables.constantObservableValue(LABEL2, String.class));
570:
571: when(emfFormsLabelProvider.getDescription(dmr1, domainModel))
572: .thenReturn(Observables.constantObservableValue(TOOLTIP1, String.class));
573:
574: when(emfFormsLabelProvider.getDescription(dmr2, domainModel))
575: .thenReturn(Observables.constantObservableValue(TOOLTIP2, String.class));
576:
577: final IEMFValueProperty valueProperty1 = mock(IEMFValueProperty.class);
578: when(emfFormsDatabindingEMF.getValueProperty(dmr1, domainModel)).thenReturn(valueProperty1);
579: final EStructuralFeature structuralFeature1 = mock(EStructuralFeature.class);
580: when(valueProperty1.getStructuralFeature()).thenReturn(structuralFeature1);
581:
582: final IEMFValueProperty valueProperty2 = mock(IEMFValueProperty.class);
583: when(emfFormsDatabindingEMF.getValueProperty(dmr2, domainModel)).thenReturn(valueProperty2);
584: final EStructuralFeature structuralFeature2 = mock(EStructuralFeature.class);
585: when(valueProperty2.getStructuralFeature()).thenReturn(structuralFeature2);
586:
587: final CompoundControlSWTRenderer renderer = createRenderer();
588:
589: /* act */
590: final Control label = renderer.createLabel(shell);
591:
592: /* assert */
593: final Label swtLabel = Label.class.cast(label);
594: assertEquals(0, swtLabel.getStyle() & SWT.WRAP);
595: }
596:
597: @Test
598: public void testCreateLabelWrapDisabled() throws NoLabelFoundException, DatabindingFailedException {
599: /* setup */
600: final VControl control1 = mock(VControl.class);
601: final VFeaturePathDomainModelReference dmr1 = mock(VFeaturePathDomainModelReference.class);
602: when(control1.getDomainModelReference()).thenReturn(dmr1);
603:
604: final VControl control2 = mock(VControl.class);
605: final VFeaturePathDomainModelReference dmr2 = mock(VFeaturePathDomainModelReference.class);
606: when(control2.getDomainModelReference()).thenReturn(dmr2);
607:
608: when(compoundControl.getControls()).thenReturn(ECollections.asEList(control1, control2));
609:
610: final EObject domainModel = mock(EObject.class);
611: when(viewModelContext.getDomainModel()).thenReturn(domainModel);
612:
613: when(emfFormsLabelProvider.getDisplayName(dmr1, domainModel))
614: .thenReturn(Observables.constantObservableValue(LABEL1, String.class));
615:
616: when(emfFormsLabelProvider.getDisplayName(dmr2, domainModel))
617: .thenReturn(Observables.constantObservableValue(LABEL2, String.class));
618:
619: when(emfFormsLabelProvider.getDescription(dmr1, domainModel))
620: .thenReturn(Observables.constantObservableValue(TOOLTIP1, String.class));
621:
622: when(emfFormsLabelProvider.getDescription(dmr2, domainModel))
623: .thenReturn(Observables.constantObservableValue(TOOLTIP2, String.class));
624:
625: final IEMFValueProperty valueProperty1 = mock(IEMFValueProperty.class);
626: when(emfFormsDatabindingEMF.getValueProperty(dmr1, domainModel)).thenReturn(valueProperty1);
627: final EStructuralFeature structuralFeature1 = mock(EStructuralFeature.class);
628: when(valueProperty1.getStructuralFeature()).thenReturn(structuralFeature1);
629:
630: final IEMFValueProperty valueProperty2 = mock(IEMFValueProperty.class);
631: when(emfFormsDatabindingEMF.getValueProperty(dmr2, domainModel)).thenReturn(valueProperty2);
632: final EStructuralFeature structuralFeature2 = mock(EStructuralFeature.class);
633: when(valueProperty2.getStructuralFeature()).thenReturn(structuralFeature2);
634:
635: final CompoundControlSWTRenderer renderer = createRenderer();
636:
637: final VTLabelWrapStyleProperty property = VTWrapFactory.eINSTANCE.createLabelWrapStyleProperty();
638: property.setWrapLabel(false);
639: final Set<VTStyleProperty> properties = Collections.<VTStyleProperty> singleton(property);
640: Mockito.when(viewTemplateProvider.getStyleProperties(compoundControl, viewModelContext)).thenReturn(properties);
641: when(valueProperty2.getStructuralFeature()).thenReturn(structuralFeature2);
642:
643: /* act */
644: final Control label = renderer.createLabel(shell);
645:
646: /* assert */
647: final Label swtLabel = Label.class.cast(label);
648: assertEquals(0, swtLabel.getStyle() & SWT.WRAP);
649: }
650:
651: @Test
652: public void testCreateLabelWrapEnabled() throws NoLabelFoundException, DatabindingFailedException {
653: /* setup */
654: final VControl control1 = mock(VControl.class);
655: final VFeaturePathDomainModelReference dmr1 = mock(VFeaturePathDomainModelReference.class);
656: when(control1.getDomainModelReference()).thenReturn(dmr1);
657:
658: final VControl control2 = mock(VControl.class);
659: final VFeaturePathDomainModelReference dmr2 = mock(VFeaturePathDomainModelReference.class);
660: when(control2.getDomainModelReference()).thenReturn(dmr2);
661:
662: when(compoundControl.getControls()).thenReturn(ECollections.asEList(control1, control2));
663:
664: final EObject domainModel = mock(EObject.class);
665: when(viewModelContext.getDomainModel()).thenReturn(domainModel);
666:
667: when(emfFormsLabelProvider.getDisplayName(dmr1, domainModel))
668: .thenReturn(Observables.constantObservableValue(LABEL1, String.class));
669:
670: when(emfFormsLabelProvider.getDisplayName(dmr2, domainModel))
671: .thenReturn(Observables.constantObservableValue(LABEL2, String.class));
672:
673: when(emfFormsLabelProvider.getDescription(dmr1, domainModel))
674: .thenReturn(Observables.constantObservableValue(TOOLTIP1, String.class));
675:
676: when(emfFormsLabelProvider.getDescription(dmr2, domainModel))
677: .thenReturn(Observables.constantObservableValue(TOOLTIP2, String.class));
678:
679: final IEMFValueProperty valueProperty1 = mock(IEMFValueProperty.class);
680: when(emfFormsDatabindingEMF.getValueProperty(dmr1, domainModel)).thenReturn(valueProperty1);
681: final EStructuralFeature structuralFeature1 = mock(EStructuralFeature.class);
682: when(valueProperty1.getStructuralFeature()).thenReturn(structuralFeature1);
683:
684: final IEMFValueProperty valueProperty2 = mock(IEMFValueProperty.class);
685: when(emfFormsDatabindingEMF.getValueProperty(dmr2, domainModel)).thenReturn(valueProperty2);
686: final EStructuralFeature structuralFeature2 = mock(EStructuralFeature.class);
687: when(valueProperty2.getStructuralFeature()).thenReturn(structuralFeature2);
688:
689: final CompoundControlSWTRenderer renderer = createRenderer();
690:
691: final VTLabelWrapStyleProperty property = VTWrapFactory.eINSTANCE.createLabelWrapStyleProperty();
692: property.setWrapLabel(true);
693: final Set<VTStyleProperty> properties = Collections.<VTStyleProperty> singleton(property);
694: Mockito.when(viewTemplateProvider.getStyleProperties(compoundControl, viewModelContext)).thenReturn(properties);
695: when(valueProperty2.getStructuralFeature()).thenReturn(structuralFeature2);
696:
697: /* act */
698: final Control label = renderer.createLabel(shell);
699:
700: /* assert */
701: final Label swtLabel = Label.class.cast(label);
702: assertNotEquals(0, swtLabel.getStyle() & SWT.WRAP);
703: }
704:
705: @Test
706: public void testCreateValidationIconNoChildren()
707: throws NoRendererFoundException, NoPropertyDescriptorFoundExeption {
708: /* setup */
709: when(compoundControl.getControls()).thenReturn(ECollections.<VControl> emptyEList());
710:
711: final EObject domainModel = mock(EObject.class);
712: when(viewModelContext.getDomainModel()).thenReturn(domainModel);
713:
714: final CompoundControlSWTRenderer renderer = spy(createRenderer());
715:
716: /* act */
717: final Control label = renderer.createValidationIcon(shell);
718:
719: /* assert */
720: verify(renderer, times(1)).createDummyValidationIcon(shell);
721: assertTrue(Label.class.isInstance(label));
722: }
723:
724: @Test
725: public void testCreateValidationIconFirstCellHasNoRenderer()
726: throws NoRendererFoundException, NoPropertyDescriptorFoundExeption {
727: /* setup */
728: final VControl control1 = mock(VControl.class);
729: final VFeaturePathDomainModelReference dmr1 = mock(VFeaturePathDomainModelReference.class);
730: when(control1.getDomainModelReference()).thenReturn(dmr1);
731:
732: final VControl control2 = mock(VControl.class);
733: final VFeaturePathDomainModelReference dmr2 = mock(VFeaturePathDomainModelReference.class);
734: when(control2.getDomainModelReference()).thenReturn(dmr2);
735:
736: when(compoundControl.getControls()).thenReturn(ECollections.asEList(control1, control2));
737:
738: final EObject domainModel = mock(EObject.class);
739: when(viewModelContext.getDomainModel()).thenReturn(domainModel);
740:
741: final CompoundControlSWTRenderer renderer = spy(createRenderer());
742:
743: /* act */
744: final Control label = renderer.createValidationIcon(shell);
745:
746: /* assert */
747: verify(renderer, times(1)).createDummyValidationIcon(shell);
748: assertTrue(Label.class.isInstance(label));
749: }
750:
751: @Test
752: public void testCreateValidationIconFirstCellRenderer1Column()
753: throws NoRendererFoundException, NoPropertyDescriptorFoundExeption, EMFFormsNoRendererException {
754: /* setup */
755: final VControl control1 = mock(VControl.class);
756: final VFeaturePathDomainModelReference dmr1 = mock(VFeaturePathDomainModelReference.class);
757: when(control1.getDomainModelReference()).thenReturn(dmr1);
758:
759: final VControl control2 = mock(VControl.class);
760: final VFeaturePathDomainModelReference dmr2 = mock(VFeaturePathDomainModelReference.class);
761: when(control2.getDomainModelReference()).thenReturn(dmr2);
762:
763: when(compoundControl.getControls()).thenReturn(ECollections.asEList(control1, control2));
764:
765: final EObject domainModel = mock(EObject.class);
766: when(viewModelContext.getDomainModel()).thenReturn(domainModel);
767:
768: final DummyRenderer dummyRenderer1 = createDummyRendererNoValidation(control1);
769: when(emfFormsRendererFactory.getRendererInstance(control1, viewModelContext)).thenReturn(dummyRenderer1);
770:
771: final CompoundControlSWTRenderer renderer = spy(createRenderer());
772:
773: /* act */
774: final Control label = renderer.createValidationIcon(shell);
775:
776: /* assert */
777: verify(renderer, times(1)).createDummyValidationIcon(shell);
778: assertTrue(Label.class.isInstance(label));
779: }
780:
781: @Test
782: public void testCreateValidationIconFirstCellRenderer2Columns()
783: throws NoRendererFoundException, NoPropertyDescriptorFoundExeption, EMFFormsNoRendererException {
784: /* setup */
785: final VControl control1 = mock(VControl.class);
786: final VFeaturePathDomainModelReference dmr1 = mock(VFeaturePathDomainModelReference.class);
787: when(control1.getDomainModelReference()).thenReturn(dmr1);
788:
789: final VControl control2 = mock(VControl.class);
790: final VFeaturePathDomainModelReference dmr2 = mock(VFeaturePathDomainModelReference.class);
791: when(control2.getDomainModelReference()).thenReturn(dmr2);
792:
793: when(compoundControl.getControls()).thenReturn(ECollections.asEList(control1, control2));
794:
795: final EObject domainModel = mock(EObject.class);
796: when(viewModelContext.getDomainModel()).thenReturn(domainModel);
797:
798: final DummyRenderer dummyRenderer1 = spy(createDummyRenderer(control1));
799: when(emfFormsRendererFactory.getRendererInstance(control1, viewModelContext)).thenReturn(dummyRenderer1);
800:
801: final CompoundControlSWTRenderer renderer = spy(createRenderer());
802:
803: /* act */
804: final Control label = renderer.createValidationIcon(shell);
805:
806: /* assert */
807: verify(renderer, times(0)).createDummyValidationIcon(shell);
808: verify(dummyRenderer1, times(1)).createLabel(C_VALIDATION, shell);
809: assertTrue(Label.class.isInstance(label));
810: }
811:
812: @Test
813: public void testCreateControls() throws EMFFormsNoRendererException {
814: /* setup */
815: final VControl control1 = mock(VControl.class);
816: final VFeaturePathDomainModelReference dmr1 = mock(VFeaturePathDomainModelReference.class);
817: when(control1.getDomainModelReference()).thenReturn(dmr1);
818:
819: final VControl control2 = mock(VControl.class);
820: final VFeaturePathDomainModelReference dmr2 = mock(VFeaturePathDomainModelReference.class);
821: when(control2.getDomainModelReference()).thenReturn(dmr2);
822:
823: when(compoundControl.getControls()).thenReturn(ECollections.asEList(control1, control2));
824:
825: final EObject domainModel = mock(EObject.class);
826: when(viewModelContext.getDomainModel()).thenReturn(domainModel);
827:
828: final DummyRenderer dummyRenderer1 = createDummyRenderer(control1);
829: final DummyRenderer dummyRenderer2 = createDummyRenderer(control2);
830:
831: when(emfFormsRendererFactory.getRendererInstance(control1, viewModelContext))
832: .thenReturn(dummyRenderer1);
833:
834: when(emfFormsRendererFactory.getRendererInstance(control2, viewModelContext))
835: .thenReturn(dummyRenderer2);
836:
837: final CompoundControlSWTRenderer renderer = spy(createRenderer());
838:
839: doReturn(GridLayoutFactory.fillDefaults().create()).when(renderer).getColumnLayout(any(Integer.class),
840: any(Boolean.class));
841:
842: doReturn(GridDataFactory.fillDefaults().create()).when(renderer).getLayoutData(any(SWTGridCell.class),
843: any(SWTGridDescription.class), any(SWTGridDescription.class),
844: any(SWTGridDescription.class), any(VElement.class), any(EObject.class), any(Control.class));
845:
846: doReturn(GridDataFactory.fillDefaults().create()).when(renderer).getSpanningLayoutData(
847: any(VContainedElement.class), any(Integer.class), any(Integer.class));
848:
849: /* act */
850: final Control controls = renderer.createControls(shell);
851:
852: /* assert */
853: assertTrue(Composite.class.isInstance(controls));
854: final Composite controlsComposite = Composite.class.cast(controls);
855: assertEquals(2, controlsComposite.getChildren().length);
856: for (final Control control : controlsComposite.getChildren()) {
857: assertTrue(Composite.class.isInstance(control));
858: }
859:
860: final Composite control1Composite = Composite.class.cast(controlsComposite.getChildren()[0]);
861: assertEquals(2, control1Composite.getChildren().length);
862: for (final Control control : control1Composite.getChildren()) {
863: assertTrue(Label.class.isInstance(control));
864: }
865: assertEquals(C_VALIDATION, Label.class.cast(control1Composite.getChildren()[0]).getText());
866: assertEquals(C_CONTROL, Label.class.cast(control1Composite.getChildren()[1]).getText());
867:
868: final Composite control2Composite = Composite.class.cast(controlsComposite.getChildren()[1]);
869: assertEquals(2, control2Composite.getChildren().length);
870: for (final Control control : control2Composite.getChildren()) {
871: assertTrue(Label.class.isInstance(control));
872: }
873: assertEquals(C_VALIDATION, Label.class.cast(control2Composite.getChildren()[0]).getText());
874: assertEquals(C_CONTROL, Label.class.cast(control2Composite.getChildren()[1]).getText());
875:
876: verify(control1, times(1)).setLabelAlignment(LabelAlignment.NONE);
877: verify(control2, times(1)).setLabelAlignment(LabelAlignment.NONE);
878: }
879:
880: @Test
881: public void testCreateControlsSkipOne() throws EMFFormsNoRendererException {
882: /* setup */
883: final VControl control1 = mock(VControl.class);
884: final VFeaturePathDomainModelReference dmr1 = mock(VFeaturePathDomainModelReference.class);
885: when(control1.getDomainModelReference()).thenReturn(dmr1);
886:
887: final VControl control2 = mock(VControl.class);
888: final VFeaturePathDomainModelReference dmr2 = mock(VFeaturePathDomainModelReference.class);
889: when(control2.getDomainModelReference()).thenReturn(dmr2);
890:
891: when(compoundControl.getControls()).thenReturn(ECollections.asEList(control1, control2));
892:
893: final EObject domainModel = mock(EObject.class);
894: when(viewModelContext.getDomainModel()).thenReturn(domainModel);
895:
896: final DummyRenderer dummyRenderer1 = createDummyRenderer(control1);
897: final DummyRenderer dummyRenderer2 = createDummyRenderer(control2);
898:
899: when(emfFormsRendererFactory.getRendererInstance(control1, viewModelContext))
900: .thenReturn(dummyRenderer1);
901:
902: when(emfFormsRendererFactory.getRendererInstance(control2, viewModelContext))
903: .thenReturn(dummyRenderer2);
904:
905: final CompoundControlSWTRenderer renderer = spy(createRenderer());
906:
907: doReturn(GridLayoutFactory.fillDefaults().create()).when(renderer).getColumnLayout(any(Integer.class),
908: any(Boolean.class));
909:
910: doReturn(GridDataFactory.fillDefaults().create()).when(renderer).getLayoutData(any(SWTGridCell.class),
911: any(SWTGridDescription.class), any(SWTGridDescription.class),
912: any(SWTGridDescription.class), any(VElement.class), any(EObject.class), any(Control.class));
913:
914: doReturn(GridDataFactory.fillDefaults().create()).when(renderer).getSpanningLayoutData(
915: any(VContainedElement.class), any(Integer.class), any(Integer.class));
916:
917: /* act */
918: final Control controls = renderer.createControls(shell, 1);
919:
920: /* assert */
921: assertTrue(Composite.class.isInstance(controls));
922: final Composite controlsComposite = Composite.class.cast(controls);
923: assertEquals(2, controlsComposite.getChildren().length);
924: for (final Control control : controlsComposite.getChildren()) {
925: assertTrue(Composite.class.isInstance(control));
926: }
927:
928: final Composite control1Composite = Composite.class.cast(controlsComposite.getChildren()[0]);
929: assertEquals(1, control1Composite.getChildren().length);
930: for (final Control control : control1Composite.getChildren()) {
931: assertTrue(Label.class.isInstance(control));
932: }
933: assertEquals(C_CONTROL, Label.class.cast(control1Composite.getChildren()[0]).getText());
934:
935: final Composite control2Composite = Composite.class.cast(controlsComposite.getChildren()[1]);
936: assertEquals(2, control2Composite.getChildren().length);
937: for (final Control control : control2Composite.getChildren()) {
938: assertTrue(Label.class.isInstance(control));
939: }
940: assertEquals(C_VALIDATION, Label.class.cast(control2Composite.getChildren()[0]).getText());
941: assertEquals(C_CONTROL, Label.class.cast(control2Composite.getChildren()[1]).getText());
942:
943: verify(control1, times(1)).setLabelAlignment(LabelAlignment.NONE);
944: verify(control2, times(1)).setLabelAlignment(LabelAlignment.NONE);
945: }
946:
947: @Test
948: public void testCreateControlsSkipTwo() throws EMFFormsNoRendererException {
949: /* setup */
950: final VControl control1 = mock(VControl.class);
951: final VFeaturePathDomainModelReference dmr1 = mock(VFeaturePathDomainModelReference.class);
952: when(control1.getDomainModelReference()).thenReturn(dmr1);
953:
954: final VControl control2 = mock(VControl.class);
955: final VFeaturePathDomainModelReference dmr2 = mock(VFeaturePathDomainModelReference.class);
956: when(control2.getDomainModelReference()).thenReturn(dmr2);
957:
958: when(compoundControl.getControls()).thenReturn(ECollections.asEList(control1, control2));
959:
960: final EObject domainModel = mock(EObject.class);
961: when(viewModelContext.getDomainModel()).thenReturn(domainModel);
962:
963: final DummyRenderer dummyRenderer1 = createDummyRenderer(control1);
964: final DummyRenderer dummyRenderer2 = createDummyRenderer(control2);
965:
966: when(emfFormsRendererFactory.getRendererInstance(control1, viewModelContext))
967: .thenReturn(dummyRenderer1);
968:
969: when(emfFormsRendererFactory.getRendererInstance(control2, viewModelContext))
970: .thenReturn(dummyRenderer2);
971:
972: final CompoundControlSWTRenderer renderer = spy(createRenderer());
973:
974: doReturn(GridLayoutFactory.fillDefaults().create()).when(renderer).getColumnLayout(any(Integer.class),
975: any(Boolean.class));
976:
977: doReturn(GridDataFactory.fillDefaults().create()).when(renderer).getLayoutData(any(SWTGridCell.class),
978: any(SWTGridDescription.class), any(SWTGridDescription.class),
979: any(SWTGridDescription.class), any(VElement.class), any(EObject.class), any(Control.class));
980:
981: doReturn(GridDataFactory.fillDefaults().create()).when(renderer).getSpanningLayoutData(
982: any(VContainedElement.class), any(Integer.class), any(Integer.class));
983:
984: /* act */
985: final Control controls = renderer.createControls(shell, 2);
986:
987: /* assert */
988: assertTrue(Composite.class.isInstance(controls));
989: final Composite controlsComposite = Composite.class.cast(controls);
990: assertEquals(2, controlsComposite.getChildren().length);
991: for (final Control control : controlsComposite.getChildren()) {
992: assertTrue(Composite.class.isInstance(control));
993: }
994:
995: final Composite control1Composite = Composite.class.cast(controlsComposite.getChildren()[0]);
996: assertEquals(0, control1Composite.getChildren().length);
997:
998: final Composite control2Composite = Composite.class.cast(controlsComposite.getChildren()[1]);
999: assertEquals(2, control2Composite.getChildren().length);
1000: for (final Control control : control2Composite.getChildren()) {
1001: assertTrue(Label.class.isInstance(control));
1002: }
1003: assertEquals(C_VALIDATION, Label.class.cast(control2Composite.getChildren()[0]).getText());
1004: assertEquals(C_CONTROL, Label.class.cast(control2Composite.getChildren()[1]).getText());
1005:
1006: verify(control1, times(1)).setLabelAlignment(LabelAlignment.NONE);
1007: verify(control2, times(1)).setLabelAlignment(LabelAlignment.NONE);
1008: }
1009:
1010: @Test
1011: public void testRenderControlColumn0() throws NoRendererFoundException, NoPropertyDescriptorFoundExeption {
1012: final SWTGridCell swtGridCell = mock(SWTGridCell.class);
1013: when(swtGridCell.getColumn()).thenReturn(0);
1014: final CompoundControlSWTRenderer renderer = spy(createRenderer());
1015: doReturn(new Label(shell, SWT.NONE)).when(renderer).createLabel(shell);
1016: renderer.renderControl(swtGridCell, shell);
1017: verify(renderer, times(1)).createLabel(shell);
1018: }
1019:
1020: @Test
1021: public void testRenderControlColumn1() throws NoRendererFoundException, NoPropertyDescriptorFoundExeption {
1022: when(compoundControl.getControls()).thenReturn(ECollections.<VControl> emptyEList());
1023: final SWTGridCell swtGridCell = mock(SWTGridCell.class);
1024: when(swtGridCell.getColumn()).thenReturn(1);
1025: final CompoundControlSWTRenderer renderer = spy(createRenderer());
1026: doReturn(new Label(shell, SWT.NONE)).when(renderer).createLabel(shell);
1027: renderer.renderControl(swtGridCell, shell);
1028: verify(renderer, times(1)).createValidationIcon(shell);
1029: }
1030:
1031: @Test
1032: public void testRenderControlColumn2() throws NoRendererFoundException, NoPropertyDescriptorFoundExeption {
1033: when(compoundControl.getControls()).thenReturn(ECollections.<VControl> emptyEList());
1034: final SWTGridCell swtGridCell = mock(SWTGridCell.class);
1035: when(swtGridCell.getColumn()).thenReturn(2);
1036: final CompoundControlSWTRenderer renderer = spy(createRenderer());
1037: doReturn(new Label(shell, SWT.NONE)).when(renderer).createControls(shell);
1038: renderer.renderControl(swtGridCell, shell);
1039: verify(renderer, times(1)).createControls(shell);
1040: }
1041:
1042: @Test(expected = IllegalArgumentException.class)
1043: public void testRenderControlColumnOther() throws NoRendererFoundException, NoPropertyDescriptorFoundExeption {
1044: when(compoundControl.getControls()).thenReturn(ECollections.<VControl> emptyEList());
1045: final SWTGridCell swtGridCell = mock(SWTGridCell.class);
1046: when(swtGridCell.getColumn()).thenReturn(3);
1047: final CompoundControlSWTRenderer renderer = spy(createRenderer());
1048: renderer.renderControl(swtGridCell, shell);
1049: }
1050:
1051: @Test
1052: public void testRenderControlColumn0ControlLabelAlignmentNone()
1053: throws NoRendererFoundException, NoPropertyDescriptorFoundExeption {
1054: when(compoundControl.getLabelAlignment()).thenReturn(LabelAlignment.NONE);
1055: final SWTGridCell swtGridCell = mock(SWTGridCell.class);
1056: when(swtGridCell.getColumn()).thenReturn(0);
1057: final CompoundControlSWTRenderer renderer = spy(createRenderer());
1058: doReturn(new Label(shell, SWT.NONE)).when(renderer).createValidationIcon(shell);
1059: renderer.renderControl(swtGridCell, shell);
1060: verify(renderer, times(1)).createValidationIcon(shell);
1061: }
1062:
1063: @Test
1064: public void testRenderControlColumn1ControlLabelAlignmentNone()
1065: throws NoRendererFoundException, NoPropertyDescriptorFoundExeption {
1066: when(compoundControl.getLabelAlignment()).thenReturn(LabelAlignment.NONE);
1067: when(compoundControl.getControls()).thenReturn(ECollections.<VControl> emptyEList());
1068: final SWTGridCell swtGridCell = mock(SWTGridCell.class);
1069: when(swtGridCell.getColumn()).thenReturn(1);
1070: final CompoundControlSWTRenderer renderer = spy(createRenderer());
1071: doReturn(new Label(shell, SWT.NONE)).when(renderer).createControls(shell);
1072: renderer.renderControl(swtGridCell, shell);
1073: verify(renderer, times(1)).createControls(shell);
1074: }
1075:
1076: @Test
1077: public void testEffectivelyReadOnlyDoesNotDisableComposite()
1078: throws EMFFormsNoRendererException, NoRendererFoundException, NoPropertyDescriptorFoundExeption {
1079: /* setup */
1080: when(compoundControl.isEffectivelyReadonly()).thenReturn(true);
1081: when(compoundControl.isEffectivelyEnabled()).thenReturn(true);
1082: when(compoundControl.isEnabled()).thenReturn(true);
1083:
1084: final VControl control1 = mock(VControl.class);
1085: final VFeaturePathDomainModelReference dmr1 = mock(VFeaturePathDomainModelReference.class);
1086: when(control1.getDomainModelReference()).thenReturn(dmr1);
1087:
1088: final VControl control2 = mock(VControl.class);
1089: final VFeaturePathDomainModelReference dmr2 = mock(VFeaturePathDomainModelReference.class);
1090: when(control2.getDomainModelReference()).thenReturn(dmr2);
1091:
1092: when(compoundControl.getControls()).thenReturn(ECollections.asEList(control1, control2));
1093:
1094: final EObject domainModel = mock(EObject.class);
1095: when(viewModelContext.getDomainModel()).thenReturn(domainModel);
1096:
1097: final DummyRenderer dummyRenderer1 = createDummyRenderer(control1);
1098: final DummyRenderer dummyRenderer2 = createDummyRenderer(control2);
1099:
1100: when(emfFormsRendererFactory.getRendererInstance(control1, viewModelContext))
1101: .thenReturn(dummyRenderer1);
1102:
1103: when(emfFormsRendererFactory.getRendererInstance(control2, viewModelContext))
1104: .thenReturn(dummyRenderer2);
1105:
1106: final CompoundControlSWTRenderer renderer = spy(createRenderer());
1107:
1108: doReturn(GridLayoutFactory.fillDefaults().create()).when(renderer).getColumnLayout(any(Integer.class),
1109: any(Boolean.class));
1110:
1111: doReturn(GridDataFactory.fillDefaults().create()).when(renderer).getLayoutData(any(SWTGridCell.class),
1112: any(SWTGridDescription.class), any(SWTGridDescription.class),
1113: any(SWTGridDescription.class), any(VElement.class), any(EObject.class), any(Control.class));
1114:
1115: doReturn(GridDataFactory.fillDefaults().create()).when(renderer).getSpanningLayoutData(
1116: any(VContainedElement.class), any(Integer.class), any(Integer.class));
1117:
1118: /* act */
1119: renderer.init();
1120: final Control controls = renderer.render(new SWTGridCell(0, 2, renderer), shell);
1121: renderer.finalizeRendering(shell);
1122:
1123: /* assert */
1124: assertTrue(Composite.class.isInstance(controls));
1125: final Composite controlsComposite = Composite.class.cast(controls);
1126: assertTrue(controlsComposite.isEnabled());
1127:
1128: assertEquals(2, controlsComposite.getChildren().length);
1129: for (final Control control : controlsComposite.getChildren()) {
1130: assertTrue(Composite.class.isInstance(control));
1131: }
1132:
1133: final Composite control1Composite = Composite.class.cast(controlsComposite.getChildren()[0]);
1134: assertTrue(control1Composite.isEnabled());
1135:
1136: final Composite control2Composite = Composite.class.cast(controlsComposite.getChildren()[1]);
1137: assertTrue(control2Composite.isEnabled());
1138:
1139: }
1140:
1141: private DummyRenderer createDummyRenderer(final VControl control) {
1142: final DummyRenderer dummyRenderer = new DummyRenderer(control, viewModelContext, reportService, true);
1143: dummyRenderer.init();
1144: return dummyRenderer;
1145: }
1146:
1147: private DummyRenderer createDummyRendererNoValidation(final VControl control) {
1148: final DummyRenderer dummyRenderer = new DummyRenderer(control, viewModelContext, reportService, false);
1149: dummyRenderer.init();
1150: return dummyRenderer;
1151: }
1152:
1153: public static class DummyRenderer extends AbstractSWTRenderer<VElement> {
1154:
1155: private SWTGridDescription rendererGridDescription;
1156: private final boolean showValidation;
1157:
1158: DummyRenderer(VControl vElement, ViewModelContext viewContext, ReportService reportService,
1159: boolean showValidation) {
1160: super(vElement, viewContext, reportService);
1161: this.showValidation = showValidation;
1162: }
1163:
1164: @Override
1165: public SWTGridDescription getGridDescription(SWTGridDescription gridDescription) {
1166:• if (rendererGridDescription == null) {
1167:• rendererGridDescription = GridDescriptionFactory.INSTANCE.createSimpleGrid(1, showValidation ? 2 : 1,
1168: this);
1169:• for (int i = 0; i < rendererGridDescription.getGrid().size() - 1; i++) {
1170: final SWTGridCell swtGridCell = rendererGridDescription.getGrid().get(i);
1171: swtGridCell.setHorizontalGrab(false);
1172: }
1173: }
1174: return rendererGridDescription;
1175: }
1176:
1177: @Override
1178: protected Control renderControl(SWTGridCell gridCell, Composite parent)
1179: throws NoRendererFoundException, NoPropertyDescriptorFoundExeption {
1180: int column = gridCell.getColumn();
1181:• if (!showValidation) {
1182: column++;
1183: }
1184:• switch (column) {
1185: case 0:
1186: return createLabel(C_VALIDATION, parent);
1187: case 1:
1188: return createLabel(C_CONTROL, parent);
1189: default:
1190: throw new IllegalArgumentException();
1191: }
1192: }
1193:
1194: protected Control createLabel(String string, Composite parent) {
1195: final Label label = new Label(parent, SWT.NONE);
1196: label.setText(string);
1197: return label;
1198: }
1199:
1200: }
1201:
1202: }