View Javadoc

1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    * 
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   * 
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.log4j.filter;
18  
19  import junit.framework.TestCase;
20  import org.apache.log4j.Level;
21  import org.apache.log4j.Logger;
22  import org.apache.log4j.util.Compare;
23  import org.apache.log4j.util.ControlFilter;
24  import org.apache.log4j.util.Filter;
25  import org.apache.log4j.util.JunitTestRunnerFilter;
26  import org.apache.log4j.util.LineNumberFilter;
27  import org.apache.log4j.util.SunReflectFilter;
28  import org.apache.log4j.util.Transformer;
29  import org.apache.log4j.extras.DOMConfigurator;
30  import org.apache.log4j.xml.Log4jEntityResolver;
31  import org.w3c.dom.Document;
32  
33  import javax.xml.parsers.DocumentBuilder;
34  import javax.xml.parsers.DocumentBuilderFactory;
35  import java.io.FileNotFoundException;
36  import java.io.InputStream;
37  
38  
39  /***
40   * Various tests verifying that filters work properly and that 
41   * JoranConfigurator can effectively parse config files containing them.
42   * 
43   * @author Ceki Gulcu
44   *
45   */
46  public class SimpleFilterTest extends TestCase {
47    Logger root; 
48    Logger logger;
49  
50    public final static String FILTERED = "filtered";
51    public final static String TEMP = "temp";
52    
53    static String TEST1_PAT = "(DEBUG|INFO|WARN|ERROR|FATAL) - Message //d";
54    static String TEST8_PAT = "WARN org.apache.log4j.filter.SimpleFilterTest - Message //d";
55    static String EXCEPTION1 = "java.lang.Exception: Just testing";
56    static String EXCEPTION2 = "//s*at .*//(.*://d{1,4}//)";
57    static String EXCEPTION3 = "//s*at .*//(Native Method//)";
58    
59    public SimpleFilterTest(String name) {
60      super(name);
61    }
62  
63    public void setUp() {
64      root = Logger.getRootLogger();
65      logger = Logger.getLogger(SimpleFilterTest.class);
66    }
67   
68    public void tearDown() {  
69      root.getLoggerRepository().resetConfiguration();
70    }
71  
72    private final void configure(final String resourceName) throws Exception {
73      InputStream is = getClass().getResourceAsStream(resourceName);
74      if (is == null) {
75          throw new FileNotFoundException(
76                  "Could not find resource " + resourceName);
77      }
78      DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
79      DocumentBuilder builder = factory.newDocumentBuilder();
80  	builder.setEntityResolver(new Log4jEntityResolver());
81      Document doc = builder.parse(is);
82      DOMConfigurator.configure(doc.getDocumentElement());
83    }
84    
85    public void test1() throws Exception {
86      configure("simpleFilter1.xml");
87  
88      common();
89      
90      ControlFilter cf = new ControlFilter(new String[]{TEST1_PAT, EXCEPTION1, EXCEPTION2, EXCEPTION3});
91      
92  
93      Transformer.transform(TEMP, FILTERED, new Filter[] {cf,
94          new LineNumberFilter(), 
95          new SunReflectFilter(), 
96          new JunitTestRunnerFilter()});
97  
98       assertTrue(Compare.compare(SimpleFilterTest.class,
99               FILTERED,
100              "witness/filter/simpleFilter.1"));
101   }
102 
103     public void test6() throws Exception {
104       configure("simpleFilter6.xml");
105       common();
106 
107       ControlFilter cf = new ControlFilter(new String[]{TEST1_PAT, EXCEPTION1, EXCEPTION2, EXCEPTION3});
108 
109 
110       Transformer.transform(TEMP, FILTERED, new Filter[] {cf,
111           new LineNumberFilter(),
112           new SunReflectFilter(),
113           new JunitTestRunnerFilter()});
114 
115        assertTrue(Compare.compare(SimpleFilterTest.class, FILTERED, "witness/filter/simpleFilter.6"));
116     }
117 
118     public void test7() throws Exception {
119       configure("simpleFilter7.xml");
120       common();
121 
122       ControlFilter cf = new ControlFilter(new String[]{TEST1_PAT, EXCEPTION1, EXCEPTION2, EXCEPTION3});
123 
124 
125       Transformer.transform(TEMP, FILTERED, new Filter[] {cf,
126           new LineNumberFilter(),
127           new SunReflectFilter(),
128           new JunitTestRunnerFilter()});
129 
130        assertTrue(Compare.compare(SimpleFilterTest.class, FILTERED, "witness/filter/simpleFilter.7"));
131     }
132 
133     public void test8() throws Exception {
134       configure("simpleFilter8.xml");
135       common();
136 
137       ControlFilter cf = new ControlFilter(new String[]{TEST8_PAT, EXCEPTION1, EXCEPTION2, EXCEPTION3});
138 
139 
140       Transformer.transform(TEMP, FILTERED, new Filter[] {cf,
141           new LineNumberFilter(),
142           new SunReflectFilter(),
143           new JunitTestRunnerFilter()});
144 
145        assertTrue(Compare.compare(SimpleFilterTest.class, FILTERED, "witness/filter/simpleFilter.8"));
146     }
147 
148     public void test9() throws Exception {
149       configure("simpleFilter9.xml");
150       common();
151 
152       ControlFilter cf = new ControlFilter(new String[]{TEST1_PAT, EXCEPTION1, EXCEPTION2, EXCEPTION3});
153 
154 
155       Transformer.transform(TEMP, FILTERED, new Filter[] {cf,
156           new LineNumberFilter(),
157           new SunReflectFilter(),
158           new JunitTestRunnerFilter()});
159 
160        assertTrue(Compare.compare(SimpleFilterTest.class, FILTERED, "witness/filter/simpleFilter.1"));
161     }
162 
163     public void test10() throws Exception {
164       configure("simpleFilter10.xml");
165       common();
166 
167       ControlFilter cf = new ControlFilter(new String[]{TEST1_PAT, EXCEPTION1, EXCEPTION2, EXCEPTION3});
168 
169 
170       Transformer.transform(TEMP, FILTERED, new Filter[] {cf,
171           new LineNumberFilter(),
172           new SunReflectFilter(),
173           new JunitTestRunnerFilter()});
174 
175        assertTrue(Compare.compare(SimpleFilterTest.class, FILTERED, "witness/filter/simpleFilter.6"));
176     }
177 
178     public void test11() throws Exception {
179       configure("simpleFilter11.xml");
180       common();
181 
182       ControlFilter cf = new ControlFilter(new String[]{TEST1_PAT, EXCEPTION1, EXCEPTION2, EXCEPTION3});
183 
184 
185       Transformer.transform(TEMP, FILTERED, new Filter[] {cf,
186           new LineNumberFilter(),
187           new SunReflectFilter(),
188           new JunitTestRunnerFilter()});
189 
190        assertTrue(Compare.compare(SimpleFilterTest.class, FILTERED, "witness/filter/simpleFilter.11"));
191     }
192 
193     public void test12() throws Exception {
194       configure("simpleFilter12.xml");
195       common();
196 
197       ControlFilter cf = new ControlFilter(new String[]{TEST8_PAT, EXCEPTION1, EXCEPTION2, EXCEPTION3});
198 
199 
200       Transformer.transform(TEMP, FILTERED, new Filter[] {cf,
201           new LineNumberFilter(),
202           new SunReflectFilter(),
203           new JunitTestRunnerFilter()});
204 
205        assertTrue(Compare.compare(SimpleFilterTest.class, FILTERED, "witness/filter/simpleFilter.8"));
206     }
207 
208   
209   void common() {
210     int i = -1;
211  
212     logger.debug("Message " + ++i);
213     root.debug("Message " + i);        
214 
215     logger.info ("Message " + ++i);
216     root.info("Message " + i);        
217 
218     logger.warn ("Message " + ++i);
219     root.warn("Message " + i);        
220 
221     logger.error("Message " + ++i);
222     root.error("Message " + i);
223     
224     logger.log(Level.FATAL, "Message " + ++i);
225     root.log(Level.FATAL, "Message " + i);    
226     
227     Exception e = new Exception("Just testing");
228     logger.debug("Message " + ++i, e);
229     root.debug("Message " + i, e);
230     
231     logger.error("Message " + ++i, e);
232     root.error("Message " + i, e);    
233   }
234   
235 }