001    /*
002     * Licensed to the Apache Software Foundation (ASF) under one or more
003     * contributor license agreements.  See the NOTICE file distributed with
004     * this work for additional information regarding copyright ownership.
005     * The ASF licenses this file to You under the Apache License, Version 2.0
006     * (the "License"); you may not use this file except in compliance with
007     * the License.  You may obtain a copy of the License at
008     * 
009     *      http://www.apache.org/licenses/LICENSE-2.0
010     * 
011     * Unless required by applicable law or agreed to in writing, software
012     * distributed under the License is distributed on an "AS IS" BASIS,
013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014     * See the License for the specific language governing permissions and
015     * limitations under the License.
016     */ 
017    
018    package org.apache.commons.logging.simple;
019    
020    
021    import java.io.ByteArrayInputStream;
022    import java.io.ByteArrayOutputStream;
023    import java.io.ObjectInputStream;
024    import java.io.ObjectOutputStream;
025    
026    import junit.framework.Test;
027    import junit.framework.TestCase;
028    
029    import org.apache.commons.logging.Log;
030    import org.apache.commons.logging.LogFactory;
031    import org.apache.commons.logging.PathableClassLoader;
032    import org.apache.commons.logging.PathableTestSuite;
033    import org.apache.commons.logging.impl.SimpleLog;
034    
035    
036    /**
037     * <p>TestCase for simple logging when running with zero configuration
038     * other than selecting the SimpleLog implementation.</p>
039     *
040     * @author Craig R. McClanahan
041     * @version $Revision: 425249 $ $Date: 2006-07-25 03:30:16 +0200 (ti, 25 jul 2006) $
042     */
043    
044    public class DefaultConfigTestCase extends TestCase {
045    
046    
047        // ----------------------------------------------------- Instance Variables
048    
049    
050        /**
051         * <p>The {@link LogFactory} implementation we have selected.</p>
052         */
053        protected LogFactory factory = null;
054    
055    
056        /**
057         * <p>The {@link Log} implementation we have selected.</p>
058         */
059        protected Log log = null;
060    
061    
062        // ------------------------------------------- JUnit Infrastructure Methods
063    
064    
065        /**
066         * Return the tests included in this test suite.
067         * <p>
068         * We need to use a PathableClassLoader here because the SimpleLog class
069         * is a pile of junk and chock-full of static variables. Any other test
070         * (like simple.CustomConfigTestCase) that has used the SimpleLog class
071         * will already have caused it to do once-only initialisation that we
072         * can't reset, even by calling LogFactory.releaseAll, because of those
073         * ugly statics. The only clean solution is to load a clean copy of
074         * commons-logging including SimpleLog via a nice clean classloader.
075         * Or we could fix SimpleLog to be sane...
076         */
077        public static Test suite() throws Exception {
078            Class thisClass = DefaultConfigTestCase.class;
079    
080            PathableClassLoader loader = new PathableClassLoader(null);
081            loader.useExplicitLoader("junit.", Test.class.getClassLoader());
082            loader.addLogicalLib("testclasses");
083            loader.addLogicalLib("commons-logging");
084            
085            Class testClass = loader.loadClass(thisClass.getName());
086            return new PathableTestSuite(testClass, loader);
087        }
088    
089        /**
090         * Set system properties that will control the LogFactory/Log objects
091         * when they are created. Subclasses can override this method to
092         * define properties that suit them.
093         */
094        public void setProperties() {
095            System.setProperty(
096                "org.apache.commons.logging.Log",
097                "org.apache.commons.logging.impl.SimpleLog");
098        }
099    
100        /**
101         * Set up instance variables required by this test case.
102         */
103        public void setUp() throws Exception {
104            LogFactory.releaseAll();
105            setProperties();
106            setUpFactory();
107            setUpLog("TestLogger");
108        }
109    
110        /**
111         * Tear down instance variables required by this test case.
112         */
113        public void tearDown() {
114            log = null;
115            factory = null;
116            LogFactory.releaseAll();
117        }
118    
119    
120        // ----------------------------------------------------------- Test Methods
121    
122    
123        // Test pristine DecoratedSimpleLog instance
124        public void testPristineDecorated() {
125    
126            setUpDecorated("DecoratedLogger");
127            checkDecorated();
128    
129        }
130    
131    
132        // Test pristine Log instance
133        public void testPristineLog() {
134    
135            checkStandard();
136    
137        }
138    
139    
140        // Test pristine LogFactory instance
141        public void testPristineFactory() {
142    
143            assertNotNull("LogFactory exists", factory);
144            assertEquals("LogFactory class",
145                         "org.apache.commons.logging.impl.LogFactoryImpl",
146                         factory.getClass().getName());
147    
148            String names[] = factory.getAttributeNames();
149            assertNotNull("Names exists", names);
150            assertEquals("Names empty", 0, names.length);
151    
152        }
153    
154    
155        // Test Serializability of standard instance
156        public void testSerializable() throws Exception {
157    
158            // Serialize and deserialize the instance
159            ByteArrayOutputStream baos = new ByteArrayOutputStream();
160            ObjectOutputStream oos = new ObjectOutputStream(baos);
161            oos.writeObject(log);
162            oos.close();
163            ByteArrayInputStream bais =
164                new ByteArrayInputStream(baos.toByteArray());
165            ObjectInputStream ois = new ObjectInputStream(bais);
166            log = (Log) ois.readObject();
167            ois.close();
168    
169            // Check the characteristics of the resulting object
170            checkStandard();
171    
172        }
173    
174    
175        // -------------------------------------------------------- Support Methods
176    
177    
178    
179        // Check the decorated log instance
180        protected void checkDecorated() {
181    
182            assertNotNull("Log exists", log);
183            assertEquals("Log class",
184                         "org.apache.commons.logging.simple.DecoratedSimpleLog",
185                         log.getClass().getName());
186    
187            // Can we call level checkers with no exceptions?
188            assertTrue(!log.isDebugEnabled());
189            assertTrue(log.isErrorEnabled());
190            assertTrue(log.isFatalEnabled());
191            assertTrue(log.isInfoEnabled());
192            assertTrue(!log.isTraceEnabled());
193            assertTrue(log.isWarnEnabled());
194    
195            // Can we retrieve the current log level?
196            assertEquals(SimpleLog.LOG_LEVEL_INFO, ((SimpleLog) log).getLevel());
197    
198            // Can we validate the extra exposed properties?
199            assertEquals("yyyy/MM/dd HH:mm:ss:SSS zzz",
200                         ((DecoratedSimpleLog) log).getDateTimeFormat());
201            assertEquals("DecoratedLogger",
202                         ((DecoratedSimpleLog) log).getLogName());
203            assertTrue(!((DecoratedSimpleLog) log).getShowDateTime());
204            assertTrue(((DecoratedSimpleLog) log).getShowShortName());
205    
206        }
207    
208    
209        // Check the standard log instance
210        protected void checkStandard() {
211    
212            assertNotNull("Log exists", log);
213            assertEquals("Log class",
214                         "org.apache.commons.logging.impl.SimpleLog",
215                         log.getClass().getName());
216    
217            // Can we call level checkers with no exceptions?
218            assertTrue(!log.isDebugEnabled());
219            assertTrue(log.isErrorEnabled());
220            assertTrue(log.isFatalEnabled());
221            assertTrue(log.isInfoEnabled());
222            assertTrue(!log.isTraceEnabled());
223            assertTrue(log.isWarnEnabled());
224    
225            // Can we retrieve the current log level?
226            assertEquals(SimpleLog.LOG_LEVEL_INFO, ((SimpleLog) log).getLevel());
227    
228        }
229    
230    
231        // Set up decorated log instance
232        protected void setUpDecorated(String name) {
233            log = new DecoratedSimpleLog(name);
234        }
235    
236    
237        // Set up factory instance
238        protected void setUpFactory() throws Exception {
239            factory = LogFactory.getFactory();
240        }
241    
242    
243        // Set up log instance
244        protected void setUpLog(String name) throws Exception {
245            log = LogFactory.getLog(name);
246        }
247    
248    
249    }