1
2
3
4
5
6
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
212
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 }