|
1
7
22
23 package de.schlichtherle.io;
24
25 import de.schlichtherle.io.archive.spi.ArchiveDriver;
26 import de.schlichtherle.io.archive.zip.Zip32Driver;
27 import java.io.ByteArrayInputStream  ;
28 import java.io.ByteArrayOutputStream ;
29 import java.io.IOException ;
30 import java.io.ObjectInputStream ;
31 import java.io.ObjectOutputStream ;
32 import java.util.logging.Logger ;
33 import junit.framework.*;
34
35
38 public class DefaultArchiveDetectorTest extends TestCase {
39
40 private static final Logger logger
41 = Logger.getLogger(DefaultArchiveDetectorTest.class.getName());
42
43 public DefaultArchiveDetectorTest(String testName) {
44 super(testName);
45 }
46
47 protected void setUp() throws Exception {
48 }
49
50 protected void tearDown() throws Exception {
51 }
52
53 public static Test suite() {
54 TestSuite suite = new TestSuite(DefaultArchiveDetectorTest.class);
55
56 return suite;
57 }
58
59 public void testIllegalConstructors() {
60 logger.fine("testIllegalConstructors");
61
62 try {
63 new DefaultArchiveDetector("xyz");
64 fail("Expected IllegalArgumentException");
65 } catch (IllegalArgumentException expected) {
66 }
67
68 try {
69 new DefaultArchiveDetector((String ) null, null);
70 fail("Expected NullPointerException");
71 } catch (NullPointerException expected) {
72 }
73 try {
74 new DefaultArchiveDetector(null, new Zip32Driver());
75 fail("Expected NullPointerException");
76 } catch (NullPointerException expected) {
77 }
78 try {
79 new DefaultArchiveDetector("xyz", null);
80 fail("Expected NullPointerException");
81 } catch (NullPointerException expected) {
82 }
83 try {
84 new DefaultArchiveDetector("", new Zip32Driver());
85 fail("Expected IllegalArgumentException");
86 } catch (IllegalArgumentException expected) {
87 }
88
89
90 try {
91 new DefaultArchiveDetector(null, null, null);
92 fail("Expected NullPointerException");
93 } catch (NullPointerException expected) {
94 }
95 try {
96 new DefaultArchiveDetector(null, null, new Zip32Driver());
97 fail("Expected NullPointerException");
98 } catch (NullPointerException expected) {
99 }
100 try {
101 new DefaultArchiveDetector(null, "xyz", null);
102 fail("Expected NullPointerException");
103 } catch (NullPointerException expected) {
104 }
105 try {
106 new DefaultArchiveDetector(null, "xyz", new Zip32Driver());
107 fail("Expected NullPointerException");
108 } catch (NullPointerException expected) {
109 }
110 try {
111 new DefaultArchiveDetector(ArchiveDetector.NULL, null, null);
112 fail("Expected NullPointerException");
113 } catch (NullPointerException expected) {
114 }
115 try {
116 new DefaultArchiveDetector(ArchiveDetector.NULL, null, new Zip32Driver());
117 fail("Expected NullPointerException");
118 } catch (NullPointerException expected) {
119 }
120 try {
121 new DefaultArchiveDetector(ArchiveDetector.NULL, "xyz", null);
122 fail("Expected NullPointerException");
123 } catch (NullPointerException expected) {
124 }
125 try {
126 new DefaultArchiveDetector(ArchiveDetector.NULL, "", new Zip32Driver());
127 fail("Expected IllegalArgumentException");
128 } catch (IllegalArgumentException expected) {
129 }
130
131 try {
132 new DefaultArchiveDetector(null, (Object []) null);
133 fail("Expected NullPointerException");
134 } catch (NullPointerException expected) {
135 }
136 try {
137 new DefaultArchiveDetector(null,
138 new Object [] { "xyz", Zip32Driver.class });
139 fail("Expected NullPointerException");
140 } catch (NullPointerException expected) {
141 }
142 try {
143 new DefaultArchiveDetector(ArchiveDetector.NULL,
144 (Object []) null);
145 fail("Expected NullPointerException");
146 } catch (NullPointerException expected) {
147 }
148 try {
149 new DefaultArchiveDetector(ArchiveDetector.NULL,
150 new Object [] { null, null });
151 fail("Expected NullPointerException");
152 } catch (NullPointerException expected) {
153 }
154 try {
155 new DefaultArchiveDetector(ArchiveDetector.NULL,
156 new Object [] { null, "xyz" });
157 fail("Expected NullPointerException");
158 } catch (NullPointerException expected) {
159 }
160 try {
161 new DefaultArchiveDetector(ArchiveDetector.NULL,
162 new Object [] { "xyz", null });
163 fail("Expected NullPointerException");
164 } catch (NullPointerException expected) {
165 }
166 try {
167 new DefaultArchiveDetector(ArchiveDetector.NULL,
168 new Object [] { "", "xyz" });
169 fail("Expected IllegalArgumentException");
170 } catch (IllegalArgumentException expected) {
171 }
172 try {
173 new DefaultArchiveDetector(ArchiveDetector.NULL,
174 new Object [] { "xyz", "" });
175 fail("Expected IllegalArgumentException");
176 } catch (IllegalArgumentException expected) {
177 }
178 try {
179 new DefaultArchiveDetector(ArchiveDetector.NULL,
180 new Object [] { Zip32Driver.class, "xyz" });
181 fail("Expected IllegalArgumentException");
182 } catch (IllegalArgumentException expected) {
183 }
184 try {
185 new DefaultArchiveDetector(ArchiveDetector.NULL,
186 new Object [] { new Zip32Driver(), "xyz" });
187 fail("Expected IllegalArgumentException");
188 } catch (IllegalArgumentException expected) {
189 }
190 try {
191 new DefaultArchiveDetector(ArchiveDetector.NULL,
192 new Object [] { "xyz", new Object () });
193 fail("Expected IllegalArgumentException");
194 } catch (IllegalArgumentException expected) {
195 }
196 try {
197 new DefaultArchiveDetector(ArchiveDetector.NULL,
198 new Object [] { "xyz", Object .class });
199 fail("Expected IllegalArgumentException");
200 } catch (IllegalArgumentException expected) {
201 }
202 }
203
204 public void testGetSuffixes() {
205 logger.fine("testGetSuffixes");
206
207 assertNull(ArchiveDetector.NULL.getSuffixes());
208 assertEquals("ear|jar|war|zip",
209 ArchiveDetector.DEFAULT.getSuffixes());
210 assertEquals("ear|exe|jar|tar|tar.bz2|tar.gz|tbz2|tgz|tzp|war|zip|zip.rae|zip.raes",
211 ArchiveDetector.ALL.getSuffixes());
212
213 testGetSuffixes(new String [] {
214 null, null,
215 null, "",
216 null, "|",
217 null, "|.",
218 "zip", "zip|",
219 "zip", "zip|zip",
220 "zip", "zip|.zip",
221 "zip", ".zip|",
222 "zip", ".zip|zip",
223 "zip", ".zip|.zip",
224 "zip", "zip|\\.zip",
225 "zip", "\\.zip|zip",
226 "zip", "\\.zip|\\.zip",
227 "zip", "ZIP|",
228 "zip", "ZIP|ZIP",
229 "zip", "ZIP|.ZIP",
230 "zip", ".ZIP|",
231 "zip", ".ZIP|ZIP",
232 "zip", ".ZIP|.ZIP",
233 "zip", "ZIP|\\.ZIP",
234 "zip", "\\.ZIP|ZIP",
235 "zip", "\\.ZIP|\\.ZIP",
236 "jar|zip", "JAR|ZIP",
237 "jar|zip", "ZIP|JAR",
238 });
239 }
240
241 private void testGetSuffixes(final String [] args) {
242 for (int i = 0; i < args.length; i++) {
243 final String expResult = args[i++];
244 final String suffixes = args[i];
245
246 DefaultArchiveDetector detector;
247
248 detector = new DefaultArchiveDetector(suffixes);
249 assertEquals(expResult, detector.getSuffixes());
250
251 if (suffixes != null && suffixes.length() > 0) {
252 detector = new DefaultArchiveDetector(suffixes, new Zip32Driver());
253 assertEquals(expResult, detector.getSuffixes());
254
255 detector = new DefaultArchiveDetector(
256 ArchiveDetector.NULL, suffixes, new Zip32Driver());
257 assertEquals(expResult, detector.getSuffixes());
258
259 detector = new DefaultArchiveDetector(
260 ArchiveDetector.NULL,
261 new Object [] { suffixes, new Zip32Driver() });
262 assertEquals(expResult, detector.getSuffixes());
263 }
264 }
265 }
266
267
270 public void testGetArchiveDriver() {
271 logger.fine("testGetArchiveDriver");
272
273 testGetArchiveDriver(ArchiveDetector.NULL, new Object [] {
274 null, "",
275 null, ".",
276 null, ".all",
277 null, ".default",
278 null, ".ear",
279 null, ".exe",
280 null, ".jar",
281 null, ".null",
282 null, ".tar",
283 null, ".tar.bz2",
284 null, ".tar.gz",
285 null, ".tbz2",
286 null, ".tgz",
287 null, ".tzp",
288 null, ".war",
289 null, ".z",
290 null, ".zip",
291 null, ".zip.rae",
292 null, ".zip.raes",
293 null, "test",
294 null, "test.",
295 null, "test.all",
296 null, "test.default",
297 null, "test.ear",
298 null, "test.exe",
299 null, "test.jar",
300 null, "test.null",
301 null, "test.tar",
302 null, "test.tar.bz2",
303 null, "test.tar.gz",
304 null, "test.tbz2",
305 null, "test.tgz",
306 null, "test.tzp",
307 null, "test.war",
308 null, "test.z",
309 null, "test.zip",
310 null, "test.zip.rae",
311 null, "test.zip.raes",
312 });
313
314 final ArchiveDriver earDriver = ArchiveDetector.ALL.getArchiveDriver("test.ear");
315 assertNotNull(earDriver);
316 final ArchiveDriver exeDriver = ArchiveDetector.ALL.getArchiveDriver("test.exe");
317 assertNotNull(exeDriver);
318 final ArchiveDriver jarDriver = ArchiveDetector.ALL.getArchiveDriver("test.jar");
319 assertNotNull(jarDriver);
320 final ArchiveDriver tarDriver = ArchiveDetector.ALL.getArchiveDriver("test.tar");
321 assertNotNull(tarDriver);
322 final ArchiveDriver tarBz2Driver = ArchiveDetector.ALL.getArchiveDriver("test.tar.bz2");
323 assertNotNull(tarBz2Driver);
324 final ArchiveDriver tarGzDriver = ArchiveDetector.ALL.getArchiveDriver("test.tar.gz");
325 assertNotNull(tarGzDriver);
326 final ArchiveDriver tbz2Driver = ArchiveDetector.ALL.getArchiveDriver("test.tbz2");
327 assertNotNull(tbz2Driver);
328 final ArchiveDriver tgzDriver = ArchiveDetector.ALL.getArchiveDriver("test.tgz");
329 assertNotNull(tgzDriver);
330 final ArchiveDriver tzpDriver = ArchiveDetector.ALL.getArchiveDriver("test.tzp");
331 assertNotNull(tzpDriver);
332 final ArchiveDriver warDriver = ArchiveDetector.ALL.getArchiveDriver("test.war");
333 assertNotNull(warDriver);
334 final ArchiveDriver zipDriver = ArchiveDetector.ALL.getArchiveDriver("test.zip");
335 assertNotNull(zipDriver);
336 final ArchiveDriver zipRaeDriver = ArchiveDetector.ALL.getArchiveDriver("test.zip.rae");
337 assertNotNull(zipRaeDriver);
338 final ArchiveDriver zipRaesDriver = ArchiveDetector.ALL.getArchiveDriver("test.zip.raes");
339 assertNotNull(zipRaesDriver);
340
341 testGetArchiveDriver(ArchiveDetector.DEFAULT, new Object [] {
342 null, "",
343 null, ".",
344 null, ".all",
345 null, ".default",
346 earDriver, ".ear",
347 null, ".exe",
348 jarDriver, ".jar",
349 null, ".null",
350 null, ".tar",
351 null, ".tar.bz2",
352 null, ".tar.gz",
353 null, ".tbz2",
354 null, ".tgz",
355 null, ".tzp",
356 warDriver, ".war",
357 null, ".z",
358 zipDriver, ".zip",
359 null, ".zip.rae",
360 null, ".zip.raes",
361 null, "test",
362 null, "test.",
363 null, "test.all",
364 null, "test.default",
365 earDriver, "test.ear",
366 null, "test.exe",
367 jarDriver, "test.jar",
368 null, "test.null",
369 null, "test.tar",
370 null, "test.tar.bz2",
371 null, "test.tar.gz",
372 null, "test.tbz2",
373 null, "test.tgz",
374 null, "test.tzp",
375 warDriver, "test.war",
376 null, "test.z",
377 zipDriver, "test.zip",
378 null, "test.zip.rae",
379 null, "test.zip.raes",
380 });
381
382 testGetArchiveDriver(ArchiveDetector.ALL, new Object [] {
383 null, "",
384 null, ".",
385 null, ".all",
386 null, ".default",
387 earDriver, ".ear",
388 exeDriver, ".exe",
389 jarDriver, ".jar",
390 null, ".null",
391 tarDriver, ".tar",
392 tarBz2Driver, ".tar.bz2",
393 tarGzDriver, ".tar.gz",
394 tbz2Driver, ".tbz2",
395 tgzDriver, ".tgz",
396 tzpDriver, ".tzp",
397 warDriver, ".war",
398 null, ".z",
399 zipDriver, ".zip",
400 zipRaeDriver, ".zip.rae",
401 zipRaesDriver, ".zip.raes",
402 null, "test",
403 null, "test.",
404 null, "test.all",
405 null, "test.default",
406 earDriver, "test.ear",
407 exeDriver, "test.exe",
408 jarDriver, "test.jar",
409 null, "test.null",
410 tarDriver, "test.tar",
411 tarBz2Driver, "test.tar.bz2",
412 tarGzDriver, "test.tar.gz",
413 tbz2Driver, "test.tbz2",
414 tgzDriver, "test.tgz",
415 tzpDriver, "test.tzp",
416 warDriver, "test.war",
417 null, "test.z",
418 zipDriver, "test.zip",
419 zipRaeDriver, "test.zip.rae",
420 zipRaesDriver, "test.zip.raes",
421 });
422 }
423
424 private void testGetArchiveDriver(DefaultArchiveDetector detector, final Object [] args) {
425 try {
426 detector.getArchiveDriver(null);
427 fail("Expected NullPointerException!");
428 } catch (NullPointerException expected) {
429 }
430
431 detector = new DefaultArchiveDetector(detector, new Object [] {
433 "foo", "java.lang.Object",
434 "bar", "java.io.FilterInputStream",
435 });
436 assertNull(detector.getArchiveDriver(".foo"));
437 assertNull(detector.getArchiveDriver("test.foo"));
438 assertNull(detector.getArchiveDriver(".bar"));
439 assertNull(detector.getArchiveDriver("test.bar"));
440
441 for (int i = 0; i < args.length; i++) {
442 final ArchiveDriver expResult = (ArchiveDriver) args[i++];
443 final String path = (String ) args[i];
444
445 ArchiveDriver driver;
446 driver = detector.getArchiveDriver(path);
447 assertSame(expResult, driver);
448
449 ArchiveDetector detector2;
450 detector2 = new DefaultArchiveDetector(detector, new Object [0]);
451 driver = detector2.getArchiveDriver(path);
452 assertSame(expResult, driver);
453 }
454 }
455
456 public void testSerialization() throws IOException , ClassNotFoundException {
457 logger.fine("testSerialization");
458
459 DefaultArchiveDetector detector = ArchiveDetector.DEFAULT;
461
462 final ByteArrayOutputStream bos = new ByteArrayOutputStream ();
464 final ObjectOutputStream out = new ObjectOutputStream (bos);
465 out.writeObject(detector);
466 out.close();
467
468 final ByteArrayInputStream bis = new ByteArrayInputStream (bos.toByteArray());
470 final ObjectInputStream in = new ObjectInputStream (bis);
471 final DefaultArchiveDetector detector2 = (DefaultArchiveDetector) in.readObject();
472 in.close();
473
474 assertNotSame(detector, detector2);
476 assertNotSame(detector.getSuffixes(), detector2.getSuffixes());
477 final Zip32Driver driver
478 = (Zip32Driver) detector.getArchiveDriver("foo.zip");
479 final Zip32Driver driver2
480 = (Zip32Driver) detector2.getArchiveDriver("bar.zip");
481 assertNotNull(driver);
482 assertNotNull(driver2);
483 assertNotSame(driver, driver2);
484 }
485 }
486 |
Popular Tags |
Java API By Example, From Geeks To Geeks.