1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 package org.apache.log4j.rolling;
19
20 import junit.framework.TestCase;
21 import org.apache.log4j.Appender;
22 import org.apache.log4j.ConsoleAppender;
23 import org.apache.log4j.LogManager;
24 import org.apache.log4j.Logger;
25 import org.apache.log4j.PatternLayout;
26 import org.apache.log4j.util.Compare;
27
28 import java.io.File;
29 import java.io.FileOutputStream;
30
31
32 /***
33 *
34 * Do not forget to call activateOptions when configuring programatically.
35 *
36 * @author Ceki Gülcü
37 *
38 */
39 public class SizeBasedRollingTest extends TestCase {
40 Logger logger = Logger.getLogger(SizeBasedRollingTest.class);
41 Logger root = Logger.getRootLogger();
42
43 public SizeBasedRollingTest(String name) {
44 super(name);
45 }
46
47 public void setUp() {
48 Appender ca = new ConsoleAppender(new PatternLayout("%d %level %c -%m%n"));
49 ca.setName("CONSOLE");
50 root.addAppender(ca);
51 }
52
53 public void tearDown() {
54 LogManager.shutdown();
55 }
56
57 /***
58 * Tests that the lack of an explicit active file will use the
59 * low index as the active file.
60 *
61 */
62 public void test1() throws Exception {
63 PatternLayout layout = new PatternLayout("%m\n");
64 RollingFileAppender rfa = new RollingFileAppender();
65 rfa.setName("ROLLING");
66 rfa.setAppend(false);
67 rfa.setLayout(layout);
68
69 FixedWindowRollingPolicy swrp = new FixedWindowRollingPolicy();
70 SizeBasedTriggeringPolicy sbtp = new SizeBasedTriggeringPolicy();
71
72 sbtp.setMaxFileSize(100);
73 swrp.setMinIndex(0);
74
75 swrp.setFileNamePattern("sizeBased-test1.%i");
76 swrp.activateOptions();
77
78 rfa.setRollingPolicy(swrp);
79 rfa.setTriggeringPolicy(sbtp);
80 rfa.activateOptions();
81 root.addAppender(rfa);
82
83
84 for (int i = 0; i < 25; i++) {
85 if (i < 10) {
86 logger.debug("Hello---" + i);
87 } else if (i < 100) {
88 logger.debug("Hello--" + i);
89 }
90 }
91
92 assertTrue(new File("sizeBased-test1.0").exists());
93 assertTrue(new File("sizeBased-test1.1").exists());
94 assertTrue(new File("sizeBased-test1.2").exists());
95
96 assertTrue(Compare.compare(SizeBasedRollingTest.class,
97 "sizeBased-test1.0",
98 "witness/rolling/sbr-test2.log"));
99 assertTrue(Compare.compare(SizeBasedRollingTest.class,
100 "sizeBased-test1.1",
101 "witness/rolling/sbr-test2.0"));
102 assertTrue(Compare.compare(SizeBasedRollingTest.class,
103 "sizeBased-test1.2",
104 "witness/rolling/sbr-test2.1"));
105 }
106
107 /***
108 * Test basic rolling functionality with explicit setting of FileAppender.file.
109 */
110 public void test2() throws Exception {
111 PatternLayout layout = new PatternLayout("%m\n");
112 RollingFileAppender rfa = new RollingFileAppender();
113 rfa.setName("ROLLING");
114 rfa.setAppend(false);
115 rfa.setLayout(layout);
116 rfa.setFile("sizeBased-test2.log");
117
118 FixedWindowRollingPolicy swrp = new FixedWindowRollingPolicy();
119 SizeBasedTriggeringPolicy sbtp = new SizeBasedTriggeringPolicy();
120
121 sbtp.setMaxFileSize(100);
122 swrp.setMinIndex(0);
123
124 swrp.setFileNamePattern("sizeBased-test2.%i");
125 swrp.activateOptions();
126
127 rfa.setRollingPolicy(swrp);
128 rfa.setTriggeringPolicy(sbtp);
129 rfa.activateOptions();
130 root.addAppender(rfa);
131
132
133 for (int i = 0; i < 25; i++) {
134 if (i < 10) {
135 logger.debug("Hello---" + i);
136 } else if (i < 100) {
137 logger.debug("Hello--" + i);
138 }
139 }
140
141 assertTrue(new File("sizeBased-test2.log").exists());
142 assertTrue(new File("sizeBased-test2.0").exists());
143 assertTrue(new File("sizeBased-test2.1").exists());
144
145 assertTrue(Compare.compare(SizeBasedRollingTest.class,
146 "sizeBased-test2.log",
147 "witness/rolling/sbr-test2.log"));
148 assertTrue(Compare.compare(SizeBasedRollingTest.class,
149 "sizeBased-test2.0",
150 "witness/rolling/sbr-test2.0"));
151 assertTrue(Compare.compare(SizeBasedRollingTest.class,
152 "sizeBased-test2.1",
153 "witness/rolling/sbr-test2.1"));
154 }
155
156 /***
157 * Same as testBasic but also with GZ compression.
158 */
159 public void test3() throws Exception {
160 PatternLayout layout = new PatternLayout("%m\n");
161 RollingFileAppender rfa = new RollingFileAppender();
162 rfa.setAppend(false);
163 rfa.setLayout(layout);
164
165 FixedWindowRollingPolicy fwrp = new FixedWindowRollingPolicy();
166 SizeBasedTriggeringPolicy sbtp = new SizeBasedTriggeringPolicy();
167
168 sbtp.setMaxFileSize(100);
169 fwrp.setMinIndex(0);
170 rfa.setFile("sbr-test3.log");
171 fwrp.setFileNamePattern("sbr-test3.%i.gz");
172 fwrp.activateOptions();
173 rfa.setRollingPolicy(fwrp);
174 rfa.setTriggeringPolicy(sbtp);
175 rfa.activateOptions();
176 root.addAppender(rfa);
177
178
179 for (int i = 0; i < 25; i++) {
180 Thread.sleep(100);
181 if (i < 10) {
182 logger.debug("Hello---" + i);
183 } else if (i < 100) {
184 logger.debug("Hello--" + i);
185 }
186 }
187
188 assertTrue(new File("sbr-test3.log").exists());
189 assertTrue(new File("sbr-test3.0.gz").exists());
190 assertTrue(new File("sbr-test3.1.gz").exists());
191
192 assertTrue(Compare.compare(SizeBasedRollingTest.class,
193 "sbr-test3.log", "witness/rolling/sbr-test3.log"));
194 assertTrue(Compare.gzCompare(SizeBasedRollingTest.class,
195 "sbr-test3.0.gz", "witness/rolling/sbr-test3.0.gz"));
196 assertTrue(Compare.gzCompare(SizeBasedRollingTest.class,
197 "sbr-test3.1.gz", "witness/rolling/sbr-test3.1.gz"));
198 }
199
200 /***
201 * Test basic rolling functionality with bogus path in file name pattern.
202 */
203 public void test4() throws Exception {
204 PatternLayout layout = new PatternLayout("%m\n");
205 RollingFileAppender rfa = new RollingFileAppender();
206 rfa.setName("ROLLING");
207 rfa.setAppend(false);
208 rfa.setLayout(layout);
209 rfa.setFile("sizeBased-test4.log");
210
211 FixedWindowRollingPolicy swrp = new FixedWindowRollingPolicy();
212 SizeBasedTriggeringPolicy sbtp = new SizeBasedTriggeringPolicy();
213
214 sbtp.setMaxFileSize(100);
215 swrp.setMinIndex(0);
216
217
218
219
220 swrp.setFileNamePattern("test4/sizeBased-test4.%i");
221 swrp.activateOptions();
222
223 rfa.setRollingPolicy(swrp);
224 rfa.setTriggeringPolicy(sbtp);
225 rfa.activateOptions();
226 root.addAppender(rfa);
227
228
229 for (int i = 0; i < 25; i++) {
230 if (i < 10) {
231 logger.debug("Hello---" + i);
232 } else if (i < 100) {
233 logger.debug("Hello--" + i);
234 }
235 }
236
237 assertTrue(new File("sizeBased-test4.log").exists());
238
239 assertTrue(Compare.compare(SizeBasedRollingTest.class,
240 "sizeBased-test4.log",
241 "witness/rolling/sbr-test4.log"));
242 }
243
244 /***
245 * Checking handling of rename failures due to other access
246 * to the indexed files.
247 */
248 public void test5() throws Exception {
249
250
251 new File("sizeBased-test5.2").delete();
252 new File("sizeBased-test5.3").delete();
253 PatternLayout layout = new PatternLayout("%m\n");
254 RollingFileAppender rfa = new RollingFileAppender();
255 rfa.setName("ROLLING");
256 rfa.setAppend(false);
257 rfa.setLayout(layout);
258 rfa.setFile("sizeBased-test5.log");
259
260 FixedWindowRollingPolicy swrp = new FixedWindowRollingPolicy();
261 SizeBasedTriggeringPolicy sbtp = new SizeBasedTriggeringPolicy();
262
263 sbtp.setMaxFileSize(100);
264 swrp.setMinIndex(0);
265
266 swrp.setFileNamePattern("sizeBased-test5.%i");
267 swrp.activateOptions();
268
269 rfa.setRollingPolicy(swrp);
270 rfa.setTriggeringPolicy(sbtp);
271 rfa.activateOptions();
272 root.addAppender(rfa);
273
274
275
276 FileOutputStream os1 = new FileOutputStream("sizeBased-test5.1");
277 os1.close();
278
279
280 FileOutputStream os0 = new FileOutputStream("sizeBased-test5.0");
281
282
283 for (int i = 0; i < 25; i++) {
284 if (i < 10) {
285 logger.debug("Hello---" + i);
286 } else if (i < 100) {
287 logger.debug("Hello--" + i);
288 }
289 }
290
291 os0.close();
292
293 if (new File("sizeBased-test5.3").exists()) {
294
295
296
297 assertTrue(new File("sizeBased-test5.log").exists());
298 assertTrue(new File("sizeBased-test5.0").exists());
299 assertTrue(new File("sizeBased-test5.1").exists());
300 assertTrue(new File("sizeBased-test5.2").exists());
301 assertTrue(new File("sizeBased-test5.3").exists());
302
303 assertTrue(Compare.compare(
304 SizeBasedRollingTest.class,
305 "sizeBased-test5.log",
306 "witness/rolling/sbr-test2.log"));
307 assertTrue(Compare.compare(SizeBasedRollingTest.class,
308 "sizeBased-test5.0",
309 "witness/rolling/sbr-test2.0"));
310 assertTrue(Compare.compare(SizeBasedRollingTest.class,
311 "sizeBased-test5.1",
312 "witness/rolling/sbr-test2.1"));
313
314 } else {
315
316
317
318
319
320 assertTrue(new File("sizeBased-test5.log").exists());
321 assertTrue(new File("sizeBased-test5.0").exists());
322 assertTrue(new File("sizeBased-test5.2").exists());
323
324 assertTrue(Compare.compare(
325 SizeBasedRollingTest.class,"sizeBased-test5.log",
326 "witness/rolling/sbr-test4.log"));
327 }
328 }
329
330
331 /***
332 * Test basic rolling functionality with explicit setting of
333 * obsolete FixedWindowRollingPolicy.activeFileName.
334 * @deprecated Tests deprecated method
335 */
336 public void test6() throws Exception {
337 PatternLayout layout = new PatternLayout("%m\n");
338 RollingFileAppender rfa = new RollingFileAppender();
339 rfa.setName("ROLLING");
340 rfa.setAppend(false);
341 rfa.setLayout(layout);
342
343 FixedWindowRollingPolicy swrp = new FixedWindowRollingPolicy();
344 SizeBasedTriggeringPolicy sbtp = new SizeBasedTriggeringPolicy();
345
346 sbtp.setMaxFileSize(100);
347 swrp.setMinIndex(0);
348 swrp.setActiveFileName("sizeBased-test6.log");
349
350 swrp.setFileNamePattern("sizeBased-test6.%i");
351 swrp.activateOptions();
352
353 rfa.setRollingPolicy(swrp);
354 rfa.setTriggeringPolicy(sbtp);
355 rfa.activateOptions();
356 root.addAppender(rfa);
357
358
359 for (int i = 0; i < 25; i++) {
360 if (i < 10) {
361 logger.debug("Hello---" + i);
362 } else if (i < 100) {
363 logger.debug("Hello--" + i);
364 }
365 }
366
367 assertTrue(new File("sizeBased-test6.log").exists());
368 assertTrue(new File("sizeBased-test6.0").exists());
369 assertTrue(new File("sizeBased-test6.1").exists());
370
371 assertTrue(Compare.compare(SizeBasedRollingTest.class,
372 "sizeBased-test6.log",
373 "witness/rolling/sbr-test2.log"));
374 assertTrue(Compare.compare(SizeBasedRollingTest.class,
375 "sizeBased-test6.0",
376 "witness/rolling/sbr-test2.0"));
377 assertTrue(Compare.compare(SizeBasedRollingTest.class,
378 "sizeBased-test6.1",
379 "witness/rolling/sbr-test2.1"));
380 }
381
382
383 }