/**
* Copyright (C) 2002
*/
package org.objectweb.util.monolog.file.monolog;
import org.objectweb.util.monolog.TestHelper;
import org.objectweb.util.monolog.TestSuite;
import org.objectweb.util.monolog.wrapper.common.LevelImpl;
import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.util.monolog.api.TopicalLogger;
import org.objectweb.util.monolog.api.Level;
import org.objectweb.util.monolog.api.Handler;
import java.util.Enumeration;
import java.util.Properties;
import java.util.Set;
import java.util.Iterator;
import java.util.Map;
import java.util.StringTokenizer;
/**
* This test is based on JUnit and verifies the PropertiesConfAccess class.
*
* @author Sebastien Chassande-Barrioz
*/
public class TestPropertiesConfAccess extends TestHelper {
/**
* For running the TestPropertiesConfAccess suite standalone.
*/
public static void main(String args[]) {
if (args.length < 1) {
System.out.println("Syntax error !");
System.out.println("java TestPropertiesConfAccess <logger factory class name>");
System.exit(1);
}
TestHelper.run(TestPropertiesConfAccess.class, new String[0],
new String[0], args[0]);
}
/**
* Return the test suite associated to this class.
*/
public static TestSuite getTestSuite(String lfcn) {
return TestHelper.getTestSuite(TestPropertiesConfAccess.class, new String[0],
new String[0], lfcn);
}
/**
* It tests the store method.
*/
public void testStoreConf() {
// Create monolog objects Logger, Handler, Level
//==============================================
try {
//------ Level ------//
//level.DEBUG1 10001
assertNotNull("Bad definition",
lef.defineLevel("DEBUG1", BasicLevel.DEBUG + 1));
//level.DEBUG2 "DEBUG + 2"
assertNotNull("Bad definition",
lef.defineLevel("DEBUG2", "DEBUG + 2"));
//level.DEBUG2bis 10002
assertNotNull("Bad definition",
lef.defineLevel("DEBUG2bis", BasicLevel.DEBUG + 2));
//level.INFObis 20000
assertNotNull("Bad definition",
lef.defineLevel("INFObis", BasicLevel.INFO));
//level.WARNbis WARN
assertNotNull("Bad definition",
lef.defineLevel("WARNbis", "WARN"));
lef.defineLevel("FATAL", "50000");
//------ Handler ------//
Handler h = hf.createHandler("handler_sys_out", "console");
h.setAttribute(Handler.OUTPUT_ATTRIBUTE, "System.out");
h.setAttribute(Handler.PATTERN_ATTRIBUTE, "%m%n");
h.setAttribute("activation", hf);
h = hf.createHandler("Handler_file", "file");
h.setAttribute(Handler.OUTPUT_ATTRIBUTE, "toto.txt");
h.setAttribute(Handler.PATTERN_ATTRIBUTE, "%p %m%n");
h.setAttribute("activation", hf);
h = hf.createHandler("Handler.rolling.file", "rollingfile");
h.setAttribute(Handler.OUTPUT_ATTRIBUTE, "toto");
h.setAttribute(Handler.MAX_SIZE_ATTRIBUTE, "300");
h.setAttribute(Handler.FILE_NUMBER_ATTRIBUTE, "2");
h.setAttribute(Handler.PATTERN_ATTRIBUTE, "%p - %m%n");
h.setAttribute("activation", hf);
//------ Logger ------//
TopicalLogger l = null;
//logger.root.level WARN
// or
//logger..level WARN
l = (TopicalLogger) lf.getLogger("");
l.setIntLevel(BasicLevel.WARN);
//nothing required
l = (TopicalLogger) lf.getLogger("org.foo.bar");
// logger.org.level FATAL
l = (TopicalLogger) lf.getLogger("org");
l.setIntLevel(BasicLevel.FATAL);
// logger.org.foo.bar2.level INFO
l = (TopicalLogger) lf.getLogger("org.foo.bar2");
l.setIntLevel(BasicLevel.INFO);
// logger.org.foo.bar3.topic.0 fr.inria.sardes3
// logger.org.foo.bar3.topic.1 fr.inrialpes.sardes3
l = (TopicalLogger) lf.getLogger("org.foo.bar3");
l.addTopic("fr.inria.sardes3");
l.addTopic("fr.inrialpes.sardes3");
// logger.org.foo.bar4.level ERROR
// logger.org.foo.bar4.topic.0 fr.inria.sardes4
// logger.org.foo.bar4.topic.1 fr.inrialpes.sardes4
l = (TopicalLogger) lf.getLogger("org.foo.bar4");
l.setIntLevel(BasicLevel.ERROR);
l.addTopic("fr.inria.sardes4");
l.addTopic("fr.inrialpes.sardes4");
//logger.org.foo.bar5.handler.0 Handler_file
l = (TopicalLogger) lf.getLogger("org.foo.bar5");
l.addHandler( hf.getHandler("Handler_file"));
//logger.org.foo.bar6.handler.0 Handler_file
l = (TopicalLogger) lf.getLogger("org.foo.bar6");
l.addHandler( hf.getHandler("Handler_file"));
l.addHandler( hf.getHandler("Handler.rolling.file"));
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
//System.out.println("Store in a properties variable:");
// Store the configuration into a properties
//==========================================
Properties p = new Properties();
try {
PropertiesConfAccess.store(p, lf, hf, lef);
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
// Check the properties
//=====================
//System.out.println("Check the properties variable:");
//------ Level ------//
Set s = p.keySet();
checkExist(p, s, "level.DEBUG1", String.valueOf(BasicLevel.DEBUG + 1),
"level: integer value");
checkExist(p, s, "level.DEBUG2", "DEBUG + 2", "level: string expr");
checkExist(p, s, "level.DEBUG2bis", String.valueOf(BasicLevel.DEBUG + 2),
"level: integer value, duplicat");
checkExist(p, s, "level.INFObis", "20000", "level: value");
checkExist(p, s, "level.WARNbis", "WARN", "level: value");
checkUnExist(s, "level.FATAL","level: predefined level");
//------ Handler ------//
checkExist(p, s, "handler.handler_sys_out.type", "console",
"handler: bad console type");
checkExist(p, s, "handler.handler_sys_out." + Handler.OUTPUT_ATTRIBUTE,
"System.out", "handler: bad console output");
checkExist(p, s, "handler.handler_sys_out." + Handler.PATTERN_ATTRIBUTE,
"%m%n", "handler: bad console pattern");
checkExist(p, s, "handler.Handler_file.type", "file",
"handler: bad file type");
checkExist(p, s, "handler.Handler_file." + Handler.OUTPUT_ATTRIBUTE,
"toto.txt", "handler: bad file output");
checkExist(p, s, "handler.Handler_file." + Handler.PATTERN_ATTRIBUTE,
"%p %m%n", "handler: bad file pattern");
checkExist(p, s, "handler.Handler.rolling.file.type", "rollingfile",
"handler: bad rolling file type");
checkExist(p, s, "handler.Handler.rolling.file." + Handler.OUTPUT_ATTRIBUTE,
"toto", "handler: bad rolling file output");
checkExist(p, s, "handler.Handler.rolling.file." + Handler.PATTERN_ATTRIBUTE,
"%p - %m%n", "handler: bad rolling file pattern");
checkExist(p, s, "handler.Handler.rolling.file." + Handler.MAX_SIZE_ATTRIBUTE,
"300", "handler: bad rolling file max size");
checkExist(p, s, "handler.Handler.rolling.file." + Handler.FILE_NUMBER_ATTRIBUTE,
"2", "handler: bad rolling file number of file");
//------ Logger ------//
checkUnExist(s, "logger.org.foo.bar.level", "just the name");
checkExist(p, s, "logger.org.level", "FATAL",
"logger: Simple name & Just level");
checkExist(p, s, "logger.org.foo.bar2.level", "INFO",
"logger: Dotted name & Just level");
checkBeginExist(p, "logger.org.foo.bar5.handler", "Handler_file",
"logger: Dotted name & Just handler");
checkBeginExist(p, "logger.org.foo.bar6.handler", "Handler_file",
"logger: Dotted name & Just handler");
checkBeginExist(p, "logger.org.foo.bar6.handler", "Handler.rolling.file",
"logger: Dotted name & Just handler");
checkBeginExist(p, "logger.org.foo.bar3.topic", "fr.inria.sardes3",
"logger: Dotted name, no level, 2 topic: topic1");
checkBeginExist(p, "logger.org.foo.bar3.topic", "fr.inrialpes.sardes3",
"logger: Dotted name, no level, 2 topic: topic2");
checkExist(p, s, "logger.org.foo.bar4.level", "ERROR",
"logger: Dotted name, Just level, topic: level");
checkBeginExist(p, "logger.org.foo.bar4.topic", "fr.inria.sardes4",
"logger: Dotted name, ERROR level, 2 topic: topic1");
checkBeginExist(p, "logger.org.foo.bar4.topic", "fr.inrialpes.sardes4",
"logger: Dotted name, ERROR level, 2 topic: topic2");
}
/**
* It tests the load method
*/
public void testLoadConf() {
// Full a properties
//==================
Properties p = new Properties();
//------ Level ------//
p.setProperty("level.LOAD_DEBUG1", "DEBUG + 1");
p.setProperty("level.LOAD_DEBUG2", String.valueOf(BasicLevel.DEBUG + 2));
//------ Handler ------//
p.setProperty("handler.myhandler1.type", "console");
p.setProperty("handler.myhandler1.output", "System.out");
p.setProperty("handler.myhandler1.pattern", "%m%n");
p.setProperty("handler.test.load.myhandler2.type", "file");
p.setProperty("handler.test.load.myhandler2.output", "myhandler2.log");
p.setProperty("handler.test.load.myhandler2.pattern", "=> %m%n");
p.setProperty("handler.test.load.myhandler3.type", "rollingfile");
p.setProperty("handler.test.load.myhandler3.output", "myhandler3.log");
p.setProperty("handler.test.load.myhandler3.pattern", "-> %m%n");
p.setProperty("handler.test.load.myhandler3.fileNumber", "2");
p.setProperty("handler.test.load.myhandler3.maxSize", "20");
//------ Logger ------//
p.setProperty("logger.test.load.bar.level", "DEBUG");
p.setProperty("logger.test.load.foo.level", "LOAD_DEBUG1");
p.setProperty("logger.test.load.foo2.topic.0", "org.ow.foo");
p.setProperty("logger.test.load.foo2.topic.1", "org.ow.foo2");
p.setProperty("logger.test.load.foo3.handler.0", "myhandler1");
p.setProperty("logger.test.load.foo4.handler.0", "test.load.myhandler2");
p.setProperty("logger.test.load.foo4.handler.1", "test.load.myhandler3");
// Load the properties
//==========================
try {
PropertiesConfAccess.load(p, lf, hf, lef);
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
// Check the monolog objects
//==========================
//------ Level ------//
Level le = null;
le = lef.getLevel("LOAD_DEBUG1");
assertNotNull("level: LOAD_DEBUG1: undefined", le);
assertEquals("level: LOAD_DEBUG1: bad int value",
BasicLevel.DEBUG + 1,le.getIntValue());
assertEquals("level: LOAD_DEBUG1: bad string expr",
"DEBUG + 1", ((LevelImpl) le).getStringValue());
le = lef.getLevel("LOAD_DEBUG2");
assertNotNull("level: LOAD_DEBUG2: undefined", le);
assertEquals("level: LOAD_DEBUG2: bad int value",
BasicLevel.DEBUG + 2,le.getIntValue());
assertEquals("level: LOAD_DEBUG2: bad string expr",
String.valueOf(BasicLevel.DEBUG + 2),
((LevelImpl) le).getStringValue());
//------ Handler ------//
Handler h = null;
h = hf.getHandler("myhandler1");
assertNotNull("handler: myhandler1: undefined", h);
assertEquals("handler: myhandler1: bad type",
PropertiesConfAccess.HANDLER_TYPE_ATTRIBUTE_CONSOLE_VALUE, h.getType());
assertEquals("handler: myhandler1: bad output",
"System.out", h.getAttribute(Handler.OUTPUT_ATTRIBUTE));
assertEquals("handler: myhandler1: bad pattern",
"%m%n", h.getAttribute(Handler.PATTERN_ATTRIBUTE));
h = hf.getHandler("test.load.myhandler2");
assertNotNull("handler: test.load.myhandler2: undefined", h);
assertEquals("handler: test.load.myhandler2: bad type",
PropertiesConfAccess.HANDLER_TYPE_ATTRIBUTE_FILE_VALUE, h.getType());
assertEquals("handler: test.load.myhandler2: bad output",
"myhandler2.log", h.getAttribute(Handler.OUTPUT_ATTRIBUTE));
assertEquals("handler: test.load.myhandler2: bad pattern",
"=> %m%n", h.getAttribute(Handler.PATTERN_ATTRIBUTE));
h = hf.getHandler("test.load.myhandler3");
assertNotNull("handler: test.load.myhandler3: undefined", h);
assertEquals("handler: test.load.myhandler3: bad type",
PropertiesConfAccess.HANDLER_TYPE_ATTRIBUTE_ROLLING_FILE_VALUE, h.getType());
assertEquals("handler: test.load.myhandler2: bad output",
"myhandler3.log", h.getAttribute(Handler.OUTPUT_ATTRIBUTE));
assertEquals("handler: test.load.myhandler2: bad pattern",
"-> %m%n", h.getAttribute(Handler.PATTERN_ATTRIBUTE));
assertEquals("handler: test.load.myhandler2: bad file number",
"2", h.getAttribute(Handler.FILE_NUMBER_ATTRIBUTE));
assertEquals("handler: test.load.myhandler2: bad max size",
"20", h.getAttribute(Handler.MAX_SIZE_ATTRIBUTE));
//------ Logger ------//
TopicalLogger l = null;
l = (TopicalLogger) lf.getLogger("test.load.bar");
assertEquals("logger: test.load.bar: bad level",
BasicLevel.DEBUG, l.getCurrentIntLevel());
l = (TopicalLogger) lf.getLogger("test.load.foo");
assertEquals("logger: test.load.foo: bad level",
BasicLevel.DEBUG + 1, l.getCurrentIntLevel());
l = (TopicalLogger) lf.getLogger("test.load.foo3");
Handler[] hs = l.getHandler();
assertNotNull("logger: test.load.foo3: handler list is null", hs);
assertEquals("logger: test.load.foo3: handler list is empty",
1, hs.length);
assertEquals("logger: test.load.foo3: bad handler",
hf.getHandler("myhandler1"), hs[0]);
l = (TopicalLogger) lf.getLogger("test.load.foo4");
hs = l.getHandler();
assertNotNull("logger: test.load.foo4: handler list is null", hs);
assertEquals("logger: test.load.foo4: handler list is empty",
2, hs.length);
assertNotNull("logger: test.load.foo4: handler element 0 is null", hs[0]);
assertNotNull("logger: test.load.foo4: handler element 1 is null", hs[1]);
if (!hs[0].equals(hf.getHandler("test.load.myhandler2"))
&& !hs[1].equals(hf.getHandler("test.load.myhandler2"))) {
fail("logger: test.load.foo4: 'test.load.myhandler2' handler not found");
}
if (!hs[0].equals(hf.getHandler("test.load.myhandler3"))
&& !hs[1].equals(hf.getHandler("test.load.myhandler3"))) {
fail("logger: test.load.foo4: 'test.load.myhandler3' handler not found");
}
l = (TopicalLogger) lf.getLogger("test.load.foo2");
String[] ts = l.getTopic();
assertNotNull("logger: test.load.foo2: topic list is null", ts);
assertEquals("logger: test.load.foo2: bad topic list size",
3, ts.length);
assertNotNull("logger: test.load.foo2: topic element 0 is null", ts[0]);
assertNotNull("logger: test.load.foo2: topic element 1 is null", ts[1]);
assertNotNull("logger: test.load.foo2: topic element 2 is null", ts[2]);
if (!ts[0].equals("test.load.foo2")
&& !ts[1].equals("test.load.foo2")
&& !ts[2].equals("test.load.foo2")) {
fail("logger: test.load.foo2: main topic not found");
}
if (!ts[0].equals("org.ow.foo")
&& !ts[1].equals("org.ow.foo")
&& !ts[2].equals("org.ow.foo")) {
fail("logger: test.load.foo2: 'org.ow.foo' topic not found");
}
if (!ts[0].equals("org.ow.foo2")
&& !ts[1].equals("org.ow.foo2")
&& !ts[2].equals("org.ow.foo2")) {
fail("logger: test.load.foo2: 'org.ow.foo2' topic not found");
}
}
/**
* It verifies that the couple (key, value) is available in a Properties.
* @param p is the properties where to find the key and the value.
* @param s is the key set of the properies p
* @param key is the string which must be a key in the properties
* @param value is the object which must be value associated to the key
* @param msg is the error messageis the (key, value) is not found
*/
public void checkExist(Properties p, Set s, String key,
String value, String msg) {
boolean t = s.contains(key);
if (!t) {
//printProperties(p);
}
assertTrue(msg + ": not found", t);
assertEquals(msg + ": (" + key + ")bad value", value, p.getProperty(key));
}
/**
* It verifies that a String is not available in a Set.
* @param s is the set.
* @param key is the string which must not be a key in the set
* @param msg is the error messageis the (key, value) is found
*/
public void checkUnExist(Set s, String key, String msg) {
assertTrue(msg + ": found", !s.contains(key));
}
public void checkBeginExist(Properties p, String key,
String value, String msg) {
boolean found = false;
debug("checkBeginExist( key=" + key + " / value=" + value);
for(Enumeration e = p.keys(); e.hasMoreElements();) {
String cur = (String) e.nextElement();
debug(" cur=" + cur + " / val=" + p.getProperty(cur, ""));
if (cur.startsWith(key)) {
StringTokenizer st = new StringTokenizer(p.getProperty(cur, ""), ", ", false);
while(st.hasMoreTokens()) {
String tok = st.nextToken();
if (tok.equals(value)) {
if (found) {
fail(msg + "duplicated value: " + value);
} else {
found = true;
}
}
}
}
}
if (!found) {
System.out.println("\n" + msg + ": not found");
this.printProperties(p);
}
assertTrue(msg + ": not found", found);
}
public void printProperties(Properties p) {
for(Iterator it = p.entrySet().iterator(); it.hasNext();) {
Map.Entry me = (Map.Entry) it.next();
System.out.println(me.getKey() + "=" + me.getValue());
}
}
}