Fix flow logging macros
Project: http://git-wip-us.apache.org/repos/asf/logging-log4j2/repo Commit: http://git-wip-us.apache.org/repos/asf/logging-log4j2/commit/0ab01565 Tree: http://git-wip-us.apache.org/repos/asf/logging-log4j2/tree/0ab01565 Diff: http://git-wip-us.apache.org/repos/asf/logging-log4j2/diff/0ab01565 Branch: refs/heads/LOG4J2-1349-gcfree-threadcontext Commit: 0ab01565a91eb24e8150d3c41c87746a80bf7cd7 Parents: bce8794 Author: Mikael Ståldal <mikael.stal...@magine.com> Authored: Wed Jun 29 20:25:13 2016 +0200 Committer: Mikael Ståldal <mikael.stal...@magine.com> Committed: Wed Jun 29 20:27:32 2016 +0200 ---------------------------------------------------------------------- .../org/apache/logging/log4j/scala/Logger.scala | 36 +++----- .../logging/log4j/scala/LoggerMacro.scala | 29 ++++++- .../apache/logging/log4j/scala/LoggerTest.scala | 90 ++++++++++++++++++-- .../org/apache/logging/log4j/scala/Logger.scala | 31 +++---- .../logging/log4j/scala/LoggerMacro.scala | 29 ++++++- .../apache/logging/log4j/scala/LoggerTest.scala | 90 ++++++++++++++++++-- 6 files changed, 245 insertions(+), 60 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/0ab01565/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logger.scala ---------------------------------------------------------------------- diff --git a/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logger.scala b/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logger.scala index 8fe926c..5fa2cb7 100644 --- a/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logger.scala +++ b/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/Logger.scala @@ -60,7 +60,8 @@ object Logger { * Since this wrapper is implemented with macros, the String construction and method invocations * will only occur when debug logging is enabled. */ -class Logger private(val delegate: ExtendedLogger) { // TODO extends AnyVal ? +class Logger private(val delegate: ExtendedLogger) { + // TODO extends AnyVal ? private final val FQCN = classOf[Logger].getName @@ -431,15 +432,14 @@ class Logger private(val delegate: ExtendedLogger) { // TODO extends AnyVal ? def isEnabled(level: Level, marker: Marker): Boolean = delegate.isEnabled(level, marker) - // TODO fix FQCN for flow logging - /** * Logs entry to a method. Used when the method in question has no parameters or when the parameters should not be * logged. * * @return The built `EntryMessage` */ - def traceEntry(): EntryMessage = delegate.traceEntry() + def traceEntry(): EntryMessage = + macro LoggerMacro.traceEntry /** * Logs entry to a method along with its parameters. @@ -476,7 +476,8 @@ class Logger private(val delegate: ExtendedLogger) { // TODO extends AnyVal ? /** * Logs exit from a method with no result. */ - def traceExit(): Unit = delegate.traceExit() + def traceExit(): Unit = + macro LoggerMacro.traceExit /** * Logs exiting from a method with result. @@ -484,14 +485,16 @@ class Logger private(val delegate: ExtendedLogger) { // TODO extends AnyVal ? * @param result The result being returned from the method call * @return `result` */ - def traceExit[R](result: R): R = delegate.traceExit(result) + def traceExit[R](result: R): R = + macro LoggerMacro.traceExitResult[R] /** * Logs exiting from a method with no result. * * @param entryMessage the `EntryMessage` returned from one of the `traceEntry` methods */ - def traceExit(entryMessage: EntryMessage): Unit = delegate.traceExit(entryMessage) + def traceExit(entryMessage: EntryMessage): Unit = + macro LoggerMacro.traceExitEntryMessage /** * Logs exiting from a method with result. @@ -508,7 +511,8 @@ class Logger private(val delegate: ExtendedLogger) { // TODO extends AnyVal ? * @param result The result being returned from the method call * @return `result` */ - def traceExit[R](entryMessage: EntryMessage, result: R): R = delegate.traceExit(entryMessage, result) + def traceExit[R](entryMessage: EntryMessage, result: R): R = + macro LoggerMacro.traceExitEntryMessageResult[R] /** * Logs exiting from a method with result. Allows custom formatting of the result. @@ -619,22 +623,10 @@ class Logger private(val delegate: ExtendedLogger) { // TODO extends AnyVal ? delegate.logMessage(FQCN, level, marker, messageFactory.newMessage(message), cause) } - - // TODO inline those to get FQCN correct? make macro of other trace methods as well - + // TODO inline this to get FQCN correct /** Should normally not be used directly from application code, but needs to be public for access by macros. */ def traceEntryParams(params: Any*): EntryMessage = { - delegate.traceEntry(null, params) // TODO should not do ifEnabled check - } - - /** Should normally not be used directly from application code, but needs to be public for access by macros. */ - def traceEntryMessage(message: Message): EntryMessage = { - delegate.traceEntry(message) // TODO should not do ifEnabled check - } - - /** Should normally not be used directly from application code, but needs to be public for access by macros. */ - def traceExitMessageResult[R](message: Message, result: R): Unit = { - delegate.traceExit(message, result) // TODO should not do ifEnabled check + delegate.traceEntry(null: String, params) // TODO should not do ifEnabled check } } http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/0ab01565/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala ---------------------------------------------------------------------- diff --git a/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala b/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala index c915ffb..513dd90 100644 --- a/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala +++ b/log4j-api-scala_2.10/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala @@ -338,6 +338,11 @@ private object LoggerMacro { ) + def traceEntry(c: LoggerContext)(): c.Expr[EntryMessage] = + c.universe.reify( + c.prefix.splice.delegate.traceEntry() + ) + def traceEntryParams(c: LoggerContext)(params: c.Expr[Any]*): c.Expr[EntryMessage] = { import c.universe._ val isEnabled = Apply( @@ -361,17 +366,37 @@ private object LoggerMacro { def traceEntryMessage(c: LoggerContext)(message: c.Expr[Message]): c.Expr[EntryMessage] = c.universe.reify( if (c.prefix.splice.delegate.isEnabled(Level.TRACE, AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef], null)) { - c.prefix.splice.traceEntryMessage(message.splice) + c.prefix.splice.delegate.traceEntry(message.splice) // TODO should not do ifEnabled check } else { null } ) + def traceExit(c: LoggerContext)(): c.Expr[Unit] = + c.universe.reify( + c.prefix.splice.delegate.traceExit() + ) + + def traceExitResult[R: c.WeakTypeTag](c: LoggerContext)(result: c.Expr[R]): c.Expr[R] = + c.universe.reify( + c.prefix.splice.delegate.traceExit(result.splice) + ) + + def traceExitEntryMessage(c: LoggerContext)(entryMessage: c.Expr[EntryMessage]): c.Expr[Unit] = + c.universe.reify( + c.prefix.splice.delegate.traceExit(entryMessage.splice) + ) + + def traceExitEntryMessageResult[R: c.WeakTypeTag](c: LoggerContext)(entryMessage: c.Expr[EntryMessage], result: c.Expr[R]): c.Expr[R] = + c.universe.reify( + c.prefix.splice.delegate.traceExit(entryMessage.splice, result.splice) + ) + def traceExitMessageResult[R: c.WeakTypeTag](c: LoggerContext)(message: c.Expr[Message], result: c.Expr[R]): c.Expr[R] = c.universe.reify( { if (message.splice != null && c.prefix.splice.delegate.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, message.splice, null)) { - c.prefix.splice.traceExitMessageResult(message.splice, result.splice) + c.prefix.splice.delegate.traceExit(message.splice, result.splice) // TODO should not do ifEnabled check } result.splice } http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/0ab01565/log4j-api-scala_2.10/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala ---------------------------------------------------------------------- diff --git a/log4j-api-scala_2.10/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala b/log4j-api-scala_2.10/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala index 6595128..d9237a5 100644 --- a/log4j-api-scala_2.10/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala +++ b/log4j-api-scala_2.10/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala @@ -16,7 +16,7 @@ */ package org.apache.logging.log4j.scala -import org.apache.logging.log4j.message.{Message, ParameterizedMessage, ParameterizedMessageFactory} +import org.apache.logging.log4j.message.{DefaultFlowMessageFactory, EntryMessage, Message, ParameterizedMessage, ParameterizedMessageFactory} import org.apache.logging.log4j.spi.{AbstractLogger, ExtendedLogger} import org.apache.logging.log4j.{Level, Marker, MarkerManager} import org.junit.runner.RunWith @@ -36,6 +36,7 @@ trait Manager { class LoggerTest extends FunSuite with Matchers with MockitoSugar { val msg = new ParameterizedMessage("msg {}", 17) + val entryMsg = new DefaultFlowMessageFactory().newEntryMessage(msg) val cseqMsg: CharSequence = new StringBuilder().append("cseq msg") val objectMsg = Custom(17) val cause = new RuntimeException("cause") @@ -430,6 +431,22 @@ class LoggerTest extends FunSuite with Matchers with MockitoSugar { } + test("traceEntry enabled") { + val f = fixture + when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef], null)).thenReturn(true) + val logger = Logger(f.mockLogger) + logger.traceEntry() + verify(f.mockLogger).traceEntry() + } + + ignore("traceEntry disabled") { + val f = fixture + when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef], null)).thenReturn(false) + val logger = Logger(f.mockLogger) + logger.traceEntry() + verify(f.mockLogger, never).traceEntry() + } + test("traceEntry enabled with params") { val f = fixture when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef], null)).thenReturn(true) @@ -446,13 +463,6 @@ class LoggerTest extends FunSuite with Matchers with MockitoSugar { verify(f.mockLogger, never).traceEntry(anyString(), any[Array[AnyRef]]) } - test("traceEntry without params") { - val f = fixture - val logger = Logger(f.mockLogger) - logger.traceEntry() - verify(f.mockLogger).traceEntry() - } - test("traceEntry enabled with message") { val f = fixture when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef], null)).thenReturn(true) @@ -469,6 +479,70 @@ class LoggerTest extends FunSuite with Matchers with MockitoSugar { verify(f.mockLogger, never).traceEntry(any[Message]) } + test("traceExit enabled") { + val f = fixture + when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(true) + val logger = Logger(f.mockLogger) + logger.traceExit() + verify(f.mockLogger).traceExit() + } + + ignore("traceExit disabled") { + val f = fixture + when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(false) + val logger = Logger(f.mockLogger) + logger.traceExit() + verify(f.mockLogger, never).traceExit() + } + + test("traceExit enabled with result") { + val f = fixture + when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(true) + val logger = Logger(f.mockLogger) + logger.traceExit(result) + verify(f.mockLogger).traceExit(result) + } + + ignore("traceExit disabled with result") { + val f = fixture + when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(false) + val logger = Logger(f.mockLogger) + logger.traceExit(result) + verify(f.mockLogger, never).traceExit(anyString()) + } + + test("traceExit enabled with entrymessage") { + val f = fixture + when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(true) + val logger = Logger(f.mockLogger) + logger.traceExit(entryMsg) + verify(f.mockLogger).traceExit(entryMsg) + } + + ignore("traceExit disabled with entrymessage") { + val f = fixture + when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(false) + val logger = Logger(f.mockLogger) + logger.traceExit(entryMsg) + verify(f.mockLogger, never).traceExit(any[EntryMessage]) + } + + test("traceExit enabled with entrymessage and result") { + val f = fixture + when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(true) + val logger = Logger(f.mockLogger) + logger.traceExit(entryMsg, result) + verify(f.mockLogger).traceExit(entryMsg, result) + } + + ignore("traceExit disabled with entrymessage and result") { + val f = fixture + when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(false) + val logger = Logger(f.mockLogger) + logger.traceExit(entryMsg, result) + verify(f.mockLogger, never).traceExit(any[EntryMessage], anyString()) + } + test("traceExit enabled with message") { val f = fixture when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(true) http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/0ab01565/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/Logger.scala ---------------------------------------------------------------------- diff --git a/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/Logger.scala b/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/Logger.scala index f58b8df..5fa2cb7 100644 --- a/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/Logger.scala +++ b/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/Logger.scala @@ -61,6 +61,7 @@ object Logger { * will only occur when debug logging is enabled. */ class Logger private(val delegate: ExtendedLogger) { + // TODO extends AnyVal ? private final val FQCN = classOf[Logger].getName @@ -431,15 +432,14 @@ class Logger private(val delegate: ExtendedLogger) { def isEnabled(level: Level, marker: Marker): Boolean = delegate.isEnabled(level, marker) - // TODO fix FQCN for flow logging - Break out flow logging logic from AbstractLogger into somethimg accessible from Scala API ? - /** * Logs entry to a method. Used when the method in question has no parameters or when the parameters should not be * logged. * * @return The built `EntryMessage` */ - def traceEntry(): EntryMessage = delegate.traceEntry() + def traceEntry(): EntryMessage = + macro LoggerMacro.traceEntry /** * Logs entry to a method along with its parameters. @@ -476,7 +476,8 @@ class Logger private(val delegate: ExtendedLogger) { /** * Logs exit from a method with no result. */ - def traceExit(): Unit = delegate.traceExit() + def traceExit(): Unit = + macro LoggerMacro.traceExit /** * Logs exiting from a method with result. @@ -484,14 +485,16 @@ class Logger private(val delegate: ExtendedLogger) { * @param result The result being returned from the method call * @return `result` */ - def traceExit[R](result: R): R = delegate.traceExit(result) + def traceExit[R](result: R): R = + macro LoggerMacro.traceExitResult[R] /** * Logs exiting from a method with no result. * * @param entryMessage the `EntryMessage` returned from one of the `traceEntry` methods */ - def traceExit(entryMessage: EntryMessage): Unit = delegate.traceExit(entryMessage) + def traceExit(entryMessage: EntryMessage): Unit = + macro LoggerMacro.traceExitEntryMessage /** * Logs exiting from a method with result. @@ -508,7 +511,8 @@ class Logger private(val delegate: ExtendedLogger) { * @param result The result being returned from the method call * @return `result` */ - def traceExit[R](entryMessage: EntryMessage, result: R): R = delegate.traceExit(entryMessage, result) + def traceExit[R](entryMessage: EntryMessage, result: R): R = + macro LoggerMacro.traceExitEntryMessageResult[R] /** * Logs exiting from a method with result. Allows custom formatting of the result. @@ -619,19 +623,10 @@ class Logger private(val delegate: ExtendedLogger) { delegate.logMessage(FQCN, level, marker, messageFactory.newMessage(message), cause) } + // TODO inline this to get FQCN correct /** Should normally not be used directly from application code, but needs to be public for access by macros. */ def traceEntryParams(params: Any*): EntryMessage = { - delegate.traceEntry(null, params) // TODO should not do ifEnabled check - } - - /** Should normally not be used directly from application code, but needs to be public for access by macros. */ - def traceEntryMessage(message: Message): EntryMessage = { - delegate.traceEntry(message) // TODO should not do ifEnabled check - } - - /** Should normally not be used directly from application code, but needs to be public for access by macros. */ - def traceExitMessageResult[R](message: Message, result: R): Unit = { - delegate.traceExit(message, result) // TODO should not do ifEnabled check + delegate.traceEntry(null: String, params) // TODO should not do ifEnabled check } } http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/0ab01565/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala ---------------------------------------------------------------------- diff --git a/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala b/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala index 440857f..77a0a0c 100644 --- a/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala +++ b/log4j-api-scala_2.11/src/main/scala/org/apache/logging/log4j/scala/LoggerMacro.scala @@ -338,6 +338,11 @@ private object LoggerMacro { ) + def traceEntry(c: LoggerContext)(): c.Expr[EntryMessage] = + c.universe.reify( + c.prefix.splice.delegate.traceEntry() + ) + def traceEntryParams(c: LoggerContext)(params: c.Expr[Any]*): c.Expr[EntryMessage] = { import c.universe._ val isEnabled = Apply( @@ -361,17 +366,37 @@ private object LoggerMacro { def traceEntryMessage(c: LoggerContext)(message: c.Expr[Message]): c.Expr[EntryMessage] = c.universe.reify( if (c.prefix.splice.delegate.isEnabled(Level.TRACE, AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef], null)) { - c.prefix.splice.traceEntryMessage(message.splice) + c.prefix.splice.delegate.traceEntry(message.splice) // TODO should not do ifEnabled check } else { null } ) + def traceExit(c: LoggerContext)(): c.Expr[Unit] = + c.universe.reify( + c.prefix.splice.delegate.traceExit() + ) + + def traceExitResult[R: c.WeakTypeTag](c: LoggerContext)(result: c.Expr[R]): c.Expr[R] = + c.universe.reify( + c.prefix.splice.delegate.traceExit(result.splice) + ) + + def traceExitEntryMessage(c: LoggerContext)(entryMessage: c.Expr[EntryMessage]): c.Expr[Unit] = + c.universe.reify( + c.prefix.splice.delegate.traceExit(entryMessage.splice) + ) + + def traceExitEntryMessageResult[R: c.WeakTypeTag](c: LoggerContext)(entryMessage: c.Expr[EntryMessage], result: c.Expr[R]): c.Expr[R] = + c.universe.reify( + c.prefix.splice.delegate.traceExit(entryMessage.splice, result.splice) + ) + def traceExitMessageResult[R: c.WeakTypeTag](c: LoggerContext)(message: c.Expr[Message], result: c.Expr[R]): c.Expr[R] = c.universe.reify( { if (message.splice != null && c.prefix.splice.delegate.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, message.splice, null)) { - c.prefix.splice.traceExitMessageResult(message.splice, result.splice) + c.prefix.splice.delegate.traceExit(message.splice, result.splice) // TODO should not do ifEnabled check } result.splice } http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/0ab01565/log4j-api-scala_2.11/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala ---------------------------------------------------------------------- diff --git a/log4j-api-scala_2.11/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala b/log4j-api-scala_2.11/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala index 6595128..d9237a5 100644 --- a/log4j-api-scala_2.11/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala +++ b/log4j-api-scala_2.11/src/test/scala/org/apache/logging/log4j/scala/LoggerTest.scala @@ -16,7 +16,7 @@ */ package org.apache.logging.log4j.scala -import org.apache.logging.log4j.message.{Message, ParameterizedMessage, ParameterizedMessageFactory} +import org.apache.logging.log4j.message.{DefaultFlowMessageFactory, EntryMessage, Message, ParameterizedMessage, ParameterizedMessageFactory} import org.apache.logging.log4j.spi.{AbstractLogger, ExtendedLogger} import org.apache.logging.log4j.{Level, Marker, MarkerManager} import org.junit.runner.RunWith @@ -36,6 +36,7 @@ trait Manager { class LoggerTest extends FunSuite with Matchers with MockitoSugar { val msg = new ParameterizedMessage("msg {}", 17) + val entryMsg = new DefaultFlowMessageFactory().newEntryMessage(msg) val cseqMsg: CharSequence = new StringBuilder().append("cseq msg") val objectMsg = Custom(17) val cause = new RuntimeException("cause") @@ -430,6 +431,22 @@ class LoggerTest extends FunSuite with Matchers with MockitoSugar { } + test("traceEntry enabled") { + val f = fixture + when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef], null)).thenReturn(true) + val logger = Logger(f.mockLogger) + logger.traceEntry() + verify(f.mockLogger).traceEntry() + } + + ignore("traceEntry disabled") { + val f = fixture + when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef], null)).thenReturn(false) + val logger = Logger(f.mockLogger) + logger.traceEntry() + verify(f.mockLogger, never).traceEntry() + } + test("traceEntry enabled with params") { val f = fixture when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef], null)).thenReturn(true) @@ -446,13 +463,6 @@ class LoggerTest extends FunSuite with Matchers with MockitoSugar { verify(f.mockLogger, never).traceEntry(anyString(), any[Array[AnyRef]]) } - test("traceEntry without params") { - val f = fixture - val logger = Logger(f.mockLogger) - logger.traceEntry() - verify(f.mockLogger).traceEntry() - } - test("traceEntry enabled with message") { val f = fixture when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.ENTRY_MARKER, null.asInstanceOf[AnyRef], null)).thenReturn(true) @@ -469,6 +479,70 @@ class LoggerTest extends FunSuite with Matchers with MockitoSugar { verify(f.mockLogger, never).traceEntry(any[Message]) } + test("traceExit enabled") { + val f = fixture + when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(true) + val logger = Logger(f.mockLogger) + logger.traceExit() + verify(f.mockLogger).traceExit() + } + + ignore("traceExit disabled") { + val f = fixture + when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(false) + val logger = Logger(f.mockLogger) + logger.traceExit() + verify(f.mockLogger, never).traceExit() + } + + test("traceExit enabled with result") { + val f = fixture + when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(true) + val logger = Logger(f.mockLogger) + logger.traceExit(result) + verify(f.mockLogger).traceExit(result) + } + + ignore("traceExit disabled with result") { + val f = fixture + when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(false) + val logger = Logger(f.mockLogger) + logger.traceExit(result) + verify(f.mockLogger, never).traceExit(anyString()) + } + + test("traceExit enabled with entrymessage") { + val f = fixture + when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(true) + val logger = Logger(f.mockLogger) + logger.traceExit(entryMsg) + verify(f.mockLogger).traceExit(entryMsg) + } + + ignore("traceExit disabled with entrymessage") { + val f = fixture + when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(false) + val logger = Logger(f.mockLogger) + logger.traceExit(entryMsg) + verify(f.mockLogger, never).traceExit(any[EntryMessage]) + } + + test("traceExit enabled with entrymessage and result") { + val f = fixture + when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(true) + val logger = Logger(f.mockLogger) + logger.traceExit(entryMsg, result) + verify(f.mockLogger).traceExit(entryMsg, result) + } + + ignore("traceExit disabled with entrymessage and result") { + val f = fixture + when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(false) + val logger = Logger(f.mockLogger) + logger.traceExit(entryMsg, result) + verify(f.mockLogger, never).traceExit(any[EntryMessage], anyString()) + } + test("traceExit enabled with message") { val f = fixture when(f.mockLogger.isEnabled(Level.TRACE, AbstractLogger.EXIT_MARKER, msg, null)).thenReturn(true)