1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
|
/*******************************************************************************
* Copyright (c) 2007 IBM Corporation and others. All rights reserved. This
* program and the accompanying materials are made available under the terms of
* the Eclipse Public License v1.0 which accompanies this distribution, and is
* available at http://www.eclipse.org/legal/epl-v10.html
*
* Contributors: IBM Corporation - initial API and implementation
******************************************************************************/
package org.eclipse.equinox.prov.tests;
import java.util.*;
import junit.framework.TestCase;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.equinox.prov.core.helpers.ServiceHelper;
import org.eclipse.equinox.prov.director.IDirector;
import org.eclipse.equinox.prov.engine.Profile;
import org.eclipse.equinox.prov.metadata.IInstallableUnit;
import org.eclipse.equinox.prov.metadata.RequiredCapability;
import org.eclipse.equinox.prov.metadata.repository.IMetadataRepository;
import org.eclipse.equinox.prov.metadata.repository.IMetadataRepositoryManager;
import org.eclipse.osgi.service.resolver.VersionRange;
import org.osgi.framework.Version;
/**
* Base class for provisioning tests with convenience methods used by multiple tests.
*/
public class AbstractProvisioningTest extends TestCase {
protected static VersionRange ANY_VERSION = new VersionRange(Version.emptyVersion, true, new Version(Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE), true);
/**
* Tracks the metadata repositories created by this test instance. The repositories
* will be removed automatically at the end of the test.
*/
private List metadataRepos = new ArrayList();
public AbstractProvisioningTest() {
super("");
}
public AbstractProvisioningTest(String name) {
super(name);
}
/**
* Asserts that the given profile contains *only* the given IUs.
*/
protected void assertProfileContains(String message, Profile profile, IInstallableUnit[] expectedUnits) {
HashSet expected = new HashSet(Arrays.asList(expectedUnits));
for (Iterator it = profile.getInstallableUnits(); it.hasNext();) {
IInstallableUnit actual = (IInstallableUnit) it.next();
if (!expected.remove(actual))
fail(message + " profile " + profile.getProfileId() + " contained an unexpected unit: " + actual);
}
if (!expected.isEmpty())
fail(message + " profile " + profile.getProfileId() + " did not contain expected units: " + expected);
}
/**
* Asserts that the given profile contains all the given IUs.
*/
protected void assertProfileContainsAll(String message, Profile profile, IInstallableUnit[] expectedUnits) {
HashSet expected = new HashSet(Arrays.asList(expectedUnits));
for (Iterator it = profile.getInstallableUnits(); it.hasNext();) {
IInstallableUnit actual = (IInstallableUnit) it.next();
expected.remove(actual);
}
if (!expected.isEmpty())
fail(message + " profile " + profile.getProfileId() + " did not contain expected units: " + expected);
}
/**
* Creates and returns a correctly formatted LDAP filter with the given key and value.
*/
protected String createFilter(String filterKey, String filterValue) {
return "(" + filterKey + '=' + filterValue + ')';
}
/**
* Creates and returns a required capability with the provided attributes.
*/
protected RequiredCapability[] createRequiredCapabilities(String namespace, String name, String filter) {
return createRequiredCapabilities(namespace, name, ANY_VERSION, filter);
}
/**
* Creates and returns a required capability with the provided attributes.
*/
protected RequiredCapability[] createRequiredCapabilities(String namespace, String name, VersionRange range, String filter) {
return new RequiredCapability[] {new RequiredCapability(namespace, name, range, filter, false, false)};
}
/**
* Adds a test metadata repository to the system that provides the given units.
* The repository will automatically be removed in the tearDown method.
*/
protected void createTestMetdataRepository(IInstallableUnit[] units) {
IMetadataRepository repo = new TestMetadataRepository(units);
IMetadataRepositoryManager repoMan = (IMetadataRepositoryManager) ServiceHelper.getService(TestActivator.getContext(), IMetadataRepositoryManager.class.getName());
assertNotNull(repoMan);
repoMan.addRepository(repo);
metadataRepos.add(repo);
}
/* (non-Javadoc)
* @see junit.framework.TestCase#tearDown()
*/
protected void tearDown() throws Exception {
super.tearDown();
//remove all metadata repositories created by this test
if (!metadataRepos.isEmpty()) {
IMetadataRepositoryManager repoMan = (IMetadataRepositoryManager) ServiceHelper.getService(TestActivator.getContext(), IMetadataRepositoryManager.class.getName());
for (Iterator it = metadataRepos.iterator(); it.hasNext();) {
IMetadataRepository repo = (IMetadataRepository) it.next();
repoMan.removeRepository(repo);
}
metadataRepos.clear();
}
}
public IDirector createDirector() {
return (IDirector) ServiceHelper.getService(TestActivator.getContext(), IDirector.class.getName());
}
public void printProfile(Profile toPrint) {
boolean containsIU = false;
for (Iterator iterator = toPrint.getInstallableUnits(); iterator.hasNext();) {
System.out.println(iterator.next());
containsIU = true;
}
if (!containsIU)
System.out.println("No iu");
}
public void assertEmptyProfile(Profile p) {
assertNotNull("The profile should not be null", p);
boolean containsIU = false;
for (Iterator iterator = p.getInstallableUnits(); iterator.hasNext();) {
containsIU = true;
}
if (containsIU)
fail("The profile should be empty,profileId=" + p);
}
protected void assertNotOK(IStatus result) {
if (result.getSeverity() != IStatus.OK)
return;
fail("The status should not have been OK");
}
protected void assertOK(IStatus result) {
if (result.getSeverity() == IStatus.OK)
return;
if (result instanceof MultiStatus) {
MultiStatus ms = (MultiStatus) result;
IStatus children[] = ms.getChildren();
for (int i = 0; i < children.length; i++) {
System.err.println(children[i]);
}
}
Throwable t = result.getException();
if (t != null)
t.printStackTrace();
fail(result.toString());
}
protected void assertNotIUs(IInstallableUnit[] ius, Iterator installableUnits) {
Set notexpected = new HashSet();
notexpected.addAll(Arrays.asList(ius));
while (installableUnits.hasNext()) {
IInstallableUnit next = (IInstallableUnit) installableUnits.next();
if (notexpected.contains(next)) {
fail("not expected [" + next + "]");
}
}
}
}
|
