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;
019    
020    import junit.framework.TestCase;
021    
022    /**
023     * Tests the basic logging operations to ensure that they all function 
024     * without exception failure. In other words, that they do no fail by
025     * throwing exceptions.
026     * This is the minimum requirement for any well behaved logger 
027     * and so this test should be run for each kind.
028     */
029    public class BasicOperationsTestCase extends TestCase
030    {
031        public void testIsEnabledClassLog()
032        {
033            Log log = LogFactory.getLog(BasicOperationsTestCase.class);
034            executeIsEnabledTest(log);
035        }
036        
037        public void testIsEnabledNamedLog()
038        {
039            Log log = LogFactory.getLog(BasicOperationsTestCase.class.getName());
040            executeIsEnabledTest(log);
041        }    
042        
043        public void executeIsEnabledTest(Log log)
044        {
045            try
046            {
047                log.isTraceEnabled();
048                log.isDebugEnabled();
049                log.isInfoEnabled();
050                log.isWarnEnabled();
051                log.isErrorEnabled();
052                log.isFatalEnabled();
053            }
054            catch (Throwable t)
055            {
056                t.printStackTrace();
057                fail("Exception thrown: " + t);
058            }
059        }
060        
061        
062        public void testMessageWithoutExceptionClassLog()
063        {
064            Log log = LogFactory.getLog(BasicOperationsTestCase.class);
065            executeMessageWithoutExceptionTest(log);
066        }
067        
068        public void testMessageWithoutExceptionNamedLog()
069        {
070            Log log = LogFactory.getLog(BasicOperationsTestCase.class.getName());
071            executeMessageWithoutExceptionTest(log);
072        }    
073        
074        public void executeMessageWithoutExceptionTest(Log log)
075        {
076            try
077            {
078                log.trace("Hello, Mum");
079                log.debug("Hello, Mum");
080                log.info("Hello, Mum");
081                log.warn("Hello, Mum");
082                log.error("Hello, Mum");
083                log.fatal("Hello, Mum");
084            }
085            catch (Throwable t)
086            {
087                t.printStackTrace();
088                fail("Exception thrown: " + t);
089            }
090        }
091        
092        public void testMessageWithExceptionClassLog()
093        {
094            Log log = LogFactory.getLog(BasicOperationsTestCase.class);
095            executeMessageWithExceptionTest(log);
096        }
097        
098        public void testMessageWithExceptionNamedLog()
099        {
100            Log log = LogFactory.getLog(BasicOperationsTestCase.class.getName());
101            executeMessageWithExceptionTest(log);
102        }    
103        
104        public void executeMessageWithExceptionTest(Log log)
105        {
106            try
107            {
108                log.trace("Hello, Mum", new ArithmeticException());
109                log.debug("Hello, Mum", new ArithmeticException());
110                log.info("Hello, Mum", new ArithmeticException());
111                log.warn("Hello, Mum", new ArithmeticException());
112                log.error("Hello, Mum", new ArithmeticException());
113                log.fatal("Hello, Mum", new ArithmeticException());
114            }
115            catch (Throwable t)
116            {
117                t.printStackTrace();
118                fail("Exception thrown: " + t);
119            }
120        }
121    }