|
1
7
22
23 package de.schlichtherle.key;
24
25 import java.util.logging.Logger  ;
26 import junit.framework.*;
27
28 import de.schlichtherle.key.passwd.swing.PromptingKeyManager;
29
30
33 public class KeyManagerTest extends TestCase {
34
35 private static final Logger logger = Logger.getLogger(
36 KeyManagerTest.class.getName());
37
38 private KeyManager instance;
39
40 public KeyManagerTest(String testName) {
41 super(testName);
42 }
43
44 protected void setUp() throws Exception {
45 instance = KeyManager.getInstance();
46 }
47
48 protected void tearDown() throws Exception {
49 }
50
51
54 public void testGetSetInstance() {
55 logger.fine("getSetInstance");
56
57 final KeyManager inst1 = KeyManager.getInstance();
58 assertNotNull(inst1);
59
60 KeyManager.setInstance(null);
61 final KeyManager inst2 = KeyManager.getInstance();
62 assertNotNull(inst2);
63 assertNotSame(inst1, inst2);
64
65 final KeyManager inst3 = new PromptingKeyManager();
66
67 KeyManager.setInstance(inst3);
68 final KeyManager inst4 = KeyManager.getInstance();
69 assertNotNull(inst4);
70
71 assertSame(inst3, inst4);
72 }
73
74
77 public void testGetSetKeyProvider() {
78 logger.fine("getSetKeyProvider");
79
80 final String idA = "getSetKeyProvider A";
81
82 final KeyProvider resA1 = instance.getKeyProvider(idA);
83 assertNotNull(resA1);
84
85 final KeyProvider resA2 = instance.getKeyProvider(idA);
86 assertSame(resA1, resA2);
87
88 final KeyProvider resA3 = instance.getKeyProvider(
89 idA, SucceedingKeyProvider.class);
90 assertSame(resA1, resA3);
91
92 final KeyProvider resA4 = new SucceedingKeyProvider();
93 try {
94 instance.setKeyProvider(null, resA4);
95 fail("A NullPointerException is expected from the previous call!");
96 } catch (NullPointerException exc) {
97 }
98 try {
99 instance.setKeyProvider(idA, null);
100 fail("A NullPointerException is expected from the previous call!");
101 } catch (NullPointerException exc) {
102 }
103 try {
104 instance.setKeyProvider(null, null);
105 fail("A NullPointerException is expected from the previous call!");
106 } catch (NullPointerException exc) {
107 }
108 instance.setKeyProvider(idA, resA4);
109
110 final KeyProvider resA5 = instance.getKeyProvider(idA);
111 assertSame(resA4, resA5);
112
113 final String idB = "getSetKeyProvider B";
114
115 final KeyProvider resB1 = instance.getKeyProvider(
116 idB, SucceedingKeyProvider.class);
117 assertNotNull(resB1);
118 assertNotSame(resA5, resB1);
119 assertTrue(resB1 instanceof SucceedingKeyProvider);
120
121 final String idC = "getSetKeyProvider C";
122
123 try {
124 final KeyProvider resC1 = instance.getKeyProvider(
125 idC, FailingKeyProvider.class);
126 fail("An IllegalArgumentException is expected from the previous call!");
127 } catch (IllegalArgumentException exc) {
128 }
129 }
130
131 static class SucceedingKeyProvider extends PromptingKeyProvider {
132 }
133
134
135 private static class FailingKeyProvider extends PromptingKeyProvider {
136 }
137
138
141 public void testResetKeyProvider() {
142 String resourceID = "resetKeyProvider";
143 logger.fine(resourceID);
144
145 final SimpleSharedKeyProvider provider
146 = (SimpleSharedKeyProvider) instance.getKeyProvider(
147 resourceID, SimpleSharedKeyProvider.class);
148 provider.reset = false;
149 boolean result = KeyManager.resetKeyProvider(resourceID);
150 assertTrue(result);
151 assertTrue(provider.reset);
152
153 assertSame(provider, instance.getKeyProvider(resourceID));
154 }
155
156 static class SimpleSharedKeyProvider extends AbstractKeyProvider {
157 public boolean reset;
158
159 public void invalidOpenKeyImpl() {
160 }
161
162 public void reset() {
163 reset = true;
164 }
165 }
166
167
170 public void testResetAndRemoveKeyProvider() {
171 logger.fine("resetAndRemoveKeyProvider");
172
173 final String resA = "resetAndRemoveKeyProvider A";
174 final String resB = "resetAndRemoveKeyProvider B";
175
176 final SimpleSharedKeyProvider provA1
177 = (SimpleSharedKeyProvider) instance.getKeyProvider(
178 resA, SimpleSharedKeyProvider.class);
179 provA1.reset = false;
180 boolean okA = KeyManager.resetAndRemoveKeyProvider(resA);
181 assertTrue(okA);
182 assertTrue(provA1.reset);
183
184 final KeyProvider provA2 = instance.getKeyProvider(resA);
185 assertNotNull(provA2);
186 assertNotSame(provA1, provA2);
187
188 final SimpleKeyProvider provB1
189 = (SimpleKeyProvider) instance.getKeyProvider(
190 resB, SimpleKeyProvider.class);
191 boolean okB = KeyManager.resetAndRemoveKeyProvider(resB);
192 assertTrue(okB);
193
194 final KeyProvider provB2 = instance.getKeyProvider(resB);
195 assertNotNull(provB2);
196 assertNotSame(provB1, provB2);
197 }
198
199 static class SimpleKeyProvider implements KeyProvider {
200 public Object getCreateKey() {
201 return this;
202 }
203
204 public Object getOpenKey() {
205 return this;
206 }
207
208 public void invalidOpenKey() {
209 }
210 }
211
212
215 public void testResetKeyProviders() {
216 logger.fine("resetKeyProviders");
217
218 final String resA = "resetKeyProviders A";
219 final String resB = "resetKeyProviders B";
220
221 final SimpleSharedKeyProvider provA
222 = (SimpleSharedKeyProvider) instance.getKeyProvider(
223 resA, SimpleSharedKeyProvider.class);
224 provA.reset = false;
225
226 final SimpleSharedKeyProvider provB
227 = (SimpleSharedKeyProvider) instance.getKeyProvider(
228 resB, SimpleSharedKeyProvider.class);
229 provB.reset = false;
230
231 KeyManager.resetKeyProviders();
232
233 assertTrue(provA.reset);
234 assertTrue(provB.reset);
235 }
236
237
240 public void testResetAndRemoveKeyProviders() {
241 logger.fine("resetAndRemoveKeyProviders");
242
243 final String resA = "resetAndRemoveKeyProviders A";
244 final String resB = "resetAndRemoveKeyProviders B";
245
246 final SimpleSharedKeyProvider provA1
247 = (SimpleSharedKeyProvider) instance.getKeyProvider(
248 resA, SimpleSharedKeyProvider.class);
249 provA1.reset = false;
250
251 final SimpleKeyProvider provB1
252 = (SimpleKeyProvider) instance.getKeyProvider(
253 resB, SimpleKeyProvider.class);
254
255 KeyManager.resetAndRemoveKeyProviders();
256 assertTrue(provA1.reset);
257
258 final KeyProvider provA2 = instance.getKeyProvider(resA);
259 assertNotNull(provA2);
260 assertNotSame(provA1, provA2);
261
262 final KeyProvider provB2 = instance.getKeyProvider(resB);
263 assertNotNull(provB2);
264 assertNotSame(provB1, provB2);
265 }
266
267
270 public void testMoveKeyProvider() {
271 logger.fine("moveKeyProvider");
272
273 String oldResourceID = "moveKeyProvider A";
274 String newResourceID = "moveKeyProvider B";
275
276 try {
277 KeyManager.moveKeyProvider(null, null);
278 fail("A NullPointerException is expected from the previous call!");
279 } catch (NullPointerException expected) {
280 }
281 try {
282 KeyManager.moveKeyProvider(oldResourceID, null);
283 fail("A NullPointerException is expected from the previous call!");
284 } catch (NullPointerException expected) {
285 }
286 try {
287 KeyManager.moveKeyProvider(null, newResourceID);
288 fail("A NullPointerException is expected from the previous call!");
289 } catch (NullPointerException expected) {
290 }
291 boolean result = KeyManager.moveKeyProvider(oldResourceID, newResourceID);
292 assertEquals(false, result);
294 final PromptingKeyProvider provA1
295 = (PromptingKeyProvider) instance.getKeyProvider(oldResourceID);
296 assertNotNull(provA1);
297 assertSame(oldResourceID, provA1.getResourceID());
298
299 result = KeyManager.moveKeyProvider(oldResourceID, newResourceID);
300 assertEquals(true, result);
301
302 final KeyProvider provA2 = instance.getKeyProvider(oldResourceID);
303 assertNotNull(provA2);
304
305 final PromptingKeyProvider provB1
306 = (PromptingKeyProvider) instance.getKeyProvider(newResourceID);
307 assertNotNull(provB1);
308 assertSame(provA1, provB1);
309 assertSame(newResourceID, provB1.getResourceID());
310 }
311 }
312 |
Popular Tags |
Java API By Example, From Geeks To Geeks.