![[Jenkins]](/ecp/static/e8bbdb94/images/svgs/logo.svg){kind=logo}
Package: ECPProjectManager_PTest$2
ECPProjectManager_PTest$2
| name | instruction | branch | complexity | line | method | ||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| projectsChanged(Collection, Collection) |
|
|
|
|
|
||||||||||||||||||||
| {...} |
|
|
|
|
|
||||||||||||||||||||
Coverage
1: /*******************************************************************************
2: * Copyright (c) 2011-2013 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: *******************************************************************************/
15: package org.eclipse.emf.ecp.core.test;
16:
17: import static org.junit.Assert.assertEquals;
18: import static org.junit.Assert.assertFalse;
19: import static org.junit.Assert.assertTrue;
20: import static org.junit.Assert.fail;
21:
22: import java.util.Collection;
23:
24: import org.eclipse.emf.ecore.EObject;
25: import org.eclipse.emf.ecore.EcoreFactory;
26: import org.eclipse.emf.ecp.core.ECPProject;
27: import org.eclipse.emf.ecp.core.ECPRepository;
28: import org.eclipse.emf.ecp.core.exceptions.ECPProjectWithNameExistsException;
29: import org.eclipse.emf.ecp.core.util.ECPProperties;
30: import org.eclipse.emf.ecp.core.util.ECPUtil;
31: import org.eclipse.emf.ecp.core.util.observer.ECPProjectOpenClosedObserver;
32: import org.eclipse.emf.ecp.core.util.observer.ECPProjectsChangedObserver;
33: import org.junit.Test;
34:
35: public class ECPProjectManager_PTest extends AbstractTest {
36:
37: private final String projectName = "name";
38:
39: @Test
40: public void createOfflineProjectTest() {
41: try {
42: final ECPProject project = getProjectManager().createProject(
43: getProvider(), projectName);
44: assertTrue(project != null);
45: assertEquals(project.getProvider(), getProvider());
46: assertEquals(project.getName(), projectName);
47: } catch (final ECPProjectWithNameExistsException e) {
48: fail();
49: }
50: }
51:
52: @Test(expected = ECPProjectWithNameExistsException.class)
53: public void createOfflineProjectWithExistingNameTest()
54: throws ECPProjectWithNameExistsException {
55:
56: final ECPProject project = getProjectManager().createProject(getProvider(),
57: projectName);
58: assertTrue(project != null);
59: assertEquals(project.getProvider(), getProvider());
60: assertEquals(project.getName(), projectName);
61:
62: getProjectManager().createProject(getProvider(), projectName);
63: }
64:
65: @Test
66: public void createOfflineProjectWithPropertiesTest() {
67: final ECPProperties properties = getNewProperties();
68: try {
69: final ECPProject project = getProjectManager().createProject(
70: getProvider(), projectName, properties);
71: assertTrue(project != null);
72: assertEquals(project.getName(), projectName);
73: assertEquals(project.getProvider(), getProvider());
74: assertEquals(project.getProperties(), properties);
75: } catch (final ECPProjectWithNameExistsException e) {
76: fail();
77: }
78: }
79:
80: @Test(expected = ECPProjectWithNameExistsException.class)
81: public void createOfflineProjectWithPropertiesAndExistingNameOffline()
82: throws ECPProjectWithNameExistsException {
83: final ECPProperties properties = getNewProperties();
84: final ECPProject project = getProjectManager().createProject(getProvider(),
85: projectName, properties);
86: assertTrue(project != null);
87: assertEquals(project.getName(), projectName);
88: assertEquals(project.getProvider(), getProvider());
89: assertEquals(project.getProperties(), properties);
90:
91: getProjectManager().createProject(getProvider(), projectName);
92: }
93:
94: @Test
95: public void createSharedProject() {
96: final ECPProperties properties = getNewProperties();
97: try {
98: final ECPProject project = getProjectManager().createProject(
99: getRepository(), projectName, properties);
100: assertTrue(project != null);
101: assertEquals(project.getName(), projectName);
102: assertEquals(project.getRepository(), getRepository());
103: assertEquals(project.getProperties(), properties);
104: } catch (final ECPProjectWithNameExistsException e) {
105: fail();
106: }
107: }
108:
109: @Test(expected = IllegalArgumentException.class)
110: public void createSharedProjectWithoutRepository() {
111: final ECPProperties properties = getNewProperties();
112: try {
113: getProjectManager().createProject(
114: (ECPRepository) null, projectName, properties);
115: fail("Null Repository not allowed.");
116: } catch (final ECPProjectWithNameExistsException e) {
117: fail();
118: }
119: }
120:
121: @Test(expected = ECPProjectWithNameExistsException.class)
122: public void createSharedWithExistingNameProject()
123: throws ECPProjectWithNameExistsException {
124: final ECPProperties properties = getNewProperties();
125: final ECPProject project = getProjectManager().createProject(getRepository(),
126: projectName, properties);
127: assertTrue(project != null);
128: assertEquals(project.getName(), projectName);
129: assertEquals(project.getRepository(), getRepository());
130: assertEquals(project.getProperties(), properties);
131:
132: getProjectManager().createProject(getRepository(), projectName,
133: properties);
134: }
135:
136: @Test
137: public void cloneProjectTest() {
138: ECPProject project = null;
139: try {
140: project = getProjectManager().createProject(
141: getProvider(), projectName);
142: } catch (final ECPProjectWithNameExistsException e) {
143: fail(e.getMessage());
144: }
145: getProjectManager().createProject(project, project.getName() + "Copy");
146: // TODO add correct assert
147: // assertTrue(project.equals(clonedProject));
148: }
149:
150: @Test
151: public void getProjectWithAdaptableNonECPProjectAwareTest() {
152:
153: }
154:
155: @Test
156: public void getProjectWithAdaptableECPProjectAwareTest() {
157:
158: }
159:
160: @Test
161: public void getProjectByNameTest() {
162: try {
163: final ECPProject project = getProjectManager().createProject(
164: getProvider(), projectName);
165: final ECPProject project2 = getProjectManager().getProject(projectName);
166: assertTrue(project == project2);
167: } catch (final ECPProjectWithNameExistsException e) {
168: fail();
169: }
170: }
171:
172: @Test
173: public void getProjectByItselfTest() {
174: try {
175: final ECPProject project = getProjectManager().createProject(
176: getProvider(), projectName);
177: final ECPProject project2 = getProjectManager().getProject(project);
178: assertTrue(project == project2);
179: } catch (final ECPProjectWithNameExistsException e) {
180: fail();
181: }
182: }
183:
184: @Test
185: public void getProjectByModelElementTest() {
186: try {
187: final ECPProject project = getProjectManager().createProject(
188: getProvider(), projectName);
189: final EObject object = EcoreFactory.eINSTANCE.createEObject();
190: project.getContents().add(object);
191:
192: final ECPProject project2 = getProjectManager().getProject(object);
193: assertTrue(project == project2);
194: } catch (final ECPProjectWithNameExistsException e) {
195: fail();
196: }
197: }
198:
199: @Test
200: public void getProjectsTest() {
201: try {
202: assertEquals(0, getProjectManager().getProjects().size());
203: final ECPProject project = getProjectManager().createProject(
204: getProvider(), projectName);
205: assertEquals(1, getProjectManager().getProjects().size());
206: final ECPProject project2 = getProjectManager().createProject(
207: getProvider(), projectName + "2");
208: assertEquals(2, getProjectManager().getProjects().size());
209: assertTrue(getProjectManager().getProjects().contains(project));
210: assertTrue(getProjectManager().getProjects().contains(project2));
211: } catch (final ECPProjectWithNameExistsException e) {
212: fail();
213: }
214: }
215:
216: @Test
217: public void getProjectByNameNonExistingTest() {
218: final ECPProject project = getProjectManager().getProject(projectName);
219: assertTrue(null == project);
220: }
221:
222: private boolean projectChangeObserverNotified;
223: private boolean projectOpenCloseObserverNotified;
224:
225: @Test
226: public void createProjectWithObservers() {
227: projectChangeObserverNotified = false;
228: projectOpenCloseObserverNotified = false;
229: ECPUtil.getECPObserverBus().register(new ECPProjectOpenClosedObserver() {
230:
231: @Override
232: public void projectChanged(ECPProject project, boolean opened) {
233: projectOpenCloseObserverNotified = true;
234:
235: }
236: });
237: ECPUtil.getECPObserverBus().register(new ECPProjectsChangedObserver() {
238:
239: @Override
240: public void projectsChanged(Collection<ECPProject> oldProjects,
241: Collection<ECPProject> newProjects) {
242: projectChangeObserverNotified = true;
243:
244: }
245: });
246:
247: try {
248: ECPUtil.getECPProjectManager().createProject(getProvider(), "TestProject");
249: } catch (final ECPProjectWithNameExistsException e) {
250: fail("Project does already exist");
251: }
252:
253: assertTrue(projectChangeObserverNotified);
254: assertFalse("Open Close Observer should not be notified", projectOpenCloseObserverNotified);
255: }
256:
257: }