![[Jenkins]](/ecp/static/e8bbdb94/images/svgs/logo.svg){kind=logo}
Package: DuplicateRowAction_Test
DuplicateRowAction_Test
| name | instruction | branch | complexity | line | method | ||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| DuplicateRowAction_Test() |
|
|
|
|
|
||||||||||||||||||||
| asList(Object) |
|
|
|
|
|
||||||||||||||||||||
| before() |
|
|
|
|
|
||||||||||||||||||||
| createAttribute(EClass, String) |
|
|
|
|
|
||||||||||||||||||||
| createEClass(EPackage, String) |
|
|
|
|
|
||||||||||||||||||||
| createReference(EClass, String, EClass, boolean, boolean, boolean, boolean) |
|
|
|
|
|
||||||||||||||||||||
| createTestPackage() |
|
|
|
|
|
||||||||||||||||||||
| test_containmentManyNoOpp() |
|
|
|
|
|
||||||||||||||||||||
| test_containmentManyOppSingle() |
|
|
|
|
|
||||||||||||||||||||
| test_containmentSingleNoOpp() |
|
|
|
|
|
||||||||||||||||||||
| test_containmentSingleOppSingle() |
|
|
|
|
|
||||||||||||||||||||
| test_refManyNoOpp() |
|
|
|
|
|
||||||||||||||||||||
| test_refManyOppMany() |
|
|
|
|
|
||||||||||||||||||||
| test_refManyOppMany_both() |
|
|
|
|
|
||||||||||||||||||||
| test_refManyOppSingle() |
|
|
|
|
|
||||||||||||||||||||
| test_refSingleNoOpp() |
|
|
|
|
|
||||||||||||||||||||
| test_refSingleOppMany() |
|
|
|
|
|
||||||||||||||||||||
| test_refSingleOppSingle() |
|
|
|
|
|
||||||||||||||||||||
Coverage
1: /*******************************************************************************
2: * Copyright (c) 2011-2019 EclipseSource Muenchen GmbH and others.
3: *
4: * All rights reserved. This program and the accompanying materials
5: * are made available under the terms of the Eclipse Public License 2.0
6: * which accompanies this distribution, and is available at
7: * https://www.eclipse.org/legal/epl-2.0/
8: *
9: * SPDX-License-Identifier: EPL-2.0
10: *
11: * Contributors:
12: * Eugen Neufeld - initial API and implementation
13: ******************************************************************************/
14: package org.eclipse.emf.ecp.view.spi.table.swt.action;
15:
16: import static org.junit.Assert.assertArrayEquals;
17: import static org.junit.Assert.assertEquals;
18: import static org.junit.Assert.assertNotSame;
19: import static org.junit.Assert.assertNull;
20: import static org.junit.Assert.assertSame;
21: import static org.junit.Assert.assertTrue;
22: import static org.mockito.Mockito.mock;
23:
24: import java.util.Arrays;
25: import java.util.Collection;
26: import java.util.Iterator;
27: import java.util.List;
28:
29: import org.eclipse.emf.ecore.EAttribute;
30: import org.eclipse.emf.ecore.EClass;
31: import org.eclipse.emf.ecore.EObject;
32: import org.eclipse.emf.ecore.EPackage;
33: import org.eclipse.emf.ecore.EReference;
34: import org.eclipse.emf.ecore.EcoreFactory;
35: import org.eclipse.emf.ecore.EcorePackage;
36: import org.eclipse.emf.ecore.util.EcoreUtil;
37: import org.junit.Before;
38: import org.junit.Test;
39:
40: /**
41: * Tests for {@link DuplicateRowAction}.
42: *
43: * @author Eugen Neufeld
44: *
45: */
46: public class DuplicateRowAction_Test {
47:
48: private DuplicateRowAction action;
49: private EClass fooClass;
50: private EClass barClass;
51:
52: @Before
53: public void before() {
54: final TableRendererViewerActionContext actionContext = mock(TableRendererViewerActionContext.class);
55: action = new DuplicateRowAction(actionContext);
56: }
57:
58: private void createTestPackage() {
59: final EPackage ePackage = EcoreFactory.eINSTANCE.createEPackage();
60: ePackage.setName("TestPackage");
61: ePackage.setNsPrefix("test");
62: ePackage.setNsURI("test");
63: fooClass = createEClass(ePackage, "Foo");
64: barClass = createEClass(ePackage, "Bar");
65:
66: // create simple attributes
67: createAttribute(fooClass, "name");
68: createAttribute(barClass, "name");
69:
70: // non containment references
71: createReference(fooClass, "refSingleNoOpp", barClass, false, false, false, false);
72: createReference(fooClass, "refManyNoOpp", barClass, false, true, false, false);
73:
74: createReference(fooClass, "refSingleOppSingle", barClass, false, false, true, false);
75: createReference(fooClass, "refManyOppSingle", barClass, false, true, true, false);
76:
77: createReference(fooClass, "refSingleOppMany", barClass, false, false, true, true);
78: createReference(fooClass, "refManyOppMany", barClass, false, true, true, true);
79:
80: // containment
81: createReference(fooClass, "containmentSingleNoOpp", barClass, true, false, false, false);
82: createReference(fooClass, "containmentManyNoOpp", barClass, true, true, false, false);
83:
84: createReference(fooClass, "containmentSingleOppSingle", barClass, true, false, true, false);
85: createReference(fooClass, "containmentManyOppSingle", barClass, true, true, true, false);
86: }
87:
88: private EClass createEClass(EPackage ePackage, String name) {
89: final EClass clazz = EcoreFactory.eINSTANCE.createEClass();
90: clazz.setName(name);
91: ePackage.getEClassifiers().add(clazz);
92: return clazz;
93: }
94:
95: private void createAttribute(EClass clazz, String name) {
96: final EAttribute attribute = EcoreFactory.eINSTANCE.createEAttribute();
97: attribute.setName(name);
98: attribute.setEType(EcorePackage.eINSTANCE.getEString());
99: clazz.getEStructuralFeatures().add(attribute);
100: }
101:
102: private void createReference(EClass clazz, String name, EClass refClass, boolean containment, boolean many,
103: boolean opposite, boolean oppositeMany) {
104: final EReference reference = EcoreFactory.eINSTANCE.createEReference();
105: reference.setName(name);
106: reference.setEType(refClass);
107: reference.setContainment(containment);
108:• reference.setUpperBound(many ? -1 : 1);
109:• if (opposite) {
110: final EReference oppReference = EcoreFactory.eINSTANCE.createEReference();
111: oppReference.setName(name + "-opposite");
112: oppReference.setEType(clazz);
113:• oppReference.setUpperBound(oppositeMany ? -1 : 1);
114: refClass.getEStructuralFeatures().add(oppReference);
115: reference.setEOpposite(oppReference);
116: oppReference.setEOpposite(reference);
117: }
118: clazz.getEStructuralFeatures().add(reference);
119: }
120:
121: @Test
122: public void test_refSingleNoOpp() {
123: createTestPackage();
124:
125: final String refToTest = "refSingleNoOpp";
126:
127: final EObject foo1 = EcoreUtil.create(fooClass);
128: final EObject foo2 = EcoreUtil.create(fooClass);
129: final EObject bar1 = EcoreUtil.create(barClass);
130: final EObject bar2 = EcoreUtil.create(barClass);
131:
132: foo1.eSet(fooClass.getEStructuralFeature("name"), "Foo 1");
133: foo2.eSet(fooClass.getEStructuralFeature("name"), "Foo 2");
134: bar1.eSet(barClass.getEStructuralFeature("name"), "Bar 1");
135: bar2.eSet(barClass.getEStructuralFeature("name"), "Bar 2");
136:
137: // fill reference
138: foo1.eSet(fooClass.getEStructuralFeature(refToTest), bar1);
139: foo2.eSet(fooClass.getEStructuralFeature(refToTest), bar2);
140:
141: // copy two objects
142: final Collection<EObject> original = Arrays.asList(foo1, foo2);
143: final Collection<EObject> copy = action.copy(original);
144: final Iterator<EObject> iterator = copy.iterator();
145: final EObject foo1Copy = iterator.next();
146: final EObject foo2Copy = iterator.next();
147:
148: // assert copy
149: final Object value1 = foo1Copy.eGet(fooClass.getEStructuralFeature(refToTest));
150: final Object value2 = foo2Copy.eGet(fooClass.getEStructuralFeature(refToTest));
151: assertSame(bar1, value1);
152: assertSame(bar2, value2);
153:
154: // assert old data
155: final Object orgValue1 = foo1.eGet(fooClass.getEStructuralFeature(refToTest));
156: final Object orgValue2 = foo2.eGet(fooClass.getEStructuralFeature(refToTest));
157: assertSame(bar1, orgValue1);
158: assertSame(bar2, orgValue2);
159: }
160:
161: @Test
162: public void test_refManyNoOpp() {
163: createTestPackage();
164: final String refToTest = "refManyNoOpp";
165: final EObject foo1 = EcoreUtil.create(fooClass);
166: final EObject foo2 = EcoreUtil.create(fooClass);
167: final EObject bar1 = EcoreUtil.create(barClass);
168: final EObject bar2 = EcoreUtil.create(barClass);
169: final List<EObject> bars1 = Arrays.asList(bar1, bar2);
170: final List<EObject> bars2 = Arrays.asList(bar1, bar2);
171:
172: foo1.eSet(fooClass.getEStructuralFeature("name"), "Foo 1");
173: foo2.eSet(fooClass.getEStructuralFeature("name"), "Foo 2");
174: bar1.eSet(barClass.getEStructuralFeature("name"), "Bar 1");
175: bar2.eSet(barClass.getEStructuralFeature("name"), "Bar 2");
176:
177: // fill reference
178: foo1.eSet(fooClass.getEStructuralFeature(refToTest), bars1);
179: foo2.eSet(fooClass.getEStructuralFeature(refToTest), bars2);
180:
181: // copy two objects
182: final Collection<EObject> original = Arrays.asList(foo1, foo2);
183: final Collection<EObject> copy = action.copy(original);
184: final Iterator<EObject> iterator = copy.iterator();
185: final EObject foo1Copy = iterator.next();
186: final EObject foo2Copy = iterator.next();
187:
188: // assert copy
189: final Object value1 = foo1Copy.eGet(fooClass.getEStructuralFeature(refToTest));
190: final Object value2 = foo2Copy.eGet(fooClass.getEStructuralFeature(refToTest));
191: assertArrayEquals(bars1.toArray(), asList(value1).toArray());
192: assertArrayEquals(bars2.toArray(), asList(value2).toArray());
193:
194: // assert old data
195: final Object orgValue1 = foo1.eGet(fooClass.getEStructuralFeature(refToTest));
196: final Object orgValue2 = foo2.eGet(fooClass.getEStructuralFeature(refToTest));
197: assertArrayEquals(bars1.toArray(), asList(orgValue1).toArray());
198: assertArrayEquals(bars2.toArray(), asList(orgValue2).toArray());
199: }
200:
201: @Test
202: public void test_refSingleOppSingle() {
203: createTestPackage();
204:
205: final String refToTest = "refSingleOppSingle";
206:
207: final EObject foo1 = EcoreUtil.create(fooClass);
208: final EObject foo2 = EcoreUtil.create(fooClass);
209: final EObject bar1 = EcoreUtil.create(barClass);
210: final EObject bar2 = EcoreUtil.create(barClass);
211:
212: foo1.eSet(fooClass.getEStructuralFeature("name"), "Foo 1");
213: foo2.eSet(fooClass.getEStructuralFeature("name"), "Foo 2");
214: bar1.eSet(barClass.getEStructuralFeature("name"), "Bar 1");
215: bar2.eSet(barClass.getEStructuralFeature("name"), "Bar 2");
216:
217: // fill reference
218: foo1.eSet(fooClass.getEStructuralFeature(refToTest), bar1);
219: foo2.eSet(fooClass.getEStructuralFeature(refToTest), bar2);
220:
221: // copy two objects
222: final Collection<EObject> original = Arrays.asList(foo1, foo2);
223: final Collection<EObject> copy = action.copy(original);
224: final Iterator<EObject> iterator = copy.iterator();
225: final EObject foo1Copy = iterator.next();
226: final EObject foo2Copy = iterator.next();
227:
228: // assert copy
229: final Object value1 = foo1Copy.eGet(fooClass.getEStructuralFeature(refToTest));
230: final Object value2 = foo2Copy.eGet(fooClass.getEStructuralFeature(refToTest));
231: assertNull(value1);
232: assertNull(value2);
233:
234: // assert old data
235: final Object orgValue1 = foo1.eGet(fooClass.getEStructuralFeature(refToTest));
236: final Object orgValue2 = foo2.eGet(fooClass.getEStructuralFeature(refToTest));
237: assertSame(bar1, orgValue1);
238: assertSame(bar2, orgValue2);
239:
240: final Object oppValue1 = bar1.eGet(barClass.getEStructuralFeature(refToTest + "-opposite"));
241: final Object oppValue2 = bar2.eGet(barClass.getEStructuralFeature(refToTest + "-opposite"));
242: assertSame(foo1, oppValue1);
243: assertSame(foo2, oppValue2);
244:
245: }
246:
247: @Test
248: public void test_refManyOppSingle() {
249: createTestPackage();
250: final String refToTest = "refManyOppSingle";
251: final EObject foo1 = EcoreUtil.create(fooClass);
252: final EObject foo2 = EcoreUtil.create(fooClass);
253: final EObject bar1 = EcoreUtil.create(barClass);
254: final EObject bar2 = EcoreUtil.create(barClass);
255: final List<EObject> bars1 = Arrays.asList(bar1);
256: final List<EObject> bars2 = Arrays.asList(bar2);
257:
258: foo1.eSet(fooClass.getEStructuralFeature("name"), "Foo 1");
259: foo2.eSet(fooClass.getEStructuralFeature("name"), "Foo 2");
260: bar1.eSet(barClass.getEStructuralFeature("name"), "Bar 1");
261: bar2.eSet(barClass.getEStructuralFeature("name"), "Bar 2");
262:
263: // fill reference
264: foo1.eSet(fooClass.getEStructuralFeature(refToTest), bars1);
265: foo2.eSet(fooClass.getEStructuralFeature(refToTest), bars2);
266:
267: // copy two objects
268: final Collection<EObject> original = Arrays.asList(foo1, foo2);
269: final Collection<EObject> copy = action.copy(original);
270: final Iterator<EObject> iterator = copy.iterator();
271: final EObject foo1Copy = iterator.next();
272: final EObject foo2Copy = iterator.next();
273:
274: // assert copy
275: final Object value1 = foo1Copy.eGet(fooClass.getEStructuralFeature(refToTest));
276: final Object value2 = foo2Copy.eGet(fooClass.getEStructuralFeature(refToTest));
277: assertEquals(0, asList(value1).size());
278: assertEquals(0, asList(value2).size());
279:
280: // assert old data
281: final Object orgValue1 = foo1.eGet(fooClass.getEStructuralFeature(refToTest));
282: final Object orgValue2 = foo2.eGet(fooClass.getEStructuralFeature(refToTest));
283: assertArrayEquals(bars1.toArray(), asList(orgValue1).toArray());
284: assertArrayEquals(bars2.toArray(), asList(orgValue2).toArray());
285:
286: final Object oppValue1 = bar1.eGet(barClass.getEStructuralFeature(refToTest + "-opposite"));
287: final Object oppValue2 = bar2.eGet(barClass.getEStructuralFeature(refToTest + "-opposite"));
288: assertSame(foo1, oppValue1);
289: assertSame(foo2, oppValue2);
290: }
291:
292: @Test
293: public void test_refSingleOppMany() {
294: createTestPackage();
295:
296: final String refToTest = "refSingleOppMany";
297:
298: final EObject foo1 = EcoreUtil.create(fooClass);
299: final EObject foo2 = EcoreUtil.create(fooClass);
300: final EObject bar1 = EcoreUtil.create(barClass);
301: final EObject bar2 = EcoreUtil.create(barClass);
302:
303: foo1.eSet(fooClass.getEStructuralFeature("name"), "Foo 1");
304: foo2.eSet(fooClass.getEStructuralFeature("name"), "Foo 2");
305: bar1.eSet(barClass.getEStructuralFeature("name"), "Bar 1");
306: bar2.eSet(barClass.getEStructuralFeature("name"), "Bar 2");
307:
308: // fill reference
309: foo1.eSet(fooClass.getEStructuralFeature(refToTest), bar1);
310: foo2.eSet(fooClass.getEStructuralFeature(refToTest), bar2);
311:
312: // copy two objects
313: final Collection<EObject> original = Arrays.asList(foo1, foo2);
314: final Collection<EObject> copy = action.copy(original);
315: final Iterator<EObject> iterator = copy.iterator();
316: final EObject foo1Copy = iterator.next();
317: final EObject foo2Copy = iterator.next();
318:
319: // assert copy
320: final Object value1 = foo1Copy.eGet(fooClass.getEStructuralFeature(refToTest));
321: final Object value2 = foo2Copy.eGet(fooClass.getEStructuralFeature(refToTest));
322: assertSame(bar1, value1);
323: assertSame(bar2, value2);
324:
325: // assert old data
326: final Object orgValue1 = foo1.eGet(fooClass.getEStructuralFeature(refToTest));
327: final Object orgValue2 = foo2.eGet(fooClass.getEStructuralFeature(refToTest));
328: assertSame(bar1, orgValue1);
329: assertSame(bar2, orgValue2);
330:
331: // we add the copy also to the many ref of the opposite
332: final Object oppValue1 = bar1.eGet(barClass.getEStructuralFeature(refToTest + "-opposite"));
333: final Object oppValue2 = bar2.eGet(barClass.getEStructuralFeature(refToTest + "-opposite"));
334: assertArrayEquals(new Object[] { foo1, foo1Copy }, asList(oppValue1).toArray());
335: assertArrayEquals(new Object[] { foo2, foo2Copy }, asList(oppValue2).toArray());
336: }
337:
338: @Test
339: public void test_refManyOppMany() {
340: createTestPackage();
341: final String refToTest = "refManyOppMany";
342: final EObject foo1 = EcoreUtil.create(fooClass);
343: final EObject foo2 = EcoreUtil.create(fooClass);
344: final EObject bar1 = EcoreUtil.create(barClass);
345: final EObject bar2 = EcoreUtil.create(barClass);
346: final List<EObject> bars1 = Arrays.asList(bar1);
347: final List<EObject> bars2 = Arrays.asList(bar2);
348:
349: foo1.eSet(fooClass.getEStructuralFeature("name"), "Foo 1");
350: foo2.eSet(fooClass.getEStructuralFeature("name"), "Foo 2");
351: bar1.eSet(barClass.getEStructuralFeature("name"), "Bar 1");
352: bar2.eSet(barClass.getEStructuralFeature("name"), "Bar 2");
353:
354: // fill reference
355: foo1.eSet(fooClass.getEStructuralFeature(refToTest), bars1);
356: foo2.eSet(fooClass.getEStructuralFeature(refToTest), bars2);
357:
358: // copy two objects
359: final Collection<EObject> original = Arrays.asList(foo1, foo2);
360: final Collection<EObject> copy = action.copy(original);
361: final Iterator<EObject> iterator = copy.iterator();
362: final EObject foo1Copy = iterator.next();
363: final EObject foo2Copy = iterator.next();
364:
365: // assert copy
366: final Object value1 = foo1Copy.eGet(fooClass.getEStructuralFeature(refToTest));
367: final Object value2 = foo2Copy.eGet(fooClass.getEStructuralFeature(refToTest));
368: assertArrayEquals(bars1.toArray(), asList(value1).toArray());
369: assertArrayEquals(bars2.toArray(), asList(value2).toArray());
370:
371: // assert old data
372: final Object orgValue1 = foo1.eGet(fooClass.getEStructuralFeature(refToTest));
373: final Object orgValue2 = foo2.eGet(fooClass.getEStructuralFeature(refToTest));
374: assertArrayEquals(bars1.toArray(), asList(orgValue1).toArray());
375: assertArrayEquals(bars2.toArray(), asList(orgValue2).toArray());
376:
377: // we add the copy also to the many ref of the opposite
378: final Object oppValue1 = bar1.eGet(barClass.getEStructuralFeature(refToTest + "-opposite"));
379: final Object oppValue2 = bar2.eGet(barClass.getEStructuralFeature(refToTest + "-opposite"));
380: assertArrayEquals(new Object[] { foo1, foo1Copy }, asList(oppValue1).toArray());
381: assertArrayEquals(new Object[] { foo2, foo2Copy }, asList(oppValue2).toArray());
382: }
383:
384: /**
385: * before copy:
386: * foo1 -> bar1
387: * foo2 -> bar2
388: * bar1 -> foo1
389: * bar2 -> foo2
390: *
391: * after copy:
392: * foo1 -> bar1, bar1Copy
393: * foo2 -> bar2, bar2Copy
394: * bar1 -> foo1, foo1Copy
395: * bar2 -> foo2, foo1Copy
396: *
397: * fooCopy1 -> bar1, bar1Copy
398: * fooCopy2 -> bar2, bar2Copy
399: * barCopy1 -> foo1, foo1Copy
400: * barCopy2 -> foo2, foo2Copy
401: */
402: @Test
403: public void test_refManyOppMany_both() {
404: createTestPackage();
405: final String refToTest = "refManyOppMany";
406: final EObject foo1 = EcoreUtil.create(fooClass);
407: final EObject foo2 = EcoreUtil.create(fooClass);
408: final EObject bar1 = EcoreUtil.create(barClass);
409: final EObject bar2 = EcoreUtil.create(barClass);
410: final List<EObject> bars1 = Arrays.asList(bar1);
411: final List<EObject> bars2 = Arrays.asList(bar2);
412:
413: foo1.eSet(fooClass.getEStructuralFeature("name"), "Foo 1");
414: foo2.eSet(fooClass.getEStructuralFeature("name"), "Foo 2");
415: bar1.eSet(barClass.getEStructuralFeature("name"), "Bar 1");
416: bar2.eSet(barClass.getEStructuralFeature("name"), "Bar 2");
417:
418: // fill reference
419: foo1.eSet(fooClass.getEStructuralFeature(refToTest), bars1);
420: foo2.eSet(fooClass.getEStructuralFeature(refToTest), bars2);
421:
422: // copy four objects
423: final Collection<EObject> original = Arrays.asList(foo1, foo2, bar1, bar2);
424: final Collection<EObject> copy = action.copy(original);
425: final Iterator<EObject> iterator = copy.iterator();
426: final EObject foo1Copy = iterator.next();
427: final EObject foo2Copy = iterator.next();
428: final EObject bar1Copy = iterator.next();
429: final EObject bar2Copy = iterator.next();
430:
431: // assert copy
432: {
433: final Object value1 = foo1Copy.eGet(fooClass.getEStructuralFeature(refToTest));
434: final Object value2 = foo2Copy.eGet(fooClass.getEStructuralFeature(refToTest));
435: final List<EObject> list1 = asList(value1);
436: final List<EObject> list2 = asList(value2);
437: assertEquals(2, list1.size());
438: assertEquals(2, list2.size());
439:
440: assertSame(bar1, list1.get(0));
441: assertSame(bar2, list2.get(0));
442: assertSame(bar1Copy, list1.get(1));
443: assertSame(bar2Copy, list2.get(1));
444: }
445: {
446: final Object value1 = bar1Copy.eGet(barClass.getEStructuralFeature(refToTest + "-opposite"));
447: final Object value2 = bar2Copy.eGet(barClass.getEStructuralFeature(refToTest + "-opposite"));
448: final List<EObject> list1 = asList(value1);
449: final List<EObject> list2 = asList(value2);
450: assertEquals(2, list1.size());
451: assertEquals(2, list2.size());
452:
453: assertSame(foo1, list1.get(0));
454: assertSame(foo2, list2.get(0));
455: assertSame(foo1Copy, list1.get(1));
456: assertSame(foo2Copy, list2.get(1));
457: }
458:
459: // assert old data
460: {
461: final Object orgValue1 = foo1.eGet(fooClass.getEStructuralFeature(refToTest));
462: final Object orgValue2 = foo2.eGet(fooClass.getEStructuralFeature(refToTest));
463: final List<EObject> list1 = asList(orgValue1);
464: final List<EObject> list2 = asList(orgValue2);
465: assertEquals(2, list1.size());
466: assertEquals(2, list2.size());
467:
468: assertSame(bar1, list1.get(0));
469: assertSame(bar2, list2.get(0));
470: assertSame(bar1Copy, list1.get(1));
471: assertSame(bar2Copy, list2.get(1));
472: }
473: // we add the copy also to the many ref of the opposite
474: {
475: final Object oppValue1 = bar1.eGet(barClass.getEStructuralFeature(refToTest + "-opposite"));
476: final Object oppValue2 = bar2.eGet(barClass.getEStructuralFeature(refToTest + "-opposite"));
477:
478: final List<EObject> list1 = asList(oppValue1);
479: final List<EObject> list2 = asList(oppValue2);
480: assertEquals(2, list1.size());
481: assertEquals(2, list2.size());
482:
483: assertSame(foo1, list1.get(0));
484: assertSame(foo1Copy, list1.get(1));
485: assertSame(foo2, list2.get(0));
486: assertSame(foo2Copy, list2.get(1));
487: }
488: }
489:
490: @Test
491: public void test_containmentSingleNoOpp() {
492: createTestPackage();
493:
494: final String refToTest = "containmentSingleNoOpp";
495:
496: final EObject foo1 = EcoreUtil.create(fooClass);
497: final EObject foo2 = EcoreUtil.create(fooClass);
498: final EObject bar1 = EcoreUtil.create(barClass);
499: final EObject bar2 = EcoreUtil.create(barClass);
500:
501: foo1.eSet(fooClass.getEStructuralFeature("name"), "Foo 1");
502: foo2.eSet(fooClass.getEStructuralFeature("name"), "Foo 2");
503: bar1.eSet(barClass.getEStructuralFeature("name"), "Bar 1");
504: bar2.eSet(barClass.getEStructuralFeature("name"), "Bar 2");
505:
506: // fill reference
507: foo1.eSet(fooClass.getEStructuralFeature(refToTest), bar1);
508: foo2.eSet(fooClass.getEStructuralFeature(refToTest), bar2);
509:
510: // copy two objects
511: final Collection<EObject> original = Arrays.asList(foo1, foo2);
512: final Collection<EObject> copy = action.copy(original);
513: final Iterator<EObject> iterator = copy.iterator();
514: final EObject foo1Copy = iterator.next();
515: final EObject foo2Copy = iterator.next();
516:
517: // assert copy
518: final Object value1 = foo1Copy.eGet(fooClass.getEStructuralFeature(refToTest));
519: final Object value2 = foo2Copy.eGet(fooClass.getEStructuralFeature(refToTest));
520: assertNotSame(bar1, value1);
521: assertNotSame(bar2, value2);
522: assertTrue(EcoreUtil.equals(bar1, (EObject) value1));
523: assertTrue(EcoreUtil.equals(bar2, (EObject) value2));
524:
525: // assert old data
526: final Object orgValue1 = foo1.eGet(fooClass.getEStructuralFeature(refToTest));
527: final Object orgValue2 = foo2.eGet(fooClass.getEStructuralFeature(refToTest));
528: assertSame(bar1, orgValue1);
529: assertSame(bar2, orgValue2);
530: }
531:
532: @Test
533: public void test_containmentManyNoOpp() {
534: createTestPackage();
535: final String refToTest = "containmentManyNoOpp";
536: final EObject foo1 = EcoreUtil.create(fooClass);
537: final EObject foo2 = EcoreUtil.create(fooClass);
538: final EObject bar10 = EcoreUtil.create(barClass);
539: final EObject bar11 = EcoreUtil.create(barClass);
540: final EObject bar20 = EcoreUtil.create(barClass);
541: final EObject bar21 = EcoreUtil.create(barClass);
542: final List<EObject> bars1 = Arrays.asList(bar10, bar11);
543: final List<EObject> bars2 = Arrays.asList(bar20, bar21);
544:
545: foo1.eSet(fooClass.getEStructuralFeature("name"), "Foo 1");
546: foo2.eSet(fooClass.getEStructuralFeature("name"), "Foo 2");
547: bar10.eSet(barClass.getEStructuralFeature("name"), "Bar 10");
548: bar11.eSet(barClass.getEStructuralFeature("name"), "Bar 11");
549: bar20.eSet(barClass.getEStructuralFeature("name"), "Bar 20");
550: bar21.eSet(barClass.getEStructuralFeature("name"), "Bar 21");
551:
552: // fill reference
553: foo1.eSet(fooClass.getEStructuralFeature(refToTest), bars1);
554: foo2.eSet(fooClass.getEStructuralFeature(refToTest), bars2);
555:
556: // copy two objects
557: final Collection<EObject> original = Arrays.asList(foo1, foo2);
558: final Collection<EObject> copy = action.copy(original);
559: final Iterator<EObject> iterator = copy.iterator();
560: final EObject foo1Copy = iterator.next();
561: final EObject foo2Copy = iterator.next();
562:
563: // assert copy
564: final Object value1 = foo1Copy.eGet(fooClass.getEStructuralFeature(refToTest));
565: final Object value2 = foo2Copy.eGet(fooClass.getEStructuralFeature(refToTest));
566: assertTrue(EcoreUtil.equals(bars1, asList(value1)));
567: assertTrue(EcoreUtil.equals(bars2, asList(value2)));
568:
569: // assert old data
570: final Object orgValue1 = foo1.eGet(fooClass.getEStructuralFeature(refToTest));
571: final Object orgValue2 = foo2.eGet(fooClass.getEStructuralFeature(refToTest));
572: assertArrayEquals(bars1.toArray(), asList(orgValue1).toArray());
573: assertArrayEquals(bars2.toArray(), asList(orgValue2).toArray());
574: }
575:
576: @Test
577: public void test_containmentSingleOppSingle() {
578: createTestPackage();
579:
580: final String refToTest = "containmentSingleOppSingle";
581:
582: final EObject foo1 = EcoreUtil.create(fooClass);
583: final EObject foo2 = EcoreUtil.create(fooClass);
584: final EObject bar1 = EcoreUtil.create(barClass);
585: final EObject bar2 = EcoreUtil.create(barClass);
586:
587: foo1.eSet(fooClass.getEStructuralFeature("name"), "Foo 1");
588: foo2.eSet(fooClass.getEStructuralFeature("name"), "Foo 2");
589: bar1.eSet(barClass.getEStructuralFeature("name"), "Bar 1");
590: bar2.eSet(barClass.getEStructuralFeature("name"), "Bar 2");
591:
592: // fill reference
593: foo1.eSet(fooClass.getEStructuralFeature(refToTest), bar1);
594: foo2.eSet(fooClass.getEStructuralFeature(refToTest), bar2);
595:
596: // copy two objects
597: final Collection<EObject> original = Arrays.asList(foo1, foo2);
598: final Collection<EObject> copy = action.copy(original);
599: final Iterator<EObject> iterator = copy.iterator();
600: final EObject foo1Copy = iterator.next();
601: final EObject foo2Copy = iterator.next();
602:
603: // assert copy
604: final Object value1 = foo1Copy.eGet(fooClass.getEStructuralFeature(refToTest));
605: final Object value2 = foo2Copy.eGet(fooClass.getEStructuralFeature(refToTest));
606: assertNotSame(bar1, value1);
607: assertNotSame(bar2, value2);
608: assertTrue(EcoreUtil.equals(bar1, (EObject) value1));
609: assertTrue(EcoreUtil.equals(bar2, (EObject) value2));
610:
611: final Object oppCopyValue1 = ((EObject) value1).eGet(barClass.getEStructuralFeature(refToTest + "-opposite"));
612: final Object oppCopyValue2 = ((EObject) value2).eGet(barClass.getEStructuralFeature(refToTest + "-opposite"));
613: assertSame(foo1Copy, oppCopyValue1);
614: assertSame(foo2Copy, oppCopyValue2);
615:
616: // assert old data
617: final Object orgValue1 = foo1.eGet(fooClass.getEStructuralFeature(refToTest));
618: final Object orgValue2 = foo2.eGet(fooClass.getEStructuralFeature(refToTest));
619: assertSame(bar1, orgValue1);
620: assertSame(bar2, orgValue2);
621:
622: final Object oppValue1 = bar1.eGet(barClass.getEStructuralFeature(refToTest + "-opposite"));
623: final Object oppValue2 = bar2.eGet(barClass.getEStructuralFeature(refToTest + "-opposite"));
624: assertSame(foo1, oppValue1);
625: assertSame(foo2, oppValue2);
626: }
627:
628: @Test
629: public void test_containmentManyOppSingle() {
630: createTestPackage();
631: final String refToTest = "containmentManyOppSingle";
632: final EObject foo1 = EcoreUtil.create(fooClass);
633: final EObject foo2 = EcoreUtil.create(fooClass);
634: final EObject bar10 = EcoreUtil.create(barClass);
635: final EObject bar11 = EcoreUtil.create(barClass);
636: final EObject bar20 = EcoreUtil.create(barClass);
637: final EObject bar21 = EcoreUtil.create(barClass);
638: final List<EObject> bars1 = Arrays.asList(bar10, bar11);
639: final List<EObject> bars2 = Arrays.asList(bar20, bar21);
640:
641: foo1.eSet(fooClass.getEStructuralFeature("name"), "Foo 1");
642: foo2.eSet(fooClass.getEStructuralFeature("name"), "Foo 2");
643: bar10.eSet(barClass.getEStructuralFeature("name"), "Bar 10");
644: bar11.eSet(barClass.getEStructuralFeature("name"), "Bar 11");
645: bar20.eSet(barClass.getEStructuralFeature("name"), "Bar 20");
646: bar21.eSet(barClass.getEStructuralFeature("name"), "Bar 21");
647:
648: // fill reference
649: foo1.eSet(fooClass.getEStructuralFeature(refToTest), bars1);
650: foo2.eSet(fooClass.getEStructuralFeature(refToTest), bars2);
651:
652: // copy two objects
653: final Collection<EObject> original = Arrays.asList(foo1, foo2);
654: final Collection<EObject> copy = action.copy(original);
655: final Iterator<EObject> iterator = copy.iterator();
656: final EObject foo1Copy = iterator.next();
657: final EObject foo2Copy = iterator.next();
658:
659: // assert copy
660: final Object value1 = foo1Copy.eGet(fooClass.getEStructuralFeature(refToTest));
661: final Object value2 = foo2Copy.eGet(fooClass.getEStructuralFeature(refToTest));
662: final List<EObject> copyBars1 = asList(value1);
663: final List<EObject> copyBars2 = asList(value2);
664: assertTrue(EcoreUtil.equals(bars1, copyBars1));
665: assertTrue(EcoreUtil.equals(bars2, copyBars2));
666:
667: assertTrue(EcoreUtil.equals(bars1.get(0), copyBars1.get(0)));
668: assertTrue(EcoreUtil.equals(bars1.get(1), copyBars1.get(1)));
669: assertTrue(EcoreUtil.equals(bars2.get(0), copyBars2.get(0)));
670: assertTrue(EcoreUtil.equals(bars2.get(1), copyBars2.get(1)));
671:
672: assertSame(foo1Copy, copyBars1.get(0).eGet(barClass.getEStructuralFeature(refToTest + "-opposite")));
673: assertSame(foo1Copy, copyBars1.get(1).eGet(barClass.getEStructuralFeature(refToTest + "-opposite")));
674: assertSame(foo2Copy, copyBars2.get(0).eGet(barClass.getEStructuralFeature(refToTest + "-opposite")));
675: assertSame(foo2Copy, copyBars2.get(1).eGet(barClass.getEStructuralFeature(refToTest + "-opposite")));
676:
677: // assert old data
678: final Object orgValue1 = foo1.eGet(fooClass.getEStructuralFeature(refToTest));
679: final Object orgValue2 = foo2.eGet(fooClass.getEStructuralFeature(refToTest));
680: assertArrayEquals(bars1.toArray(), asList(orgValue1).toArray());
681: assertArrayEquals(bars2.toArray(), asList(orgValue2).toArray());
682:
683: final Object oppValue10 = bar10.eGet(barClass.getEStructuralFeature(refToTest + "-opposite"));
684: final Object oppValue11 = bar11.eGet(barClass.getEStructuralFeature(refToTest + "-opposite"));
685: final Object oppValue20 = bar20.eGet(barClass.getEStructuralFeature(refToTest + "-opposite"));
686: final Object oppValue21 = bar21.eGet(barClass.getEStructuralFeature(refToTest + "-opposite"));
687: assertSame(foo1, oppValue10);
688: assertSame(foo1, oppValue11);
689: assertSame(foo2, oppValue20);
690: assertSame(foo2, oppValue21);
691: }
692:
693: @SuppressWarnings({ "unchecked", "rawtypes" })
694: private List<EObject> asList(Object value) {
695: return (List) value;
696: }
697:
698: }