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.util.ArrayList; 022 import java.util.Iterator; 023 import java.util.List; 024 025 import junit.framework.Test; 026 027 import org.apache.commons.logging.DummyException; 028 import org.apache.commons.logging.LogFactory; 029 import org.apache.commons.logging.PathableClassLoader; 030 import org.apache.commons.logging.PathableTestSuite; 031 import org.apache.commons.logging.impl.SimpleLog; 032 033 034 /** 035 * <p>TestCase for simple logging when running with custom configuration 036 * properties.</p> 037 * 038 * @author Craig R. McClanahan 039 * @version $Revision: 563165 $ $Date: 2007-08-06 17:08:05 +0200 $ 040 */ 041 public class CustomConfigTestCase extends DefaultConfigTestCase { 042 043 044 // ----------------------------------------------------- Instance Variables 045 046 047 /** 048 * <p>The expected log records.</p> 049 */ 050 protected List expected; 051 052 053 /** 054 * <p>The message levels that should have been logged.</p> 055 */ 056 /* 057 protected Level testLevels[] = 058 { Level.FINE, Level.INFO, Level.WARNING, Level.SEVERE, Level.SEVERE }; 059 */ 060 061 062 /** 063 * <p>The message strings that should have been logged.</p> 064 */ 065 protected String testMessages[] = 066 { "debug", "info", "warn", "error", "fatal" }; 067 068 069 // ------------------------------------------- JUnit Infrastructure Methods 070 071 /** 072 * Set system properties that will control the LogFactory/Log objects 073 * when they are created. Subclasses can override this method to 074 * define properties that suit them. 075 */ 076 public void setProperties() { 077 System.setProperty( 078 "org.apache.commons.logging.Log", 079 "org.apache.commons.logging.simple.DecoratedSimpleLog"); 080 System.setProperty( 081 "org.apache.commons.logging.simplelog.defaultlog", 082 "debug"); 083 } 084 085 /** 086 * Set up instance variables required by this test case. 087 */ 088 public void setUp() throws Exception { 089 LogFactory.releaseAll(); 090 setProperties(); 091 expected = new ArrayList(); 092 setUpFactory(); 093 setUpLog("DecoratedLogger"); 094 } 095 096 097 /** 098 * Return the tests included in this test suite. 099 * <p> 100 * We need to use a PathableClassLoader here because the SimpleLog class 101 * is a pile of junk and chock-full of static variables. Any other test 102 * (like simple.CustomConfigTestCase) that has used the SimpleLog class 103 * will already have caused it to do once-only initialisation that we 104 * can't reset, even by calling LogFactory.releaseAll, because of those 105 * ugly statics. The only clean solution is to load a clean copy of 106 * commons-logging including SimpleLog via a nice clean classloader. 107 * Or we could fix SimpleLog to be sane... 108 */ 109 public static Test suite() throws Exception { 110 Class thisClass = CustomConfigTestCase.class; 111 112 PathableClassLoader loader = new PathableClassLoader(null); 113 loader.useExplicitLoader("junit.", Test.class.getClassLoader()); 114 loader.addLogicalLib("testclasses"); 115 loader.addLogicalLib("commons-logging"); 116 117 Class testClass = loader.loadClass(thisClass.getName()); 118 return new PathableTestSuite(testClass, loader); 119 } 120 121 /** 122 * Tear down instance variables required by this test case. 123 */ 124 public void tearDown() { 125 super.tearDown(); 126 expected = null; 127 } 128 129 130 // ----------------------------------------------------------- Test Methods 131 132 133 // Test logging message strings with exceptions 134 public void testExceptionMessages() throws Exception { 135 136 ((DecoratedSimpleLog) log).clearCache(); 137 logExceptionMessages(); 138 checkExpected(); 139 140 } 141 142 143 // Test logging plain message strings 144 public void testPlainMessages() throws Exception { 145 146 ((DecoratedSimpleLog) log).clearCache(); 147 logPlainMessages(); 148 checkExpected(); 149 150 } 151 152 153 // Test Serializability of standard instance 154 public void testSerializable() throws Exception { 155 156 ((DecoratedSimpleLog) log).clearCache(); 157 logPlainMessages(); 158 super.testSerializable(); 159 logExceptionMessages(); 160 checkExpected(); 161 162 } 163 164 165 // -------------------------------------------------------- Support Methods 166 167 168 // Check the decorated log instance 169 protected void checkDecorated() { 170 171 assertNotNull("Log exists", log); 172 assertEquals("Log class", 173 "org.apache.commons.logging.simple.DecoratedSimpleLog", 174 log.getClass().getName()); 175 176 // Can we call level checkers with no exceptions? 177 assertTrue(log.isDebugEnabled()); 178 assertTrue(log.isErrorEnabled()); 179 assertTrue(log.isFatalEnabled()); 180 assertTrue(log.isInfoEnabled()); 181 assertTrue(!log.isTraceEnabled()); 182 assertTrue(log.isWarnEnabled()); 183 184 // Can we retrieve the current log level? 185 assertEquals(SimpleLog.LOG_LEVEL_DEBUG, ((SimpleLog) log).getLevel()); 186 187 // Can we validate the extra exposed properties? 188 checkDecoratedDateTime(); 189 assertEquals("DecoratedLogger", 190 ((DecoratedSimpleLog) log).getLogName()); 191 checkShowDateTime(); 192 assertTrue(((DecoratedSimpleLog) log).getShowShortName()); 193 194 } 195 196 /** Hook for subclassses */ 197 protected void checkShowDateTime() { 198 assertTrue(!((DecoratedSimpleLog) log).getShowDateTime()); 199 } 200 201 /** Hook for subclasses */ 202 protected void checkDecoratedDateTime() { 203 assertEquals("yyyy/MM/dd HH:mm:ss:SSS zzz", 204 ((DecoratedSimpleLog) log).getDateTimeFormat()); 205 } 206 207 208 209 // Check the actual log records against the expected ones 210 protected void checkExpected() { 211 212 List acts = ((DecoratedSimpleLog) log).getCache(); 213 Iterator exps = expected.iterator(); 214 int n = 0; 215 while (exps.hasNext()) { 216 LogRecord exp = (LogRecord) exps.next(); 217 LogRecord act = (LogRecord) acts.get(n++); 218 assertEquals("Row " + n + " type", exp.type, act.type); 219 assertEquals("Row " + n + " message", exp.message, act.message); 220 assertEquals("Row " + n + " throwable", exp.t, act.t); 221 } 222 223 } 224 225 226 // Check the standard log instance 227 protected void checkStandard() { 228 229 checkDecorated(); 230 231 } 232 233 234 // Log the messages with exceptions 235 protected void logExceptionMessages() { 236 237 // Generate log records 238 Throwable t = new DummyException(); 239 log.trace("trace", t); // Should not actually get logged 240 log.debug("debug", t); 241 log.info("info", t); 242 log.warn("warn", t); 243 log.error("error", t); 244 log.fatal("fatal", t); 245 246 // Record the log records we expect 247 expected.add(new LogRecord(SimpleLog.LOG_LEVEL_DEBUG, "debug", t)); 248 expected.add(new LogRecord(SimpleLog.LOG_LEVEL_INFO, "info", t)); 249 expected.add(new LogRecord(SimpleLog.LOG_LEVEL_WARN, "warn", t)); 250 expected.add(new LogRecord(SimpleLog.LOG_LEVEL_ERROR, "error", t)); 251 expected.add(new LogRecord(SimpleLog.LOG_LEVEL_FATAL, "fatal", t)); 252 253 } 254 255 256 // Log the plain messages 257 protected void logPlainMessages() { 258 259 // Generate log records 260 log.trace("trace"); // Should not actually get logged 261 log.debug("debug"); 262 log.info("info"); 263 log.warn("warn"); 264 log.error("error"); 265 log.fatal("fatal"); 266 267 // Record the log records we expect 268 expected.add(new LogRecord(SimpleLog.LOG_LEVEL_DEBUG, "debug", null)); 269 expected.add(new LogRecord(SimpleLog.LOG_LEVEL_INFO, "info", null)); 270 expected.add(new LogRecord(SimpleLog.LOG_LEVEL_WARN, "warn", null)); 271 expected.add(new LogRecord(SimpleLog.LOG_LEVEL_ERROR, "error", null)); 272 expected.add(new LogRecord(SimpleLog.LOG_LEVEL_FATAL, "fatal", null)); 273 274 } 275 276 277 }