001/*
002 *   Copyright (C) Christian Schulte, 2005-206
003 *   All rights reserved.
004 *
005 *   Redistribution and use in source and binary forms, with or without
006 *   modification, are permitted provided that the following conditions
007 *   are met:
008 *
009 *     o Redistributions of source code must retain the above copyright
010 *       notice, this list of conditions and the following disclaimer.
011 *
012 *     o Redistributions in binary form must reproduce the above copyright
013 *       notice, this list of conditions and the following disclaimer in
014 *       the documentation and/or other materials provided with the
015 *       distribution.
016 *
017 *   THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
018 *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
019 *   AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
020 *   THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT,
021 *   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
022 *   NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
023 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
024 *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
025 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
026 *   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
027 *
028 *   $JOMC: ClassFileProcessorTest.java 4579 2012-06-03 00:28:14Z schulte2005 $
029 *
030 */
031package org.jomc.tools.test;
032
033import java.io.File;
034import java.io.IOException;
035import java.io.InputStream;
036import java.io.OutputStream;
037import java.net.URISyntaxException;
038import java.net.URL;
039import java.net.URLClassLoader;
040import java.util.Arrays;
041import java.util.Collections;
042import java.util.List;
043import java.util.zip.ZipEntry;
044import java.util.zip.ZipInputStream;
045import javax.xml.bind.Marshaller;
046import javax.xml.bind.Unmarshaller;
047import javax.xml.transform.Transformer;
048import javax.xml.transform.TransformerConfigurationException;
049import javax.xml.transform.TransformerFactory;
050import javax.xml.transform.stream.StreamSource;
051import org.apache.bcel.classfile.ClassParser;
052import org.apache.bcel.classfile.JavaClass;
053import org.apache.commons.io.FileUtils;
054import org.apache.commons.io.IOUtils;
055import org.jomc.model.Dependency;
056import org.jomc.model.Implementation;
057import org.jomc.model.Message;
058import org.jomc.model.ModelObject;
059import org.jomc.model.Module;
060import org.jomc.model.Modules;
061import org.jomc.model.Multiplicity;
062import org.jomc.model.Property;
063import org.jomc.model.Specification;
064import org.jomc.model.modlet.DefaultModelProvider;
065import org.jomc.model.modlet.ModelHelper;
066import org.jomc.modlet.Model;
067import org.jomc.modlet.ModelContext;
068import org.jomc.modlet.ModelContextFactory;
069import org.jomc.modlet.ModelException;
070import org.jomc.modlet.ModelValidationReport;
071import org.jomc.tools.ClassFileProcessor;
072import org.jomc.tools.ResourceFileProcessor;
073import org.jomc.tools.SourceFileProcessor;
074import org.junit.Test;
075import static org.junit.Assert.assertNotNull;
076import static org.junit.Assert.assertTrue;
077import static org.junit.Assert.fail;
078
079/**
080 * Test cases for class {@code org.jomc.tools.ClassFileProcessor}.
081 *
082 * @author <a href="mailto:schulte2005@users.sourceforge.net">Christian Schulte</a>
083 * @version $JOMC: ClassFileProcessorTest.java 4579 2012-06-03 00:28:14Z schulte2005 $
084 */
085public class ClassFileProcessorTest extends JomcToolTest
086{
087
088    /** Creates a new {@code ClassFileProcessorTest} instance. */
089    public ClassFileProcessorTest()
090    {
091        super();
092    }
093
094    /** {@inheritDoc} */
095    @Override
096    public ClassFileProcessor getJomcTool()
097    {
098        return (ClassFileProcessor) super.getJomcTool();
099    }
100
101    /** {@inheritDoc} */
102    @Override
103    protected ClassFileProcessor newJomcTool()
104    {
105        return new ClassFileProcessor();
106    }
107
108    /** {@inheritDoc} */
109    @Override
110    protected Model newModel()
111    {
112        try
113        {
114            DefaultModelProvider.setDefaultModuleLocation( this.getClass().getPackage().getName().replace( '.', '/' )
115                                                           + "/jomc-tools.xml" );
116
117            Model m = this.getModelContext().findModel( ModelObject.MODEL_PUBLIC_ID );
118
119            if ( m != null )
120            {
121                final Modules modules = ModelHelper.getModules( m );
122
123                if ( modules != null )
124                {
125                    final Module cp = modules.getClasspathModule( Modules.getDefaultClasspathModuleName(),
126                                                                  this.getClass().getClassLoader() );
127
128                    if ( cp != null )
129                    {
130                        modules.getModule().add( cp );
131                    }
132                }
133
134                m = this.getModelContext().processModel( m );
135
136                if ( m != null )
137                {
138                    final ModelValidationReport validationReport = this.getModelContext().validateModel( m );
139
140                    for ( int i = 0, s0 = validationReport.getDetails().size(); i < s0; i++ )
141                    {
142                        System.out.println( validationReport.getDetails().get( i ) );
143                    }
144
145                    assertTrue( "Unexpected invalid '" + m.getIdentifier() + "' model.",
146                                validationReport.isModelValid() );
147
148                }
149            }
150
151            return m;
152        }
153        catch ( final ModelException e )
154        {
155            throw new AssertionError( e );
156        }
157        finally
158        {
159            DefaultModelProvider.setDefaultModuleLocation( null );
160        }
161    }
162
163    /**
164     * Gets a directory holding class files corresponding to the model of the instance.
165     *
166     * @return A directory holding class files corresponding to the model of the instance.
167     *
168     * @see #getNextOutputDirectory()
169     */
170    public final File getNextClassesDirectory()
171    {
172        try
173        {
174            final File classesDirectory = this.getNextOutputDirectory();
175            this.unzipResource( "classfiles.zip", classesDirectory );
176            return classesDirectory;
177        }
178        catch ( final IOException e )
179        {
180            throw new AssertionError( e );
181        }
182    }
183
184    @Test
185    public final void testClassFileProcessorNullPointerException() throws Exception
186    {
187        final Marshaller marshaller = this.getModelContext().createMarshaller( ModelObject.MODEL_PUBLIC_ID );
188        final Unmarshaller unmarshaller = this.getModelContext().createUnmarshaller( ModelObject.MODEL_PUBLIC_ID );
189        final URL object = this.getClass().getResource( "/java/lang/Object.class" );
190
191        InputStream in = null;
192        JavaClass objectClass = null;
193        boolean suppressExceptionOnClose = true;
194
195        try
196        {
197            in = object.openStream();
198            objectClass = new ClassParser( in, object.toExternalForm() ).parse();
199            suppressExceptionOnClose = false;
200        }
201        finally
202        {
203            try
204            {
205                if ( in != null )
206                {
207                    in.close();
208                }
209            }
210            catch ( final IOException e )
211            {
212                if ( !suppressExceptionOnClose )
213                {
214                    throw e;
215                }
216            }
217        }
218
219        try
220        {
221            this.getJomcTool().commitModelObjects( null, null );
222            fail( "Expected NullPointerException not thrown." );
223        }
224        catch ( final NullPointerException e )
225        {
226            assertNullPointerException( e );
227        }
228        try
229        {
230            this.getJomcTool().commitModelObjects( this.getModelContext(), null );
231            fail( "Expected NullPointerException not thrown." );
232        }
233        catch ( final NullPointerException e )
234        {
235            assertNullPointerException( e );
236        }
237
238        try
239        {
240            this.getJomcTool().commitModelObjects( (Implementation) null, (ModelContext) null, null );
241            fail( "Expected NullPointerException not thrown." );
242        }
243        catch ( final NullPointerException e )
244        {
245            assertNullPointerException( e );
246        }
247        try
248        {
249            this.getJomcTool().commitModelObjects( new Implementation(), (ModelContext) null, null );
250            fail( "Expected NullPointerException not thrown." );
251        }
252        catch ( final NullPointerException e )
253        {
254            assertNullPointerException( e );
255        }
256        try
257        {
258            this.getJomcTool().commitModelObjects( new Implementation(), this.getModelContext(), null );
259            fail( "Expected NullPointerException not thrown." );
260        }
261        catch ( final NullPointerException e )
262        {
263            assertNullPointerException( e );
264        }
265
266        try
267        {
268            this.getJomcTool().commitModelObjects( (Implementation) null, (Marshaller) null, null );
269            fail( "Expected NullPointerException not thrown." );
270        }
271        catch ( final NullPointerException e )
272        {
273            assertNullPointerException( e );
274        }
275        try
276        {
277            this.getJomcTool().commitModelObjects( new Implementation(), (Marshaller) null, null );
278            fail( "Expected NullPointerException not thrown." );
279        }
280        catch ( final NullPointerException e )
281        {
282            assertNullPointerException( e );
283        }
284        try
285        {
286            this.getJomcTool().commitModelObjects( new Implementation(), marshaller, null );
287            fail( "Expected NullPointerException not thrown." );
288        }
289        catch ( final NullPointerException e )
290        {
291            assertNullPointerException( e );
292        }
293
294        try
295        {
296            this.getJomcTool().commitModelObjects( (Module) null, null, null );
297            fail( "Expected NullPointerException not thrown." );
298        }
299        catch ( final NullPointerException e )
300        {
301            assertNullPointerException( e );
302        }
303        try
304        {
305            this.getJomcTool().commitModelObjects( new Module(), null, null );
306            fail( "Expected NullPointerException not thrown." );
307        }
308        catch ( final NullPointerException e )
309        {
310            assertNullPointerException( e );
311        }
312        try
313        {
314            this.getJomcTool().commitModelObjects( new Module(), this.getModelContext(), null );
315            fail( "Expected NullPointerException not thrown." );
316        }
317        catch ( final NullPointerException e )
318        {
319            assertNullPointerException( e );
320        }
321
322        try
323        {
324            this.getJomcTool().commitModelObjects( (Specification) null, (ModelContext) null, null );
325            fail( "Expected NullPointerException not thrown." );
326        }
327        catch ( final NullPointerException e )
328        {
329            assertNullPointerException( e );
330        }
331        try
332        {
333            this.getJomcTool().commitModelObjects( new Specification(), (ModelContext) null, null );
334            fail( "Expected NullPointerException not thrown." );
335        }
336        catch ( final NullPointerException e )
337        {
338            assertNullPointerException( e );
339        }
340        try
341        {
342            this.getJomcTool().commitModelObjects( new Specification(), this.getModelContext(), null );
343            fail( "Expected NullPointerException not thrown." );
344        }
345        catch ( final NullPointerException e )
346        {
347            assertNullPointerException( e );
348        }
349
350        try
351        {
352            this.getJomcTool().commitModelObjects( (Specification) null, (Marshaller) null, null );
353            fail( "Expected NullPointerException not thrown." );
354        }
355        catch ( final NullPointerException e )
356        {
357            assertNullPointerException( e );
358        }
359        try
360        {
361            this.getJomcTool().commitModelObjects( new Specification(), (Marshaller) null, null );
362            fail( "Expected NullPointerException not thrown." );
363        }
364        catch ( final NullPointerException e )
365        {
366            assertNullPointerException( e );
367        }
368        try
369        {
370            this.getJomcTool().commitModelObjects( new Specification(), marshaller, null );
371            fail( "Expected NullPointerException not thrown." );
372        }
373        catch ( final NullPointerException e )
374        {
375            assertNullPointerException( e );
376        }
377
378        try
379        {
380            this.getJomcTool().decodeModelObject( null, null, null );
381            fail( "Expected NullPointerException not thrown." );
382        }
383        catch ( final NullPointerException e )
384        {
385            assertNullPointerException( e );
386        }
387        try
388        {
389            this.getJomcTool().decodeModelObject( unmarshaller, null, null );
390            fail( "Expected NullPointerException not thrown." );
391        }
392        catch ( final NullPointerException e )
393        {
394            assertNullPointerException( e );
395        }
396        try
397        {
398            this.getJomcTool().decodeModelObject( unmarshaller, new byte[ 0 ], null );
399            fail( "Expected NullPointerException not thrown." );
400        }
401        catch ( final NullPointerException e )
402        {
403            assertNullPointerException( e );
404        }
405
406        try
407        {
408            this.getJomcTool().encodeModelObject( null, null );
409            fail( "Expected NullPointerException not thrown." );
410        }
411        catch ( final NullPointerException e )
412        {
413            assertNullPointerException( e );
414        }
415        try
416        {
417            this.getJomcTool().encodeModelObject( marshaller, null );
418            fail( "Expected NullPointerException not thrown." );
419        }
420        catch ( final NullPointerException e )
421        {
422            assertNullPointerException( e );
423        }
424
425        try
426        {
427            this.getJomcTool().getClassfileAttribute( null, null );
428            fail( "Expected NullPointerException not thrown." );
429        }
430        catch ( final NullPointerException e )
431        {
432            assertNullPointerException( e );
433        }
434        try
435        {
436            this.getJomcTool().getClassfileAttribute( objectClass, null );
437            fail( "Expected NullPointerException not thrown." );
438        }
439        catch ( final NullPointerException e )
440        {
441            assertNullPointerException( e );
442        }
443
444        try
445        {
446            this.getJomcTool().setClassfileAttribute( null, null, null );
447            fail( "Expected NullPointerException not thrown." );
448        }
449        catch ( final NullPointerException e )
450        {
451            assertNullPointerException( e );
452        }
453        try
454        {
455            this.getJomcTool().setClassfileAttribute( objectClass, null, null );
456            fail( "Expected NullPointerException not thrown." );
457        }
458        catch ( final NullPointerException e )
459        {
460            assertNullPointerException( e );
461        }
462
463        try
464        {
465            this.getJomcTool().transformModelObjects( null, null, null );
466            fail( "Expected NullPointerException not thrown." );
467        }
468        catch ( final NullPointerException e )
469        {
470            assertNullPointerException( e );
471        }
472        try
473        {
474            this.getJomcTool().transformModelObjects( this.getModelContext(), null, null );
475            fail( "Expected NullPointerException not thrown." );
476        }
477        catch ( final NullPointerException e )
478        {
479            assertNullPointerException( e );
480        }
481        try
482        {
483            this.getJomcTool().transformModelObjects( this.getModelContext(), new File( "/" ), null );
484            fail( "Expected NullPointerException not thrown." );
485        }
486        catch ( final NullPointerException e )
487        {
488            assertNullPointerException( e );
489        }
490
491        try
492        {
493            this.getJomcTool().transformModelObjects( (Module) null, null, null, null );
494            fail( "Expected NullPointerException not thrown." );
495        }
496        catch ( final NullPointerException e )
497        {
498            assertNullPointerException( e );
499        }
500        try
501        {
502            this.getJomcTool().transformModelObjects( new Module(), null, null, null );
503            fail( "Expected NullPointerException not thrown." );
504        }
505        catch ( final NullPointerException e )
506        {
507            assertNullPointerException( e );
508        }
509        try
510        {
511            this.getJomcTool().transformModelObjects( new Module(), this.getModelContext(), null, null );
512            fail( "Expected NullPointerException not thrown." );
513        }
514        catch ( final NullPointerException e )
515        {
516            assertNullPointerException( e );
517        }
518        try
519        {
520            this.getJomcTool().transformModelObjects( new Module(), this.getModelContext(), new File( "/" ), null );
521            fail( "Expected NullPointerException not thrown." );
522        }
523        catch ( final NullPointerException e )
524        {
525            assertNullPointerException( e );
526        }
527
528        try
529        {
530            this.getJomcTool().transformModelObjects( (Specification) null, null, null, null );
531            fail( "Expected NullPointerException not thrown." );
532        }
533        catch ( final NullPointerException e )
534        {
535            assertNullPointerException( e );
536        }
537        try
538        {
539            this.getJomcTool().transformModelObjects( new Specification(), null, null, null );
540            fail( "Expected NullPointerException not thrown." );
541        }
542        catch ( final NullPointerException e )
543        {
544            assertNullPointerException( e );
545        }
546        try
547        {
548            this.getJomcTool().transformModelObjects( new Specification(), this.getModelContext(), null, null );
549            fail( "Expected NullPointerException not thrown." );
550        }
551        catch ( final NullPointerException e )
552        {
553            assertNullPointerException( e );
554        }
555        try
556        {
557            this.getJomcTool().transformModelObjects(
558                new Specification(), this.getModelContext(), new File( "/" ), null );
559
560            fail( "Expected NullPointerException not thrown." );
561        }
562        catch ( final NullPointerException e )
563        {
564            assertNullPointerException( e );
565        }
566
567        try
568        {
569            this.getJomcTool().transformModelObjects( (Implementation) null, null, null, null );
570            fail( "Expected NullPointerException not thrown." );
571        }
572        catch ( final NullPointerException e )
573        {
574            assertNullPointerException( e );
575        }
576        try
577        {
578            this.getJomcTool().transformModelObjects( new Implementation(), null, null, null );
579            fail( "Expected NullPointerException not thrown." );
580        }
581        catch ( final NullPointerException e )
582        {
583            assertNullPointerException( e );
584        }
585        try
586        {
587            this.getJomcTool().transformModelObjects( new Implementation(), this.getModelContext(), null, null );
588            fail( "Expected NullPointerException not thrown." );
589        }
590        catch ( final NullPointerException e )
591        {
592            assertNullPointerException( e );
593        }
594        try
595        {
596            this.getJomcTool().transformModelObjects(
597                new Implementation(), this.getModelContext(), new File( "/" ), null );
598
599            fail( "Expected NullPointerException not thrown." );
600        }
601        catch ( final NullPointerException e )
602        {
603            assertNullPointerException( e );
604        }
605
606        try
607        {
608            this.getJomcTool().transformModelObjects( (Specification) null, null, null, null, null );
609            fail( "Expected NullPointerException not thrown." );
610        }
611        catch ( final NullPointerException e )
612        {
613            assertNullPointerException( e );
614        }
615        try
616        {
617            this.getJomcTool().transformModelObjects( new Specification(), null, null, null, null );
618            fail( "Expected NullPointerException not thrown." );
619        }
620        catch ( final NullPointerException e )
621        {
622            assertNullPointerException( e );
623        }
624        try
625        {
626            this.getJomcTool().transformModelObjects( new Specification(), marshaller, null, null, null );
627            fail( "Expected NullPointerException not thrown." );
628        }
629        catch ( final NullPointerException e )
630        {
631            assertNullPointerException( e );
632        }
633        try
634        {
635            this.getJomcTool().transformModelObjects( new Specification(), marshaller, unmarshaller, null, null );
636            fail( "Expected NullPointerException not thrown." );
637        }
638        catch ( final NullPointerException e )
639        {
640            assertNullPointerException( e );
641        }
642        try
643        {
644            this.getJomcTool().transformModelObjects( new Specification(), marshaller, unmarshaller, objectClass, null );
645            fail( "Expected NullPointerException not thrown." );
646        }
647        catch ( final NullPointerException e )
648        {
649            assertNullPointerException( e );
650        }
651
652        try
653        {
654            this.getJomcTool().transformModelObjects( (Implementation) null, null, null, null, null );
655            fail( "Expected NullPointerException not thrown." );
656        }
657        catch ( final NullPointerException e )
658        {
659            assertNullPointerException( e );
660        }
661        try
662        {
663            this.getJomcTool().transformModelObjects( new Implementation(), null, null, null, null );
664            fail( "Expected NullPointerException not thrown." );
665        }
666        catch ( final NullPointerException e )
667        {
668            assertNullPointerException( e );
669        }
670        try
671        {
672            this.getJomcTool().transformModelObjects( new Implementation(), marshaller, null, null, null );
673            fail( "Expected NullPointerException not thrown." );
674        }
675        catch ( final NullPointerException e )
676        {
677            assertNullPointerException( e );
678        }
679        try
680        {
681            this.getJomcTool().transformModelObjects( new Implementation(), marshaller, unmarshaller, null, null );
682            fail( "Expected NullPointerException not thrown." );
683        }
684        catch ( final NullPointerException e )
685        {
686            assertNullPointerException( e );
687        }
688        try
689        {
690            this.getJomcTool().transformModelObjects( new Implementation(), marshaller, unmarshaller, objectClass, null );
691            fail( "Expected NullPointerException not thrown." );
692        }
693        catch ( final NullPointerException e )
694        {
695            assertNullPointerException( e );
696        }
697
698        try
699        {
700            this.getJomcTool().validateModelObjects( null );
701            fail( "Expected NullPointerException not thrown." );
702        }
703        catch ( final NullPointerException e )
704        {
705            assertNullPointerException( e );
706        }
707
708        try
709        {
710            this.getJomcTool().validateModelObjects( null, (File) null );
711            fail( "Expected NullPointerException not thrown." );
712        }
713        catch ( final NullPointerException e )
714        {
715            assertNullPointerException( e );
716        }
717        try
718        {
719            this.getJomcTool().validateModelObjects( this.getModelContext(), (File) null );
720            fail( "Expected NullPointerException not thrown." );
721        }
722        catch ( final NullPointerException e )
723        {
724            assertNullPointerException( e );
725        }
726
727        try
728        {
729            this.getJomcTool().validateModelObjects( (Module) null, null );
730            fail( "Expected NullPointerException not thrown." );
731        }
732        catch ( final NullPointerException e )
733        {
734            assertNullPointerException( e );
735        }
736        try
737        {
738            this.getJomcTool().validateModelObjects( new Module(), null );
739            fail( "Expected NullPointerException not thrown." );
740        }
741        catch ( final NullPointerException e )
742        {
743            assertNullPointerException( e );
744        }
745
746        try
747        {
748            this.getJomcTool().validateModelObjects( (Module) null, null, (File) null );
749            fail( "Expected NullPointerException not thrown." );
750        }
751        catch ( final NullPointerException e )
752        {
753            assertNullPointerException( e );
754        }
755        try
756        {
757            this.getJomcTool().validateModelObjects( new Module(), null, (File) null );
758            fail( "Expected NullPointerException not thrown." );
759        }
760        catch ( final NullPointerException e )
761        {
762            assertNullPointerException( e );
763        }
764        try
765        {
766            this.getJomcTool().validateModelObjects( new Module(), this.getModelContext(), (File) null );
767            fail( "Expected NullPointerException not thrown." );
768        }
769        catch ( final NullPointerException e )
770        {
771            assertNullPointerException( e );
772        }
773
774        try
775        {
776            this.getJomcTool().validateModelObjects( (Specification) null, null );
777            fail( "Expected NullPointerException not thrown." );
778        }
779        catch ( final NullPointerException e )
780        {
781            assertNullPointerException( e );
782        }
783        try
784        {
785            this.getJomcTool().validateModelObjects( new Specification(), null );
786            fail( "Expected NullPointerException not thrown." );
787        }
788        catch ( final NullPointerException e )
789        {
790            assertNullPointerException( e );
791        }
792
793        try
794        {
795            this.getJomcTool().validateModelObjects( (Specification) null, (ModelContext) null, null );
796            fail( "Expected NullPointerException not thrown." );
797        }
798        catch ( final NullPointerException e )
799        {
800            assertNullPointerException( e );
801        }
802        try
803        {
804            this.getJomcTool().validateModelObjects( new Specification(), (ModelContext) null, null );
805            fail( "Expected NullPointerException not thrown." );
806        }
807        catch ( final NullPointerException e )
808        {
809            assertNullPointerException( e );
810        }
811        try
812        {
813            this.getJomcTool().validateModelObjects( new Specification(), this.getModelContext(), null );
814            fail( "Expected NullPointerException not thrown." );
815        }
816        catch ( final NullPointerException e )
817        {
818            assertNullPointerException( e );
819        }
820
821        try
822        {
823            this.getJomcTool().validateModelObjects( (Implementation) null, null );
824            fail( "Expected NullPointerException not thrown." );
825        }
826        catch ( final NullPointerException e )
827        {
828            assertNullPointerException( e );
829        }
830        try
831        {
832            this.getJomcTool().validateModelObjects( new Implementation(), null );
833            fail( "Expected NullPointerException not thrown." );
834        }
835        catch ( final NullPointerException e )
836        {
837            assertNullPointerException( e );
838        }
839
840        try
841        {
842            this.getJomcTool().validateModelObjects( (Implementation) null, (ModelContext) null, null );
843            fail( "Expected NullPointerException not thrown." );
844        }
845        catch ( final NullPointerException e )
846        {
847            assertNullPointerException( e );
848        }
849        try
850        {
851            this.getJomcTool().validateModelObjects( new Implementation(), (ModelContext) null, null );
852            fail( "Expected NullPointerException not thrown." );
853        }
854        catch ( final NullPointerException e )
855        {
856            assertNullPointerException( e );
857        }
858        try
859        {
860            this.getJomcTool().validateModelObjects( new Implementation(), this.getModelContext(), null );
861            fail( "Expected NullPointerException not thrown." );
862        }
863        catch ( final NullPointerException e )
864        {
865            assertNullPointerException( e );
866        }
867
868        try
869        {
870            this.getJomcTool().validateModelObjects( (Specification) null, (Unmarshaller) null, null );
871            fail( "Expected NullPointerException not thrown." );
872        }
873        catch ( final NullPointerException e )
874        {
875            assertNullPointerException( e );
876        }
877        try
878        {
879            this.getJomcTool().validateModelObjects( new Specification(), (Unmarshaller) null, null );
880            fail( "Expected NullPointerException not thrown." );
881        }
882        catch ( final NullPointerException e )
883        {
884            assertNullPointerException( e );
885        }
886        try
887        {
888            this.getJomcTool().validateModelObjects( new Specification(), unmarshaller, null );
889            fail( "Expected NullPointerException not thrown." );
890        }
891        catch ( final NullPointerException e )
892        {
893            assertNullPointerException( e );
894        }
895
896        try
897        {
898            this.getJomcTool().validateModelObjects( (Implementation) null, (Unmarshaller) null, null );
899            fail( "Expected NullPointerException not thrown." );
900        }
901        catch ( final NullPointerException e )
902        {
903            assertNullPointerException( e );
904        }
905        try
906        {
907            this.getJomcTool().validateModelObjects( new Implementation(), (Unmarshaller) null, null );
908            fail( "Expected NullPointerException not thrown." );
909        }
910        catch ( final NullPointerException e )
911        {
912            assertNullPointerException( e );
913        }
914        try
915        {
916            this.getJomcTool().validateModelObjects( new Implementation(), unmarshaller, null );
917            fail( "Expected NullPointerException not thrown." );
918        }
919        catch ( final NullPointerException e )
920        {
921            assertNullPointerException( e );
922        }
923    }
924
925    @Test
926    public final void testCommitTransformValidateClasses() throws Exception
927    {
928        final File nonExistentDirectory = this.getNextOutputDirectory();
929        final File emptyDirectory = this.getNextOutputDirectory();
930        assertTrue( emptyDirectory.mkdirs() );
931
932        final File allClasses = this.getNextClassesDirectory();
933        final ClassLoader allClassesLoader = new URLClassLoader( new URL[]
934            {
935                allClasses.toURI().toURL()
936            } );
937
938        final File moduleClasses = this.getNextClassesDirectory();
939        final ClassLoader moduleClassesLoader = new URLClassLoader( new URL[]
940            {
941                moduleClasses.toURI().toURL()
942            } );
943
944        final File implementationClasses = this.getNextClassesDirectory();
945        final ClassLoader implementationClassesLoader = new URLClassLoader( new URL[]
946            {
947                implementationClasses.toURI().toURL()
948            } );
949
950        final File specificationClasses = this.getNextClassesDirectory();
951        final ClassLoader specificationClassesLoader = new URLClassLoader( new URL[]
952            {
953                specificationClasses.toURI().toURL()
954            } );
955
956        final File uncommittedClasses = this.getNextClassesDirectory();
957        final ClassLoader uncommittedClassesLoader = new URLClassLoader( new URL[]
958            {
959                uncommittedClasses.toURI().toURL()
960            } );
961
962        final Module m = this.getJomcTool().getModules().getModule( "JOMC Tools" );
963        final Specification s = this.getJomcTool().getModules().getSpecification( "org.jomc.tools.ClassFileProcessor" );
964        final Implementation i =
965            this.getJomcTool().getModules().getImplementation( "org.jomc.tools.ClassFileProcessor" );
966
967        assertNotNull( m );
968        assertNotNull( s );
969        assertNotNull( i );
970
971        final List<Transformer> transformers = Arrays.asList( new Transformer[]
972            {
973                this.getTransformer( "no-op.xsl" )
974            } );
975
976        final List<Transformer> illegalSpecificationTransformers = Arrays.asList( new Transformer[]
977            {
978                this.getTransformer( "illegal-specification-transformation.xsl" )
979            } );
980
981        final List<Transformer> illegalSpecificationsTransformers = Arrays.asList( new Transformer[]
982            {
983                this.getTransformer( "illegal-specifications-transformation.xsl" )
984            } );
985
986        final List<Transformer> illegalDependenciesTransformers = Arrays.asList( new Transformer[]
987            {
988                this.getTransformer( "illegal-dependencies-transformation.xsl" )
989            } );
990
991        final List<Transformer> illegalMessagesTransformers = Arrays.asList( new Transformer[]
992            {
993                this.getTransformer( "illegal-messages-transformation.xsl" )
994            } );
995
996        final List<Transformer> illegalPropertiesTransformers = Arrays.asList( new Transformer[]
997            {
998                this.getTransformer( "illegal-properties-transformation.xsl" )
999            } );
1000
1001        try
1002        {
1003            this.getJomcTool().commitModelObjects( this.getModelContext(), nonExistentDirectory );
1004            fail( "Expected IOException not thrown." );
1005        }
1006        catch ( final IOException e )
1007        {
1008            assertNotNull( e.getMessage() );
1009            System.out.println( e );
1010        }
1011        try
1012        {
1013            this.getJomcTool().commitModelObjects( this.getModelContext(), emptyDirectory );
1014            fail( "Expected IOException not thrown." );
1015        }
1016        catch ( final IOException e )
1017        {
1018            assertNotNull( e.getMessage() );
1019            System.out.println( e );
1020        }
1021
1022        try
1023        {
1024            this.getJomcTool().commitModelObjects( m, this.getModelContext(), nonExistentDirectory );
1025            fail( "Expected IOException not thrown." );
1026        }
1027        catch ( final IOException e )
1028        {
1029            assertNotNull( e.getMessage() );
1030            System.out.println( e );
1031        }
1032        try
1033        {
1034            this.getJomcTool().commitModelObjects( m, this.getModelContext(), emptyDirectory );
1035            fail( "Expected IOException not thrown." );
1036        }
1037        catch ( final IOException e )
1038        {
1039            assertNotNull( e.getMessage() );
1040            System.out.println( e );
1041        }
1042
1043        try
1044        {
1045            this.getJomcTool().commitModelObjects( s, this.getModelContext(), nonExistentDirectory );
1046            fail( "Expected IOException not thrown." );
1047        }
1048        catch ( final IOException e )
1049        {
1050            assertNotNull( e.getMessage() );
1051            System.out.println( e );
1052        }
1053        try
1054        {
1055            this.getJomcTool().commitModelObjects( s, this.getModelContext(), emptyDirectory );
1056            fail( "Expected IOException not thrown." );
1057        }
1058        catch ( final IOException e )
1059        {
1060            assertNotNull( e.getMessage() );
1061            System.out.println( e );
1062        }
1063
1064        try
1065        {
1066            this.getJomcTool().commitModelObjects( i, this.getModelContext(), nonExistentDirectory );
1067            fail( "Expected IOException not thrown." );
1068        }
1069        catch ( final IOException e )
1070        {
1071            assertNotNull( e.getMessage() );
1072            System.out.println( e );
1073        }
1074        try
1075        {
1076            this.getJomcTool().commitModelObjects( i, this.getModelContext(), emptyDirectory );
1077            fail( "Expected IOException not thrown." );
1078        }
1079        catch ( final IOException e )
1080        {
1081            assertNotNull( e.getMessage() );
1082            System.out.println( e );
1083        }
1084
1085        try
1086        {
1087            this.getJomcTool().transformModelObjects( this.getModelContext(), nonExistentDirectory, transformers );
1088            fail( "Expected IOException not thrown." );
1089        }
1090        catch ( final IOException e )
1091        {
1092            assertNotNull( e.getMessage() );
1093            System.out.println( e );
1094        }
1095        try
1096        {
1097            this.getJomcTool().transformModelObjects( this.getModelContext(), emptyDirectory, transformers );
1098            fail( "Expected IOException not thrown." );
1099        }
1100        catch ( final IOException e )
1101        {
1102            assertNotNull( e.getMessage() );
1103            System.out.println( e );
1104        }
1105
1106        try
1107        {
1108            this.getJomcTool().transformModelObjects( m, this.getModelContext(), nonExistentDirectory, transformers );
1109            fail( "Expected IOException not thrown." );
1110        }
1111        catch ( final IOException e )
1112        {
1113            assertNotNull( e.getMessage() );
1114            System.out.println( e );
1115        }
1116        try
1117        {
1118            this.getJomcTool().transformModelObjects( m, this.getModelContext(), emptyDirectory, transformers );
1119            fail( "Expected IOException not thrown." );
1120        }
1121        catch ( final IOException e )
1122        {
1123            assertNotNull( e.getMessage() );
1124            System.out.println( e );
1125        }
1126
1127        try
1128        {
1129            this.getJomcTool().transformModelObjects( s, this.getModelContext(), nonExistentDirectory, transformers );
1130            fail( "Expected IOException not thrown." );
1131        }
1132        catch ( final IOException e )
1133        {
1134            assertNotNull( e.getMessage() );
1135            System.out.println( e );
1136        }
1137        try
1138        {
1139            this.getJomcTool().transformModelObjects( s, this.getModelContext(), emptyDirectory, transformers );
1140            fail( "Expected IOException not thrown." );
1141        }
1142        catch ( final IOException e )
1143        {
1144            assertNotNull( e.getMessage() );
1145            System.out.println( e );
1146        }
1147
1148        try
1149        {
1150            this.getJomcTool().transformModelObjects( i, this.getModelContext(), nonExistentDirectory, transformers );
1151            fail( "Expected IOException not thrown." );
1152        }
1153        catch ( final IOException e )
1154        {
1155            assertNotNull( e.getMessage() );
1156            System.out.println( e );
1157        }
1158        try
1159        {
1160            this.getJomcTool().transformModelObjects( i, this.getModelContext(), emptyDirectory, transformers );
1161            fail( "Expected IOException not thrown." );
1162        }
1163        catch ( final IOException e )
1164        {
1165            assertNotNull( e.getMessage() );
1166            System.out.println( e );
1167        }
1168
1169        try
1170        {
1171            this.getJomcTool().validateModelObjects( this.getModelContext(), nonExistentDirectory );
1172            fail( "Expected IOException not thrown." );
1173        }
1174        catch ( final IOException e )
1175        {
1176            assertNotNull( e.getMessage() );
1177            System.out.println( e );
1178        }
1179        try
1180        {
1181            this.getJomcTool().validateModelObjects( this.getModelContext(), emptyDirectory );
1182            fail( "Expected IOException not thrown." );
1183        }
1184        catch ( final IOException e )
1185        {
1186            assertNotNull( e.getMessage() );
1187            System.out.println( e );
1188        }
1189
1190        try
1191        {
1192            this.getJomcTool().validateModelObjects( m, this.getModelContext(), nonExistentDirectory );
1193            fail( "Expected IOException not thrown." );
1194        }
1195        catch ( final IOException e )
1196        {
1197            assertNotNull( e.getMessage() );
1198            System.out.println( e );
1199        }
1200        try
1201        {
1202            this.getJomcTool().validateModelObjects( m, this.getModelContext(), emptyDirectory );
1203            fail( "Expected IOException not thrown." );
1204        }
1205        catch ( final IOException e )
1206        {
1207            assertNotNull( e.getMessage() );
1208            System.out.println( e );
1209        }
1210
1211        try
1212        {
1213            this.getJomcTool().validateModelObjects( s, this.getModelContext(), nonExistentDirectory );
1214            fail( "Expected IOException not thrown." );
1215        }
1216        catch ( final IOException e )
1217        {
1218            assertNotNull( e.getMessage() );
1219            System.out.println( e );
1220        }
1221        try
1222        {
1223            this.getJomcTool().validateModelObjects( s, this.getModelContext(), emptyDirectory );
1224            fail( "Expected IOException not thrown." );
1225        }
1226        catch ( final IOException e )
1227        {
1228            assertNotNull( e.getMessage() );
1229            System.out.println( e );
1230        }
1231
1232        try
1233        {
1234            this.getJomcTool().validateModelObjects( i, this.getModelContext(), nonExistentDirectory );
1235            fail( "Expected IOException not thrown." );
1236        }
1237        catch ( final IOException e )
1238        {
1239            assertNotNull( e.getMessage() );
1240            System.out.println( e );
1241        }
1242        try
1243        {
1244            this.getJomcTool().validateModelObjects( i, this.getModelContext(), emptyDirectory );
1245            fail( "Expected IOException not thrown." );
1246        }
1247        catch ( final IOException e )
1248        {
1249            assertNotNull( e.getMessage() );
1250            System.out.println( e );
1251        }
1252
1253        this.getJomcTool().commitModelObjects( this.getModelContext(), allClasses );
1254        this.getJomcTool().commitModelObjects( m, this.getModelContext(), moduleClasses );
1255        this.getJomcTool().commitModelObjects( s, this.getModelContext(), specificationClasses );
1256        this.getJomcTool().commitModelObjects( i, this.getModelContext(), implementationClasses );
1257
1258        try
1259        {
1260            this.getJomcTool().transformModelObjects( this.getModelContext(), allClasses,
1261                                                      illegalSpecificationTransformers );
1262
1263            fail( "Expected IOException not thrown." );
1264        }
1265        catch ( final IOException e )
1266        {
1267            assertNotNull( e.getMessage() );
1268            System.out.println( e );
1269        }
1270        try
1271        {
1272            this.getJomcTool().transformModelObjects( this.getModelContext(), allClasses,
1273                                                      illegalSpecificationsTransformers );
1274
1275            fail( "Expected IOException not thrown." );
1276        }
1277        catch ( final IOException e )
1278        {
1279            assertNotNull( e.getMessage() );
1280            System.out.println( e );
1281        }
1282        try
1283        {
1284            this.getJomcTool().transformModelObjects( this.getModelContext(), allClasses,
1285                                                      illegalDependenciesTransformers );
1286
1287            fail( "Expected IOException not thrown." );
1288        }
1289        catch ( final IOException e )
1290        {
1291            assertNotNull( e.getMessage() );
1292            System.out.println( e );
1293        }
1294        try
1295        {
1296            this.getJomcTool().transformModelObjects( this.getModelContext(), allClasses,
1297                                                      illegalMessagesTransformers );
1298
1299            fail( "Expected IOException not thrown." );
1300        }
1301        catch ( final IOException e )
1302        {
1303            assertNotNull( e.getMessage() );
1304            System.out.println( e );
1305        }
1306        try
1307        {
1308            this.getJomcTool().transformModelObjects( this.getModelContext(), allClasses,
1309                                                      illegalPropertiesTransformers );
1310
1311            fail( "Expected IOException not thrown." );
1312        }
1313        catch ( final IOException e )
1314        {
1315            assertNotNull( e.getMessage() );
1316            System.out.println( e );
1317        }
1318
1319        try
1320        {
1321            this.getJomcTool().transformModelObjects( m, this.getModelContext(), moduleClasses,
1322                                                      illegalSpecificationTransformers );
1323
1324            fail( "Expected IOException not thrown." );
1325        }
1326        catch ( final IOException e )
1327        {
1328            assertNotNull( e.getMessage() );
1329            System.out.println( e );
1330        }
1331        try
1332        {
1333            this.getJomcTool().transformModelObjects( m, this.getModelContext(), moduleClasses,
1334                                                      illegalSpecificationsTransformers );
1335
1336            fail( "Expected IOException not thrown." );
1337        }
1338        catch ( final IOException e )
1339        {
1340            assertNotNull( e.getMessage() );
1341            System.out.println( e );
1342        }
1343        try
1344        {
1345            this.getJomcTool().transformModelObjects( m, this.getModelContext(), moduleClasses,
1346                                                      illegalDependenciesTransformers );
1347
1348            fail( "Expected IOException not thrown." );
1349        }
1350        catch ( final IOException e )
1351        {
1352            assertNotNull( e.getMessage() );
1353            System.out.println( e );
1354        }
1355        try
1356        {
1357            this.getJomcTool().transformModelObjects( m, this.getModelContext(), moduleClasses,
1358                                                      illegalMessagesTransformers );
1359
1360            fail( "Expected IOException not thrown." );
1361        }
1362        catch ( final IOException e )
1363        {
1364            assertNotNull( e.getMessage() );
1365            System.out.println( e );
1366        }
1367        try
1368        {
1369            this.getJomcTool().transformModelObjects( m, this.getModelContext(), moduleClasses,
1370                                                      illegalPropertiesTransformers );
1371
1372            fail( "Expected IOException not thrown." );
1373        }
1374        catch ( final IOException e )
1375        {
1376            assertNotNull( e.getMessage() );
1377            System.out.println( e );
1378        }
1379
1380        try
1381        {
1382            this.getJomcTool().transformModelObjects( s, this.getModelContext(), specificationClasses,
1383                                                      illegalSpecificationTransformers );
1384
1385            fail( "Expected IOException not thrown." );
1386        }
1387        catch ( final IOException e )
1388        {
1389            assertNotNull( e.getMessage() );
1390            System.out.println( e );
1391        }
1392
1393        try
1394        {
1395            this.getJomcTool().transformModelObjects( i, this.getModelContext(), implementationClasses,
1396                                                      illegalSpecificationsTransformers );
1397
1398            fail( "Expected IOException not thrown." );
1399        }
1400        catch ( final IOException e )
1401        {
1402            assertNotNull( e.getMessage() );
1403            System.out.println( e );
1404        }
1405        try
1406        {
1407            this.getJomcTool().transformModelObjects( i, this.getModelContext(), implementationClasses,
1408                                                      illegalDependenciesTransformers );
1409
1410            fail( "Expected IOException not thrown." );
1411        }
1412        catch ( final IOException e )
1413        {
1414            assertNotNull( e.getMessage() );
1415            System.out.println( e );
1416        }
1417        try
1418        {
1419            this.getJomcTool().transformModelObjects( i, this.getModelContext(), implementationClasses,
1420                                                      illegalMessagesTransformers );
1421
1422            fail( "Expected IOException not thrown." );
1423        }
1424        catch ( final IOException e )
1425        {
1426            assertNotNull( e.getMessage() );
1427            System.out.println( e );
1428        }
1429        try
1430        {
1431            this.getJomcTool().transformModelObjects( i, this.getModelContext(), implementationClasses,
1432                                                      illegalPropertiesTransformers );
1433
1434            fail( "Expected IOException not thrown." );
1435        }
1436        catch ( final IOException e )
1437        {
1438            assertNotNull( e.getMessage() );
1439            System.out.println( e );
1440        }
1441
1442        this.getJomcTool().transformModelObjects( this.getModelContext(), allClasses, transformers );
1443        this.getJomcTool().transformModelObjects( m, this.getModelContext(), moduleClasses, transformers );
1444        this.getJomcTool().transformModelObjects( s, this.getModelContext(), specificationClasses, transformers );
1445        this.getJomcTool().transformModelObjects( i, this.getModelContext(), implementationClasses, transformers );
1446
1447        this.getJomcTool().validateModelObjects(
1448            ModelContextFactory.newInstance().newModelContext( allClassesLoader ) );
1449
1450        this.getJomcTool().validateModelObjects(
1451            m, ModelContextFactory.newInstance().newModelContext( moduleClassesLoader ) );
1452
1453        this.getJomcTool().validateModelObjects(
1454            s, ModelContextFactory.newInstance().newModelContext( specificationClassesLoader ) );
1455
1456        this.getJomcTool().validateModelObjects(
1457            i, ModelContextFactory.newInstance().newModelContext( implementationClassesLoader ) );
1458
1459        this.getJomcTool().validateModelObjects( this.getModelContext(), allClasses );
1460        this.getJomcTool().validateModelObjects( m, this.getModelContext(), moduleClasses );
1461        this.getJomcTool().validateModelObjects( s, this.getModelContext(), specificationClasses );
1462        this.getJomcTool().validateModelObjects( i, this.getModelContext(), implementationClasses );
1463
1464        this.getJomcTool().validateModelObjects(
1465            ModelContextFactory.newInstance().newModelContext( uncommittedClassesLoader ) );
1466
1467        this.getJomcTool().validateModelObjects( this.getModelContext(), uncommittedClasses );
1468
1469        final Model model = this.getJomcTool().getModel();
1470        final Model copy = model.clone();
1471        final Modules modules = ModelHelper.getModules( copy );
1472        final Module testModule = modules.getModule( "JOMC Tools" );
1473        assertNotNull( testModule );
1474
1475        final Specification classFileProcessor =
1476            testModule.getSpecifications().getSpecification( ClassFileProcessor.class.getName() );
1477
1478        final Specification resourceFileProcessor =
1479            testModule.getSpecifications().getSpecification( ResourceFileProcessor.class.getName() );
1480
1481        final Specification sourceFileProcessor =
1482            testModule.getSpecifications().getSpecification( SourceFileProcessor.class.getName() );
1483
1484        final Implementation classFileProcessorImpl =
1485            testModule.getImplementations().getImplementation( ClassFileProcessor.class.getName() );
1486
1487        final Implementation resourceFileProcessorImpl =
1488            testModule.getImplementations().getImplementation( ResourceFileProcessor.class.getName() );
1489
1490        final Implementation sourceFileProcessorImpl =
1491            testModule.getImplementations().getImplementation( SourceFileProcessor.class.getName() );
1492
1493        assertNotNull( classFileProcessor );
1494        assertNotNull( resourceFileProcessor );
1495        assertNotNull( sourceFileProcessor );
1496        assertNotNull( classFileProcessorImpl );
1497        assertNotNull( resourceFileProcessorImpl );
1498        assertNotNull( sourceFileProcessorImpl );
1499
1500        classFileProcessor.setMultiplicity( Multiplicity.ONE );
1501        classFileProcessor.setScope( "TEST" );
1502        resourceFileProcessor.setMultiplicity( Multiplicity.ONE );
1503        resourceFileProcessor.setScope( "TEST" );
1504        sourceFileProcessor.setMultiplicity( Multiplicity.ONE );
1505        sourceFileProcessor.setScope( "TEST" );
1506
1507        Property p = classFileProcessorImpl.getProperties().getProperty( "TestStringProperty" );
1508        assertNotNull( p );
1509        assertNotNull( classFileProcessorImpl.getProperties().getProperty().remove( p ) );
1510
1511        p = classFileProcessorImpl.getProperties().getProperty( "TestPrimitiveProperty" );
1512        assertNotNull( p );
1513        p.setType( null );
1514
1515        p = resourceFileProcessorImpl.getProperties().getProperty( "TestStringProperty" );
1516        assertNotNull( p );
1517        assertNotNull( resourceFileProcessorImpl.getProperties().getProperty().remove( p ) );
1518
1519        p = resourceFileProcessorImpl.getProperties().getProperty( "TestPrimitiveProperty" );
1520        assertNotNull( p );
1521        p.setType( null );
1522
1523        p = sourceFileProcessorImpl.getProperties().getProperty( "TestStringProperty" );
1524        assertNotNull( p );
1525        assertNotNull( sourceFileProcessorImpl.getProperties().getProperty().remove( p ) );
1526
1527        p = sourceFileProcessorImpl.getProperties().getProperty( "TestPrimitiveProperty" );
1528        assertNotNull( p );
1529        p.setType( null );
1530
1531        Message message = classFileProcessorImpl.getMessages().getMessage( "TestMessage" );
1532        assertNotNull( message );
1533        assertNotNull( classFileProcessorImpl.getMessages().getMessage().remove( message ) );
1534
1535        message = resourceFileProcessorImpl.getMessages().getMessage( "TestMessage" );
1536        assertNotNull( message );
1537        assertNotNull( resourceFileProcessorImpl.getMessages().getMessage().remove( message ) );
1538
1539        message = sourceFileProcessorImpl.getMessages().getMessage( "TestMessage" );
1540        assertNotNull( message );
1541        assertNotNull( sourceFileProcessorImpl.getMessages().getMessage().remove( message ) );
1542
1543        Dependency dependency = classFileProcessorImpl.getDependencies().getDependency( "Locale" );
1544        assertNotNull( dependency );
1545        dependency.setImplementationName( null );
1546        dependency.setVersion( Integer.toString( Integer.MAX_VALUE ) );
1547
1548        dependency = classFileProcessorImpl.getDependencies().getDependency( "ClassFileProcessor" );
1549        assertNotNull( dependency );
1550        assertNotNull( classFileProcessorImpl.getDependencies().getDependency().remove( dependency ) );
1551
1552        dependency = resourceFileProcessorImpl.getDependencies().getDependency( "Locale" );
1553        assertNotNull( dependency );
1554        dependency.setImplementationName( null );
1555        dependency.setVersion( Integer.toString( Integer.MAX_VALUE ) );
1556
1557        dependency = resourceFileProcessorImpl.getDependencies().getDependency( "ResourceFileProcessor" );
1558        assertNotNull( dependency );
1559        assertNotNull( resourceFileProcessorImpl.getDependencies().getDependency().remove( dependency ) );
1560
1561        dependency = sourceFileProcessorImpl.getDependencies().getDependency( "Locale" );
1562        assertNotNull( dependency );
1563        dependency.setImplementationName( null );
1564        dependency.setVersion( Integer.toString( Integer.MAX_VALUE ) );
1565
1566        dependency = sourceFileProcessorImpl.getDependencies().getDependency( "SourceFileProcessor" );
1567        assertNotNull( dependency );
1568        assertNotNull( sourceFileProcessorImpl.getDependencies().getDependency().remove( dependency ) );
1569
1570        this.getJomcTool().setModel( copy );
1571
1572        this.getJomcTool().validateModelObjects(
1573            ModelContextFactory.newInstance().newModelContext( allClassesLoader ) );
1574
1575        this.getJomcTool().validateModelObjects(
1576            testModule, ModelContextFactory.newInstance().newModelContext( moduleClassesLoader ) );
1577
1578        this.getJomcTool().validateModelObjects(
1579            classFileProcessor, ModelContextFactory.newInstance().newModelContext( specificationClassesLoader ) );
1580
1581        this.getJomcTool().validateModelObjects(
1582            classFileProcessorImpl, ModelContextFactory.newInstance().newModelContext( implementationClassesLoader ) );
1583
1584        this.getJomcTool().validateModelObjects( this.getModelContext(), allClasses );
1585        this.getJomcTool().validateModelObjects( testModule, this.getModelContext(), moduleClasses );
1586        this.getJomcTool().validateModelObjects( classFileProcessor, this.getModelContext(), specificationClasses );
1587        this.getJomcTool().validateModelObjects( classFileProcessorImpl, this.getModelContext(),
1588                                                 implementationClasses );
1589
1590        this.getJomcTool().validateModelObjects(
1591            ModelContextFactory.newInstance().newModelContext( uncommittedClassesLoader ) );
1592
1593        this.getJomcTool().validateModelObjects( this.getModelContext(), uncommittedClasses );
1594
1595        classFileProcessor.setClazz( this.getClass().getPackage().getName() + ".DoesNotExist" );
1596        classFileProcessorImpl.setClazz( this.getClass().getPackage().getName() + ".DoesNotExist" );
1597        resourceFileProcessor.setClazz( this.getClass().getPackage().getName() + ".DoesNotExist" );
1598        resourceFileProcessorImpl.setClazz( this.getClass().getPackage().getName() + ".DoesNotExist" );
1599        sourceFileProcessor.setClazz( this.getClass().getPackage().getName() + ".DoesNotExist" );
1600        sourceFileProcessorImpl.setClazz( this.getClass().getPackage().getName() + ".DoesNotExist" );
1601
1602        try
1603        {
1604            this.getJomcTool().validateModelObjects(
1605                ModelContextFactory.newInstance().newModelContext( allClassesLoader ) );
1606
1607            fail( "Expected IOException not thrown." );
1608        }
1609        catch ( final IOException e )
1610        {
1611            assertNotNull( e.getMessage() );
1612            System.out.println( e );
1613        }
1614
1615        try
1616        {
1617            this.getJomcTool().validateModelObjects(
1618                testModule, ModelContextFactory.newInstance().newModelContext( moduleClassesLoader ) );
1619
1620            fail( "Expected IOException not thrown." );
1621        }
1622        catch ( final IOException e )
1623        {
1624            assertNotNull( e.getMessage() );
1625            System.out.println( e );
1626        }
1627
1628        try
1629        {
1630            this.getJomcTool().validateModelObjects(
1631                classFileProcessor, ModelContextFactory.newInstance().newModelContext( specificationClassesLoader ) );
1632
1633            fail( "Expected IOException not thrown." );
1634        }
1635        catch ( final IOException e )
1636        {
1637            assertNotNull( e.getMessage() );
1638            System.out.println( e );
1639        }
1640
1641        try
1642        {
1643            this.getJomcTool().validateModelObjects(
1644                classFileProcessorImpl, ModelContextFactory.newInstance().newModelContext( implementationClassesLoader ) );
1645
1646            fail( "Expected IOException not thrown." );
1647        }
1648        catch ( final IOException e )
1649        {
1650            assertNotNull( e.getMessage() );
1651            System.out.println( e );
1652        }
1653
1654        try
1655        {
1656            this.getJomcTool().validateModelObjects( this.getModelContext(), allClasses );
1657            fail( "Expected IOException not thrown." );
1658        }
1659        catch ( final IOException e )
1660        {
1661            assertNotNull( e.getMessage() );
1662            System.out.println( e );
1663        }
1664
1665        try
1666        {
1667            this.getJomcTool().validateModelObjects( testModule, this.getModelContext(), moduleClasses );
1668            fail( "Expected IOException not thrown." );
1669        }
1670        catch ( final IOException e )
1671        {
1672            assertNotNull( e.getMessage() );
1673            System.out.println( e );
1674        }
1675
1676        try
1677        {
1678            this.getJomcTool().validateModelObjects( classFileProcessor, this.getModelContext(), specificationClasses );
1679            fail( "Expected IOException not thrown." );
1680        }
1681        catch ( final IOException e )
1682        {
1683            assertNotNull( e.getMessage() );
1684            System.out.println( e );
1685        }
1686
1687        try
1688        {
1689            this.getJomcTool().validateModelObjects( classFileProcessorImpl,
1690                                                     this.getModelContext(), implementationClasses );
1691
1692            fail( "Expected IOException not thrown." );
1693        }
1694        catch ( final IOException e )
1695        {
1696            assertNotNull( e.getMessage() );
1697            System.out.println( e );
1698        }
1699
1700        try
1701        {
1702            this.getJomcTool().validateModelObjects(
1703                ModelContextFactory.newInstance().newModelContext( uncommittedClassesLoader ) );
1704
1705            fail( "Expected IOException not thrown." );
1706        }
1707        catch ( final IOException e )
1708        {
1709            assertNotNull( e.getMessage() );
1710            System.out.println( e );
1711        }
1712
1713        try
1714        {
1715            this.getJomcTool().validateModelObjects( this.getModelContext(), uncommittedClasses );
1716            fail( "Expected IOException not thrown." );
1717        }
1718        catch ( final IOException e )
1719        {
1720            assertNotNull( e.getMessage() );
1721            System.out.println( e );
1722        }
1723
1724        this.getJomcTool().setModel( model );
1725    }
1726
1727    @Test
1728    public final void testCopyConstructor() throws Exception
1729    {
1730        try
1731        {
1732            new ClassFileProcessor( null );
1733            fail( "Expected NullPointerException not thrown." );
1734        }
1735        catch ( final NullPointerException e )
1736        {
1737            assertNotNull( e.getMessage() );
1738            System.out.println( e.toString() );
1739        }
1740
1741        new ClassFileProcessor( this.getJomcTool() );
1742    }
1743
1744    @Test
1745    public final void testClassFileProcessorModelObjectsNotFound() throws Exception
1746    {
1747        final File tmpDir = new File( System.getProperty( "java.io.tmpdir", "/tmp" ) );
1748        final JavaClass object = new ClassParser(
1749            ClassLoader.getSystemResourceAsStream( "java/lang/Object.class" ), "Object.class" ).parse();
1750
1751        final Module m = new Module();
1752        m.setName( "DOES_NOT_EXIST" );
1753
1754        final Specification s = new Specification();
1755        s.setIdentifier( "DOES_NOT_EXIST)" );
1756
1757        final Implementation i = new Implementation();
1758        i.setIdentifier( "DOES_NOT_EXIST" );
1759
1760        final Model oldModel = this.getJomcTool().getModel();
1761        this.getJomcTool().setModel( null );
1762
1763        this.getJomcTool().commitModelObjects( this.getModelContext(), tmpDir );
1764        this.getJomcTool().commitModelObjects( m, this.getModelContext(), tmpDir );
1765        this.getJomcTool().commitModelObjects( s, this.getModelContext(), tmpDir );
1766        this.getJomcTool().commitModelObjects( i, this.getModelContext(), tmpDir );
1767
1768        this.getJomcTool().commitModelObjects(
1769            s, this.getModelContext().createMarshaller( ModelObject.MODEL_PUBLIC_ID ), object );
1770
1771        this.getJomcTool().commitModelObjects(
1772            i, this.getModelContext().createMarshaller( ModelObject.MODEL_PUBLIC_ID ), object );
1773
1774        this.getJomcTool().validateModelObjects( this.getModelContext() );
1775        this.getJomcTool().validateModelObjects( m, this.getModelContext() );
1776        this.getJomcTool().validateModelObjects( s, this.getModelContext() );
1777        this.getJomcTool().validateModelObjects( i, this.getModelContext() );
1778
1779        this.getJomcTool().validateModelObjects( this.getModelContext(), tmpDir );
1780        this.getJomcTool().validateModelObjects( m, this.getModelContext(), tmpDir );
1781        this.getJomcTool().validateModelObjects( s, this.getModelContext(), tmpDir );
1782        this.getJomcTool().validateModelObjects( i, this.getModelContext(), tmpDir );
1783
1784        this.getJomcTool().validateModelObjects(
1785            s, this.getModelContext().createUnmarshaller( ModelObject.MODEL_PUBLIC_ID ), object );
1786
1787        this.getJomcTool().validateModelObjects(
1788            i, this.getModelContext().createUnmarshaller( ModelObject.MODEL_PUBLIC_ID ), object );
1789
1790        this.getJomcTool().transformModelObjects( this.getModelContext(), tmpDir,
1791                                                  Collections.<Transformer>emptyList() );
1792
1793        this.getJomcTool().transformModelObjects( m, this.getModelContext(), tmpDir,
1794                                                  Collections.<Transformer>emptyList() );
1795
1796        this.getJomcTool().transformModelObjects( s, this.getModelContext(), tmpDir,
1797                                                  Collections.<Transformer>emptyList() );
1798
1799        this.getJomcTool().transformModelObjects( i, this.getModelContext(), tmpDir,
1800                                                  Collections.<Transformer>emptyList() );
1801
1802        this.getJomcTool().transformModelObjects(
1803            s, this.getModelContext().createMarshaller( ModelObject.MODEL_PUBLIC_ID ),
1804            this.getModelContext().createUnmarshaller( ModelObject.MODEL_PUBLIC_ID ), object,
1805            Collections.<Transformer>emptyList() );
1806
1807        this.getJomcTool().transformModelObjects(
1808            i, this.getModelContext().createMarshaller( ModelObject.MODEL_PUBLIC_ID ),
1809            this.getModelContext().createUnmarshaller( ModelObject.MODEL_PUBLIC_ID ), object,
1810            Collections.<Transformer>emptyList() );
1811
1812        this.getJomcTool().setModel( oldModel );
1813    }
1814
1815    private Transformer getTransformer( final String resource )
1816        throws URISyntaxException, TransformerConfigurationException
1817    {
1818        final TransformerFactory transformerFactory = TransformerFactory.newInstance();
1819        final URL url = this.getClass().getResource( resource );
1820        assertNotNull( url );
1821
1822        final Transformer transformer =
1823            transformerFactory.newTransformer( new StreamSource( url.toURI().toASCIIString() ) );
1824
1825        return transformer;
1826    }
1827
1828    private void unzipResource( final String resourceName, final File targetDirectory ) throws IOException
1829    {
1830        final URL resource = this.getClass().getResource( resourceName );
1831        assertNotNull( "Expected '" + resourceName + "' not found.", resource );
1832
1833        assertTrue( targetDirectory.isAbsolute() );
1834        FileUtils.deleteDirectory( targetDirectory );
1835        assertTrue( targetDirectory.mkdirs() );
1836
1837        ZipInputStream in = null;
1838        boolean suppressExceptionOnClose = true;
1839
1840        try
1841        {
1842            in = new ZipInputStream( resource.openStream() );
1843            ZipEntry e;
1844
1845            while ( ( e = in.getNextEntry() ) != null )
1846            {
1847                if ( e.isDirectory() )
1848                {
1849                    continue;
1850                }
1851
1852                final File dest = new File( targetDirectory, e.getName() );
1853                assertTrue( dest.isAbsolute() );
1854                OutputStream out = null;
1855
1856                try
1857                {
1858                    out = FileUtils.openOutputStream( dest );
1859                    IOUtils.copy( in, out );
1860                    suppressExceptionOnClose = false;
1861                }
1862                finally
1863                {
1864                    try
1865                    {
1866                        if ( out != null )
1867                        {
1868                            out.close();
1869                        }
1870
1871                        suppressExceptionOnClose = true;
1872                    }
1873                    catch ( final IOException ex )
1874                    {
1875                        if ( !suppressExceptionOnClose )
1876                        {
1877                            throw ex;
1878                        }
1879                    }
1880                }
1881
1882                in.closeEntry();
1883            }
1884
1885            suppressExceptionOnClose = false;
1886        }
1887        finally
1888        {
1889            try
1890            {
1891                if ( in != null )
1892                {
1893                    in.close();
1894                }
1895            }
1896            catch ( final IOException e )
1897            {
1898                if ( !suppressExceptionOnClose )
1899                {
1900                    throw e;
1901                }
1902            }
1903        }
1904    }
1905
1906}