Java > Open Source Codes > org > objectweb > util > monolog > file > monolog > TestPropertiesConfAccess


1 /**
2  * Copyright (C) 2002
3  */
4
5 package org.objectweb.util.monolog.file.monolog;
6
7 import org.objectweb.util.monolog.TestHelper;
8 import org.objectweb.util.monolog.TestSuite;
9 import org.objectweb.util.monolog.wrapper.common.LevelImpl;
10 import org.objectweb.util.monolog.api.BasicLevel;
11 import org.objectweb.util.monolog.api.TopicalLogger;
12 import org.objectweb.util.monolog.api.Level;
13 import org.objectweb.util.monolog.api.Handler;
14
15 import java.util.Enumeration ;
16 import java.util.Properties ;
17 import java.util.Set ;
18 import java.util.Iterator ;
19 import java.util.Map ;
20 import java.util.StringTokenizer ;
21
22 /**
23  * This test is based on JUnit and verifies the PropertiesConfAccess class.
24  *
25  * @author Sebastien Chassande-Barrioz
26  */
27 public class TestPropertiesConfAccess extends TestHelper {
28     /**
29      * For running the TestPropertiesConfAccess suite standalone.
30      */
31     public static void main(String args[]) {
32         if (args.length < 1) {
33             System.out.println("Syntax error !");
34             System.out.println("java TestPropertiesConfAccess <logger factory class name>");
35             System.exit(1);
36         }
37         TestHelper.run(TestPropertiesConfAccess.class, new String [0],
38             new String [0], args[0]);
39     }
40
41     /**
42      * Return the test suite associated to this class.
43      */
44     public static TestSuite getTestSuite(String lfcn) {
45         return TestHelper.getTestSuite(TestPropertiesConfAccess.class, new String [0],
46             new String [0], lfcn);
47     }
48
49     /**
50      * It tests the store method.
51      */
52     public void testStoreConf() {
53         // Create monolog objects Logger, Handler, Level
54 //==============================================
55 try {
56             //------ Level ------//
57
58             //level.DEBUG1 10001
59 assertNotNull("Bad definition",
60                 lef.defineLevel("DEBUG1", BasicLevel.DEBUG + 1));
61
62             //level.DEBUG2 "DEBUG + 2"
63 assertNotNull("Bad definition",
64                 lef.defineLevel("DEBUG2", "DEBUG + 2"));
65
66             //level.DEBUG2bis 10002
67 assertNotNull("Bad definition",
68                 lef.defineLevel("DEBUG2bis", BasicLevel.DEBUG + 2));
69
70             //level.INFObis 20000
71 assertNotNull("Bad definition",
72                 lef.defineLevel("INFObis", BasicLevel.INFO));
73
74             //level.WARNbis WARN
75 assertNotNull("Bad definition",
76                 lef.defineLevel("WARNbis", "WARN"));
77
78             lef.defineLevel("FATAL", "50000");
79
80             //------ Handler ------//
81 Handler h = hf.createHandler("handler_sys_out", "console");
82             h.setAttribute(Handler.OUTPUT_ATTRIBUTE, "System.out");
83             h.setAttribute(Handler.PATTERN_ATTRIBUTE, "%m%n");
84             h.setAttribute("activation", hf);
85
86             h = hf.createHandler("Handler_file", "file");
87             h.setAttribute(Handler.OUTPUT_ATTRIBUTE, "toto.txt");
88             h.setAttribute(Handler.PATTERN_ATTRIBUTE, "%p %m%n");
89             h.setAttribute("activation", hf);
90
91             h = hf.createHandler("Handler.rolling.file", "rollingfile");
92             h.setAttribute(Handler.OUTPUT_ATTRIBUTE, "toto");
93             h.setAttribute(Handler.MAX_SIZE_ATTRIBUTE, "300");
94             h.setAttribute(Handler.FILE_NUMBER_ATTRIBUTE, "2");
95             h.setAttribute(Handler.PATTERN_ATTRIBUTE, "%p - %m%n");
96             h.setAttribute("activation", hf);
97
98
99             //------ Logger ------//
100
101             TopicalLogger l = null;
102             //logger.root.level WARN
103 // or
104 //logger..level WARN
105 l = (TopicalLogger) lf.getLogger("");
106             l.setIntLevel(BasicLevel.WARN);
107
108             //nothing required
109 l = (TopicalLogger) lf.getLogger("org.foo.bar");
110
111             // logger.org.level FATAL
112 l = (TopicalLogger) lf.getLogger("org");
113             l.setIntLevel(BasicLevel.FATAL);
114
115             // logger.org.foo.bar2.level INFO
116 l = (TopicalLogger) lf.getLogger("org.foo.bar2");
117             l.setIntLevel(BasicLevel.INFO);
118
119             // logger.org.foo.bar3.topic.0 fr.inria.sardes3
120 // logger.org.foo.bar3.topic.1 fr.inrialpes.sardes3
121 l = (TopicalLogger) lf.getLogger("org.foo.bar3");
122             l.addTopic("fr.inria.sardes3");
123             l.addTopic("fr.inrialpes.sardes3");
124
125             // logger.org.foo.bar4.level ERROR
126 // logger.org.foo.bar4.topic.0 fr.inria.sardes4
127 // logger.org.foo.bar4.topic.1 fr.inrialpes.sardes4
128 l = (TopicalLogger) lf.getLogger("org.foo.bar4");
129             l.setIntLevel(BasicLevel.ERROR);
130             l.addTopic("fr.inria.sardes4");
131             l.addTopic("fr.inrialpes.sardes4");
132
133             //logger.org.foo.bar5.handler.0 Handler_file
134 l = (TopicalLogger) lf.getLogger("org.foo.bar5");
135             l.addHandler( hf.getHandler("Handler_file"));
136
137             //logger.org.foo.bar6.handler.0 Handler_file
138 l = (TopicalLogger) lf.getLogger("org.foo.bar6");
139             l.addHandler( hf.getHandler("Handler_file"));
140             l.addHandler( hf.getHandler("Handler.rolling.file"));
141         }
142         catch (Exception e) {
143             e.printStackTrace();
144             fail(e.getMessage());
145         }
146         //System.out.println("Store in a properties variable:");
147 // Store the configuration into a properties
148 //==========================================
149 Properties p = new Properties ();
150         try {
151             PropertiesConfAccess.store(p, lf, hf, lef);
152         }
153         catch (Exception e) {
154             e.printStackTrace();
155             fail(e.getMessage());
156         }
157
158         // Check the properties
159 //=====================
160 //System.out.println("Check the properties variable:");
161
162         //------ Level ------//
163 Set s = p.keySet();
164         checkExist(p, s, "level.DEBUG1", String.valueOf(BasicLevel.DEBUG + 1),
165             "level: integer value");
166         checkExist(p, s, "level.DEBUG2", "DEBUG + 2", "level: string expr");
167         checkExist(p, s, "level.DEBUG2bis", String.valueOf(BasicLevel.DEBUG + 2),
168             "level: integer value, duplicat");
169         checkExist(p, s, "level.INFObis", "20000", "level: value");
170         checkExist(p, s, "level.WARNbis", "WARN", "level: value");
171         checkUnExist(s, "level.FATAL","level: predefined level");
172
173         //------ Handler ------//
174 checkExist(p, s, "handler.handler_sys_out.type", "console",
175             "handler: bad console type");
176         checkExist(p, s, "handler.handler_sys_out." + Handler.OUTPUT_ATTRIBUTE,
177             "System.out", "handler: bad console output");
178         checkExist(p, s, "handler.handler_sys_out." + Handler.PATTERN_ATTRIBUTE,
179             "%m%n", "handler: bad console pattern");
180
181         checkExist(p, s, "handler.Handler_file.type", "file",
182             "handler: bad file type");
183         checkExist(p, s, "handler.Handler_file." + Handler.OUTPUT_ATTRIBUTE,
184             "toto.txt", "handler: bad file output");
185         checkExist(p, s, "handler.Handler_file." + Handler.PATTERN_ATTRIBUTE,
186             "%p %m%n", "handler: bad file pattern");
187
188         checkExist(p, s, "handler.Handler.rolling.file.type", "rollingfile",
189             "handler: bad rolling file type");
190         checkExist(p, s, "handler.Handler.rolling.file." + Handler.OUTPUT_ATTRIBUTE,
191             "toto", "handler: bad rolling file output");
192         checkExist(p, s, "handler.Handler.rolling.file." + Handler.PATTERN_ATTRIBUTE,
193             "%p - %m%n", "handler: bad rolling file pattern");
194         checkExist(p, s, "handler.Handler.rolling.file." + Handler.MAX_SIZE_ATTRIBUTE,
195             "300", "handler: bad rolling file max size");
196         checkExist(p, s, "handler.Handler.rolling.file." + Handler.FILE_NUMBER_ATTRIBUTE,
197             "2", "handler: bad rolling file number of file");
198
199         //------ Logger ------//
200 checkUnExist(s, "logger.org.foo.bar.level", "just the name");
201
202         checkExist(p, s, "logger.org.level", "FATAL",
203             "logger: Simple name & Just level");
204
205         checkExist(p, s, "logger.org.foo.bar2.level", "INFO",
206             "logger: Dotted name & Just level");
207
208         checkBeginExist(p, "logger.org.foo.bar5.handler", "Handler_file",
209             "logger: Dotted name & Just handler");
210
211         checkBeginExist(p, "logger.org.foo.bar6.handler", "Handler_file",
212             "logger: Dotted name & Just handler");
213         checkBeginExist(p, "logger.org.foo.bar6.handler", "Handler.rolling.file",
214             "logger: Dotted name & Just handler");
215
216         checkBeginExist(p, "logger.org.foo.bar3.topic", "fr.inria.sardes3",
217             "logger: Dotted name, no level, 2 topic: topic1");
218         checkBeginExist(p, "logger.org.foo.bar3.topic", "fr.inrialpes.sardes3",
219             "logger: Dotted name, no level, 2 topic: topic2");
220
221         checkExist(p, s, "logger.org.foo.bar4.level", "ERROR",
222             "logger: Dotted name, Just level, topic: level");
223         checkBeginExist(p, "logger.org.foo.bar4.topic", "fr.inria.sardes4",
224             "logger: Dotted name, ERROR level, 2 topic: topic1");
225         checkBeginExist(p, "logger.org.foo.bar4.topic", "fr.inrialpes.sardes4",
226             "logger: Dotted name, ERROR level, 2 topic: topic2");
227
228     }
229
230     /**
231      * It tests the load method
232      */
233     public void testLoadConf() {
234
235         // Full a properties
236 //==================
237 Properties p = new Properties ();
238         //------ Level ------//
239 p.setProperty("level.LOAD_DEBUG1", "DEBUG + 1");
240
241         p.setProperty("level.LOAD_DEBUG2", String.valueOf(BasicLevel.DEBUG + 2));
242
243         //------ Handler ------//
244 p.setProperty("handler.myhandler1.type", "console");
245         p.setProperty("handler.myhandler1.output", "System.out");
246         p.setProperty("handler.myhandler1.pattern", "%m%n");
247
248         p.setProperty("handler.test.load.myhandler2.type", "file");
249         p.setProperty("handler.test.load.myhandler2.output", "myhandler2.log");
250         p.setProperty("handler.test.load.myhandler2.pattern", "=> %m%n");
251
252         p.setProperty("handler.test.load.myhandler3.type", "rollingfile");
253         p.setProperty("handler.test.load.myhandler3.output", "myhandler3.log");
254         p.setProperty("handler.test.load.myhandler3.pattern", "-> %m%n");
255         p.setProperty("handler.test.load.myhandler3.fileNumber", "2");
256         p.setProperty("handler.test.load.myhandler3.maxSize", "20");
257
258         //------ Logger ------//
259 p.setProperty("logger.test.load.bar.level", "DEBUG");
260
261         p.setProperty("logger.test.load.foo.level", "LOAD_DEBUG1");
262
263         p.setProperty("logger.test.load.foo2.topic.0", "org.ow.foo");
264         p.setProperty("logger.test.load.foo2.topic.1", "org.ow.foo2");
265
266         p.setProperty("logger.test.load.foo3.handler.0", "myhandler1");
267
268         p.setProperty("logger.test.load.foo4.handler.0", "test.load.myhandler2");
269         p.setProperty("logger.test.load.foo4.handler.1", "test.load.myhandler3");
270
271
272         // Load the properties
273 //==========================
274 try {
275             PropertiesConfAccess.load(p, lf, hf, lef);
276         }
277         catch (Exception e) {
278             e.printStackTrace();
279             fail(e.getMessage());
280         }
281
282         // Check the monolog objects
283 //==========================
284 //------ Level ------//
285 Level le = null;
286         le = lef.getLevel("LOAD_DEBUG1");
287         assertNotNull("level: LOAD_DEBUG1: undefined", le);
288         assertEquals("level: LOAD_DEBUG1: bad int value",
289             BasicLevel.DEBUG + 1,le.getIntValue());
290         assertEquals("level: LOAD_DEBUG1: bad string expr",
291             "DEBUG + 1", ((LevelImpl) le).getStringValue());
292
293         le = lef.getLevel("LOAD_DEBUG2");
294         assertNotNull("level: LOAD_DEBUG2: undefined", le);
295         assertEquals("level: LOAD_DEBUG2: bad int value",
296             BasicLevel.DEBUG + 2,le.getIntValue());
297         assertEquals("level: LOAD_DEBUG2: bad string expr",
298             String.valueOf(BasicLevel.DEBUG + 2),
299             ((LevelImpl) le).getStringValue());
300
301         //------ Handler ------//
302 Handler h = null;
303         h = hf.getHandler("myhandler1");
304         assertNotNull("handler: myhandler1: undefined", h);
305         assertEquals("handler: myhandler1: bad type",
306             PropertiesConfAccess.HANDLER_TYPE_ATTRIBUTE_CONSOLE_VALUE, h.getType());
307         assertEquals("handler: myhandler1: bad output",
308             "System.out", h.getAttribute(Handler.OUTPUT_ATTRIBUTE));
309         assertEquals("handler: myhandler1: bad pattern",
310             "%m%n", h.getAttribute(Handler.PATTERN_ATTRIBUTE));
311
312         h = hf.getHandler("test.load.myhandler2");
313         assertNotNull("handler: test.load.myhandler2: undefined", h);
314         assertEquals("handler: test.load.myhandler2: bad type",
315             PropertiesConfAccess.HANDLER_TYPE_ATTRIBUTE_FILE_VALUE, h.getType());
316         assertEquals("handler: test.load.myhandler2: bad output",
317             "myhandler2.log", h.getAttribute(Handler.OUTPUT_ATTRIBUTE));
318         assertEquals("handler: test.load.myhandler2: bad pattern",
319             "=> %m%n", h.getAttribute(Handler.PATTERN_ATTRIBUTE));
320
321         h = hf.getHandler("test.load.myhandler3");
322         assertNotNull("handler: test.load.myhandler3: undefined", h);
323         assertEquals("handler: test.load.myhandler3: bad type",
324             PropertiesConfAccess.HANDLER_TYPE_ATTRIBUTE_ROLLING_FILE_VALUE, h.getType());
325         assertEquals("handler: test.load.myhandler2: bad output",
326             "myhandler3.log", h.getAttribute(Handler.OUTPUT_ATTRIBUTE));
327         assertEquals("handler: test.load.myhandler2: bad pattern",
328             "-> %m%n", h.getAttribute(Handler.PATTERN_ATTRIBUTE));
329         assertEquals("handler: test.load.myhandler2: bad file number",
330             "2", h.getAttribute(Handler.FILE_NUMBER_ATTRIBUTE));
331         assertEquals("handler: test.load.myhandler2: bad max size",
332             "20", h.getAttribute(Handler.MAX_SIZE_ATTRIBUTE));
333
334         //------ Logger ------//
335 TopicalLogger l = null;
336         l = (TopicalLogger) lf.getLogger("test.load.bar");
337         assertEquals("logger: test.load.bar: bad level",
338             BasicLevel.DEBUG, l.getCurrentIntLevel());
339
340         l = (TopicalLogger) lf.getLogger("test.load.foo");
341         assertEquals("logger: test.load.foo: bad level",
342             BasicLevel.DEBUG + 1, l.getCurrentIntLevel());
343
344         l = (TopicalLogger) lf.getLogger("test.load.foo3");
345         Handler[] hs = l.getHandler();
346         assertNotNull("logger: test.load.foo3: handler list is null", hs);
347         assertEquals("logger: test.load.foo3: handler list is empty",
348             1, hs.length);
349         assertEquals("logger: test.load.foo3: bad handler",
350             hf.getHandler("myhandler1"), hs[0]);
351
352         l = (TopicalLogger) lf.getLogger("test.load.foo4");
353         hs = l.getHandler();
354         assertNotNull("logger: test.load.foo4: handler list is null", hs);
355         assertEquals("logger: test.load.foo4: handler list is empty",
356             2, hs.length);
357         assertNotNull("logger: test.load.foo4: handler element 0 is null", hs[0]);
358         assertNotNull("logger: test.load.foo4: handler element 1 is null", hs[1]);
359         if (!hs[0].equals(hf.getHandler("test.load.myhandler2"))
360                 && !hs[1].equals(hf.getHandler("test.load.myhandler2"))) {
361             fail("logger: test.load.foo4: 'test.load.myhandler2' handler not found");
362         }
363         if (!hs[0].equals(hf.getHandler("test.load.myhandler3"))
364                 && !hs[1].equals(hf.getHandler("test.load.myhandler3"))) {
365             fail("logger: test.load.foo4: 'test.load.myhandler3' handler not found");
366         }
367
368         l = (TopicalLogger) lf.getLogger("test.load.foo2");
369         String [] ts = l.getTopic();
370         assertNotNull("logger: test.load.foo2: topic list is null", ts);
371         assertEquals("logger: test.load.foo2: bad topic list size",
372             3, ts.length);
373         assertNotNull("logger: test.load.foo2: topic element 0 is null", ts[0]);
374         assertNotNull("logger: test.load.foo2: topic element 1 is null", ts[1]);
375         assertNotNull("logger: test.load.foo2: topic element 2 is null", ts[2]);
376         if (!ts[0].equals("test.load.foo2")
377             && !ts[1].equals("test.load.foo2")
378             && !ts[2].equals("test.load.foo2")) {
379             fail("logger: test.load.foo2: main topic not found");
380         }
381         if (!ts[0].equals("org.ow.foo")
382             && !ts[1].equals("org.ow.foo")
383             && !ts[2].equals("org.ow.foo")) {
384             fail("logger: test.load.foo2: 'org.ow.foo' topic not found");
385         }
386         if (!ts[0].equals("org.ow.foo2")
387             && !ts[1].equals("org.ow.foo2")
388             && !ts[2].equals("org.ow.foo2")) {
389             fail("logger: test.load.foo2: 'org.ow.foo2' topic not found");
390         }
391     }
392
393     /**
394      * It verifies that the couple (key, value) is available in a Properties.
395      * @param p is the properties where to find the key and the value.
396      * @param s is the key set of the properies p
397      * @param key is the string which must be a key in the properties
398      * @param value is the object which must be value associated to the key
399      * @param msg is the error messageis the (key, value) is not found
400      */
401     public void checkExist(Properties p, Set s, String key,
402                            String value, String msg) {
403         boolean t = s.contains(key);
404         if (!t) {
405             //printProperties(p);
406 }
407         assertTrue(msg + ": not found", t);
408         assertEquals(msg + ": (" + key + ")bad value", value, p.getProperty(key));
409     }
410
411     /**
412      * It verifies that a String is not available in a Set.
413      * @param s is the set.
414      * @param key is the string which must not be a key in the set
415      * @param msg is the error messageis the (key, value) is found
416      */
417     public void checkUnExist(Set s, String key, String msg) {
418         assertTrue(msg + ": found", !s.contains(key));
419     }
420
421     public void checkBeginExist(Properties p, String key,
422                            String value, String msg) {
423         boolean found = false;
424         debug("checkBeginExist( key=" + key + " / value=" + value);
425         for(Enumeration e = p.keys(); e.hasMoreElements();) {
426             String cur = (String ) e.nextElement();
427             debug(" cur=" + cur + " / val=" + p.getProperty(cur, ""));
428             if (cur.startsWith(key)) {
429                 StringTokenizer st = new StringTokenizer (p.getProperty(cur, ""), ", ", false);
430                 while(st.hasMoreTokens()) {
431                     String tok = st.nextToken();
432                     if (tok.equals(value)) {
433                         if (found) {
434                             fail(msg + "duplicated value: " + value);
435                         } else {
436                             found = true;
437                         }
438                     }
439                 }
440             }
441         }
442         if (!found) {
443             System.out.println("\n" + msg + ": not found");
444             this.printProperties(p);
445         }
446         assertTrue(msg + ": not found", found);
447     }
448     public void printProperties(Properties p) {
449         for(Iterator it = p.entrySet().iterator(); it.hasNext();) {
450             Map.Entry me = (Map.Entry ) it.next();
451             System.out.println(me.getKey() + "=" + me.getValue());
452         }
453     }
454 }

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags