KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > codehaus > loom > components > util > monitor > DirectoryScannerTestCase


1 /*
2  * Copyright (C) The Loom Group. All rights reserved.
3  *
4  * This software is published under the terms of the Loom
5  * Software License version 1.1, a copy of which has been included
6  * with this distribution in the LICENSE.txt file.
7  */

8 package org.codehaus.loom.components.util.monitor;
9
10 import java.io.File JavaDoc;
11 import java.io.FileOutputStream JavaDoc;
12 import java.util.Iterator JavaDoc;
13
14 import junit.framework.TestCase;
15
16 /**
17  * Testcase for DirectoryScanner
18  *
19  * @author Johan Sjoberg
20  * @version $Revision: 1.3 $ $Date: 2004/10/11 20:12:28 $
21  */

22 public class DirectoryScannerTestCase extends TestCase
23 {
24     /**
25      * Test a completely empty directory with no changes done to it.
26      */

27     public void testNoChanges_1() throws Exception JavaDoc
28     {
29         File JavaDoc testDirectory = createTestDirectory();
30         MockDirectoryChangeListener changeListener =
31           new MockDirectoryChangeListener();
32
33         DirectoryScanner scanner = new DirectoryScanner();
34         scanner.setDirectory( testDirectory.getAbsolutePath() );
35         scanner.setDirectoryChangeListener( changeListener );
36         scanner.testModifiedAfter( System.currentTimeMillis() );
37
38         deleteDirectory( testDirectory );
39         if( !changeListener.m_fileSet.isEmpty() &&
40           !( 0 == changeListener.m_changeType ) )
41         {
42             fail( "Changes in were logged even if none suspected." );
43         }
44     }
45
46     /**
47      * Test a directory with some files in it, but with no changes
48      * done to it.
49      */

50     public void testNoChanges_2() throws Exception JavaDoc
51     {
52         File JavaDoc testDirectory = createTestDirectory();
53         createFile( testDirectory, "a.test" );
54         modifyFile( testDirectory, "a.test" );
55         createFile( testDirectory, "b.tst" );
56         createFile( testDirectory, "b.test" );
57         createFile( testDirectory, "c.test" );
58         createFile( testDirectory, ".test" );
59
60         MockDirectoryChangeListener changeListener =
61           new MockDirectoryChangeListener();
62         DirectoryScanner scanner = new DirectoryScanner();
63         scanner.setDirectory( testDirectory.getAbsolutePath() );
64         scanner.setDirectoryChangeListener( changeListener );
65         scanner.testModifiedAfter( System.currentTimeMillis() );
66
67         deleteDirectory( testDirectory );
68         if( !changeListener.m_fileSet.isEmpty() &&
69           !( 0 == changeListener.m_changeType ) )
70         {
71             fail( "Changes in were logged even if none suspected." );
72         }
73     }
74
75     /**
76      * Test addition of one file to an empty directory.
77      */

78     public void testAddition() throws Exception JavaDoc
79     {
80          File JavaDoc testDirectory = createTestDirectory();
81
82         MockDirectoryChangeListener changeListener =
83           new MockDirectoryChangeListener();
84         DirectoryScanner scanner = new DirectoryScanner();
85         scanner.setDirectory( testDirectory.getAbsolutePath() );
86         scanner.setDirectoryChangeListener( changeListener );
87
88         createFile( testDirectory, "a.txt" );
89         modifyFile( testDirectory, "a.txt" );
90
91         scanner.testModifiedAfter( System.currentTimeMillis() );
92
93         deleteDirectory( testDirectory );
94         if( !( 1 == changeListener.m_fileSet.size() ) &&
95           !( DirectoryChangeListener.ADDITION == changeListener.m_changeType ) )
96         {
97             fail( "Wrong type or number of changes." );
98         }
99         File JavaDoc changedFile = (File JavaDoc)changeListener.m_fileSet.iterator().next();
100         if( !( changedFile.getPath().endsWith( "a.txt" ) ) )
101         {
102             fail( "Wrong filename." );
103         }
104     }
105
106     /**
107      * Test removal of a file, leaving the directory empty.
108      */

109     public void testRemoval() throws Exception JavaDoc
110     {
111          File JavaDoc testDirectory = createTestDirectory();
112         createFile( testDirectory, "r.txt" );
113         modifyFile( testDirectory, "r.txt" );
114
115         MockDirectoryChangeListener changeListener =
116           new MockDirectoryChangeListener();
117         DirectoryScanner scanner = new DirectoryScanner();
118         scanner.setDirectory( testDirectory.getAbsolutePath() );
119         scanner.setDirectoryChangeListener( changeListener );
120
121         deleteFile( testDirectory, "r.txt" );
122         scanner.testModifiedAfter( System.currentTimeMillis() );
123
124         deleteDirectory( testDirectory );
125         if( !( 1 == changeListener.m_fileSet.size() ) &&
126           !( DirectoryChangeListener.REMOVAL == changeListener.m_changeType ) )
127         {
128             fail( "Wrong type or number of changes." );
129         }
130         File JavaDoc changedFile = (File JavaDoc)changeListener.m_fileSet.iterator().next();
131         if( !( changedFile.getPath().endsWith( "r.txt" ) ) )
132         {
133             fail( "Wrong filename." );
134         }
135     }
136
137     /**
138      * Test modification of a single file.
139      * <br/>
140      * To keep the tested <code>DirectoryScanner</code> from getting
141      * the same initial time as the change done to the file a pause of the
142      * running thread is needed. 500ms should do it, but here we go to
143      * sleep fo a whole second.
144      */

145     public void testModification() throws Exception JavaDoc
146     {
147         File JavaDoc testDirectory = createTestDirectory();
148         createFile( testDirectory, "m.txt" );
149         modifyFile( testDirectory, "m.txt" );
150
151         MockDirectoryChangeListener changeListener =
152           new MockDirectoryChangeListener();
153         DirectoryScanner scanner = new DirectoryScanner();
154         scanner.setDirectory( testDirectory.getAbsolutePath() );
155         scanner.setDirectoryChangeListener( changeListener );
156
157         Thread.sleep( 1000 );
158
159         modifyFile( testDirectory, "m.txt" );
160         scanner.testModifiedAfter( System.currentTimeMillis() );
161
162         deleteDirectory( testDirectory );
163         if( 1 != changeListener.m_fileSet.size() &&
164           DirectoryChangeListener.MODIFICATION != changeListener.m_changeType )
165         {
166             fail( "Wrong type or number of changes." );
167         }
168         File JavaDoc changedFile = (File JavaDoc)changeListener.m_fileSet.iterator().next();
169         if( !( changedFile.getPath().endsWith( "m.txt" ) ) )
170         {
171             fail( "Wrong filename." );
172         }
173     }
174
175     /**
176      * Test all operations on an already populated directory.
177      * <br/>
178      * The test consists of six parts; 1) creation and population
179      * of a test directory, 2) creation of the DirectoryScanner to
180      * test, 3) a file creation test, 4) a file modification test, 5)
181      * a file removal test and 6) removal of the test directory.
182      *
183      * @throws Exception an any kind of error or problem.
184      */

185     public void testAll() throws Exception JavaDoc
186     {
187         /** Iterator used holding changed files */
188         Iterator JavaDoc fileIterator;
189
190         File JavaDoc testDirectory = createTestDirectory();
191         createFile( testDirectory, "a.jar" );
192         createFile( testDirectory, "a.sar" );
193         createFile( testDirectory, "a.war" );
194         createFile( testDirectory, "a.bar" );
195
196         MockDirectoryChangeListener changeListener =
197           new MockDirectoryChangeListener();
198         DirectoryScanner scanner = new DirectoryScanner();
199         scanner.setDirectory( testDirectory.getAbsolutePath() );
200         scanner.setDirectoryChangeListener( changeListener );
201
202         // Test file creation
203
createFile( testDirectory, "a.txt" );
204         createFile( testDirectory, "b.txt" );
205         scanner.testModifiedAfter( System.currentTimeMillis() );
206         if( 2 != changeListener.m_fileSet.size() &&
207           DirectoryChangeListener.ADDITION != changeListener.m_changeType )
208         {
209             fail( "Wrong type or number of changes. Two additions expected." );
210         }
211         fileIterator = changeListener.m_fileSet.iterator();
212         File JavaDoc changedFile = (File JavaDoc)fileIterator.next();
213         if( ( changedFile.getPath().endsWith( "b.txt" ) ) )
214         {
215             File JavaDoc changedFile2 = (File JavaDoc)fileIterator.next();
216             if( !( changedFile2.getPath().endsWith( "a.txt" ) ) )
217             {
218                 fail( "Wrong filename in addition test, [a.txt] expected." );
219             }
220         }
221         else if( ( changedFile.getPath().endsWith( "a.txt" ) ) )
222         {
223             File JavaDoc changedFile2 = (File JavaDoc)fileIterator.next();
224             if( !( changedFile2.getPath().endsWith( "b.txt" ) ) )
225             {
226                 fail( "Wrong filename in addition test, [b.txt] expected." );
227             }
228         }
229         else
230         {
231             fail( "Wrong filename addition test, [a.txt] or [b.txt] expected." );
232         }
233
234         // Test file modification
235
modifyFile( testDirectory, "a.txt" );
236         modifyFile( testDirectory, "b.txt" );
237         scanner.testModifiedAfter( System.currentTimeMillis() );
238         if( 2 != changeListener.m_fileSet.size() &&
239           DirectoryChangeListener.MODIFICATION != changeListener.m_changeType )
240         {
241             fail( "Wrong type or number of changes. Two modifications expected." );
242         }
243         fileIterator = changeListener.m_fileSet.iterator();
244         changedFile = (File JavaDoc)fileIterator.next();
245         if( ( changedFile.getPath().endsWith( "b.txt" ) ) )
246         {
247             File JavaDoc changedFile2 = (File JavaDoc)fileIterator.next();
248             if( !( changedFile2.getPath().endsWith( "a.txt" ) ) )
249             {
250                 fail( "Wrong filename in modification test, [a.txt] expected." );
251             }
252         }
253         else if( ( changedFile.getPath().endsWith( "a.txt" ) ) )
254         {
255             File JavaDoc changedFile2 = (File JavaDoc)fileIterator.next();
256             if( !( changedFile2.getPath().endsWith( "b.txt" ) ) )
257             {
258                 fail( "Wrong filename in modification test, [b.txt] expected." );
259             }
260         }
261         else
262         {
263             fail( "Wrong filename modification test, [a.txt] or [b.txt] expected." );
264         }
265
266         // Test file removal
267
deleteFile( testDirectory, "a.txt" );
268         deleteFile( testDirectory, "b.txt" );
269         scanner.testModifiedAfter( System.currentTimeMillis() );
270         if( 2 != changeListener.m_fileSet.size() &&
271           DirectoryChangeListener.REMOVAL != changeListener.m_changeType )
272         {
273             fail( "Wrong type or number of changes. Two removals expected." );
274         }
275         fileIterator = changeListener.m_fileSet.iterator();
276         changedFile = (File JavaDoc)fileIterator.next();
277         if( ( changedFile.getPath().endsWith( "b.txt" ) ) )
278         {
279             File JavaDoc changedFile2 = (File JavaDoc)fileIterator.next();
280             if( !( changedFile2.getPath().endsWith( "a.txt" ) ) )
281             {
282                 fail( "Wrong filename in removal test, [a.txt] expected." );
283             }
284         }
285         else if( ( changedFile.getPath().endsWith( "a.txt" ) ) )
286         {
287             File JavaDoc changedFile2 = (File JavaDoc)fileIterator.next();
288             if( !( changedFile2.getPath().endsWith( "b.txt" ) ) )
289             {
290                 fail( "Wrong filename in removal test, [b.txt] expected." );
291             }
292         }
293         else
294         {
295             fail( "Wrong filename removal test, [a.txt] or [b.txt] expected." );
296         }
297
298         deleteDirectory( testDirectory );
299     }
300
301
302     /**
303      * Create a directory for testing
304      *
305      * @return A newly created test directory
306      */

307     private File JavaDoc createTestDirectory() throws Exception JavaDoc
308     {
309         String JavaDoc tempDirectoryName = System.getProperty( "java.io.tmpdir" );
310         String JavaDoc testDirectoryName = "loom_directory_scanner_testcase";
311         if( null != tempDirectoryName )
312         {
313             testDirectoryName = tempDirectoryName + "/" + testDirectoryName;
314         }
315         int counter = 0;
316         File JavaDoc testDirectory = new File JavaDoc( testDirectoryName );
317         while( testDirectory.exists() )
318         {
319             testDirectory = new File JavaDoc( testDirectoryName + "-" + counter++ );
320         }
321         testDirectory.deleteOnExit();
322         testDirectory.mkdirs();
323         return testDirectory;
324     }
325
326     /**
327      * Remove a test directory and all test files in it
328      */

329     private void deleteDirectory( File JavaDoc directory ) throws Exception JavaDoc
330     {
331         final File JavaDoc[] files = directory.listFiles();
332         for( int i = 0; i < files.length; i++ )
333         {
334             File JavaDoc file = files[i];
335             file.delete();
336         }
337         directory.delete();
338     }
339
340     /**
341      * Create a test file;
342      */

343     private void createFile( final File JavaDoc directory, final String JavaDoc name )
344         throws Exception JavaDoc
345     {
346         File JavaDoc newFile = new File JavaDoc( directory, name );
347         newFile.createNewFile();
348     }
349
350     /**
351      * Delete a test file
352      */

353     private void deleteFile( final File JavaDoc directory, final String JavaDoc name )
354         throws Exception JavaDoc
355     {
356         File JavaDoc file = new File JavaDoc( directory, name );
357         file.delete();
358     }
359
360     /**
361      * Modify a test file
362      */

363     private void modifyFile( final File JavaDoc directory, final String JavaDoc name )
364         throws Exception JavaDoc
365     {
366         File JavaDoc file = new File JavaDoc( directory, name );
367         FileOutputStream JavaDoc outStream = new FileOutputStream JavaDoc( file, true );
368         outStream.write( (byte)48 );
369         outStream.close();
370     }
371 }
372
Popular Tags