1 /*
2 * Copyright (C) The Spice Group. All rights reserved.
3 *
4 * This software is published under the terms of the Spice
5 * Software License version 1.1, a copy of which has been included
6 * with this distribution in the LICENSE.txt file.
7 */
8 package org.codehaus.spice.loggerstore;
9
10 import java.io.BufferedReader;
11 import java.io.File;
12 import java.io.FileInputStream;
13 import java.io.InputStream;
14 import java.io.InputStreamReader;
15 import java.net.URL;
16 import java.util.HashMap;
17 import javax.xml.parsers.DocumentBuilder;
18 import javax.xml.parsers.DocumentBuilderFactory;
19 import javax.xml.parsers.FactoryConfigurationError;
20 import junit.framework.TestCase;
21 import org.codehaus.spice.loggerstore.stores.Jdk14LoggerStore;
22 import org.jcontainer.dna.Logger;
23 import org.jcontainer.dna.impl.ConsoleLogger;
24 import org.jcontainer.dna.impl.ContainerUtil;
25 import org.w3c.dom.Document;
26 import org.w3c.dom.Element;
27 import org.xml.sax.EntityResolver;
28 import org.xml.sax.InputSource;
29
30 /***
31 * AbstactLoggerStoreTestCase
32 *
33 * @author <a href="mailto:mauro.talevi at aquilonia.org">Mauro Talevi</a>
34 * @author Peter Donald
35 */
36 public class AbstractTestCase
37 extends TestCase
38 {
39 protected static final String MESSAGE = "Testing Logger";
40 protected static final String MESSAGE2 = "This occurs in sub-category";
41
42 private File m_logsDir;
43
44 public AbstractTestCase( final String name )
45 {
46 super( name );
47 }
48
49 protected void setUp()
50 throws Exception
51 {
52 m_logsDir = new File( "logs/" );
53 m_logsDir.mkdirs();
54 }
55
56 protected final InputStream getResource( final String name )
57 {
58 return getClass().getResourceAsStream( name );
59 }
60
61 protected void runLoggerTest( final String filename,
62 final LoggerStore store,
63 final int level )
64 throws Exception
65 {
66 ContainerUtil.enableLogging( store, new ConsoleLogger( level ) );
67 runLoggerTest( filename, store );
68 }
69
70 protected void runLoggerTest( final String filename,
71 final LoggerStore store )
72 throws Exception
73 {
74 BufferedReader reader = null;
75 try
76 {
77 final Logger logger = store.getLogger();
78 assertNotNull( "rootLogger for " + filename, logger );
79 logger.info( MESSAGE );
80 final Logger noExistLogger = store.getLogger( "no-exist" );
81 assertNotNull( "noExistLogger for " + filename, noExistLogger );
82 noExistLogger.info( MESSAGE2 );
83
84 assertEquals( "Same Logger returned multiple times:",
85 noExistLogger,
86 store.getLogger( "no-exist" ) );
87
88 try
89 {
90 store.getLogger( null );
91 fail( "Expected a NullPointerException when passing " +
92 "null in for getLogger parameter" );
93 }
94 catch( final NullPointerException npe )
95 {
96 assertEquals( "NullPointer message",
97 "name",
98 npe.getMessage() );
99 }
100
101 final File logFile = new File( m_logsDir, filename + ".log" );
102 assertTrue( "Checking LogFile Exists: " + filename,
103 logFile.exists() );
104
105 reader =
106 new BufferedReader(
107 new InputStreamReader( new FileInputStream( logFile ) ) );
108 assertEquals( "First line Contents for logger" + filename,
109 MESSAGE, reader.readLine() );
110 assertEquals( "Second line Contents for logger" + filename,
111 MESSAGE2, reader.readLine() );
112 assertNull( "Third Line Contents for logger" + filename,
113 reader.readLine() );
114 reader.close();
115 logFile.delete();
116
117 if( !( store instanceof Jdk14LoggerStore ) )
118 {
119 final Logger nejney = store.getLogger( "nejney" );
120 nejney.info( MESSAGE );
121
122 final File logFile2 = new File( m_logsDir,
123 filename + "2.log" );
124 reader =
125 new BufferedReader(
126 new InputStreamReader( new FileInputStream( logFile2 ) ) );
127 assertEquals(
128 "First line Contents for nejney logger" + filename,
129 MESSAGE, reader.readLine() );
130 assertNull(
131 "Second Line Contents for nejney logger" + filename,
132 reader.readLine() );
133 reader.close();
134 logFile2.delete();
135 }
136 }
137 finally
138 {
139 store.close();
140 if( null != reader )
141 {
142 reader.close();
143 }
144 }
145 }
146
147 /***
148 * Builds an Element from a resource
149 *
150 * @param resource the InputStream of the configuration resource
151 * @param resolver the EntityResolver required by the DocumentBuilder - or
152 * <code>null</code> if none required
153 * @param systemId the String encoding the systemId required by the
154 * InputSource - or <code>null</code> if none required
155 */
156 protected static Element buildElement( final InputStream resource,
157 final EntityResolver resolver,
158 final String systemId )
159 throws Exception
160 {
161 DocumentBuilderFactory dbf = null;
162 try
163 {
164 dbf = DocumentBuilderFactory.newInstance();
165 }
166 catch( FactoryConfigurationError e )
167 {
168 final String message = "Failed to create a DocumentBuilderFactory";
169 throw new Exception( message, e );
170 }
171
172 try
173 {
174 dbf.setValidating( true );
175 DocumentBuilder db = dbf.newDocumentBuilder();
176 if( resolver != null )
177 {
178 db.setEntityResolver( resolver );
179 }
180 InputSource source = new InputSource( resource );
181 if( systemId != null )
182 {
183 source.setSystemId( systemId );
184 }
185 Document doc = db.parse( source );
186 return doc.getDocumentElement();
187 }
188 catch( Exception e )
189 {
190 final String message = "Failed to parse Document";
191 throw new Exception( message, e );
192 }
193 }
194
195 protected void performConsoleTest( final LoggerStore store,
196 final int level )
197 throws Exception
198 {
199 ContainerUtil.enableLogging( store, new ConsoleLogger( level ) );
200 final Logger logger = store.getLogger();
201 assertNotNull( "rootLogger for console", logger );
202 logger.info( MESSAGE );
203 final Logger noExistLogger = store.getLogger( "no-exist" );
204 assertNotNull( "noExistLogger for console", noExistLogger );
205 noExistLogger.info( MESSAGE2 );
206 store.close();
207 }
208
209 protected void runInvalidInputData( final LoggerStoreFactory factory )
210 {
211 try
212 {
213 factory.createLoggerStore( new HashMap() );
214 fail( "Expected createLoggerStore to fail with invalid input data" );
215 }
216 catch( Exception e )
217 {
218 }
219 }
220
221 protected void runStreamBasedFactoryTest( final String inputFile,
222 final LoggerStoreFactory factory,
223 final int level,
224 final String outputFile,
225 final HashMap inputData )
226 throws Exception
227 {
228 //URL Should in file: format
229 final URL url = getClass().getResource( inputFile );
230 assertEquals( "URL is of file type", url.getProtocol(), "file" );
231
232 final HashMap config = new HashMap();
233 config.put( LoggerStoreFactory.URL_LOCATION,
234 url.toExternalForm() );
235 config.putAll( inputData );
236 runFactoryTest( factory,
237 level,
238 config,
239 outputFile );
240 final HashMap config2 = new HashMap();
241 config2.put( URL.class.getName(), url );
242 config2.putAll( inputData );
243 runFactoryTest( factory,
244 level,
245 config2,
246 outputFile );
247 final String filename = url.toExternalForm().substring( 5 );
248 final HashMap config3 = new HashMap();
249 config3.put( LoggerStoreFactory.FILE_LOCATION, filename );
250 config3.putAll( inputData );
251 runFactoryTest( factory,
252 level,
253 config3,
254 outputFile );
255 final HashMap config4 = new HashMap();
256 config4.put( File.class.getName(), new File( filename ) );
257 config4.putAll( inputData );
258 runFactoryTest( factory,
259 level,
260 config4,
261 outputFile );
262 final HashMap config5 = new HashMap();
263 config5.put( InputStream.class.getName(),
264 new FileInputStream( filename ) );
265 config5.putAll( inputData );
266 runFactoryTest( factory,
267 level,
268 config5,
269 outputFile );
270 }
271
272 protected void runFactoryTest( final LoggerStoreFactory factory,
273 final int level,
274 final HashMap config,
275 final String filename )
276 throws Exception
277 {
278 ContainerUtil.enableLogging( factory, new ConsoleLogger( level ) );
279 final LoggerStore store = factory.createLoggerStore( config );
280 runLoggerTest( filename, store, level );
281 }
282 }
This page was automatically generated by Maven