This is an automated email from the ASF dual-hosted git repository.
rec pushed a commit to branch
bugfix/UIMA-6389-Logger_common_impl-swallows-exception
in repository https://gitbox.apache.org/repos/asf/uima-uimaj.git
commit e1c2c03e4be4ef271b07e5460a12532bd8736026
Author: Richard Eckart de Castilho <r...@apache.org>
AuthorDate: Mon Oct 18 16:18:48 2021 +0200
[UIMA-6389] Logger_common_impl swallows exception
- Extract Log4J2 log capturing code into a convenient auto-closable class
- Add test at the level of the Slf4JLogger_impl to test that messages are
logged properly (currently fails)
---
.../apache/uima/util/impl/Slf4jLogger_impl.java | 328 ++++++-----
.../uima/util/impl/JSR47Logger_implTest.java | 434 +++++++--------
.../uima/util/impl/Log4jLogger_implTest.java | 610 ++++++++++-----------
3 files changed, 671 insertions(+), 701 deletions(-)
diff --git
a/uimaj-core/src/main/java/org/apache/uima/util/impl/Slf4jLogger_impl.java
b/uimaj-core/src/main/java/org/apache/uima/util/impl/Slf4jLogger_impl.java
index 75a2aaa..9349d1d 100644
--- a/uimaj-core/src/main/java/org/apache/uima/util/impl/Slf4jLogger_impl.java
+++ b/uimaj-core/src/main/java/org/apache/uima/util/impl/Slf4jLogger_impl.java
@@ -30,29 +30,28 @@ import org.slf4j.spi.LocationAwareLogger;
/**
* UIMA Logging interface implementation for SLF4j
*
- * This design gets a logger in static initialization,
- * in order to see what the back end is. If it is JUL or Log4j,
- * it sets flags so that subsequent calls to getInstance gets those
- * UIMA logger impls, not this one,
- * in order to slightly reduce indirection at run time.
+ * This design gets a logger in static initialization, in order to see what
the back end is. If it
+ * is JUL or Log4j, it sets flags so that subsequent calls to getInstance gets
those UIMA logger
+ * impls, not this one, in order to slightly reduce indirection at run time.
*
*/
public class Slf4jLogger_impl extends Logger_common_impl {
-
+
public static final String DEFAULT_JUL =
"uima.use_jul_as_default_uima_logger";
public static final boolean IS_DEFAULT_JUL =
Misc.getNoValueSystemProperty(DEFAULT_JUL);
-
+
static final boolean isJul;
static final boolean isLog4j;
-
+
static {
Class<?> staticLoggerBinderClass = null;
try {
staticLoggerBinderClass =
Class.forName("org.slf4j.impl.StaticLoggerBinder");
} catch (Exception e) {
- // empty on purpose, if class not present, no back end logger, and
staticLoggerBinderClass is left as null
+ // empty on purpose, if class not present, no back end logger, and
staticLoggerBinderClass is
+ // left as null
}
-
+
if (null == staticLoggerBinderClass) {
if (IS_DEFAULT_JUL) {
isJul = true;
@@ -65,33 +64,33 @@ public class Slf4jLogger_impl extends Logger_common_impl {
// have some backend binding
boolean tb;
org.slf4j.Logger tempLogger =
org.slf4j.LoggerFactory.getLogger("org.apache.uima");
- try { // for jdk14 impl
+ try { // for jdk14 impl
Class<?> clazz = Class.forName("org.slf4j.impl.JDK14LoggerAdapter");
tb = clazz != null && clazz.isAssignableFrom(tempLogger.getClass());
} catch (ClassNotFoundException e1) {
tb = false;
}
isJul = tb;
-
+
tb = false;
if (!isJul) {
- try { // for log4j 2 impl
+ try { // for log4j 2 impl
Class<?> clazz =
Class.forName("org.apache.logging.slf4j.Log4jLogger");
tb = null != clazz && clazz.isAssignableFrom(tempLogger.getClass());
} catch (ClassNotFoundException e1) {
tb = false;
}
}
- isLog4j = tb;
+ isLog4j = tb;
}
}
-
+
/**
* logger object from the underlying Slf4j logging framework
*/
final private org.slf4j.Logger logger;
- final private boolean isLocationCapable; // the slf4j simple logger is not
-
+ final private boolean isLocationCapable; // the slf4j simple logger is not
+
/**
* create a new LogWrapper class for the specified source class
*
@@ -100,20 +99,18 @@ public class Slf4jLogger_impl extends Logger_common_impl {
*/
private Slf4jLogger_impl(Class<?> component) {
super(component);
- final String loggerName = (component != null)
- ? component.getName()
- : "org.apache.uima";
-
+ final String loggerName = (component != null) ? component.getName() :
"org.apache.uima";
+
logger = org.slf4j.LoggerFactory.getLogger(loggerName);
isLocationCapable = logger instanceof org.slf4j.spi.LocationAwareLogger;
}
-
+
private Slf4jLogger_impl(Slf4jLogger_impl l, int limit) {
super(l, limit);
this.logger = l.logger;
isLocationCapable = logger instanceof org.slf4j.spi.LocationAwareLogger;
}
-
+
/**
* creates a new Logger instance for the specified source class
*
@@ -127,7 +124,7 @@ public class Slf4jLogger_impl extends Logger_common_impl {
return JSR47Logger_impl.getInstance(component);
}
if (isLog4j) {
- return Log4jLogger_impl.getInstance(component);
+ return Log4jLogger_impl.getInstance(component);
}
return new Slf4jLogger_impl(component);
}
@@ -140,76 +137,86 @@ public class Slf4jLogger_impl extends Logger_common_impl {
public static synchronized Logger getInstance() {
return getInstance(null);
}
-
+
+ @Override
public Slf4jLogger_impl getLimitedLogger(int aLimit) {
if (aLimit == Integer.MAX_VALUE || aLimit == this.limit_common) {
return this;
}
return new Slf4jLogger_impl(this, aLimit);
}
-
+
public static int getSlf4jLevel(Level level) {
- switch(level.toInteger()) {
- case Level.SEVERE_INT: return LocationAwareLogger.ERROR_INT;
- case Level.WARNING_INT: return LocationAwareLogger.WARN_INT;
- case Level.INFO_INT: return LocationAwareLogger.INFO_INT;
- case Level.CONFIG_INT: return LocationAwareLogger.INFO_INT;
- case Level.FINE_INT: return LocationAwareLogger.DEBUG_INT;
- case Level.FINER_INT: return LocationAwareLogger.TRACE_INT;
- case Level.FINEST_INT: return LocationAwareLogger.TRACE_INT;
+ switch (level.toInteger()) {
+ case Level.SEVERE_INT:
+ return LocationAwareLogger.ERROR_INT;
+ case Level.WARNING_INT:
+ return LocationAwareLogger.WARN_INT;
+ case Level.INFO_INT:
+ return LocationAwareLogger.INFO_INT;
+ case Level.CONFIG_INT:
+ return LocationAwareLogger.INFO_INT;
+ case Level.FINE_INT:
+ return LocationAwareLogger.DEBUG_INT;
+ case Level.FINER_INT:
+ return LocationAwareLogger.TRACE_INT;
+ case Level.FINEST_INT:
+ return LocationAwareLogger.TRACE_INT;
}
Misc.internalError();
- return LocationAwareLogger.ERROR_INT; //ignored, just here for compile
error avoidance
- }
-
+ return LocationAwareLogger.ERROR_INT; // ignored, just here for compile
error avoidance
+ }
+
/*
* (non-Javadoc)
*
* @see org.apache.uima.util.Logger#isLoggable(org.apache.uima.util.Level)
*/
+ @Override
public boolean isLoggable(Level level) {
switch (level.toInteger()) {
- case org.apache.uima.util.Level.OFF_INT:
- return false;
- case org.apache.uima.util.Level.SEVERE_INT:
- return logger.isErrorEnabled();
- case org.apache.uima.util.Level.WARNING_INT:
- return logger.isWarnEnabled();
- case org.apache.uima.util.Level.INFO_INT:
- return logger.isInfoEnabled();
- case org.apache.uima.util.Level.CONFIG_INT:
- return logger.isDebugEnabled(UIMA_MARKER_CONFIG);
- case org.apache.uima.util.Level.FINE_INT:
- return logger.isDebugEnabled();
- case org.apache.uima.util.Level.FINER_INT:
- return logger.isTraceEnabled();
- case org.apache.uima.util.Level.FINEST_INT:
- return logger.isTraceEnabled(UIMA_MARKER_FINEST);
- default: // for Level.ALL return false, that's what jul logger does
- return false;
+ case org.apache.uima.util.Level.OFF_INT:
+ return false;
+ case org.apache.uima.util.Level.SEVERE_INT:
+ return logger.isErrorEnabled();
+ case org.apache.uima.util.Level.WARNING_INT:
+ return logger.isWarnEnabled();
+ case org.apache.uima.util.Level.INFO_INT:
+ return logger.isInfoEnabled();
+ case org.apache.uima.util.Level.CONFIG_INT:
+ return logger.isDebugEnabled(UIMA_MARKER_CONFIG);
+ case org.apache.uima.util.Level.FINE_INT:
+ return logger.isDebugEnabled();
+ case org.apache.uima.util.Level.FINER_INT:
+ return logger.isTraceEnabled();
+ case org.apache.uima.util.Level.FINEST_INT:
+ return logger.isTraceEnabled(UIMA_MARKER_FINEST);
+ default: // for Level.ALL return false, that's what jul logger does
+ return false;
}
}
+ @Override
public boolean isLoggable(Level level, Marker marker) {
switch (level.toInteger()) {
- case org.apache.uima.util.Level.OFF_INT:
- return false;
- case org.apache.uima.util.Level.SEVERE_INT:
- return logger.isErrorEnabled(marker);
- case org.apache.uima.util.Level.WARNING_INT:
- return logger.isWarnEnabled(marker);
- case org.apache.uima.util.Level.INFO_INT:
- return logger.isInfoEnabled(marker);
- case org.apache.uima.util.Level.CONFIG_INT:
- return logger.isInfoEnabled(marker);
- case org.apache.uima.util.Level.FINE_INT:
- return logger.isDebugEnabled(marker);
- case org.apache.uima.util.Level.FINER_INT:
- return logger.isTraceEnabled(marker);
- case org.apache.uima.util.Level.FINEST_INT:
- return logger.isTraceEnabled(marker);
- default: // for Level.ALL return false, that's what jul logger does
- return false;
+ case org.apache.uima.util.Level.OFF_INT:
+ return false;
+ case org.apache.uima.util.Level.SEVERE_INT:
+ return logger.isErrorEnabled(marker);
+ case org.apache.uima.util.Level.WARNING_INT:
+ return logger.isWarnEnabled(marker);
+ case org.apache.uima.util.Level.INFO_INT:
+ return logger.isInfoEnabled(marker);
+ case org.apache.uima.util.Level.CONFIG_INT:
+ return logger.isInfoEnabled(marker);
+ case org.apache.uima.util.Level.FINE_INT:
+ return logger.isDebugEnabled(marker);
+ case org.apache.uima.util.Level.FINER_INT:
+ return logger.isTraceEnabled(marker);
+ case org.apache.uima.util.Level.FINEST_INT:
+ return logger.isTraceEnabled(marker);
+ default: // for Level.ALL return false, that's what jul logger does
+ return false;
}
}
@@ -218,62 +225,66 @@ public class Slf4jLogger_impl extends Logger_common_impl {
*
* @see org.apache.uima.util.Logger#setLevel(org.apache.uima.util.Level)
*/
- public void setLevel(Level level) {
+ @Override
+ public void setLevel(Level level) {
// allow nop operation
}
-
+
// does the uima-logger style of message formatting
- public void log(Marker m, String aFqcn, Level level, String message,
Object[] args, Throwable thrown) {
+ @Override
+ public void log(Marker m, String aFqcn, Level level, String message,
Object[] args,
+ Throwable thrown) {
log(m, aFqcn, level, MessageFormat.format(message, args), thrown);
}
-
+
@Override
public void log(Marker m, String aFqcn, Level level, String msg_with_params,
Throwable thrown) {
- m = (m == null)
- ? getMarkerForLevel(level)
- : m;
-
- if (isLocationCapable) { // slf4j simple logger is not
- ((org.slf4j.spi.LocationAwareLogger)logger).log(m, aFqcn,
getSlf4jLevel(level), msg_with_params, null, thrown);
- } else {
- switch(level.toInteger()) {
- case Level.SEVERE_INT:
- // all of these calls to MessageFormat are to the java.text.MessageFormat
- // to do {n} style format substitution
- logger.error(m, msg_with_params, thrown);
- break;
- case Level.WARNING_INT:
- logger.warn(m, msg_with_params, thrown);
- break;
- case Level.INFO_INT:
- logger.info(m, msg_with_params, thrown);
- break;
- case Level.CONFIG_INT:
- logger.info(m, msg_with_params, thrown);
- break;
- case Level.FINE_INT:
- logger.debug(m, msg_with_params, thrown);
- break;
- case Level.FINER_INT:
- logger.trace(m, msg_with_params, thrown);
- break;
- case Level.FINEST_INT:
- logger.trace(m, msg_with_params, thrown);
- break;
- default: Misc.internalError();
+ m = (m == null) ? getMarkerForLevel(level) : m;
+
+ if (isLocationCapable) { // slf4j simple logger is not
+ ((org.slf4j.spi.LocationAwareLogger) logger).log(m, aFqcn,
getSlf4jLevel(level),
+ msg_with_params, null, thrown);
+ } else {
+ switch (level.toInteger()) {
+ case Level.SEVERE_INT:
+ // all of these calls to MessageFormat are to the
java.text.MessageFormat
+ // to do {n} style format substitution
+ logger.error(m, msg_with_params, thrown);
+ break;
+ case Level.WARNING_INT:
+ logger.warn(m, msg_with_params, thrown);
+ break;
+ case Level.INFO_INT:
+ logger.info(m, msg_with_params, thrown);
+ break;
+ case Level.CONFIG_INT:
+ logger.info(m, msg_with_params, thrown);
+ break;
+ case Level.FINE_INT:
+ logger.debug(m, msg_with_params, thrown);
+ break;
+ case Level.FINER_INT:
+ logger.trace(m, msg_with_params, thrown);
+ break;
+ case Level.FINEST_INT:
+ logger.trace(m, msg_with_params, thrown);
+ break;
+ default:
+ Misc.internalError();
+ }
}
- }
-
+
}
// does the slf4j style of message formatting
- public void log2(Marker m, String aFqcn, Level level, String message,
Object[] args, Throwable thrown) {
- m = (m == null)
- ? getMarkerForLevel(level)
- : m;
-
- if (isLocationCapable) { // slf4j simple logger is not
- ((org.slf4j.spi.LocationAwareLogger)logger).log(m, aFqcn,
getSlf4jLevel(level), message, args, thrown);
+ @Override
+ public void log2(Marker m, String aFqcn, Level level, String message,
Object[] args,
+ Throwable thrown) {
+ m = (m == null) ? getMarkerForLevel(level) : m;
+
+ if (isLocationCapable) { // slf4j simple logger is not
+ ((org.slf4j.spi.LocationAwareLogger) logger).log(m, aFqcn,
getSlf4jLevel(level), message,
+ args, thrown);
} else {
if (thrown != null) {
Object[] args1 = (args == null) ? new Object[1] : new
Object[args.length + 1];
@@ -282,38 +293,40 @@ public class Slf4jLogger_impl extends Logger_common_impl {
}
args1[args1.length - 1] = thrown;
args = args1;
- }
- switch(level.toInteger()) {
- case Level.SEVERE_INT:
- logger.error(m, message, args);
- break;
- case Level.WARNING_INT:
- logger.warn(m, message, args);
- break;
- case Level.INFO_INT:
- logger.info(m, message, args);
- break;
- case Level.CONFIG_INT:
- logger.info(m, message, args);
- break;
- case Level.FINE_INT:
- logger.debug(m, message, args);
- break;
- case Level.FINER_INT:
- logger.trace(m, message, args);
- break;
- case Level.FINEST_INT:
- logger.trace(m, message, args);
- break;
- default: Misc.internalError();
+ }
+ switch (level.toInteger()) {
+ case Level.SEVERE_INT:
+ logger.error(m, message, args);
+ break;
+ case Level.WARNING_INT:
+ logger.warn(m, message, args);
+ break;
+ case Level.INFO_INT:
+ logger.info(m, message, args);
+ break;
+ case Level.CONFIG_INT:
+ logger.info(m, message, args);
+ break;
+ case Level.FINE_INT:
+ logger.debug(m, message, args);
+ break;
+ case Level.FINER_INT:
+ logger.trace(m, message, args);
+ break;
+ case Level.FINEST_INT:
+ logger.trace(m, message, args);
+ break;
+ default:
+ Misc.internalError();
}
}
}
-
+
/**
* @return the logger name
* @see org.slf4j.Logger#getName()
*/
+ @Override
public String getName() {
return logger.getName();
}
@@ -322,70 +335,78 @@ public class Slf4jLogger_impl extends Logger_common_impl {
* @return -
* @see org.slf4j.Logger#isTraceEnabled()
*/
+ @Override
public boolean isTraceEnabled() {
return logger.isTraceEnabled();
}
/**
- * @param marker -
+ * @param marker
+ * -
* @return true if trace is enabled for this marker
* @see org.slf4j.Logger#isTraceEnabled(org.slf4j.Marker)
*/
+ @Override
public boolean isTraceEnabled(Marker marker) {
return logger.isTraceEnabled(marker);
}
-
/**
* @return -
* @see org.slf4j.Logger#isDebugEnabled()
*/
+ @Override
public boolean isDebugEnabled() {
return logger.isDebugEnabled();
}
/**
- * @param marker -
+ * @param marker
+ * -
* @return true if is enabled for this marker
* @see org.slf4j.Logger#isDebugEnabled(org.slf4j.Marker)
*/
+ @Override
public boolean isDebugEnabled(Marker marker) {
return logger.isDebugEnabled(marker);
}
-
/**
* @return -
* @see org.slf4j.Logger#isInfoEnabled()
*/
+ @Override
public boolean isInfoEnabled() {
return logger.isInfoEnabled();
}
-
/**
- * @param marker -
+ * @param marker
+ * -
* @return true if is enabled for this marker
* @see org.slf4j.Logger#isInfoEnabled(org.slf4j.Marker)
*/
+ @Override
public boolean isInfoEnabled(Marker marker) {
return logger.isInfoEnabled(marker);
}
-
/**
* @return -
* @see org.slf4j.Logger#isWarnEnabled()
*/
+ @Override
public boolean isWarnEnabled() {
return logger.isWarnEnabled();
}
/**
- * @param marker -
+ * @param marker
+ * -
* @return true if is enabled for this marker
* @see org.slf4j.Logger#isWarnEnabled(org.slf4j.Marker)
*/
+ @Override
public boolean isWarnEnabled(Marker marker) {
return logger.isWarnEnabled(marker);
}
@@ -394,15 +415,18 @@ public class Slf4jLogger_impl extends Logger_common_impl {
* @return -
* @see org.slf4j.Logger#isErrorEnabled()
*/
+ @Override
public boolean isErrorEnabled() {
return logger.isErrorEnabled();
}
/**
- * @param marker -
+ * @param marker
+ * -
* @return true if is enabled for this marker
* @see org.slf4j.Logger#isErrorEnabled(org.slf4j.Marker)
*/
+ @Override
public boolean isErrorEnabled(Marker marker) {
return logger.isErrorEnabled(marker);
}
diff --git
a/uimaj-core/src/test/java/org/apache/uima/util/impl/JSR47Logger_implTest.java
b/uimaj-core/src/test/java/org/apache/uima/util/impl/JSR47Logger_implTest.java
index c0364f1..1221a40 100644
---
a/uimaj-core/src/test/java/org/apache/uima/util/impl/JSR47Logger_implTest.java
+++
b/uimaj-core/src/test/java/org/apache/uima/util/impl/JSR47Logger_implTest.java
@@ -16,15 +16,14 @@
* specific language governing permissions and limitations
* under the License.
*/
-
package org.apache.uima.util.impl;
import java.util.HashMap;
import java.util.logging.Logger;
import org.apache.uima.util.Level;
-
import org.junit.Assert;
+
import junit.framework.TestCase;
/**
@@ -51,21 +50,21 @@ public class JSR47Logger_implTest extends TestCase {
}
public void testLogWrapperCreation() throws Exception {
-
+
// Set the root logger's level to INFO ... may not be the default
java.util.logging.Logger.getLogger("").setLevel(java.util.logging.Level.INFO);
try {
- org.apache.uima.util.Logger uimaLogger = JSR47Logger_impl.getInstance();
- org.apache.uima.util.Logger classLogger =
JSR47Logger_impl.getInstance(this.getClass());
- uimaLogger.setLevel(null); // causes it to inherit from above
- classLogger.setLevel(null); // causes it to inherit from above
-
- // check base configuration
- Assert.assertNotNull(uimaLogger);
- Assert.assertNotNull(classLogger);
- Assert.assertTrue(uimaLogger.isLoggable(Level.INFO));
- Assert.assertTrue(classLogger.isLoggable(Level.INFO));
+ org.apache.uima.util.Logger uimaLogger = JSR47Logger_impl.getInstance();
+ org.apache.uima.util.Logger classLogger =
JSR47Logger_impl.getInstance(this.getClass());
+ uimaLogger.setLevel(null); // causes it to inherit from above
+ classLogger.setLevel(null); // causes it to inherit from above
+
+ // check base configuration
+ Assert.assertNotNull(uimaLogger);
+ Assert.assertNotNull(classLogger);
+ Assert.assertTrue(uimaLogger.isLoggable(Level.INFO));
+ Assert.assertTrue(classLogger.isLoggable(Level.INFO));
} finally {
java.util.logging.Logger.getLogger("").setLevel(java.util.logging.Level.INFO);
@@ -76,102 +75,101 @@ public class JSR47Logger_implTest extends TestCase {
// create logger
org.apache.uima.util.Logger uimaLogger = JSR47Logger_impl.getInstance();
org.apache.uima.util.Logger classLogger =
JSR47Logger_impl.getInstance(this.getClass());
- //get uimaLogger log level, get parent logger of "org.apache.uima" until
we have the
- //JSR47 root logger that defines the default log level
+ // get uimaLogger log level, get parent logger of "org.apache.uima" until
we have the
+ // JSR47 root logger that defines the default log level
Logger jsrLogger = java.util.logging.Logger.getLogger("org.apache.uima");
- while(jsrLogger.getLevel() == null) {
- jsrLogger = jsrLogger.getParent();
+ while (jsrLogger.getLevel() == null) {
+ jsrLogger = jsrLogger.getParent();
}
Level defaultLogLevel = logLevels.get(jsrLogger.getLevel().toString());
try {
- uimaLogger.setLevel(null); // causes it to inherit from above
- classLogger.setLevel(null); // causes it to inherit from above
-
-
- // check message logging for root logger based on default log level
- Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.ALL), uimaLogger
- .isLoggable(Level.ALL));
- Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.FINEST),
uimaLogger
- .isLoggable(Level.FINEST));
- Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.FINER),
uimaLogger
- .isLoggable(Level.FINER));
- Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.FINE),
uimaLogger
- .isLoggable(Level.FINE));
- Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.CONFIG),
uimaLogger
- .isLoggable(Level.CONFIG));
- Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.INFO),
uimaLogger
- .isLoggable(Level.INFO));
- Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.WARNING),
uimaLogger
- .isLoggable(Level.WARNING));
- Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.SEVERE),
uimaLogger
- .isLoggable(Level.SEVERE));
- Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.OFF), uimaLogger
- .isLoggable(Level.OFF));
-
- // check message logging for class logger based on default log level
- Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.ALL),
classLogger
- .isLoggable(Level.ALL));
- Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.FINEST),
classLogger
- .isLoggable(Level.FINEST));
- Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.FINER),
classLogger
- .isLoggable(Level.FINER));
- Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.FINE),
classLogger
- .isLoggable(Level.FINE));
- Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.CONFIG),
classLogger
- .isLoggable(Level.CONFIG));
- Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.INFO),
classLogger
- .isLoggable(Level.INFO));
- Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.WARNING),
classLogger
- .isLoggable(Level.WARNING));
- Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.SEVERE),
classLogger
- .isLoggable(Level.SEVERE));
- Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.OFF),
classLogger
- .isLoggable(Level.OFF));
-
- // reset class logger level to OFF
- //
Logger.getLogger(this.getClass().getName()).setLevel(java.util.logging.Level.OFF);
- classLogger.setLevel(Level.OFF);
- Assert.assertFalse(classLogger.isLoggable(Level.ALL));
- Assert.assertFalse(classLogger.isLoggable(Level.FINEST));
- Assert.assertFalse(classLogger.isLoggable(Level.FINER));
- Assert.assertFalse(classLogger.isLoggable(Level.FINE));
- Assert.assertFalse(classLogger.isLoggable(Level.CONFIG));
- Assert.assertFalse(classLogger.isLoggable(Level.INFO));
- Assert.assertFalse(classLogger.isLoggable(Level.WARNING));
- Assert.assertFalse(classLogger.isLoggable(Level.SEVERE));
- Assert.assertFalse(classLogger.isLoggable(Level.OFF));
-
- // reset class logger level to ALL
- //
Logger.getLogger(this.getClass().getName()).setLevel(java.util.logging.Level.ALL);
- classLogger.setLevel(Level.ALL);
- Assert.assertTrue(classLogger.isLoggable(Level.ALL));
- Assert.assertTrue(classLogger.isLoggable(Level.FINEST));
- Assert.assertTrue(classLogger.isLoggable(Level.FINER));
- Assert.assertTrue(classLogger.isLoggable(Level.FINE));
- Assert.assertTrue(classLogger.isLoggable(Level.CONFIG));
- Assert.assertTrue(classLogger.isLoggable(Level.INFO));
- Assert.assertTrue(classLogger.isLoggable(Level.WARNING));
- Assert.assertTrue(classLogger.isLoggable(Level.SEVERE));
- Assert.assertTrue(classLogger.isLoggable(Level.OFF));
-
- // reset class logger level to WARNING
- //
Logger.getLogger(this.getClass().getName()).setLevel(java.util.logging.Level.WARNING);
- classLogger.setLevel(Level.WARNING);
- Assert.assertFalse(classLogger.isLoggable(Level.ALL));
- Assert.assertFalse(classLogger.isLoggable(Level.FINEST));
- Assert.assertFalse(classLogger.isLoggable(Level.FINER));
- Assert.assertFalse(classLogger.isLoggable(Level.FINE));
- Assert.assertFalse(classLogger.isLoggable(Level.CONFIG));
- Assert.assertFalse(classLogger.isLoggable(Level.INFO));
- Assert.assertTrue(classLogger.isLoggable(Level.WARNING));
- Assert.assertTrue(classLogger.isLoggable(Level.SEVERE));
- Assert.assertTrue(classLogger.isLoggable(Level.OFF));
+ uimaLogger.setLevel(null); // causes it to inherit from above
+ classLogger.setLevel(null); // causes it to inherit from above
+
+ // check message logging for root logger based on default log level
+ Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.ALL),
+ uimaLogger.isLoggable(Level.ALL));
+ Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.FINEST),
+ uimaLogger.isLoggable(Level.FINEST));
+ Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.FINER),
+ uimaLogger.isLoggable(Level.FINER));
+ Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.FINE),
+ uimaLogger.isLoggable(Level.FINE));
+ Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.CONFIG),
+ uimaLogger.isLoggable(Level.CONFIG));
+ Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.INFO),
+ uimaLogger.isLoggable(Level.INFO));
+ Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.WARNING),
+ uimaLogger.isLoggable(Level.WARNING));
+ Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.SEVERE),
+ uimaLogger.isLoggable(Level.SEVERE));
+ Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.OFF),
+ uimaLogger.isLoggable(Level.OFF));
+
+ // check message logging for class logger based on default log level
+ Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.ALL),
+ classLogger.isLoggable(Level.ALL));
+ Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.FINEST),
+ classLogger.isLoggable(Level.FINEST));
+ Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.FINER),
+ classLogger.isLoggable(Level.FINER));
+ Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.FINE),
+ classLogger.isLoggable(Level.FINE));
+ Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.CONFIG),
+ classLogger.isLoggable(Level.CONFIG));
+ Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.INFO),
+ classLogger.isLoggable(Level.INFO));
+ Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.WARNING),
+ classLogger.isLoggable(Level.WARNING));
+ Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.SEVERE),
+ classLogger.isLoggable(Level.SEVERE));
+ Assert.assertEquals(defaultLogLevel.isGreaterOrEqual(Level.OFF),
+ classLogger.isLoggable(Level.OFF));
+
+ // reset class logger level to OFF
+ //
Logger.getLogger(this.getClass().getName()).setLevel(java.util.logging.Level.OFF);
+ classLogger.setLevel(Level.OFF);
+ Assert.assertFalse(classLogger.isLoggable(Level.ALL));
+ Assert.assertFalse(classLogger.isLoggable(Level.FINEST));
+ Assert.assertFalse(classLogger.isLoggable(Level.FINER));
+ Assert.assertFalse(classLogger.isLoggable(Level.FINE));
+ Assert.assertFalse(classLogger.isLoggable(Level.CONFIG));
+ Assert.assertFalse(classLogger.isLoggable(Level.INFO));
+ Assert.assertFalse(classLogger.isLoggable(Level.WARNING));
+ Assert.assertFalse(classLogger.isLoggable(Level.SEVERE));
+ Assert.assertFalse(classLogger.isLoggable(Level.OFF));
+
+ // reset class logger level to ALL
+ //
Logger.getLogger(this.getClass().getName()).setLevel(java.util.logging.Level.ALL);
+ classLogger.setLevel(Level.ALL);
+ Assert.assertTrue(classLogger.isLoggable(Level.ALL));
+ Assert.assertTrue(classLogger.isLoggable(Level.FINEST));
+ Assert.assertTrue(classLogger.isLoggable(Level.FINER));
+ Assert.assertTrue(classLogger.isLoggable(Level.FINE));
+ Assert.assertTrue(classLogger.isLoggable(Level.CONFIG));
+ Assert.assertTrue(classLogger.isLoggable(Level.INFO));
+ Assert.assertTrue(classLogger.isLoggable(Level.WARNING));
+ Assert.assertTrue(classLogger.isLoggable(Level.SEVERE));
+ Assert.assertTrue(classLogger.isLoggable(Level.OFF));
+
+ // reset class logger level to WARNING
+ //
Logger.getLogger(this.getClass().getName()).setLevel(java.util.logging.Level.WARNING);
+ classLogger.setLevel(Level.WARNING);
+ Assert.assertFalse(classLogger.isLoggable(Level.ALL));
+ Assert.assertFalse(classLogger.isLoggable(Level.FINEST));
+ Assert.assertFalse(classLogger.isLoggable(Level.FINER));
+ Assert.assertFalse(classLogger.isLoggable(Level.FINE));
+ Assert.assertFalse(classLogger.isLoggable(Level.CONFIG));
+ Assert.assertFalse(classLogger.isLoggable(Level.INFO));
+ Assert.assertTrue(classLogger.isLoggable(Level.WARNING));
+ Assert.assertTrue(classLogger.isLoggable(Level.SEVERE));
+ Assert.assertTrue(classLogger.isLoggable(Level.OFF));
} finally {
// reset log level to default log level
classLogger.setLevel(Level.INFO);
- uimaLogger.setLevel(Level.INFO);
+ uimaLogger.setLevel(Level.INFO);
}
}
@@ -180,61 +178,62 @@ public class JSR47Logger_implTest extends TestCase {
final org.apache.uima.util.Logger logger = JSR47Logger_impl.getInstance();
// reset log level to INFO
try {
- logger.setLevel(Level.INFO);
-
- // File file = File.createTempFile("LoggingTest","log");
- // file.deleteOnExit();
-
- // change output temporary file
- // logger.setOutputStream(new PrintStream(new FileOutputStream(file)));
-
- // log test with method log(Level,String)
- logger.log(Level.INFO, "My first test message");
- logger.log(Level.INFO, "");
- logger.log(Level.INFO, null);
-
- // log test with method log(Level,String,Object)
- Object obj = null;
- logger.log(Level.INFO, "My {0} test message", "second");
- logger.log(Level.INFO, "My {0} test message", new Object());
- logger.log(Level.INFO, "My {0} test message", "");
- logger.log(Level.INFO, "My {0} test message", obj);
- logger.log(Level.INFO, "", "");
- logger.log(Level.INFO, null, "");
-
- // log test with method log(Level,String,Object[])
- logger.log(Level.INFO, "My {0} test message", new Object[] { "third" });
- logger.log(Level.INFO, "My {0} test message", new Object[] {});
- logger.log(Level.INFO, "", new Object[] { "" });
- logger.log(Level.INFO, "", new Object[] { null });
- logger.log(Level.INFO, "My {0} test message", new Object[] { "" });
- logger.log(Level.INFO, "My {0} test message", new Object[] { null });
- logger.log(Level.INFO, null, "");
-
- // log test with method log(Level,String,Throwable)
- logger.setLevel(Level.WARNING); // Don't log the expected exceptions
- Throwable thrown = new Throwable();
- logger.log(Level.INFO, "My fourth test message", thrown);
- logger.log(Level.INFO, "", thrown);
- logger.log(Level.INFO, null, thrown);
- thrown = null;
- logger.log(Level.INFO, "My fourth test message", thrown);
-
- new Runnable() {
- public void run() {
- logger.log(getClass().getName(), Level.INFO, "Message from wrapper",
null);
- }
- }.run();
-
- // test deprecated log method
- logger.log("My fifth test message");
- logger.log("");
- logger.log(null);
-
- // test deprecated logException method
- Exception ex = new Exception("My sixth test message");
- logger.logException(ex);
- logger.logException(null);
+ logger.setLevel(Level.INFO);
+
+ // File file = File.createTempFile("LoggingTest","log");
+ // file.deleteOnExit();
+
+ // change output temporary file
+ // logger.setOutputStream(new PrintStream(new FileOutputStream(file)));
+
+ // log test with method log(Level,String)
+ logger.log(Level.INFO, "My first test message");
+ logger.log(Level.INFO, "");
+ logger.log(Level.INFO, null);
+
+ // log test with method log(Level,String,Object)
+ Object obj = null;
+ logger.log(Level.INFO, "My {0} test message", "second");
+ logger.log(Level.INFO, "My {0} test message", new Object());
+ logger.log(Level.INFO, "My {0} test message", "");
+ logger.log(Level.INFO, "My {0} test message", obj);
+ logger.log(Level.INFO, "", "");
+ logger.log(Level.INFO, null, "");
+
+ // log test with method log(Level,String,Object[])
+ logger.log(Level.INFO, "My {0} test message", new Object[] { "third" });
+ logger.log(Level.INFO, "My {0} test message", new Object[] {});
+ logger.log(Level.INFO, "", new Object[] { "" });
+ logger.log(Level.INFO, "", new Object[] { null });
+ logger.log(Level.INFO, "My {0} test message", new Object[] { "" });
+ logger.log(Level.INFO, "My {0} test message", new Object[] { null });
+ logger.log(Level.INFO, null, "");
+
+ // log test with method log(Level,String,Throwable)
+ logger.setLevel(Level.WARNING); // Don't log the expected exceptions
+ Throwable thrown = new Throwable();
+ logger.log(Level.INFO, "My fourth test message", thrown);
+ logger.log(Level.INFO, "", thrown);
+ logger.log(Level.INFO, null, thrown);
+ thrown = null;
+ logger.log(Level.INFO, "My fourth test message", thrown);
+
+ new Runnable() {
+ @Override
+ public void run() {
+ logger.log(getClass().getName(), Level.INFO, "Message from wrapper",
null);
+ }
+ }.run();
+
+ // test deprecated log method
+ logger.log("My fifth test message");
+ logger.log("");
+ logger.log(null);
+
+ // test deprecated logException method
+ Exception ex = new Exception("My sixth test message");
+ logger.logException(ex);
+ logger.logException(null);
} finally {
logger.setLevel(Level.INFO);
}
@@ -243,68 +242,69 @@ public class JSR47Logger_implTest extends TestCase {
public void testMessageKeyLogMethods() throws Exception {
// create Logger
org.apache.uima.util.Logger logger = JSR47Logger_impl.getInstance();
-
+
try {
- // reset log level to INFO
- logger.setLevel(Level.INFO);
-
- // File file = File.createTempFile("LoggingTest","log");
- // file.deleteOnExit();
-
- // change output temporary file
- // logger.setOutputStream(new PrintStream(new FileOutputStream(file)));
-
- // test deprecated log(String, String, Object[])
- String msgKey = "UIMA_logger_test";
- String bundle = "org.apache.uima.util.impl.logger_test_messages";
- logger.log(bundle, msgKey, new Object[] { "message key test" });
- logger.log(bundle, null, new Object[] { "message key test" });
- logger.log(bundle, msgKey, new Object[] { "" });
- logger.log(bundle, msgKey, new Object[] { null });
-
- // test method logrb(Level, String, String, String, String)
- logger.logrb(Level.INFO, null, null, bundle, msgKey);
- logger.logrb(Level.INFO, null, null, bundle, null);
- logger.logrb(Level.INFO, null, null, null, msgKey);
- logger.logrb(Level.INFO, null, null, null, null);
- logger.logrb(Level.INFO, "testClass", "testMethod", bundle, msgKey);
- logger.logrb(Level.INFO, "testClass", "testMethod", null, null);
-
- // test method logrb(Level, String, String, String, String, Object)
- Object obj = null;
- logger.logrb(Level.INFO, null, null, bundle, msgKey, new Object());
- logger.logrb(Level.INFO, null, null, bundle, msgKey, "message key test");
- logger.logrb(Level.INFO, null, null, bundle, null, "message key test");
- logger.logrb(Level.INFO, null, null, null, msgKey, "");
- logger.logrb(Level.INFO, null, null, null, null, "");
- logger.logrb(Level.INFO, "testClass", "testMethod", bundle, msgKey, obj);
- logger.logrb(Level.INFO, "testClass", "testMethod", null, null, obj);
-
- // test method logrb(Level, String, String, String, String, Object[])
- Object[] objects = null;
- logger.logrb(Level.INFO, null, null, bundle, msgKey, new Object[] {});
- logger.logrb(Level.INFO, null, null, bundle, null, new Object[] { "message
key test" });
- logger.logrb(Level.INFO, null, null, null, msgKey, new Object[] { "" });
- logger.logrb(Level.INFO, null, null, null, null, new Object[] { "" });
- logger.logrb(Level.INFO, null, null, null, null, new Object[] { null });
- logger.logrb(Level.INFO, "testClass", "testMethod", bundle, msgKey,
objects);
- logger.logrb(Level.INFO, "testClass", "testMethod", null, null, objects);
-
- // test method logrb(Level, String, String, String, String, thrown)
- Throwable thrown = new Throwable();
- logger.setLevel(Level.WARNING); // Don't log the expected exceptions
- logger.logrb(Level.INFO, null, null, bundle, msgKey, thrown);
- logger.logrb(Level.INFO, null, null, bundle, null, thrown);
- logger.logrb(Level.INFO, null, null, null, msgKey, thrown);
- logger.logrb(Level.INFO, null, null, null, null, thrown);
- thrown = null;
- logger.logrb(Level.INFO, "testClass", "testMethod", bundle, msgKey,
thrown);
- logger.logrb(Level.INFO, "testClass", "testMethod", null, null, thrown);
-
- // https://issues.apache.org/jira/browse/UIMA-5719
- logger.logrb(Level.WARNING, "testClass", "testMethod",
"org.apache.uima.impl.log_messages", "UIMA_external_override_ignored__CONFIG",
new Object[] { "n1", "${abc}" });
- } finally {
- logger.setLevel(Level.INFO);
- }
+ // reset log level to INFO
+ logger.setLevel(Level.INFO);
+
+ // File file = File.createTempFile("LoggingTest","log");
+ // file.deleteOnExit();
+
+ // change output temporary file
+ // logger.setOutputStream(new PrintStream(new FileOutputStream(file)));
+
+ // test deprecated log(String, String, Object[])
+ String msgKey = "UIMA_logger_test";
+ String bundle = "org.apache.uima.util.impl.logger_test_messages";
+ logger.log(bundle, msgKey, new Object[] { "message key test" });
+ logger.log(bundle, null, new Object[] { "message key test" });
+ logger.log(bundle, msgKey, new Object[] { "" });
+ logger.log(bundle, msgKey, new Object[] { null });
+
+ // test method logrb(Level, String, String, String, String)
+ logger.logrb(Level.INFO, null, null, bundle, msgKey);
+ logger.logrb(Level.INFO, null, null, bundle, null);
+ logger.logrb(Level.INFO, null, null, null, msgKey);
+ logger.logrb(Level.INFO, null, null, null, null);
+ logger.logrb(Level.INFO, "testClass", "testMethod", bundle, msgKey);
+ logger.logrb(Level.INFO, "testClass", "testMethod", null, null);
+
+ // test method logrb(Level, String, String, String, String, Object)
+ Object obj = null;
+ logger.logrb(Level.INFO, null, null, bundle, msgKey, new Object());
+ logger.logrb(Level.INFO, null, null, bundle, msgKey, "message key test");
+ logger.logrb(Level.INFO, null, null, bundle, null, "message key test");
+ logger.logrb(Level.INFO, null, null, null, msgKey, "");
+ logger.logrb(Level.INFO, null, null, null, null, "");
+ logger.logrb(Level.INFO, "testClass", "testMethod", bundle, msgKey, obj);
+ logger.logrb(Level.INFO, "testClass", "testMethod", null, null, obj);
+
+ // test method logrb(Level, String, String, String, String, Object[])
+ Object[] objects = null;
+ logger.logrb(Level.INFO, null, null, bundle, msgKey, new Object[] {});
+ logger.logrb(Level.INFO, null, null, bundle, null, new Object[] {
"message key test" });
+ logger.logrb(Level.INFO, null, null, null, msgKey, new Object[] { "" });
+ logger.logrb(Level.INFO, null, null, null, null, new Object[] { "" });
+ logger.logrb(Level.INFO, null, null, null, null, new Object[] { null });
+ logger.logrb(Level.INFO, "testClass", "testMethod", bundle, msgKey,
objects);
+ logger.logrb(Level.INFO, "testClass", "testMethod", null, null, objects);
+
+ // test method logrb(Level, String, String, String, String, thrown)
+ Throwable thrown = new Throwable();
+ logger.setLevel(Level.WARNING); // Don't log the expected exceptions
+ logger.logrb(Level.INFO, null, null, bundle, msgKey, thrown);
+ logger.logrb(Level.INFO, null, null, bundle, null, thrown);
+ logger.logrb(Level.INFO, null, null, null, msgKey, thrown);
+ logger.logrb(Level.INFO, null, null, null, null, thrown);
+ thrown = null;
+ logger.logrb(Level.INFO, "testClass", "testMethod", bundle, msgKey,
thrown);
+ logger.logrb(Level.INFO, "testClass", "testMethod", null, null, thrown);
+
+ // https://issues.apache.org/jira/browse/UIMA-5719
+ logger.logrb(Level.WARNING, "testClass", "testMethod",
"org.apache.uima.impl.log_messages",
+ "UIMA_external_override_ignored__CONFIG", new Object[] { "n1",
"${abc}" });
+ } finally {
+ logger.setLevel(Level.INFO);
+ }
}
}
diff --git
a/uimaj-core/src/test/java/org/apache/uima/util/impl/Log4jLogger_implTest.java
b/uimaj-core/src/test/java/org/apache/uima/util/impl/Log4jLogger_implTest.java
index 79ba1da..cbd4d35 100644
---
a/uimaj-core/src/test/java/org/apache/uima/util/impl/Log4jLogger_implTest.java
+++
b/uimaj-core/src/test/java/org/apache/uima/util/impl/Log4jLogger_implTest.java
@@ -34,192 +34,148 @@ import junit.framework.TestCase;
*/
public class Log4jLogger_implTest extends TestCase {
- @Override
+ @Override
public void setUp() throws Exception {
-// BasicConfigurator.configure();
- }
+ // BasicConfigurator.configure();
+ }
- @Override
+ @Override
public void tearDown() throws Exception {
-// BasicConfigurator.resetConfiguration();
- }
-
-// private static HashMap<String, Level> logLevels = new HashMap<String,
Level>(
-// 9);
-// static {
-// logLevels.put("OFF", Level.OFF);
-// logLevels.put("ERROR", Level.SEVERE);
-// logLevels.put("WARN", Level.WARNING);
-// logLevels.put("INFO", Level.INFO);
-// logLevels.put("INFO", Level.CONFIG);
-// logLevels.put("DEBUG", Level.FINE);
-// logLevels.put("ALL", Level.FINER);
-// logLevels.put("ALL", Level.FINEST);
-// logLevels.put("ALL", Level.ALL);
-// }
-
- public void testLogWrapperCreation() throws Exception {
- org.apache.uima.util.Logger uimaLogger = Log4jLogger_impl.getInstance();
- org.apache.uima.util.Logger classLogger = Log4jLogger_impl
- .getInstance(this.getClass());
-
- // check base configuration
- assertNotNull(uimaLogger);
- assertNotNull(classLogger);
- assertTrue(uimaLogger.isLoggable(Level.INFO));
- assertTrue(classLogger.isLoggable(Level.INFO));
- classLogger.log("ola");
- classLogger.log(Level.INFO, "OLA in info");
-
- uimaLogger.log(Level.INFO, "UIMA OLA in info");
- https://issues.apache.org/jira/browse/UIMA-5719
- uimaLogger.logrb(Level.WARNING, "testClass", "testMethod",
"org.apache.uima.impl.log_messages", "UIMA_external_override_ignored__CONFIG",
new Object[] { "n1", "${abc}" });
- }
-
- public void testIsLoggable() throws Exception {
- // create logger
- org.apache.uima.util.Logger uimaLogger = null;
- try {
- uimaLogger = Log4jLogger_impl.getInstance();
- } catch (Exception e) {
- System.err.println(e);
- e.printStackTrace(System.err);
- throw e;
- }
- org.apache.uima.util.Logger classLogger = Log4jLogger_impl
- .getInstance(this.getClass());
-
- assertNotNull(uimaLogger);
- assertNotNull(classLogger);
- Logger log4jLogger =
org.apache.logging.log4j.LogManager.getLogger("org.apache.uima");
- while (log4jLogger.getLevel() == null) {
- log4jLogger = LogManager.getRootLogger();
- }
-
- String key = "INFO"; // log4jLogger.getLevel().toString();
-
- Level defaultLogLevel = Level.INFO; // logLevels.get(key); // doesn't
work
-
- assertNotNull(defaultLogLevel);
- // check message logging for root logger based on default log level
- assertEquals(defaultLogLevel.isGreaterOrEqual(Level.ALL), uimaLogger
- .isLoggable(Level.ALL));
- assertEquals(defaultLogLevel.isGreaterOrEqual(Level.FINEST), uimaLogger
- .isLoggable(Level.FINEST));
- assertEquals(defaultLogLevel.isGreaterOrEqual(Level.FINER), uimaLogger
- .isLoggable(Level.FINER));
- assertEquals(defaultLogLevel.isGreaterOrEqual(Level.FINE), uimaLogger
- .isLoggable(Level.FINE));
- assertEquals(defaultLogLevel.isGreaterOrEqual(Level.CONFIG), uimaLogger
- .isLoggable(Level.CONFIG));
- assertEquals(defaultLogLevel.isGreaterOrEqual(Level.INFO), uimaLogger
- .isLoggable(Level.INFO));
- assertEquals(defaultLogLevel.isGreaterOrEqual(Level.WARNING), uimaLogger
- .isLoggable(Level.WARNING));
- assertEquals(defaultLogLevel.isGreaterOrEqual(Level.SEVERE), uimaLogger
- .isLoggable(Level.SEVERE));
- assertEquals(defaultLogLevel.isGreaterOrEqual(Level.OFF), uimaLogger
- .isLoggable(Level.OFF));
-
- // check message logging for class logger based on default log level
- assertEquals(defaultLogLevel.isGreaterOrEqual(Level.ALL), classLogger
- .isLoggable(Level.ALL));
- assertEquals(defaultLogLevel.isGreaterOrEqual(Level.FINEST), classLogger
- .isLoggable(Level.FINEST));
- assertEquals(defaultLogLevel.isGreaterOrEqual(Level.FINER), classLogger
- .isLoggable(Level.FINER));
- assertEquals(defaultLogLevel.isGreaterOrEqual(Level.FINE), classLogger
- .isLoggable(Level.FINE));
- assertEquals(defaultLogLevel.isGreaterOrEqual(Level.CONFIG), classLogger
- .isLoggable(Level.CONFIG));
- assertEquals(defaultLogLevel.isGreaterOrEqual(Level.INFO), classLogger
- .isLoggable(Level.INFO));
- assertEquals(defaultLogLevel.isGreaterOrEqual(Level.WARNING), classLogger
- .isLoggable(Level.WARNING));
- assertEquals(defaultLogLevel.isGreaterOrEqual(Level.SEVERE), classLogger
- .isLoggable(Level.SEVERE));
- assertEquals(defaultLogLevel.isGreaterOrEqual(Level.OFF), classLogger
- .isLoggable(Level.OFF));
-
- // reset class logger level to OFF
- //
Logger.getLogger(this.getClass().getName()).setLevel(java.util.logging.Level.OFF);
- classLogger.setLevel(Level.OFF);
- assertFalse(classLogger.isLoggable(Level.ALL));
- assertFalse(classLogger.isLoggable(Level.FINEST));
- assertFalse(classLogger.isLoggable(Level.FINER));
- assertFalse(classLogger.isLoggable(Level.FINE));
- assertFalse(classLogger.isLoggable(Level.CONFIG));
- assertFalse(classLogger.isLoggable(Level.INFO));
- assertFalse(classLogger.isLoggable(Level.WARNING));
- assertFalse(classLogger.isLoggable(Level.SEVERE));
- assertTrue(classLogger.isLoggable(Level.OFF));
-
- // reset class logger level to ALL
- //
Logger.getLogger(this.getClass().getName()).setLevel(java.util.logging.Level.ALL);
- classLogger.setLevel(Level.ALL);
- assertTrue(classLogger.isLoggable(Level.ALL));
- assertTrue(classLogger.isLoggable(Level.FINEST));
- assertTrue(classLogger.isLoggable(Level.FINER));
- assertTrue(classLogger.isLoggable(Level.FINE));
- assertTrue(classLogger.isLoggable(Level.CONFIG));
- assertTrue(classLogger.isLoggable(Level.INFO));
- assertTrue(classLogger.isLoggable(Level.WARNING));
- assertTrue(classLogger.isLoggable(Level.SEVERE));
- assertTrue(classLogger.isLoggable(Level.OFF));
-
- // reset class logger level to WARNING
- //
Logger.getLogger(this.getClass().getName()).setLevel(java.util.logging.Level.WARNING);
- classLogger.setLevel(Level.WARNING);
- assertFalse(classLogger.isLoggable(Level.ALL));
- assertFalse(classLogger.isLoggable(Level.FINEST));
- assertFalse(classLogger.isLoggable(Level.FINER));
- assertFalse(classLogger.isLoggable(Level.FINE));
- assertFalse(classLogger.isLoggable(Level.CONFIG));
- assertFalse(classLogger.isLoggable(Level.INFO));
- assertTrue(classLogger.isLoggable(Level.WARNING));
- assertTrue(classLogger.isLoggable(Level.SEVERE));
- assertTrue(classLogger.isLoggable(Level.OFF));
-
- // reset log level to default log level
- classLogger.setLevel(defaultLogLevel);
- }
-
- public void testMessageLogMethods() throws Exception {
-// final List<LoggingEvent> records = new ArrayList<LoggingEvent>();
- final int[] nbrcalls = new int[1];
- nbrcalls[0] = 0;
-
- // Tell the logger to log everything
-// long start = System.nanoTime();
- org.apache.logging.log4j.core.Logger rootLogger =
(org.apache.logging.log4j.core.Logger)
org.apache.logging.log4j.LogManager.getRootLogger();
-// System.out.format("debug time to init logger is %f%n ",
((double)(System.nanoTime() - start)) / 1000000000.0d);
- rootLogger.get().setLevel(org.apache.logging.log4j.Level.ALL);
- rootLogger.getContext().updateLoggers();
-// Configurator.setLevel(null, org.apache.logging.log4j.Level.ALL);
-// final LoggerContext loggerContext = LoggerContext.getContext(false);
-// final LoggerConfig loggerConfig =
loggerContext.getConfiguration().getRootLogger();
-//
-// Appender appender = (Appender)
rootLogger.getAllAppenders().nextElement();
- // Capture the logging output without actually logging it
-// ConsoleAppender app = (ConsoleAppender)
rootLogger.getAppenders().values().stream().findFirst().get();
- // add the filter to the shared Logger Context appender
- ConsoleAppender app = (ConsoleAppender)
rootLogger.get().getAppenders().values().stream().findFirst().get();
- Filter filter = new AbstractFilter() {
- @Override
- public Result filter(LogEvent event) {
- nbrcalls[0] ++;
- StackTraceElement ste = event.getSource();
- System.out.printf("[%s:%s] %s%n", ste.getFileName(),
ste.getLineNumber(), event.getMessage().getFormattedMessage());
- assertEquals(Log4jLogger_implTest.this.getClass().getName() ,
ste.getClassName());
- return Result.DENY;
- }
- };
-
- app.addFilter(filter);
-
- try {
- // create Logger
- // debug
+ // BasicConfigurator.resetConfiguration();
+ }
+
+ // private static HashMap<String, Level> logLevels = new HashMap<String,
Level>(
+ // 9);
+ // static {
+ // logLevels.put("OFF", Level.OFF);
+ // logLevels.put("ERROR", Level.SEVERE);
+ // logLevels.put("WARN", Level.WARNING);
+ // logLevels.put("INFO", Level.INFO);
+ // logLevels.put("INFO", Level.CONFIG);
+ // logLevels.put("DEBUG", Level.FINE);
+ // logLevels.put("ALL", Level.FINER);
+ // logLevels.put("ALL", Level.FINEST);
+ // logLevels.put("ALL", Level.ALL);
+ // }
+
+ public void testLogWrapperCreation() throws Exception {
+ org.apache.uima.util.Logger uimaLogger = Log4jLogger_impl.getInstance();
+ org.apache.uima.util.Logger classLogger =
Log4jLogger_impl.getInstance(this.getClass());
+
+ // check base configuration
+ assertNotNull(uimaLogger);
+ assertNotNull(classLogger);
+ assertTrue(uimaLogger.isLoggable(Level.INFO));
+ assertTrue(classLogger.isLoggable(Level.INFO));
+ classLogger.log("ola");
+ classLogger.log(Level.INFO, "OLA in info");
+
+ uimaLogger.log(Level.INFO, "UIMA OLA in info");
+ https: // issues.apache.org/jira/browse/UIMA-5719
+ uimaLogger.logrb(Level.WARNING, "testClass", "testMethod",
"org.apache.uima.impl.log_messages",
+ "UIMA_external_override_ignored__CONFIG", new Object[] { "n1",
"${abc}" });
+ }
+
+ public void testIsLoggable() throws Exception {
+ // create logger
+ org.apache.uima.util.Logger uimaLogger = null;
+ try {
+ uimaLogger = Log4jLogger_impl.getInstance();
+ } catch (Exception e) {
+ System.err.println(e);
+ e.printStackTrace(System.err);
+ throw e;
+ }
+ org.apache.uima.util.Logger classLogger =
Log4jLogger_impl.getInstance(this.getClass());
+
+ assertNotNull(uimaLogger);
+ assertNotNull(classLogger);
+ Logger log4jLogger =
org.apache.logging.log4j.LogManager.getLogger("org.apache.uima");
+ while (log4jLogger.getLevel() == null) {
+ log4jLogger = LogManager.getRootLogger();
+ }
+
+ String key = "INFO"; // log4jLogger.getLevel().toString();
+
+ Level defaultLogLevel = Level.INFO; // logLevels.get(key); // doesn't work
+
+ assertNotNull(defaultLogLevel);
+ // check message logging for root logger based on default log level
+ assertEquals(defaultLogLevel.isGreaterOrEqual(Level.ALL),
uimaLogger.isLoggable(Level.ALL));
+ assertEquals(defaultLogLevel.isGreaterOrEqual(Level.FINEST),
+ uimaLogger.isLoggable(Level.FINEST));
+ assertEquals(defaultLogLevel.isGreaterOrEqual(Level.FINER),
uimaLogger.isLoggable(Level.FINER));
+ assertEquals(defaultLogLevel.isGreaterOrEqual(Level.FINE),
uimaLogger.isLoggable(Level.FINE));
+ assertEquals(defaultLogLevel.isGreaterOrEqual(Level.CONFIG),
+ uimaLogger.isLoggable(Level.CONFIG));
+ assertEquals(defaultLogLevel.isGreaterOrEqual(Level.INFO),
uimaLogger.isLoggable(Level.INFO));
+ assertEquals(defaultLogLevel.isGreaterOrEqual(Level.WARNING),
+ uimaLogger.isLoggable(Level.WARNING));
+ assertEquals(defaultLogLevel.isGreaterOrEqual(Level.SEVERE),
+ uimaLogger.isLoggable(Level.SEVERE));
+ assertEquals(defaultLogLevel.isGreaterOrEqual(Level.OFF),
uimaLogger.isLoggable(Level.OFF));
+
+ // check message logging for class logger based on default log level
+ assertEquals(defaultLogLevel.isGreaterOrEqual(Level.ALL),
classLogger.isLoggable(Level.ALL));
+ assertEquals(defaultLogLevel.isGreaterOrEqual(Level.FINEST),
+ classLogger.isLoggable(Level.FINEST));
+ assertEquals(defaultLogLevel.isGreaterOrEqual(Level.FINER),
+ classLogger.isLoggable(Level.FINER));
+ assertEquals(defaultLogLevel.isGreaterOrEqual(Level.FINE),
classLogger.isLoggable(Level.FINE));
+ assertEquals(defaultLogLevel.isGreaterOrEqual(Level.CONFIG),
+ classLogger.isLoggable(Level.CONFIG));
+ assertEquals(defaultLogLevel.isGreaterOrEqual(Level.INFO),
classLogger.isLoggable(Level.INFO));
+ assertEquals(defaultLogLevel.isGreaterOrEqual(Level.WARNING),
+ classLogger.isLoggable(Level.WARNING));
+ assertEquals(defaultLogLevel.isGreaterOrEqual(Level.SEVERE),
+ classLogger.isLoggable(Level.SEVERE));
+ assertEquals(defaultLogLevel.isGreaterOrEqual(Level.OFF),
classLogger.isLoggable(Level.OFF));
+
+ // reset class logger level to OFF
+ //
Logger.getLogger(this.getClass().getName()).setLevel(java.util.logging.Level.OFF);
+ classLogger.setLevel(Level.OFF);
+ assertFalse(classLogger.isLoggable(Level.ALL));
+ assertFalse(classLogger.isLoggable(Level.FINEST));
+ assertFalse(classLogger.isLoggable(Level.FINER));
+ assertFalse(classLogger.isLoggable(Level.FINE));
+ assertFalse(classLogger.isLoggable(Level.CONFIG));
+ assertFalse(classLogger.isLoggable(Level.INFO));
+ assertFalse(classLogger.isLoggable(Level.WARNING));
+ assertFalse(classLogger.isLoggable(Level.SEVERE));
+ assertTrue(classLogger.isLoggable(Level.OFF));
+
+ // reset class logger level to ALL
+ //
Logger.getLogger(this.getClass().getName()).setLevel(java.util.logging.Level.ALL);
+ classLogger.setLevel(Level.ALL);
+ assertTrue(classLogger.isLoggable(Level.ALL));
+ assertTrue(classLogger.isLoggable(Level.FINEST));
+ assertTrue(classLogger.isLoggable(Level.FINER));
+ assertTrue(classLogger.isLoggable(Level.FINE));
+ assertTrue(classLogger.isLoggable(Level.CONFIG));
+ assertTrue(classLogger.isLoggable(Level.INFO));
+ assertTrue(classLogger.isLoggable(Level.WARNING));
+ assertTrue(classLogger.isLoggable(Level.SEVERE));
+ assertTrue(classLogger.isLoggable(Level.OFF));
+
+ // reset class logger level to WARNING
+ //
Logger.getLogger(this.getClass().getName()).setLevel(java.util.logging.Level.WARNING);
+ classLogger.setLevel(Level.WARNING);
+ assertFalse(classLogger.isLoggable(Level.ALL));
+ assertFalse(classLogger.isLoggable(Level.FINEST));
+ assertFalse(classLogger.isLoggable(Level.FINER));
+ assertFalse(classLogger.isLoggable(Level.FINE));
+ assertFalse(classLogger.isLoggable(Level.CONFIG));
+ assertFalse(classLogger.isLoggable(Level.INFO));
+ assertTrue(classLogger.isLoggable(Level.WARNING));
+ assertTrue(classLogger.isLoggable(Level.SEVERE));
+ assertTrue(classLogger.isLoggable(Level.OFF));
+
+ // reset log level to default log level
+ classLogger.setLevel(defaultLogLevel);
+ }
+
+ public void testMessageLogMethods() throws Exception {
+ try (Log4JMessageCapture capture = new Log4JMessageCapture()) {
org.apache.uima.util.Logger tempLogger = null;
try {
tempLogger = Log4jLogger_impl.getInstance(getClass());
@@ -229,18 +185,9 @@ public class Log4jLogger_implTest extends TestCase {
System.err.println("debug finished stacktrace");
throw e;
}
+
final org.apache.uima.util.Logger logger = tempLogger;
- // reset log level to INFO
logger.setLevel(Level.INFO);
-// Configurator.setLevel("Console", org.apache.logging.log4j.Level.INFO);
-
- // File file = File.createTempFile("LoggingTest","log");
- // file.deleteOnExit();
-
- // change output temporary file
- // logger.setOutputStream(new PrintStream(new FileOutputStream(file)));
-
- // log test with method log(Level,String)
logger.log(Level.INFO, "My first test message");
logger.log(Level.INFO, "");
@@ -273,11 +220,12 @@ public class Log4jLogger_implTest extends TestCase {
logger.log(Level.INFO, "My fourth test message", thrown);
new Runnable() {
+ @Override
public void run() {
logger.log(getClass().getName(), Level.INFO, "Message from wrapper",
null);
}
}.run();
-
+
// test deprecated log method
logger.log("My fifth test message");
logger.log("");
@@ -287,151 +235,149 @@ public class Log4jLogger_implTest extends TestCase {
Exception ex = new Exception("My sixth test message");
logger.logException(ex);
logger.logException(null);
-
- assertEquals(16, nbrcalls[0]); // all calls except those with null or
"" msgs (including non-null throwable/exception)
+
+ // all calls except those with null or "" msgs (including non-null
throwable/exception)
+ assertEquals(16, capture.getAllEvents().size());
+
// https://issues.apache.org/jira/browse/UIMA-5719
- logger.logrb(Level.WARNING, "testClass", "testMethod",
"org.apache.uima.impl.log_messages", "UIMA_external_override_ignored__CONFIG",
new Object[] { "n1", "${abc}" });
-
- } finally {
- app.removeFilter(filter);
- }
-
- }
-
-
- public void testMessageKeyLogMethods() throws Exception {
- final int[] nbrcalls = new int[1];
- nbrcalls[0] = 0;
-
- // Tell the logger to log everything
- org.apache.logging.log4j.core.Logger rootLogger =
(org.apache.logging.log4j.core.Logger)
org.apache.logging.log4j.LogManager.getRootLogger();
- // create Logger
- org.apache.uima.util.Logger logger = Log4jLogger_impl.getInstance();
-
- try {
- rootLogger.get().setLevel(org.apache.logging.log4j.Level.ALL);
- rootLogger.getContext().updateLoggers();
-// Appender appender = (Appender)
rootLogger.getAllAppenders().nextElement();
- // Capture the logging output without actually logging it
-// appender.addFilter(new org.apache.logging.log4j.spi.Filter() {
-
- Filter filter = new AbstractFilter() {
- @Override
- public Result filter(LogEvent event) {
- nbrcalls[0] ++;
- StackTraceElement ste = event.getSource();
- System.out.printf("[%s:%s] %s%n", ste.getFileName(),
ste.getLineNumber(), event.getMessage().getFormattedMessage());
-
assertEquals(Log4jLogger_implTest.this.getClass().getSimpleName()+".java",
ste.getFileName());
- return Result.DENY;
- }
- };
-
- ConsoleAppender app = (ConsoleAppender)
rootLogger.get().getAppenders().values().stream().findFirst().get();
- app.addFilter(filter);
- try {
-// @Override
-// public int decide(LoggingEvent event) {
-// nbrcalss[0] ++;
-// LocationInfo l = event.getLocationInformation();
-// System.out.printf("[%s:%s] %s%n", l.getFileName(),
l.getLineNumber(), event.getMessage());
-//
assertEquals(TestLog4jLogger_impl.this.getClass().getSimpleName()+".java",
-// l.getFileName());
-// return org.apache.logging.log4j.spi.Filter.DENY;
-// }
-// });
-
- // reset log level to INFO
- logger.setLevel(Level.INFO);
+ logger.logrb(Level.WARNING, "testClass", "testMethod",
"org.apache.uima.impl.log_messages",
+ "UIMA_external_override_ignored__CONFIG", new Object[] { "n1",
"${abc}" });
+ }
+ }
+
+ public void testMessageKeyLogMethods() throws Exception {
+ final int[] nbrcalls = new int[1];
+ nbrcalls[0] = 0;
+
+ // Tell the logger to log everything
+ org.apache.logging.log4j.core.Logger rootLogger =
(org.apache.logging.log4j.core.Logger) org.apache.logging.log4j.LogManager
+ .getRootLogger();
+ // create Logger
+ org.apache.uima.util.Logger logger = Log4jLogger_impl.getInstance();
+
+ try {
+ rootLogger.get().setLevel(org.apache.logging.log4j.Level.ALL);
+ rootLogger.getContext().updateLoggers();
+ // Appender appender = (Appender)
rootLogger.getAllAppenders().nextElement();
+ // Capture the logging output without actually logging it
+ // appender.addFilter(new org.apache.logging.log4j.spi.Filter() {
+
+ Filter filter = new AbstractFilter() {
+ @Override
+ public Result filter(LogEvent event) {
+ nbrcalls[0]++;
+ StackTraceElement ste = event.getSource();
+ System.out.printf("[%s:%s] %s%n", ste.getFileName(),
ste.getLineNumber(),
+ event.getMessage().getFormattedMessage());
+ assertEquals(Log4jLogger_implTest.this.getClass().getSimpleName() +
".java",
+ ste.getFileName());
+ return Result.DENY;
+ }
+ };
- // File file = File.createTempFile("LoggingTest","log");
- // file.deleteOnExit();
-
- // change output temporary file
- // logger.setOutputStream(new PrintStream(new FileOutputStream(file)));
-
- // test deprecated log(String, String, Object[])
- String msgKey = "UIMA_logger_test";
- String bundle = "org.apache.uima.util.impl.logger_test_messages";
- logger.log(bundle, msgKey, new Object[] { "message key test" });
- logger.log(bundle, null, new Object[] { "message key test" });
- logger.log(bundle, msgKey, new Object[] { "" });
- logger.log(bundle, msgKey, new Object[] { null });
-
- // test method logrb(Level, String, String, String, String)
- logger.logrb(Level.INFO, null, null, bundle, msgKey);
- logger.logrb(Level.INFO, null, null, bundle, null);
- logger.logrb(Level.INFO, null, null, null, msgKey);
- logger.logrb(Level.INFO, null, null, null, null);
- logger.logrb(Level.INFO, "testClass", "testMethod", bundle, msgKey);
- logger.logrb(Level.INFO, "testClass", "testMethod", null, null);
-
- // test method logrb(Level, String, String, String, String, Object)
- Object obj = null;
- logger.logrb(Level.INFO, null, null, bundle, msgKey, new Object());
- logger.logrb(Level.INFO, null, null, bundle, msgKey, "message key test");
- logger.logrb(Level.INFO, null, null, bundle, null, "message key test");
- logger.logrb(Level.INFO, null, null, null, msgKey, "");
- logger.logrb(Level.INFO, null, null, null, null, "");
- logger.logrb(Level.INFO, "testClass", "testMethod", bundle, msgKey, obj);
- logger.logrb(Level.INFO, "testClass", "testMethod", null, null, obj);
-
- // test method logrb(Level, String, String, String, String, Object[])
- Object[] objects = null;
- logger.logrb(Level.INFO, null, null, bundle, msgKey, new Object[] {});
- logger.logrb(Level.INFO, null, null, bundle, null,
- new Object[] { "message key test" });
- logger.logrb(Level.INFO, null, null, null, msgKey, new Object[] { "" });
- logger.logrb(Level.INFO, null, null, null, null, new Object[] { "" });
- logger.logrb(Level.INFO, null, null, null, null, new Object[] { null });
- logger.logrb(Level.INFO, "testClass", "testMethod", bundle, msgKey,
- objects);
- logger.logrb(Level.INFO, "testClass", "testMethod", null, null, objects);
-
- // test method logrb(Level, String, String, String, String, thrown)
- Throwable thrown = new Throwable();
- logger.logrb(Level.INFO, null, null, bundle, msgKey, thrown);
- logger.logrb(Level.INFO, null, null, bundle, null, thrown);
- logger.logrb(Level.INFO, null, null, null, msgKey, thrown);
- logger.logrb(Level.INFO, null, null, null, null, thrown);
- thrown = null;
- logger.logrb(Level.INFO, "testClass", "testMethod", bundle, msgKey,
- thrown);
- logger.logrb(Level.INFO, "testClass", "testMethod", null, null, thrown);
-
- assertEquals(18, nbrcalls[0]);
- } finally {
- app.removeFilter(filter); // otherwise, subsequent test's filter gets
appended, not replace
- }
-
- } finally {
- logger.setLevel(Level.INFO);
- rootLogger.setLevel(org.apache.logging.log4j.Level.INFO);
- }
- }
-
- public void testLoggerFromUIMAFramework() {
- org.apache.uima.util.Logger logger = UIMAFramework.getLogger(this
- .getClass());
+ ConsoleAppender app = (ConsoleAppender)
rootLogger.get().getAppenders().values().stream()
+ .findFirst().get();
+ app.addFilter(filter);
+ try {
+ // @Override
+ // public int decide(LoggingEvent event) {
+ // nbrcalss[0] ++;
+ // LocationInfo l = event.getLocationInformation();
+ // System.out.printf("[%s:%s] %s%n", l.getFileName(),
l.getLineNumber(),
+ // event.getMessage());
+ //
assertEquals(TestLog4jLogger_impl.this.getClass().getSimpleName()+".java",
+ // l.getFileName());
+ // return org.apache.logging.log4j.spi.Filter.DENY;
+ // }
+ // });
+
+ // reset log level to INFO
+ logger.setLevel(Level.INFO);
+
+ // File file = File.createTempFile("LoggingTest","log");
+ // file.deleteOnExit();
+
+ // change output temporary file
+ // logger.setOutputStream(new PrintStream(new FileOutputStream(file)));
+
+ // test deprecated log(String, String, Object[])
+ String msgKey = "UIMA_logger_test";
+ String bundle = "org.apache.uima.util.impl.logger_test_messages";
+ logger.log(bundle, msgKey, new Object[] { "message key test" });
+ logger.log(bundle, null, new Object[] { "message key test" });
+ logger.log(bundle, msgKey, new Object[] { "" });
+ logger.log(bundle, msgKey, new Object[] { null });
+
+ // test method logrb(Level, String, String, String, String)
+ logger.logrb(Level.INFO, null, null, bundle, msgKey);
+ logger.logrb(Level.INFO, null, null, bundle, null);
+ logger.logrb(Level.INFO, null, null, null, msgKey);
+ logger.logrb(Level.INFO, null, null, null, null);
+ logger.logrb(Level.INFO, "testClass", "testMethod", bundle, msgKey);
+ logger.logrb(Level.INFO, "testClass", "testMethod", null, null);
+
+ // test method logrb(Level, String, String, String, String, Object)
+ Object obj = null;
+ logger.logrb(Level.INFO, null, null, bundle, msgKey, new Object());
+ logger.logrb(Level.INFO, null, null, bundle, msgKey, "message key
test");
+ logger.logrb(Level.INFO, null, null, bundle, null, "message key test");
+ logger.logrb(Level.INFO, null, null, null, msgKey, "");
+ logger.logrb(Level.INFO, null, null, null, null, "");
+ logger.logrb(Level.INFO, "testClass", "testMethod", bundle, msgKey,
obj);
+ logger.logrb(Level.INFO, "testClass", "testMethod", null, null, obj);
+
+ // test method logrb(Level, String, String, String, String, Object[])
+ Object[] objects = null;
+ logger.logrb(Level.INFO, null, null, bundle, msgKey, new Object[] {});
+ logger.logrb(Level.INFO, null, null, bundle, null, new Object[] {
"message key test" });
+ logger.logrb(Level.INFO, null, null, null, msgKey, new Object[] { ""
});
+ logger.logrb(Level.INFO, null, null, null, null, new Object[] { "" });
+ logger.logrb(Level.INFO, null, null, null, null, new Object[] { null
});
+ logger.logrb(Level.INFO, "testClass", "testMethod", bundle, msgKey,
objects);
+ logger.logrb(Level.INFO, "testClass", "testMethod", null, null,
objects);
+
+ // test method logrb(Level, String, String, String, String, thrown)
+ Throwable thrown = new Throwable();
+ logger.logrb(Level.INFO, null, null, bundle, msgKey, thrown);
+ logger.logrb(Level.INFO, null, null, bundle, null, thrown);
+ logger.logrb(Level.INFO, null, null, null, msgKey, thrown);
+ logger.logrb(Level.INFO, null, null, null, null, thrown);
+ thrown = null;
+ logger.logrb(Level.INFO, "testClass", "testMethod", bundle, msgKey,
thrown);
+ logger.logrb(Level.INFO, "testClass", "testMethod", null, null,
thrown);
+
+ assertEquals(18, nbrcalls[0]);
+ } finally {
+ app.removeFilter(filter); // otherwise, subsequent test's filter gets
appended, not replace
+ }
+ } finally {
logger.setLevel(Level.INFO);
+ rootLogger.setLevel(org.apache.logging.log4j.Level.INFO);
+ }
+ }
- // File file = File.createTempFile("LoggingTest","log");
- // file.deleteOnExit();
+ public void testLoggerFromUIMAFramework() {
+ org.apache.uima.util.Logger logger =
UIMAFramework.getLogger(this.getClass());
- // change output temporary file
- // logger.setOutputStream(new PrintStream(new FileOutputStream(file)));
+ logger.setLevel(Level.INFO);
- // log test with method log(Level,String)
- logger.log(Level.INFO,
- "------------------------------------------------------------");
- logger.log(Level.INFO, "My first test message");
- logger.log(Level.INFO, "message with \"{0}\"", "substitute");
- logger.info("message with \"{}\"", "substitute"); // new logger style
- logger.info("message with \"{}\"", new Object[] {"substitute"}); // new
logger style
-
- // https://issues.apache.org/jira/browse/UIMA-5719
- logger.logrb(Level.WARNING, "testClass", "testMethod",
"org.apache.uima.impl.log_messages", "UIMA_external_override_ignored__CONFIG",
new Object[] { "n1", "${abc}" });
+ // File file = File.createTempFile("LoggingTest","log");
+ // file.deleteOnExit();
+
+ // change output temporary file
+ // logger.setOutputStream(new PrintStream(new FileOutputStream(file)));
+
+ // log test with method log(Level,String)
+ logger.log(Level.INFO,
"------------------------------------------------------------");
+ logger.log(Level.INFO, "My first test message");
+ logger.log(Level.INFO, "message with \"{0}\"", "substitute");
+ logger.info("message with \"{}\"", "substitute"); // new logger style
+ logger.info("message with \"{}\"", new Object[] { "substitute" }); // new
logger style
+ // https://issues.apache.org/jira/browse/UIMA-5719
+ logger.logrb(Level.WARNING, "testClass", "testMethod",
"org.apache.uima.impl.log_messages",
+ "UIMA_external_override_ignored__CONFIG", new Object[] { "n1",
"${abc}" });
- }
+ }
}
