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: ModelContextTest.java 4256 2012-02-13 06:32:10Z schulte2005 $
029     *
030     */
031    package org.jomc.modlet.test;
032    
033    import java.io.IOException;
034    import java.io.InputStream;
035    import java.io.StringWriter;
036    import java.net.URI;
037    import java.util.Properties;
038    import java.util.logging.Level;
039    import javax.xml.bind.JAXBElement;
040    import javax.xml.bind.Marshaller;
041    import javax.xml.bind.util.JAXBSource;
042    import org.jomc.modlet.DefaultModletProvider;
043    import org.jomc.modlet.Model;
044    import org.jomc.modlet.ModelContext;
045    import org.jomc.modlet.ModelContextFactory;
046    import org.jomc.modlet.ModelException;
047    import org.jomc.modlet.ModletObject;
048    import org.jomc.modlet.ModletProvider;
049    import org.jomc.modlet.Modlets;
050    import org.jomc.modlet.Property;
051    import org.jomc.modlet.Service;
052    import org.jomc.modlet.test.support.ClassCastExceptionModelContext;
053    import org.jomc.modlet.test.support.IllegalAccessExceptionModelContext;
054    import org.jomc.modlet.test.support.InstantiationExceptionModelContext;
055    import org.jomc.modlet.test.support.InvocationTargetExceptionModelContext;
056    import org.jomc.modlet.test.support.NoSuchMethodExceptionModelContext;
057    import org.jomc.modlet.test.support.TestModletProvider;
058    import org.junit.Test;
059    import org.w3c.dom.ls.LSInput;
060    import org.w3c.dom.ls.LSResourceResolver;
061    import org.xml.sax.EntityResolver;
062    import static javax.xml.XMLConstants.W3C_XML_SCHEMA_NS_URI;
063    import static org.junit.Assert.assertEquals;
064    import static org.junit.Assert.assertFalse;
065    import static org.junit.Assert.assertNotNull;
066    import static org.junit.Assert.assertNull;
067    import static org.junit.Assert.assertTrue;
068    import static org.junit.Assert.fail;
069    
070    /**
071     * Test cases for {@code org.jomc.modlet.ModelContext} implementations.
072     *
073     * @author <a href="mailto:schulte2005@users.sourceforge.net">Christian Schulte</a> 1.0
074     * @version $JOMC: ModelContextTest.java 4256 2012-02-13 06:32:10Z schulte2005 $
075     */
076    public class ModelContextTest
077    {
078    
079        /** Constant for the name of a modlet provided without {@code ModletProvider}. */
080        public static final String DEFAULT_MODLET_NAME;
081    
082        /** Constant for the absolute location of an existing test resource. */
083        private static final String TEST_RESOURCE_LOCATION =
084            ModelContextTest.class.getName().replace( '.', '/' ) + ".properties";
085    
086        static
087        {
088            InputStream in = null;
089            boolean suppressExceptionOnClose = true;
090    
091            try
092            {
093                final Properties p = new Properties();
094                in = ModelContextTest.class.getResourceAsStream( "/" + TEST_RESOURCE_LOCATION );
095                assertNotNull( "Expected '" + TEST_RESOURCE_LOCATION + "' not found.", in );
096                p.load( in );
097    
098                final String defaultModletName = p.getProperty( "defaultModletName" );
099                assertNotNull( "Expected 'defaultModletName' property not found.", defaultModletName );
100                DEFAULT_MODLET_NAME = defaultModletName;
101    
102                suppressExceptionOnClose = false;
103            }
104            catch ( final IOException e )
105            {
106                throw new AssertionError( e );
107            }
108            finally
109            {
110                try
111                {
112                    if ( in != null )
113                    {
114                        in.close();
115                    }
116                }
117                catch ( final IOException e )
118                {
119                    if ( !suppressExceptionOnClose )
120                    {
121                        throw new AssertionError( e );
122                    }
123                }
124            }
125        }
126    
127        /** The {@code ModelContext} instance tests are performed with. */
128        private ModelContext modelContext;
129    
130        /** Creates a new {@code ModelContextTest} instance. */
131        public ModelContextTest()
132        {
133            super();
134        }
135    
136        /**
137         * Gets the {@code ModelContext} instance tests are performed with.
138         *
139         * @return The {@code ModelContext} instance tests are performed with.
140         *
141         * @throws ModelException if creating a new instance fails.
142         *
143         * @see #newModelContext()
144         */
145        public ModelContext getModelContext() throws ModelException
146        {
147            if ( this.modelContext == null )
148            {
149                this.modelContext = this.newModelContext();
150                this.modelContext.getListeners().add( new ModelContext.Listener()
151                {
152    
153                    @Override
154                    public void onLog( final Level level, final String message, final Throwable t )
155                    {
156                        super.onLog( level, message, t );
157                        System.out.println( "[" + level.getLocalizedName() + "] " + message );
158                    }
159    
160                } );
161    
162            }
163    
164            return this.modelContext;
165        }
166    
167        /**
168         * Creates a new {@code ModelContext} instance to test.
169         *
170         * @return A new {@code ModelContext} instance to test.
171         *
172         * @see #getModelContext()
173         */
174        protected ModelContext newModelContext()
175        {
176            return ModelContextFactory.newInstance().newModelContext();
177        }
178    
179        @Test
180        public final void testAttributes() throws Exception
181        {
182            try
183            {
184                this.getModelContext().getAttribute( null );
185                fail( "Expected NullPointerException not thrown." );
186            }
187            catch ( final NullPointerException e )
188            {
189                assertNotNull( e.getMessage() );
190                System.out.println( e.toString() );
191            }
192    
193            try
194            {
195                this.getModelContext().getAttribute( null, null );
196                fail( "Expected NullPointerException not thrown." );
197            }
198            catch ( final NullPointerException e )
199            {
200                assertNotNull( e.getMessage() );
201                System.out.println( e.toString() );
202            }
203    
204            try
205            {
206                this.getModelContext().setAttribute( "TEST", null );
207                fail( "Expected NullPointerException not thrown." );
208            }
209            catch ( final NullPointerException e )
210            {
211                assertNotNull( e.getMessage() );
212                System.out.println( e.toString() );
213            }
214    
215            try
216            {
217                this.getModelContext().setAttribute( null, "TEST" );
218                fail( "Expected NullPointerException not thrown." );
219            }
220            catch ( final NullPointerException e )
221            {
222                assertNotNull( e.getMessage() );
223                System.out.println( e.toString() );
224            }
225    
226            try
227            {
228                this.getModelContext().clearAttribute( null );
229                fail( "Expected NullPointerException not thrown." );
230            }
231            catch ( final NullPointerException e )
232            {
233                assertNotNull( e.getMessage() );
234                System.out.println( e.toString() );
235            }
236    
237            assertNull( this.getModelContext().getAttribute( "ATTRIBUTE" ) );
238            assertEquals( "TEST", this.getModelContext().getAttribute( "ATTRIBUTE", "TEST" ) );
239            assertNull( this.getModelContext().setAttribute( "ATTRIBUTE", "VALUE" ) );
240            assertEquals( "VALUE", this.getModelContext().getAttribute( "ATTRIBUTE", "TEST" ) );
241            assertEquals( "VALUE", this.getModelContext().setAttribute( "ATTRIBUTE", "TEST" ) );
242            assertEquals( "TEST", this.getModelContext().getAttribute( "ATTRIBUTE" ) );
243            this.getModelContext().clearAttribute( "ATTRIBUTE" );
244            assertNull( this.getModelContext().getAttribute( "ATTRIBUTE" ) );
245            assertEquals( "TEST", this.getModelContext().getAttribute( "ATTRIBUTE", "TEST" ) );
246        }
247    
248        @Test
249        public final void testFindClass() throws Exception
250        {
251            try
252            {
253                this.getModelContext().findClass( null );
254                fail( "Expected NullPointerException not thrown." );
255            }
256            catch ( final NullPointerException e )
257            {
258                assertNotNull( e.getMessage() );
259                System.out.println( e.toString() );
260            }
261    
262            assertEquals( Object.class, this.getModelContext().findClass( "java.lang.Object" ) );
263            assertNull( this.getModelContext().findClass( "DOES_NOT_EXIST" ) );
264        }
265    
266        @Test
267        public final void testFindResource() throws Exception
268        {
269            try
270            {
271                this.getModelContext().findResource( null );
272                fail( "Expected NullPointerException not thrown." );
273            }
274            catch ( final NullPointerException e )
275            {
276                assertNotNull( e.getMessage() );
277                System.out.println( e.toString() );
278            }
279    
280            assertNotNull( this.getModelContext().findResource( TEST_RESOURCE_LOCATION ) );
281        }
282    
283        @Test
284        public final void testFindResources() throws Exception
285        {
286            try
287            {
288                this.getModelContext().findResources( null );
289                fail( "Expected NullPointerException not thrown." );
290            }
291            catch ( final NullPointerException e )
292            {
293                assertNotNull( e.getMessage() );
294                System.out.println( e.toString() );
295            }
296    
297            assertTrue( this.getModelContext().findResources( TEST_RESOURCE_LOCATION ).hasMoreElements() );
298        }
299    
300        @Test
301        public final void testGetModlets() throws Exception
302        {
303            this.getModelContext().setModlets( null );
304            DefaultModletProvider.setDefaultEnabled( Boolean.FALSE );
305            final Modlets modlets = this.getModelContext().getModlets();
306            assertNotNull( modlets );
307            assertNotNull( modlets.getModlet( DEFAULT_MODLET_NAME ) );
308            DefaultModletProvider.setDefaultEnabled( null );
309        }
310    
311        @Test
312        public final void testGetInvalidModlets() throws Exception
313        {
314            DefaultModletProvider.setDefaultEnabled( Boolean.TRUE );
315            DefaultModletProvider.setDefaultModletLocation( "META-INF/invalid-modlet/jomc-modlet.xml" );
316            this.getModelContext().setModlets( null );
317    
318            try
319            {
320                this.getModelContext().createContext( ModletObject.MODEL_PUBLIC_ID );
321                fail( "Expected 'ModelException' not thrown." );
322            }
323            catch ( final ModelException e )
324            {
325                assertNotNull( e.getMessage() );
326                System.out.println( e.toString() );
327            }
328    
329            try
330            {
331                this.getModelContext().createContext( ModletObject.PUBLIC_ID );
332                fail( "Expected 'ModelException' not thrown." );
333            }
334            catch ( final ModelException e )
335            {
336                assertNotNull( e.getMessage() );
337                System.out.println( e.toString() );
338            }
339    
340            try
341            {
342                this.getModelContext().createMarshaller( ModletObject.MODEL_PUBLIC_ID );
343                fail( "Expected 'ModelException' not thrown." );
344            }
345            catch ( final ModelException e )
346            {
347                assertNotNull( e.getMessage() );
348                System.out.println( e.toString() );
349            }
350    
351            try
352            {
353                this.getModelContext().createMarshaller( ModletObject.PUBLIC_ID );
354                fail( "Expected 'ModelException' not thrown." );
355            }
356            catch ( final ModelException e )
357            {
358                assertNotNull( e.getMessage() );
359                System.out.println( e.toString() );
360            }
361    
362            try
363            {
364                this.getModelContext().createSchema( ModletObject.MODEL_PUBLIC_ID );
365                fail( "Expected 'ModelException' not thrown." );
366            }
367            catch ( final ModelException e )
368            {
369                assertNotNull( e.getMessage() );
370                System.out.println( e.toString() );
371            }
372    
373            try
374            {
375                this.getModelContext().createSchema( ModletObject.PUBLIC_ID );
376                fail( "Expected 'ModelException' not thrown." );
377            }
378            catch ( final ModelException e )
379            {
380                assertNotNull( e.getMessage() );
381                System.out.println( e.toString() );
382            }
383    
384            try
385            {
386                this.getModelContext().createUnmarshaller( ModletObject.MODEL_PUBLIC_ID );
387                fail( "Expected 'ModelException' not thrown." );
388            }
389            catch ( final ModelException e )
390            {
391                assertNotNull( e.getMessage() );
392                System.out.println( e.toString() );
393            }
394    
395            try
396            {
397                this.getModelContext().createUnmarshaller( ModletObject.PUBLIC_ID );
398                fail( "Expected 'ModelException' not thrown." );
399            }
400            catch ( final ModelException e )
401            {
402                assertNotNull( e.getMessage() );
403                System.out.println( e.toString() );
404            }
405    
406            try
407            {
408                this.getModelContext().createEntityResolver( ModletObject.MODEL_PUBLIC_ID );
409                fail( "Expected 'ModelException' not thrown." );
410            }
411            catch ( final ModelException e )
412            {
413                assertNotNull( e.getMessage() );
414                System.out.println( e.toString() );
415            }
416    
417            try
418            {
419                this.getModelContext().createEntityResolver( ModletObject.PUBLIC_ID );
420                fail( "Expected 'ModelException' not thrown." );
421            }
422            catch ( final ModelException e )
423            {
424                assertNotNull( e.getMessage() );
425                System.out.println( e.toString() );
426            }
427    
428            try
429            {
430                this.getModelContext().createResourceResolver( ModletObject.MODEL_PUBLIC_ID );
431                fail( "Expected 'ModelException' not thrown." );
432            }
433            catch ( final ModelException e )
434            {
435                assertNotNull( e.getMessage() );
436                System.out.println( e.toString() );
437            }
438    
439            try
440            {
441                this.getModelContext().createResourceResolver( ModletObject.PUBLIC_ID );
442                fail( "Expected 'ModelException' not thrown." );
443            }
444            catch ( final ModelException e )
445            {
446                assertNotNull( e.getMessage() );
447                System.out.println( e.toString() );
448            }
449    
450            DefaultModletProvider.setDefaultEnabled( null );
451            DefaultModletProvider.setDefaultModletLocation( null );
452            this.getModelContext().setModlets( null );
453        }
454    
455        @Test
456        @SuppressWarnings( "deprecation" )
457        public final void testCreateModelContext() throws Exception
458        {
459            ModelContext.setModelContextClassName( null );
460            assertNotNull( ModelContext.createModelContext( null ) );
461            assertNotNull( ModelContext.createModelContext( this.getClass().getClassLoader() ) );
462    
463            ModelContext.setModelContextClassName( "DOES_NOT_EXIST" );
464    
465            try
466            {
467                ModelContext.createModelContext( null );
468                fail( "Expected ModelException not thrown." );
469            }
470            catch ( final ModelException e )
471            {
472                assertNotNull( e.getMessage() );
473                System.out.println( e );
474            }
475    
476            try
477            {
478                ModelContext.createModelContext( this.getClass().getClassLoader() );
479                fail( "Expected ModelException not thrown." );
480            }
481            catch ( final ModelException e )
482            {
483                assertNotNull( e.getMessage() );
484                System.out.println( e );
485            }
486    
487            ModelContext.setModelContextClassName( InstantiationExceptionModelContext.class.getName() );
488    
489            try
490            {
491                ModelContext.createModelContext( this.getClass().getClassLoader() );
492                fail( "Expected ModelException not thrown." );
493            }
494            catch ( final ModelException e )
495            {
496                assertNotNull( e.getMessage() );
497                System.out.println( e );
498            }
499    
500            ModelContext.setModelContextClassName( IllegalAccessExceptionModelContext.class.getName() );
501    
502            try
503            {
504                ModelContext.createModelContext( this.getClass().getClassLoader() );
505                fail( "Expected ModelException not thrown." );
506            }
507            catch ( final ModelException e )
508            {
509                assertNotNull( e.getMessage() );
510                System.out.println( e );
511            }
512    
513            ModelContext.setModelContextClassName( ClassCastExceptionModelContext.class.getName() );
514    
515            try
516            {
517                ModelContext.createModelContext( this.getClass().getClassLoader() );
518                fail( "Expected ModelException not thrown." );
519            }
520            catch ( final ModelException e )
521            {
522                assertNotNull( e.getMessage() );
523                System.out.println( e );
524            }
525    
526            ModelContext.setModelContextClassName( NoSuchMethodExceptionModelContext.class.getName() );
527    
528            try
529            {
530                ModelContext.createModelContext( this.getClass().getClassLoader() );
531                fail( "Expected ModelException not thrown." );
532            }
533            catch ( final ModelException e )
534            {
535                assertNotNull( e.getMessage() );
536                System.out.println( e );
537            }
538    
539            ModelContext.setModelContextClassName( InvocationTargetExceptionModelContext.class.getName() );
540    
541            try
542            {
543                ModelContext.createModelContext( this.getClass().getClassLoader() );
544                fail( "Expected ModelException not thrown." );
545            }
546            catch ( final ModelException e )
547            {
548                assertNotNull( e.getMessage() );
549                System.out.println( e );
550            }
551    
552            ModelContext.setModelContextClassName( null );
553        }
554    
555        @Test
556        public final void testCreateEntityResolver() throws Exception
557        {
558            this.getModelContext().setModlets( null );
559    
560            try
561            {
562                this.getModelContext().createEntityResolver( (String) null );
563                fail( "Expected NullPointerException not thrown." );
564            }
565            catch ( final NullPointerException e )
566            {
567                assertNotNull( e.getMessage() );
568                System.out.println( e.toString() );
569            }
570    
571            try
572            {
573                this.getModelContext().createEntityResolver( (URI) null );
574                fail( "Expected NullPointerException not thrown." );
575            }
576            catch ( final NullPointerException e )
577            {
578                assertNotNull( e.getMessage() );
579                System.out.println( e.toString() );
580            }
581    
582            EntityResolver r = this.getModelContext().createEntityResolver( ModletObject.MODEL_PUBLIC_ID );
583            assertNotNull( r );
584    
585            try
586            {
587                r.resolveEntity( null, null );
588                fail( "Expected NullPointerException not thrown." );
589            }
590            catch ( final NullPointerException e )
591            {
592                assertNotNull( e.getMessage() );
593                System.out.println( e.toString() );
594            }
595    
596            assertNull( r.resolveEntity( null, "DOES_NOT_EXIST" ) );
597            assertNotNull( r.resolveEntity( "http://jomc.org/modlet", "DOES_NOT_EXIST" ) );
598            assertNull( r.resolveEntity( ":", "DOES_NOT_EXIST" ) );
599            assertNull( r.resolveEntity( null, ":" ) );
600    
601            r = this.getModelContext().createEntityResolver( ModletObject.PUBLIC_ID );
602            assertNotNull( r );
603    
604            try
605            {
606                r.resolveEntity( null, null );
607                fail( "Expected NullPointerException not thrown." );
608            }
609            catch ( final NullPointerException e )
610            {
611                assertNotNull( e.getMessage() );
612                System.out.println( e.toString() );
613            }
614    
615            assertNull( r.resolveEntity( null, "DOES_NOT_EXIST" ) );
616            assertNotNull( r.resolveEntity( "http://jomc.org/modlet", "DOES_NOT_EXIST" ) );
617            assertNull( r.resolveEntity( ":", "DOES_NOT_EXIST" ) );
618            assertNull( r.resolveEntity( null, ":" ) );
619        }
620    
621        @Test
622        public final void testCreateResourceResolver() throws Exception
623        {
624            this.getModelContext().setModlets( null );
625    
626            try
627            {
628                this.getModelContext().createResourceResolver( (String) null );
629                fail( "Expected NullPointerException not thrown." );
630            }
631            catch ( final NullPointerException e )
632            {
633                assertNotNull( e.getMessage() );
634                System.out.println( e.toString() );
635            }
636    
637            try
638            {
639                this.getModelContext().createResourceResolver( (URI) null );
640                fail( "Expected NullPointerException not thrown." );
641            }
642            catch ( final NullPointerException e )
643            {
644                assertNotNull( e.getMessage() );
645                System.out.println( e.toString() );
646            }
647    
648            LSResourceResolver r = this.getModelContext().createResourceResolver( ModletObject.MODEL_PUBLIC_ID );
649    
650            assertNotNull( r );
651            assertNull( r.resolveResource( null, null, null, null, null ) );
652            assertNull( r.resolveResource( W3C_XML_SCHEMA_NS_URI, null, null, "DOES_NOT_EXIST", null ) );
653            assertNull( r.resolveResource( "UNSUPPORTED", null, ModletObject.MODEL_PUBLIC_ID, null, null ) );
654            assertNotNull( r.resolveResource( W3C_XML_SCHEMA_NS_URI, null, ModletObject.MODEL_PUBLIC_ID,
655                                              ModelContext.getDefaultModletSchemaSystemId(), null ) );
656    
657            LSInput input = r.resolveResource( W3C_XML_SCHEMA_NS_URI, null, null,
658                                               ModelContext.getDefaultModletSchemaSystemId(), null );
659    
660            assertNotNull( input );
661    
662            input.getBaseURI();
663            input.getByteStream();
664            input.getCertifiedText();
665            input.getCharacterStream();
666            input.getEncoding();
667            input.getPublicId();
668            input.getStringData();
669            input.getSystemId();
670    
671            input.setBaseURI( null );
672            input.setByteStream( null );
673            input.setCertifiedText( false );
674            input.setCharacterStream( null );
675            input.setEncoding( null );
676            input.setPublicId( null );
677            input.setStringData( null );
678            input.setSystemId( null );
679    
680            r = this.getModelContext().createResourceResolver( ModletObject.PUBLIC_ID );
681    
682            assertNotNull( r );
683            assertNull( r.resolveResource( null, null, null, null, null ) );
684            assertNull( r.resolveResource( W3C_XML_SCHEMA_NS_URI, null, null, "DOES_NOT_EXIST", null ) );
685            assertNull( r.resolveResource( "UNSUPPORTED", null, ModletObject.MODEL_PUBLIC_ID, null, null ) );
686            assertNotNull( r.resolveResource( W3C_XML_SCHEMA_NS_URI, null, ModletObject.MODEL_PUBLIC_ID,
687                                              ModelContext.getDefaultModletSchemaSystemId(), null ) );
688    
689            input = r.resolveResource( W3C_XML_SCHEMA_NS_URI, null, null,
690                                       ModelContext.getDefaultModletSchemaSystemId(), null );
691    
692            assertNotNull( input );
693    
694            input.getBaseURI();
695            input.getByteStream();
696            input.getCertifiedText();
697            input.getCharacterStream();
698            input.getEncoding();
699            input.getPublicId();
700            input.getStringData();
701            input.getSystemId();
702    
703            input.setBaseURI( null );
704            input.setByteStream( null );
705            input.setCertifiedText( false );
706            input.setCharacterStream( null );
707            input.setEncoding( null );
708            input.setPublicId( null );
709            input.setStringData( null );
710            input.setSystemId( null );
711        }
712    
713        @Test
714        public final void testCreateContext() throws Exception
715        {
716            this.getModelContext().setModlets( null );
717    
718            try
719            {
720                this.getModelContext().createContext( (String) null );
721                fail( "Expected NullPointerException not thrown." );
722            }
723            catch ( final NullPointerException e )
724            {
725                assertNotNull( e.getMessage() );
726                System.out.println( e.toString() );
727            }
728    
729            try
730            {
731                this.getModelContext().createContext( (URI) null );
732                fail( "Expected NullPointerException not thrown." );
733            }
734            catch ( final NullPointerException e )
735            {
736                assertNotNull( e.getMessage() );
737                System.out.println( e.toString() );
738            }
739    
740            this.getModelContext().setModlets( new Modlets() );
741    
742            try
743            {
744                this.getModelContext().createContext( "" );
745                fail( "Expected ModelException not thrown." );
746            }
747            catch ( final ModelException e )
748            {
749                assertNotNull( e.getMessage() );
750                System.out.println( e.toString() );
751            }
752    
753            try
754            {
755                this.getModelContext().createContext( new URI( "DOES_NOT_EXIST" ) );
756                fail( "Expected ModelException not thrown." );
757            }
758            catch ( final ModelException e )
759            {
760                assertNotNull( e.getMessage() );
761                System.out.println( e.toString() );
762            }
763    
764            this.getModelContext().setModlets( null );
765            assertNotNull( this.getModelContext().createContext( ModletObject.MODEL_PUBLIC_ID ) );
766            assertNotNull( this.getModelContext().createContext( ModletObject.PUBLIC_ID ) );
767        }
768    
769        @Test
770        public final void testCreateMarshaller() throws Exception
771        {
772            this.getModelContext().setModlets( null );
773    
774            try
775            {
776                this.getModelContext().createMarshaller( (String) null );
777                fail( "Expected NullPointerException not thrown." );
778            }
779            catch ( final NullPointerException e )
780            {
781                assertNotNull( e.getMessage() );
782                System.out.println( e.toString() );
783            }
784    
785            try
786            {
787                this.getModelContext().createMarshaller( (URI) null );
788                fail( "Expected NullPointerException not thrown." );
789            }
790            catch ( final NullPointerException e )
791            {
792                assertNotNull( e.getMessage() );
793                System.out.println( e.toString() );
794            }
795    
796            this.getModelContext().setModlets( new Modlets() );
797    
798            try
799            {
800                this.getModelContext().createMarshaller( "" );
801                fail( "Expected ModelException not thrown." );
802            }
803            catch ( final ModelException e )
804            {
805                assertNotNull( e.getMessage() );
806                System.out.println( e.toString() );
807            }
808    
809            try
810            {
811                this.getModelContext().createMarshaller( new URI( "DOES_NOT_EXIST" ) );
812                fail( "Expected ModelException not thrown." );
813            }
814            catch ( final ModelException e )
815            {
816                assertNotNull( e.getMessage() );
817                System.out.println( e.toString() );
818            }
819    
820            this.getModelContext().setModlets( null );
821            assertNotNull( this.getModelContext().createMarshaller( ModletObject.MODEL_PUBLIC_ID ) );
822            assertNotNull( this.getModelContext().createMarshaller( ModletObject.PUBLIC_ID ) );
823        }
824    
825        @Test
826        public final void testCreateUnmarshaller() throws Exception
827        {
828            this.getModelContext().setModlets( null );
829    
830            try
831            {
832                this.getModelContext().createUnmarshaller( (String) null );
833                fail( "Expected NullPointerException not thrown." );
834            }
835            catch ( final NullPointerException e )
836            {
837                assertNotNull( e.getMessage() );
838                System.out.println( e.toString() );
839            }
840    
841            try
842            {
843                this.getModelContext().createUnmarshaller( (URI) null );
844                fail( "Expected NullPointerException not thrown." );
845            }
846            catch ( final NullPointerException e )
847            {
848                assertNotNull( e.getMessage() );
849                System.out.println( e.toString() );
850            }
851    
852            this.getModelContext().setModlets( new Modlets() );
853    
854            try
855            {
856                this.getModelContext().createUnmarshaller( "" );
857                fail( "Expected ModelException not thrown." );
858            }
859            catch ( final ModelException e )
860            {
861                assertNotNull( e.getMessage() );
862                System.out.println( e.toString() );
863            }
864    
865            try
866            {
867                this.getModelContext().createUnmarshaller( new URI( "DOES_NOT_EXIST" ) );
868                fail( "Expected ModelException not thrown." );
869            }
870            catch ( final ModelException e )
871            {
872                assertNotNull( e.getMessage() );
873                System.out.println( e.toString() );
874            }
875    
876            this.getModelContext().setModlets( null );
877            assertNotNull( this.getModelContext().createUnmarshaller( ModletObject.MODEL_PUBLIC_ID ) );
878            assertNotNull( this.getModelContext().createUnmarshaller( ModletObject.PUBLIC_ID ) );
879        }
880    
881        @Test
882        public final void testCreateSchema() throws Exception
883        {
884            this.getModelContext().setModlets( null );
885    
886            try
887            {
888                this.getModelContext().createSchema( (String) null );
889                fail( "Expected NullPointerException not thrown." );
890            }
891            catch ( final NullPointerException e )
892            {
893                assertNotNull( e.getMessage() );
894                System.out.println( e.toString() );
895            }
896    
897            try
898            {
899                this.getModelContext().createSchema( (URI) null );
900                fail( "Expected NullPointerException not thrown." );
901            }
902            catch ( final NullPointerException e )
903            {
904                assertNotNull( e.getMessage() );
905                System.out.println( e.toString() );
906            }
907    
908            this.getModelContext().setModlets( new Modlets() );
909    
910            try
911            {
912                this.getModelContext().createSchema( "" );
913                fail( "Expected ModelException not thrown." );
914            }
915            catch ( final ModelException e )
916            {
917                assertNotNull( e.getMessage() );
918                System.out.println( e.toString() );
919            }
920    
921            try
922            {
923                this.getModelContext().createSchema( new URI( "DOES_NOT_EXIST" ) );
924                fail( "Expected ModelException not thrown." );
925            }
926            catch ( final ModelException e )
927            {
928                assertNotNull( e.getMessage() );
929                System.out.println( e.toString() );
930            }
931    
932            this.getModelContext().setModlets( null );
933            assertNotNull( this.getModelContext().createSchema( ModletObject.MODEL_PUBLIC_ID ) );
934            assertNotNull( this.getModelContext().createSchema( ModletObject.PUBLIC_ID ) );
935        }
936    
937        @Test
938        public final void testCreateServiceObject() throws Exception
939        {
940            try
941            {
942                this.getModelContext().createServiceObject( null, Object.class );
943                fail( "Expected 'NullPointerException' not thrown." );
944            }
945            catch ( final NullPointerException e )
946            {
947                assertNotNull( e.getMessage() );
948                System.out.println( e.toString() );
949            }
950    
951            try
952            {
953                this.getModelContext().createServiceObject( new Service(), null );
954                fail( "Expected 'NullPointerException' not thrown." );
955            }
956            catch ( final NullPointerException e )
957            {
958                assertNotNull( e.getMessage() );
959                System.out.println( e.toString() );
960            }
961    
962            final Service illegalAccessService = new Service();
963            illegalAccessService.setIdentifier( ModelContext.class.getName() );
964            illegalAccessService.setClazz( IllegalAccessExceptionModelContext.class.getName() );
965    
966            try
967            {
968                this.getModelContext().createServiceObject( illegalAccessService, ModelContext.class );
969                fail( "Expected 'ModelException' not thrown." );
970            }
971            catch ( final ModelException e )
972            {
973                assertNotNull( e.getMessage() );
974                System.out.println( e.toString() );
975            }
976    
977            final Service instantiationExceptionService = new Service();
978            instantiationExceptionService.setIdentifier( ModelContext.class.getName() );
979            instantiationExceptionService.setClazz( InstantiationExceptionModelContext.class.getName() );
980    
981            try
982            {
983                this.getModelContext().createServiceObject( instantiationExceptionService, ModelContext.class );
984                fail( "Expected 'ModelException' not thrown." );
985            }
986            catch ( final ModelException e )
987            {
988                assertNotNull( e.getMessage() );
989                System.out.println( e.toString() );
990            }
991    
992            final Service legalService = new Service();
993            legalService.setIdentifier( ModletProvider.class.getName() );
994            legalService.setClazz( TestModletProvider.class.getName() );
995            assertNotNull( this.getModelContext().createServiceObject( legalService, ModletProvider.class ) );
996    
997            final Property unsupportedTypeProperty = new Property();
998            unsupportedTypeProperty.setName( "unsupportedPropertyType" );
999            unsupportedTypeProperty.setValue( "UNSUPPORTED TYPE" );
1000    
1001            final Property instantiationExceptionProperty = new Property();
1002            instantiationExceptionProperty.setName( "instantiationExceptionProperty" );
1003            instantiationExceptionProperty.setValue( "UNSUPPORTED TYPE" );
1004    
1005            final Property invocationTargetExceptionProperty = new Property();
1006            invocationTargetExceptionProperty.setName( "invocationTargetExceptionProperty" );
1007            invocationTargetExceptionProperty.setValue( "UNSUPPORTED TYPE" );
1008    
1009            legalService.getProperty().add( unsupportedTypeProperty );
1010    
1011            try
1012            {
1013                this.getModelContext().createServiceObject( legalService, ModletProvider.class );
1014                fail( "Expected 'ModelException' not thrown." );
1015            }
1016            catch ( final ModelException e )
1017            {
1018                assertNotNull( e.getMessage() );
1019                System.out.println( e.toString() );
1020            }
1021    
1022            legalService.getProperty().remove( unsupportedTypeProperty );
1023            legalService.getProperty().add( instantiationExceptionProperty );
1024    
1025            try
1026            {
1027                this.getModelContext().createServiceObject( legalService, ModletProvider.class );
1028                fail( "Expected 'ModelException' not thrown." );
1029            }
1030            catch ( final ModelException e )
1031            {
1032                assertNotNull( e.getMessage() );
1033                System.out.println( e.toString() );
1034            }
1035    
1036            legalService.getProperty().remove( instantiationExceptionProperty );
1037            legalService.getProperty().add( invocationTargetExceptionProperty );
1038    
1039            try
1040            {
1041                this.getModelContext().createServiceObject( legalService, ModletProvider.class );
1042                fail( "Expected 'ModelException' not thrown." );
1043            }
1044            catch ( final ModelException e )
1045            {
1046                assertNotNull( e.getMessage() );
1047                System.out.println( e.toString() );
1048            }
1049        }
1050    
1051        @Test
1052        public final void testDefaultLogLevel() throws Exception
1053        {
1054            final String testLogLevel = System.getProperty( "org.jomc.modlet.ModelContext.defaultLogLevel" );
1055    
1056            System.clearProperty( "org.jomc.modlet.ModelContext.defaultLogLevel" );
1057            ModelContext.setDefaultLogLevel( null );
1058            assertNotNull( ModelContext.getDefaultLogLevel() );
1059            ModelContext.setDefaultLogLevel( null );
1060            System.setProperty( "org.jomc.modlet.ModelContext.defaultLogLevel", "OFF" );
1061            assertEquals( Level.OFF, ModelContext.getDefaultLogLevel() );
1062    
1063            if ( testLogLevel != null )
1064            {
1065                System.setProperty( "org.jomc.modlet.ModelContext.defaultLogLevel", testLogLevel );
1066            }
1067            else
1068            {
1069                System.clearProperty( "org.jomc.modlet.ModelContext.defaultLogLevel" );
1070            }
1071    
1072            ModelContext.setDefaultLogLevel( null );
1073        }
1074    
1075        @Test
1076        public final void testDefaultModletSchemaSystemId() throws Exception
1077        {
1078            System.clearProperty( "org.jomc.modlet.ModelContext.defaultModletSchemaSystemId" );
1079            ModelContext.setDefaultModletSchemaSystemId( null );
1080            assertNotNull( ModelContext.getDefaultModletSchemaSystemId() );
1081            ModelContext.setDefaultModletSchemaSystemId( null );
1082            System.setProperty( "org.jomc.modlet.ModelContext.defaultModletSchemaSystemId", "TEST" );
1083            assertEquals( "TEST", ModelContext.getDefaultModletSchemaSystemId() );
1084            System.clearProperty( "org.jomc.modlet.ModelContext.defaultModletSchemaSystemId" );
1085            ModelContext.setDefaultModletSchemaSystemId( null );
1086            assertNotNull( ModelContext.getDefaultModletSchemaSystemId() );
1087        }
1088    
1089        @Test
1090        public final void testLogLevel() throws Exception
1091        {
1092            ModelContext.setDefaultLogLevel( null );
1093            this.getModelContext().setLogLevel( null );
1094            assertNotNull( this.getModelContext().getLogLevel() );
1095    
1096            ModelContext.setDefaultLogLevel( Level.OFF );
1097            this.getModelContext().setLogLevel( null );
1098            assertEquals( Level.OFF, this.getModelContext().getLogLevel() );
1099    
1100            ModelContext.setDefaultLogLevel( null );
1101            this.getModelContext().setLogLevel( null );
1102        }
1103    
1104        @Test
1105        public final void testLogging() throws Exception
1106        {
1107            try
1108            {
1109                this.getModelContext().isLoggable( null );
1110                fail( "Expected NullPointerException not thrown." );
1111            }
1112            catch ( final NullPointerException e )
1113            {
1114                assertNotNull( e.getMessage() );
1115                System.out.println( e.toString() );
1116            }
1117    
1118            try
1119            {
1120                this.getModelContext().log( null, "Message", new Throwable() );
1121                fail( "Expected NullPointerException not thrown." );
1122            }
1123            catch ( final NullPointerException e )
1124            {
1125                assertNotNull( e.getMessage() );
1126                System.out.println( e.toString() );
1127            }
1128    
1129            this.getModelContext().log( Level.ALL, null, null );
1130            this.getModelContext().setLogLevel( Level.SEVERE );
1131            assertFalse( this.getModelContext().isLoggable( Level.WARNING ) );
1132            assertTrue( this.getModelContext().isLoggable( Level.SEVERE ) );
1133            this.getModelContext().setLogLevel( null );
1134        }
1135    
1136        @Test
1137        public final void testModletSchemaSystemId() throws Exception
1138        {
1139            ModelContext.setDefaultModletSchemaSystemId( null );
1140            this.getModelContext().setModletSchemaSystemId( null );
1141            assertNotNull( this.getModelContext().getModletSchemaSystemId() );
1142    
1143            ModelContext.setDefaultModletSchemaSystemId( "TEST" );
1144            this.getModelContext().setModletSchemaSystemId( null );
1145            assertEquals( "TEST", this.getModelContext().getModletSchemaSystemId() );
1146    
1147            ModelContext.setDefaultModletSchemaSystemId( null );
1148            this.getModelContext().setModletSchemaSystemId( null );
1149        }
1150    
1151        @Test
1152        public final void testFindModel() throws Exception
1153        {
1154            this.getModelContext().setModlets( null );
1155    
1156            try
1157            {
1158                this.getModelContext().findModel( (String) null );
1159                fail( "Expected NullPointerException not thrown." );
1160            }
1161            catch ( final NullPointerException e )
1162            {
1163                assertNotNull( e.getMessage() );
1164                System.out.println( e.toString() );
1165            }
1166    
1167            try
1168            {
1169                this.getModelContext().findModel( (Model) null );
1170                fail( "Expected NullPointerException not thrown." );
1171            }
1172            catch ( final NullPointerException e )
1173            {
1174                assertNotNull( e.getMessage() );
1175                System.out.println( e.toString() );
1176            }
1177    
1178            assertNotNull( this.getModelContext().findModel( ModletObject.MODEL_PUBLIC_ID ) );
1179    
1180            final Model model = new Model();
1181            model.setIdentifier( ModletObject.MODEL_PUBLIC_ID );
1182    
1183            assertNotNull( this.getModelContext().findModel( model ) );
1184        }
1185    
1186        @Test
1187        public final void testProcessModel() throws Exception
1188        {
1189            this.getModelContext().setModlets( null );
1190    
1191            try
1192            {
1193                this.getModelContext().processModel( null );
1194                fail( "Expected NullPointerException not thrown." );
1195            }
1196            catch ( final NullPointerException e )
1197            {
1198                assertNotNull( e.getMessage() );
1199                System.out.println( e.toString() );
1200            }
1201        }
1202    
1203        @Test
1204        public final void testValidateModel() throws Exception
1205        {
1206            this.getModelContext().setModlets( null );
1207    
1208            try
1209            {
1210                this.getModelContext().validateModel( null, null );
1211                fail( "Expected NullPointerException not thrown." );
1212            }
1213            catch ( final NullPointerException e )
1214            {
1215                assertNotNull( e.getMessage() );
1216                System.out.println( e.toString() );
1217            }
1218    
1219            try
1220            {
1221                this.getModelContext().validateModel( "TEST", null );
1222                fail( "Expected NullPointerException not thrown." );
1223            }
1224            catch ( final NullPointerException e )
1225            {
1226                assertNotNull( e.getMessage() );
1227                System.out.println( e.toString() );
1228            }
1229    
1230            try
1231            {
1232                this.getModelContext().validateModel( null );
1233                fail( "Expected NullPointerException not thrown." );
1234            }
1235            catch ( final NullPointerException e )
1236            {
1237                assertNotNull( e.getMessage() );
1238                System.out.println( e.toString() );
1239            }
1240    
1241            final Model invalidModel = new Model();
1242            final Model validModel = new Model();
1243            validModel.setIdentifier( ModletObject.MODEL_PUBLIC_ID );
1244    
1245            final Marshaller m = this.getModelContext().createMarshaller( ModletObject.MODEL_PUBLIC_ID );
1246            final JAXBElement<Model> invalid = new org.jomc.modlet.ObjectFactory().createModel( invalidModel );
1247            final JAXBElement<Model> valid = new org.jomc.modlet.ObjectFactory().createModel( validModel );
1248    
1249            StringWriter stringWriter = new StringWriter();
1250            m.marshal( invalid, stringWriter );
1251            System.out.println( stringWriter );
1252    
1253            stringWriter = new StringWriter();
1254            m.marshal( valid, stringWriter );
1255            System.out.println( stringWriter );
1256    
1257            assertFalse( this.getModelContext().validateModel( ModletObject.MODEL_PUBLIC_ID,
1258                                                               new JAXBSource( m, invalid ) ).isModelValid() );
1259    
1260            assertTrue( this.getModelContext().validateModel( ModletObject.MODEL_PUBLIC_ID,
1261                                                              new JAXBSource( m, valid ) ).isModelValid() );
1262    
1263        }
1264    
1265    }