1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 package org.apache.commons.logging.jdk14;
19
20 import java.io.ByteArrayOutputStream;
21 import java.io.InputStream;
22 import java.lang.reflect.Method;
23 import java.util.Iterator;
24 import java.util.logging.Handler;
25 import java.util.logging.Level;
26 import java.util.logging.LogManager;
27 import java.util.logging.LogRecord;
28 import java.util.logging.Logger;
29
30 import org.apache.commons.logging.DummyException;
31 import org.apache.commons.logging.PathableClassLoader;
32 import org.apache.commons.logging.PathableTestSuite;
33
34 import junit.framework.Test;
35
36
37
38
39
40
41
42 public class CustomConfigTestCase extends DefaultConfigTestCase {
43
44 protected static final String HANDLER_NAME = "org.apache.commons.logging.jdk14.TestHandler";
45
46
47
48
49
50
51
52 protected static void loadTestHandler(final String className, final ClassLoader targetCL) {
53 try {
54 targetCL.loadClass(className);
55
56 return;
57 } catch (final ClassNotFoundException ex) {
58
59 }
60
61 try {
62 final ClassLoader srcCL = CustomConfigAPITestCase.class.getClassLoader();
63 final byte[] classData = readClass(className, srcCL);
64
65 final Class[] params = { String.class, classData.getClass(), Integer.TYPE, Integer.TYPE };
66 final Method m = ClassLoader.class.getDeclaredMethod("defineClass", params);
67
68 final Object[] args = new Object[4];
69 args[0] = className;
70 args[1] = classData;
71 args[2] = Integer.valueOf(0);
72 args[3] = Integer.valueOf(classData.length);
73 m.setAccessible(true);
74 m.invoke(targetCL, args);
75 } catch (final Exception e) {
76 e.printStackTrace();
77 fail("Unable to load class " + className);
78 }
79 }
80
81
82
83
84
85 protected static byte[] readClass(final String name, final ClassLoader srcCL) throws Exception {
86 final String resName = name.replace('.', '/') + ".class";
87 System.err.println("Trying to load resource [" + resName + "]");
88 final InputStream is = srcCL.getResourceAsStream(resName);
89 final ByteArrayOutputStream baos = new ByteArrayOutputStream();
90 System.err.println("Reading resource [" + resName + "]");
91 final byte[] buf = new byte[1000];
92 for(;;) {
93 final int read = is.read(buf);
94 if (read <= 0) {
95 break;
96 }
97 baos.write(buf, 0, read);
98 }
99 is.close();
100 return baos.toByteArray();
101 }
102
103
104
105
106 public static Test suite() throws Exception {
107 final PathableClassLoader cl = new PathableClassLoader(null);
108 cl.useExplicitLoader("junit.", Test.class.getClassLoader());
109
110
111
112
113
114
115 final ClassLoader scl = ClassLoader.getSystemClassLoader();
116 loadTestHandler(HANDLER_NAME, scl);
117 cl.useExplicitLoader(HANDLER_NAME, scl);
118 cl.addLogicalLib("commons-logging");
119 cl.addLogicalLib("testclasses");
120
121 final Class testClass = cl.loadClass(CustomConfigTestCase.class.getName());
122 return new PathableTestSuite(testClass, cl);
123 }
124
125
126
127
128 protected TestHandler handler;
129
130
131
132
133 protected Handler handlers[];
134
135
136
137
138 protected Logger logger;
139
140
141
142
143 protected LogManager manager;
144
145
146
147
148 protected Level[] testLevels =
149 { Level.FINE, Level.INFO, Level.WARNING, Level.SEVERE, Level.SEVERE };
150
151
152
153
154 protected String[] testMessages =
155 { "debug", "info", "warn", "error", "fatal" };
156
157
158
159
160
161
162 public CustomConfigTestCase(final String name) {
163 super(name);
164 }
165
166
167 @Override
168 protected void checkLog() {
169
170 assertNotNull("Log exists", log);
171 assertEquals("Log class",
172 "org.apache.commons.logging.impl.Jdk14Logger",
173 log.getClass().getName());
174
175
176 assertTrue(log.isFatalEnabled());
177 assertTrue(log.isErrorEnabled());
178 assertTrue(log.isWarnEnabled());
179 assertTrue(log.isInfoEnabled());
180 assertTrue(log.isDebugEnabled());
181 assertFalse(log.isTraceEnabled());
182
183 }
184
185
186 protected void checkLogRecords(final boolean thrown) {
187 final Iterator records = handler.records();
188 for (int i = 0; i < testMessages.length; i++) {
189 assertTrue(records.hasNext());
190 final LogRecord record = (LogRecord) records.next();
191 assertEquals("LogRecord level",
192 testLevels[i], record.getLevel());
193 assertEquals("LogRecord message",
194 testMessages[i], record.getMessage());
195 assertTrue("LogRecord class",
196 record.getSourceClassName().startsWith(
197 "org.apache.commons.logging.jdk14.CustomConfig"));
198 if (thrown) {
199 assertEquals("LogRecord method",
200 "logExceptionMessages",
201 record.getSourceMethodName());
202 } else {
203 assertEquals("LogRecord method",
204 "logPlainMessages",
205 record.getSourceMethodName());
206 }
207 if (thrown) {
208 assertNotNull("LogRecord thrown", record.getThrown());
209 assertTrue("LogRecord thrown type",
210 record.getThrown() instanceof DummyException);
211 } else {
212 assertNull("LogRecord thrown",
213 record.getThrown());
214 }
215 }
216 assertFalse(records.hasNext());
217 handler.flush();
218 }
219
220
221 protected void logExceptionMessages() {
222 final Throwable t = new DummyException();
223 log.trace("trace", t);
224 log.debug("debug", t);
225 log.info("info", t);
226 log.warn("warn", t);
227 log.error("error", t);
228 log.fatal("fatal", t);
229 }
230
231
232 protected void logPlainMessages() {
233 log.trace("trace");
234 log.debug("debug");
235 log.info("info");
236 log.warn("warn");
237 log.error("error");
238 log.fatal("fatal");
239 }
240
241
242
243
244 @Override
245 public void setUp() throws Exception {
246 setUpManager
247 ("org/apache/commons/logging/jdk14/CustomConfig.properties");
248 setUpLogger(this.getClass().getName());
249 setUpHandlers();
250 setUpFactory();
251 setUpLog(this.getClass().getName());
252 }
253
254
255 protected void setUpHandlers() throws Exception {
256 Logger parent = logger;
257 while (parent.getParent() != null) {
258 parent = parent.getParent();
259 }
260 handlers = parent.getHandlers();
261
262
263
264
265
266
267
268
269
270
271
272
273
274 assertNotNull("No Handlers defined for JDK14 logging", handlers);
275 assertEquals("Unexpected number of handlers for JDK14 logging", 1, handlers.length);
276 assertNotNull("Handler is null", handlers[0]);
277 assertTrue("Handler not of expected type", handlers[0] instanceof TestHandler);
278 handler = (TestHandler) handlers[0];
279 }
280
281
282 protected void setUpLogger(final String name) throws Exception {
283 logger = Logger.getLogger(name);
284 }
285
286
287 protected void setUpManager(final String config) throws Exception {
288 manager = LogManager.getLogManager();
289 final InputStream is =
290 this.getClass().getClassLoader().getResourceAsStream(config);
291 manager.readConfiguration(is);
292 is.close();
293 }
294
295
296
297
298 @Override
299 public void tearDown() {
300 super.tearDown();
301 handlers = null;
302 logger = null;
303 manager = null;
304 }
305
306
307 public void testExceptionMessages() throws Exception {
308
309 logExceptionMessages();
310 checkLogRecords(true);
311
312 }
313
314
315 public void testPlainMessages() throws Exception {
316
317 logPlainMessages();
318 checkLogRecords(false);
319
320 }
321
322
323 public void testPristineHandlers() {
324
325 assertNotNull(handlers);
326 assertEquals(1, handlers.length);
327 assertTrue(handlers[0] instanceof TestHandler);
328 assertNotNull(handler);
329
330 }
331
332
333 public void testPristineLogger() {
334
335 assertNotNull("Logger exists", logger);
336 assertEquals("Logger name", this.getClass().getName(), logger.getName());
337
338
339 assertTrue(logger.isLoggable(Level.SEVERE));
340 assertTrue(logger.isLoggable(Level.WARNING));
341 assertTrue(logger.isLoggable(Level.INFO));
342 assertTrue(logger.isLoggable(Level.CONFIG));
343 assertTrue(logger.isLoggable(Level.FINE));
344 assertFalse(logger.isLoggable(Level.FINER));
345 assertFalse(logger.isLoggable(Level.FINEST));
346
347 }
348
349
350 @Override
351 public void testSerializable() throws Exception {
352
353 super.testSerializable();
354 testExceptionMessages();
355
356 }
357
358 }