1   /*
2    * Copyright (C) The MetaClass Group. All rights reserved.
3    *
4    * This software is published under the terms of the Spice
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.metaclass.tools.tasks;
9   
10  import java.io.File;
11  import java.io.FileInputStream;
12  import java.io.FileOutputStream;
13  import java.io.IOException;
14  import junit.framework.TestCase;
15  import org.apache.tools.ant.BuildException;
16  import org.apache.tools.ant.Project;
17  import org.apache.tools.ant.types.FileSet;
18  import org.codehaus.metaclass.io.MetaClassIO;
19  import org.codehaus.metaclass.io.MetaClassIOASM;
20  import org.codehaus.metaclass.io.MetaClassIOBinary;
21  import org.codehaus.metaclass.io.MetaClassIOXml;
22  import org.codehaus.metaclass.model.Attribute;
23  import org.codehaus.metaclass.model.ClassDescriptor;
24  import org.codehaus.metaclass.model.FieldDescriptor;
25  import org.codehaus.metaclass.model.MethodDescriptor;
26  import org.codehaus.metaclass.tools.compiler.ClassDescriptorCompiler;
27  import org.codehaus.metaclass.tools.compiler.JavaClassFilter;
28  import org.codehaus.metaclass.tools.qdox.DefaultQDoxAttributeInterceptor;
29  
30  /***
31   * @author Peter Donald
32   * @version $Revision: 1.29 $ $Date: 2003/12/11 08:41:51 $
33   */
34  public class MetaGenerateTaskTestCase
35      extends TestCase
36  {
37      public void testErrorGeneratingDescriptor()
38          throws Exception
39      {
40          final MockMetaGenerateTask task = new MockMetaGenerateTask();
41          task.setProject( new Project() );
42          task.errorGeneratingDescriptor( "foo", new Throwable() );
43      }
44  
45      public void testGetOutputDescriptionWithBinary()
46          throws Exception
47      {
48          final MockMetaGenerateTask task = new MockMetaGenerateTask();
49          final FormatEnum format = new FormatEnum();
50          format.setValue( "binary" );
51          task.setFormat( format );
52          assertEquals( "binary", task.getOutputDescription() );
53      }
54  
55      public void testGetOutputDescriptionWithXML()
56          throws Exception
57      {
58          final MockMetaGenerateTask task = new MockMetaGenerateTask();
59          final FormatEnum format = new FormatEnum();
60          format.setValue( "xml" );
61          task.setFormat( format );
62          assertEquals( "xml", task.getOutputDescription() );
63      }
64  
65      public void testGetMetaClassIOWithBinary()
66          throws Exception
67      {
68          final MockMetaGenerateTask task = new MockMetaGenerateTask();
69          final FormatEnum format = new FormatEnum();
70          format.setValue( "binary" );
71          task.setFormat( format );
72          task.setupTarget();
73          final ClassDescriptorCompiler compiler = task.getCompiler();
74          final MetaClassIO io = compiler.getMetaClassIO();
75          assertTrue( "compiler.getMetaClassIO instanceof Binary",
76                      io instanceof MetaClassIOBinary );
77      }
78  
79      public void testGetMetaClassIOWithXML()
80          throws Exception
81      {
82          final MockMetaGenerateTask task = new MockMetaGenerateTask();
83          final FormatEnum format = new FormatEnum();
84          format.setValue( "xml" );
85          task.setFormat( format );
86          task.setupTarget();
87          final ClassDescriptorCompiler compiler = task.getCompiler();
88          final MetaClassIO io = compiler.getMetaClassIO();
89          assertTrue( "compiler.getMetaClassIO instanceof XML",
90                      io instanceof MetaClassIOXml );
91      }
92  
93      public void testGetMetaClassIOWithClass()
94          throws Exception
95      {
96          final MockMetaGenerateTask task = new MockMetaGenerateTask();
97          final FormatEnum format = new FormatEnum();
98          format.setValue( "class" );
99          task.setFormat( format );
100         task.setupTarget();
101         final ClassDescriptorCompiler compiler = task.getCompiler();
102         final MetaClassIO io = compiler.getMetaClassIO();
103         assertTrue( "compiler.getMetaClassIO instanceof ASM",
104                     io instanceof MetaClassIOASM );
105     }
106 
107     public void testCreateFilterOfBadType()
108         throws Exception
109     {
110         final MockMetaGenerateTask task = new MockMetaGenerateTask();
111         task.setProject( new Project() );
112 
113         final PluginElement element = new PluginElement();
114         element.setName( MetaGenerateTaskTestCase.class.getName() );
115         try
116         {
117             task.createInstance( element, JavaClassFilter.class, "filter" );
118         }
119         catch( Exception e )
120         {
121             return;
122         }
123         fail( "Expected to fail to create badly typed filter." );
124     }
125 
126     public void testCreateFilterUsingBadClassname()
127         throws Exception
128     {
129         final MockMetaGenerateTask task = new MockMetaGenerateTask();
130         task.setProject( new Project() );
131 
132         final PluginElement element = new PluginElement();
133         element.setName( "noExist" );
134         try
135         {
136             task.createInstance( element, JavaClassFilter.class, "filter" );
137         }
138         catch( Exception e )
139         {
140             return;
141         }
142         fail( "Expected to fail to create badly named filter." );
143     }
144 
145     public void testCreateFilterUsingBadClassnameButSpecifyingClasspath()
146         throws Exception
147     {
148         final MockMetaGenerateTask task = new MockMetaGenerateTask();
149         final Project project = new Project();
150         task.setProject( project );
151 
152         final PluginElement element = new PluginElement();
153         element.setName( "noExist" );
154         final FileSet set = new FileSet();
155         set.setProject( project );
156         element.createClasspath().addFileset( set );
157         try
158         {
159             task.createInstance( element, JavaClassFilter.class, "filter" );
160         }
161         catch( Exception e )
162         {
163             return;
164         }
165         fail( "Expected to fail to create badly named filter." );
166     }
167 
168     public void testNullDestDir()
169         throws Exception
170     {
171         final MockMetaGenerateTask task = new MockMetaGenerateTask();
172         try
173         {
174             task.execute();
175         }
176         catch( final BuildException e )
177         {
178             assertEquals( "DestDir not specified", e.getMessage() );
179             return;
180         }
181         fail( "Expected execute to fail as no destdir specified." );
182     }
183 
184     public void testFileAsDestDir()
185         throws Exception
186     {
187         final MockMetaGenerateTask task = new MockMetaGenerateTask();
188         final File baseDirectory = getBaseDirectory();
189         final File destDir =
190             File.createTempFile( "mgtest", ".tmp", baseDirectory )
191             .getCanonicalFile();
192         task.setDestDir( destDir );
193         try
194         {
195             task.execute();
196         }
197         catch( final BuildException e )
198         {
199             assertEquals( "DestDir (" + destDir + ") is not a directory.",
200                           e.getMessage() );
201             return;
202         }
203         fail( "Expected execute to fail as destdir specified by file." );
204     }
205 
206     public void testDestDirNoExistAndNoCreate()
207         throws Exception
208     {
209         if( -1 != System.getProperty( "os.name" ).indexOf( "Windows" ) )
210         {
211             //Read-Only directorys still allow java to write
212             //to them under windows
213             return;
214         }
215         final MockMetaGenerateTask task = new MockMetaGenerateTask();
216         final File baseDirectory = getBaseDirectory();
217         final File secondBaseDir = new File( baseDirectory, "subDir1" );
218         secondBaseDir.mkdirs();
219         secondBaseDir.setReadOnly();
220         final File destDir = new File( secondBaseDir, "subDir" );
221         assertFalse( "destDir.exists()", destDir.exists() );
222 
223         task.setDestDir( destDir );
224         try
225         {
226             task.execute();
227         }
228         catch( final BuildException e )
229         {
230             assertEquals( "DestDir (" + destDir + ") could not be created.",
231                           e.getMessage() );
232             return;
233         }
234         fail( "Expected execute to fail as destdir could not be created." );
235     }
236 
237     public void testNoSourceFiles()
238         throws Exception
239     {
240         final File sourceDirectory = generateDirectory();
241         final File destDirectory = generateDirectory();
242         final FileSet fileSet = new FileSet();
243         fileSet.setDir( sourceDirectory );
244 
245         final MockMetaGenerateTask task = new MockMetaGenerateTask();
246         final Project project = new Project();
247         project.setBaseDir( getBaseDirectory() );
248         task.setProject( project );
249         task.setDestDir( destDirectory );
250         task.addFileset( fileSet );
251         task.execute();
252 
253         assertEquals( "generated dirs", 0, destDirectory.listFiles().length );
254     }
255 
256     public void testSingleSourceFile()
257         throws Exception
258     {
259         final String source =
260             "package com.biz;\n" +
261             "\n" +
262             "/**\n" +
263             " * @anAttribute\n" +
264             " */\n" +
265             "public class MyClass\n" +
266             "{\n" +
267             "}\n";
268 
269         final File sourceDirectory = generateDirectory();
270         final File destDirectory = generateDirectory();
271         final FileSet fileSet = new FileSet();
272         fileSet.setDir( sourceDirectory );
273         fileSet.setIncludes( "**/*.java" );
274 
275         final String sourceFilename =
276             sourceDirectory +
277             File.separator +
278             "com" +
279             File.separator +
280             "biz" +
281             File.separator +
282             "MyClass.java";
283         final File sourceFile = new File( sourceFilename );
284         sourceFile.getParentFile().mkdirs();
285         final FileOutputStream output = new FileOutputStream( sourceFile );
286         output.write( source.getBytes() );
287         output.close();
288 
289         final MockMetaGenerateTask task = new MockMetaGenerateTask();
290         final Project project = new Project();
291         project.setBaseDir( getBaseDirectory() );
292         task.setProject( project );
293         task.setNamespaceTagsOnly( false );
294         final FormatEnum format = new FormatEnum();
295         format.setValue( "binary" );
296         task.setFormat( format );
297         task.setKeepEmptyMethods( false );
298         task.setDestDir( destDirectory );
299         task.addFileset( fileSet );
300         task.execute();
301         final String destFilename =
302             destDirectory +
303             File.separator +
304             "com" +
305             File.separator +
306             "biz" +
307             File.separator +
308             "MyClass" +
309             MetaClassIOBinary.EXTENSION;
310         final File destFile = new File( destFilename );
311 
312         assertTrue( "destFile.exists()", destFile.exists() );
313         final MetaClassIOBinary io = new MetaClassIOBinary();
314         final FileInputStream input = new FileInputStream( destFile );
315         final ClassDescriptor descriptor = io.deserializeClass( input );
316         assertEquals( "descriptor.name",
317                       "com.biz.MyClass",
318                       descriptor.getName() );
319         assertEquals( "descriptor.attributes.length",
320                       1,
321                       descriptor.getAttributes().length );
322         assertEquals( "descriptor.attributes[0].name",
323                       "anAttribute",
324                       descriptor.getAttributes()[ 0 ].getName() );
325         assertEquals( "descriptor.methods.length",
326                       0,
327                       descriptor.getMethods().length );
328         assertEquals( "descriptor.fields.length",
329                       0,
330                       descriptor.getFields().length );
331     }
332 
333     public void testSingleSourceFileAsXML()
334         throws Exception
335     {
336         final String source =
337             "package com.biz;\n" +
338             "\n" +
339             "/**\n" +
340             " * @anAttribute\n" +
341             " */\n" +
342             "public class MyClass\n" +
343             "{\n" +
344             "}\n";
345 
346         final File sourceDirectory = generateDirectory();
347         final File destDirectory = generateDirectory();
348         final FileSet fileSet = new FileSet();
349         fileSet.setDir( sourceDirectory );
350         fileSet.setIncludes( "**/*.java" );
351 
352         final String sourceFilename =
353             sourceDirectory +
354             File.separator +
355             "com" +
356             File.separator +
357             "biz" +
358             File.separator +
359             "MyClass.java";
360         final File sourceFile = new File( sourceFilename );
361         sourceFile.getParentFile().mkdirs();
362         final FileOutputStream output = new FileOutputStream( sourceFile );
363         output.write( source.getBytes() );
364         output.close();
365 
366         final MockMetaGenerateTask task = new MockMetaGenerateTask();
367         final Project project = new Project();
368         project.setBaseDir( getBaseDirectory() );
369         task.setProject( project );
370         task.setNamespaceTagsOnly( false );
371         final FormatEnum format = new FormatEnum();
372         format.setValue( "xml" );
373         task.setFormat( format );
374         task.setDestDir( destDirectory );
375         task.addFileset( fileSet );
376         task.execute();
377         final String destFilename =
378             destDirectory +
379             File.separator +
380             "com" +
381             File.separator +
382             "biz" +
383             File.separator +
384             "MyClass" +
385             MetaClassIOXml.EXTENSION;
386         final File destFile = new File( destFilename );
387 
388         assertTrue( "destFile.exists()", destFile.exists() );
389         final FileInputStream input = new FileInputStream( destFile );
390         final ClassDescriptor descriptor = MetaClassIOXml.IO.deserializeClass(
391             input );
392         assertEquals( "descriptor.name",
393                       "com.biz.MyClass",
394                       descriptor.getName() );
395         assertEquals( "descriptor.attributes.length",
396                       1,
397                       descriptor.getAttributes().length );
398         assertEquals( "descriptor.attributes[0].name",
399                       "anAttribute",
400                       descriptor.getAttributes()[ 0 ].getName() );
401         assertEquals( "descriptor.methods.length",
402                       0,
403                       descriptor.getMethods().length );
404         assertEquals( "descriptor.fields.length",
405                       0,
406                       descriptor.getFields().length );
407     }
408 
409     public void testSingleSourceFileCompactedAway()
410         throws Exception
411     {
412         final String source =
413             "package com.biz;\n" +
414             "\n" +
415             "/**\n" +
416             " */\n" +
417             "public class MyClass\n" +
418             "{\n" +
419             "}\n";
420 
421         final File sourceDirectory = generateDirectory();
422         final File destDirectory = generateDirectory();
423         final FileSet fileSet = new FileSet();
424         fileSet.setDir( sourceDirectory );
425         fileSet.setIncludes( "**/*.java" );
426 
427         final String sourceFilename =
428             sourceDirectory +
429             File.separator +
430             "com" +
431             File.separator +
432             "biz" +
433             File.separator +
434             "MyClass.java";
435         final File sourceFile = new File( sourceFilename );
436         sourceFile.getParentFile().mkdirs();
437         final FileOutputStream output = new FileOutputStream( sourceFile );
438         output.write( source.getBytes() );
439         output.close();
440 
441         final MockMetaGenerateTask task = new MockMetaGenerateTask();
442         final Project project = new Project();
443         project.setBaseDir( getBaseDirectory() );
444         task.setProject( project );
445         task.setNamespaceTagsOnly( false );
446         task.setDestDir( destDirectory );
447         task.addFileset( fileSet );
448         task.execute();
449         final String destFilename =
450             destDirectory +
451             File.separator +
452             "com" +
453             File.separator +
454             "biz" +
455             File.separator +
456             "MyClass" +
457             MetaClassIOXml.EXTENSION;
458         final File destFile = new File( destFilename );
459 
460         assertTrue( "!destFile.exists()", !destFile.exists() );
461     }
462 
463     public void testSingleSourceFileInWrongDirectory()
464         throws Exception
465     {
466         final String source =
467             "package com.biz;\n" +
468             "\n" +
469             "/**\n" +
470             " * @anAttribute.baz\n" +
471             " */\n" +
472             "public class MyClass\n" +
473             "{\n" +
474             "}\n";
475 
476         final File sourceDirectory = generateDirectory();
477         final File destDirectory = generateDirectory();
478         final FileSet fileSet = new FileSet();
479         fileSet.setDir( sourceDirectory );
480         fileSet.setIncludes( "**/*.java" );
481 
482         final String sourceFilename =
483             sourceDirectory +
484             File.separator +
485             "com" +
486             File.separator +
487             "MyClass.java";
488         final File sourceFile = new File( sourceFilename );
489         sourceFile.getParentFile().mkdirs();
490         final FileOutputStream output = new FileOutputStream( sourceFile );
491         output.write( source.getBytes() );
492         output.close();
493 
494         final MockMetaGenerateTask task = new MockMetaGenerateTask();
495         final Project project = new Project();
496         project.setBaseDir( getBaseDirectory() );
497         task.setProject( project );
498         final FormatEnum format = new FormatEnum();
499         format.setValue( "binary" );
500         task.setFormat( format );
501         task.setDestDir( destDirectory );
502         task.addFileset( fileSet );
503         task.execute();
504         final String destFilename =
505             destDirectory +
506             File.separator +
507             "com" +
508             File.separator +
509             "biz" +
510             File.separator +
511             "MyClass" +
512             MetaClassIOBinary.EXTENSION;
513         final File destFile = new File( destFilename );
514 
515         assertTrue( "destFile.exists()", destFile.exists() );
516         final MetaClassIOBinary io = new MetaClassIOBinary();
517         final FileInputStream input = new FileInputStream( destFile );
518         final ClassDescriptor descriptor = io.deserializeClass( input );
519         assertEquals( "descriptor.name",
520                       "com.biz.MyClass",
521                       descriptor.getName() );
522         assertEquals( "descriptor.attributes.length",
523                       1,
524                       descriptor.getAttributes().length );
525         assertEquals( "descriptor.attributes[0].name",
526                       "anAttribute.baz",
527                       descriptor.getAttributes()[ 0 ].getName() );
528         assertEquals( "descriptor.methods.length",
529                       0,
530                       descriptor.getMethods().length );
531         assertEquals( "descriptor.fields.length",
532                       0,
533                       descriptor.getFields().length );
534     }
535 
536     public void testErrorWritingDescriptor()
537         throws Exception
538     {
539         final String source =
540             "package com.biz;\n" +
541             "\n" +
542             "/**\n" +
543             " * @anAttribute\n" +
544             " */\n" +
545             "public class MyClass\n" +
546             "{\n" +
547             "}\n";
548 
549         final Project project = new Project();
550 
551         final File sourceDirectory = generateDirectory();
552         final File destDirectory = generateDirectory();
553         final FileSet fileSet = new FileSet();
554         fileSet.setProject( project );
555         fileSet.setDir( sourceDirectory );
556         fileSet.setIncludes( "**/*.java" );
557 
558         final String sourceFilename =
559             sourceDirectory +
560             File.separator +
561             "com" +
562             File.separator +
563             "biz" +
564             File.separator +
565             "MyClass.java";
566         final File sourceFile = new File( sourceFilename );
567         sourceFile.getParentFile().mkdirs();
568         final FileOutputStream output = new FileOutputStream( sourceFile );
569         output.write( source.getBytes() );
570         output.close();
571 
572         final MockMetaGenerateTask task = new MockMetaGenerateTask();
573         project.setBaseDir( getBaseDirectory() );
574         task.setProject( project );
575         task.setDestDir( destDirectory );
576         task.setNamespaceTagsOnly( false );
577         task.addFileset( fileSet );
578         final ClassDescriptor descriptor =
579             new ClassDescriptor( "test",
580                                  Attribute.EMPTY_SET,
581                                  Attribute.EMPTY_SET,
582                                  FieldDescriptor.EMPTY_SET,
583                                  MethodDescriptor.EMPTY_SET );
584         task.errorWritingDescriptor( descriptor, new Exception() );
585         try
586         {
587             task.execute();
588         }
589         catch( BuildException e )
590         {
591             final String message = "Error generating ClassDescriptors";
592             assertEquals( message, e.getMessage() );
593             return;
594         }
595         fail( "Expected to fail executing task" );
596     }
597 
598     public void testMissingFile()
599         throws Exception
600     {
601         final String source =
602             "package com.biz;\n" +
603             "\n" +
604             "/**\n" +
605             " * @anAttribute\n" +
606             " */\n" +
607             "public class MyClass\n" +
608             "{\n" +
609             "}\n";
610 
611         final Project project = new Project();
612 
613         final File sourceDirectory = generateDirectory();
614         final File destDirectory = generateDirectory();
615         final FileSet fileSet = new FileSet();
616         fileSet.setProject( project );
617         fileSet.setDir( sourceDirectory );
618         fileSet.setIncludes( "**/*.java" );
619 
620         final String sourceFilename =
621             sourceDirectory +
622             File.separator +
623             "com" +
624             File.separator +
625             "biz" +
626             File.separator +
627             "MyClass.java";
628         final File sourceFile = new File( sourceFilename );
629         sourceFile.getParentFile().mkdirs();
630         final FileOutputStream output = new FileOutputStream( sourceFile );
631         output.write( source.getBytes() );
632         output.close();
633 
634         final MockMetaGenerateTask task = new MockMetaGenerateTask();
635         project.setBaseDir( getBaseDirectory() );
636         task.setProject( project );
637         task.setDestDir( destDirectory );
638         task.addFileset( fileSet );
639         task.setNamespaceTagsOnly( false );
640         task.missingSourceFile( new File( "." ) );
641         try
642         {
643             task.execute();
644         }
645         catch( BuildException e )
646         {
647             final String message = "Error generating ClassDescriptors";
648             assertEquals( message, e.getMessage() );
649             return;
650         }
651         fail( "Expected to fail executing task" );
652     }
653 
654     public void testSingleSourceFileWithPassThroughInterceptor()
655         throws Exception
656     {
657         final String source =
658             "package com.biz;\n" +
659             "\n" +
660             "/**\n" +
661             " * @anAttribute\n" +
662             " */\n" +
663             "public class MyClass\n" +
664             "{\n" +
665             "}\n";
666 
667         final Project project = new Project();
668 
669         final File sourceDirectory = generateDirectory();
670         final File destDirectory = generateDirectory();
671         final FileSet fileSet = new FileSet();
672         fileSet.setProject( project );
673         fileSet.setDir( sourceDirectory );
674         fileSet.setIncludes( "**/*.java" );
675 
676         final PluginElement element = new PluginElement();
677         element.setName( DefaultQDoxAttributeInterceptor.class.getName() );
678 
679         final String sourceFilename =
680             sourceDirectory +
681             File.separator +
682             "com" +
683             File.separator +
684             "biz" +
685             File.separator +
686             "MyClass.java";
687         final File sourceFile = new File( sourceFilename );
688         sourceFile.getParentFile().mkdirs();
689         final FileOutputStream output = new FileOutputStream( sourceFile );
690         output.write( source.getBytes() );
691         output.close();
692 
693         final MockMetaGenerateTask task = new MockMetaGenerateTask();
694         project.setBaseDir( getBaseDirectory() );
695         task.setProject( project );
696         task.setDestDir( destDirectory );
697         task.addFileset( fileSet );
698         final FormatEnum format = new FormatEnum();
699         format.setValue( "binary" );
700         task.setFormat( format );
701         task.setNamespaceTagsOnly( false );
702         task.addInterceptor( element );
703         task.addInterceptorSet( new InterceptorSet() );
704         task.execute();
705         final String destFilename =
706             destDirectory +
707             File.separator +
708             "com" +
709             File.separator +
710             "biz" +
711             File.separator +
712             "MyClass" +
713             MetaClassIOBinary.EXTENSION;
714         final File destFile = new File( destFilename );
715 
716         assertTrue( "destFile.exists()", destFile.exists() );
717         final MetaClassIOBinary io = new MetaClassIOBinary();
718         final FileInputStream input = new FileInputStream( destFile );
719         final ClassDescriptor descriptor = io.deserializeClass( input );
720         assertEquals( "descriptor.name",
721                       "com.biz.MyClass",
722                       descriptor.getName() );
723         assertEquals( "descriptor.attributes.length",
724                       1,
725                       descriptor.getAttributes().length );
726         assertEquals( "descriptor.attributes[0].name",
727                       "anAttribute",
728                       descriptor.getAttributes()[ 0 ].getName() );
729         assertEquals( "descriptor.methods.length",
730                       0,
731                       descriptor.getMethods().length );
732         assertEquals( "descriptor.fields.length",
733                       0,
734                       descriptor.getFields().length );
735     }
736 
737     public void testSingleSourceFileWithPassThroughFilter()
738         throws Exception
739     {
740         final String source =
741             "package com.biz;\n" +
742             "\n" +
743             "/**\n" +
744             " * @anAttribute\n" +
745             " */\n" +
746             "public class MyClass\n" +
747             "{\n" +
748             "}\n";
749 
750         final File sourceDirectory = generateDirectory();
751         final File destDirectory = generateDirectory();
752         final FileSet fileSet = new FileSet();
753         fileSet.setDir( sourceDirectory );
754         fileSet.setIncludes( "**/*.java" );
755 
756         final String sourceFilename =
757             sourceDirectory +
758             File.separator +
759             "com" +
760             File.separator +
761             "biz" +
762             File.separator +
763             "MyClass.java";
764         final File sourceFile = new File( sourceFilename );
765         sourceFile.getParentFile().mkdirs();
766         final FileOutputStream output = new FileOutputStream( sourceFile );
767         output.write( source.getBytes() );
768         output.close();
769 
770         final MockMetaGenerateTask task = new MockMetaGenerateTask();
771         final Project project = new Project();
772         project.setBaseDir( getBaseDirectory() );
773         task.setProject( project );
774         final FormatEnum format = new FormatEnum();
775         format.setValue( "binary" );
776         task.setFormat( format );
777         task.setDestDir( destDirectory );
778         task.addFileset( fileSet );
779         final PluginElement element = new PluginElement();
780         element.setName( PassThroughFilter.class.getName() );
781         task.addFilter( element );
782         task.addFilterSet( new FilterSet() );
783         task.setNamespaceTagsOnly( false );
784         task.execute();
785         final String destFilename =
786             destDirectory +
787             File.separator +
788             "com" +
789             File.separator +
790             "biz" +
791             File.separator +
792             "MyClass" +
793             MetaClassIOBinary.EXTENSION;
794         final File destFile = new File( destFilename );
795 
796         assertTrue( "destFile.exists()", destFile.exists() );
797         final MetaClassIOBinary io = new MetaClassIOBinary();
798         final FileInputStream input = new FileInputStream( destFile );
799         final ClassDescriptor descriptor = io.deserializeClass( input );
800         assertEquals( "descriptor.name",
801                       "com.biz.MyClass",
802                       descriptor.getName() );
803         assertEquals( "descriptor.attributes.length",
804                       1,
805                       descriptor.getAttributes().length );
806         assertEquals( "descriptor.attributes[0].name",
807                       "anAttribute",
808                       descriptor.getAttributes()[ 0 ].getName() );
809         assertEquals( "descriptor.methods.length",
810                       0,
811                       descriptor.getMethods().length );
812         assertEquals( "descriptor.fields.length",
813                       0,
814                       descriptor.getFields().length );
815     }
816 
817     private static final File generateDirectory()
818         throws IOException
819     {
820         final File baseDirectory = getBaseDirectory();
821         final File dir =
822             File.createTempFile( "mgtest", ".tmp", baseDirectory )
823             .getCanonicalFile();
824         dir.delete();
825         dir.mkdirs();
826         assertTrue( "dir.exists()", dir.exists() );
827         return dir;
828     }
829 
830     private static final File getBaseDirectory()
831     {
832         final String tempDir = System.getProperty( "java.io.tmpdir" );
833         final String baseDir = System.getProperty( "basedir", tempDir );
834 
835         final File base = new File( baseDir ).getAbsoluteFile();
836         final String pathname =
837             base + File.separator + "target" + File.separator + "test-data";
838         final File dir = new File( pathname );
839         dir.mkdirs();
840         return dir;
841     }
842 }