You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@logging.apache.org by mi...@apache.org on 2016/06/18 21:32:07 UTC
[2/3] logging-log4j2 git commit: Import unit tests
Import unit tests
Project: http://git-wip-us.apache.org/repos/asf/logging-log4j2/repo
Commit: http://git-wip-us.apache.org/repos/asf/logging-log4j2/commit/ed201dff
Tree: http://git-wip-us.apache.org/repos/asf/logging-log4j2/tree/ed201dff
Diff: http://git-wip-us.apache.org/repos/asf/logging-log4j2/diff/ed201dff
Branch: refs/heads/LOG4J-1181
Commit: ed201dffecfa579f643409a8989760eb471b8d90
Parents: 2cc9c79
Author: Mikael St�ldal <mi...@magine.com>
Authored: Sat Jun 18 21:31:56 2016 +0200
Committer: Mikael St�ldal <mi...@magine.com>
Committed: Sat Jun 18 21:31:56 2016 +0200
----------------------------------------------------------------------
.../apache/logging/log4j/scala/LoggerTest.scala | 440 ++++++++++---------
.../apache/logging/log4j/scala/LoggerTest.scala | 440 ++++++++++---------
2 files changed, 470 insertions(+), 410 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/ed201dff/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 ea8225c..1c3a126 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
@@ -28,374 +28,404 @@ import org.scalatest.{FunSuite, Matchers}
case class Custom(i: Int)
+trait Manager {
+ def fetchValue(): Int
+}
+
@RunWith(classOf[JUnitRunner])
class LoggerTest extends FunSuite with Matchers with MockitoSugar {
val msg = new ParameterizedMessage("msg {}", 17)
- val stringMsg = "string msg"
- val cseqMsg = new StringBuilder().append("cseq msg")
+ val cseqMsg: CharSequence = new StringBuilder().append("cseq msg")
val objectMsg = Custom(17)
val cause = new RuntimeException("cause")
val marker = MarkerManager.getMarker("marker")
+ def fixture =
+ new {
+ val mockLogger = {
+ val mockLogger = mock[ExtendedLogger]
+ when(mockLogger.getMessageFactory).thenReturn(new ParameterizedMessageFactory)
+ mockLogger
+ }
+ val manager = {
+ val mockManager = mock[Manager]
+ when(mockManager.fetchValue()).thenReturn(4711)
+ mockManager
+ }
+ }
+
test("fatal enabled with String message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.FATAL)).thenReturn(true)
- val logger = new Logger(mockLogger)
- logger.fatal(stringMsg)
- verify(mockLogger).logMessage(anyString(), eqv(Level.FATAL), eqv(null), any[Message], eqv(null))
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.FATAL)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
+ logger.fatal(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.FATAL), eqv(null), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
}
test("fatal disabled with String message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.FATAL)).thenReturn(false)
- val logger = new Logger(mockLogger)
- logger.fatal(stringMsg)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.FATAL)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
+ logger.fatal(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
}
test("error enabled with String message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.ERROR)).thenReturn(true)
- val logger = new Logger(mockLogger)
- logger.error(stringMsg)
- verify(mockLogger).logMessage(anyString(), eqv(Level.ERROR), eqv(null), any[Message], eqv(null))
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.ERROR)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
+ logger.error(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.ERROR), eqv(null), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
}
test("error disabled with String message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.ERROR)).thenReturn(false)
- val logger = new Logger(mockLogger)
- logger.error(stringMsg)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.ERROR)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
+ logger.error(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
}
test("warn enabled with String message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.WARN)).thenReturn(true)
- val logger = new Logger(mockLogger)
- logger.warn(stringMsg)
- verify(mockLogger).logMessage(anyString(), eqv(Level.WARN), eqv(null), any[Message], eqv(null))
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.WARN)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
+ logger.warn(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.WARN), eqv(null), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
}
test("warn disabled with String message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.WARN)).thenReturn(false)
- val logger = new Logger(mockLogger)
- logger.warn(stringMsg)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.WARN)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
+ logger.warn(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
}
test("info enabled with String message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(true)
- val logger = new Logger(mockLogger)
- logger.info(stringMsg)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null))
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
+ logger.info(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
}
test("info disabled with String message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(false)
- val logger = new Logger(mockLogger)
- logger.info(stringMsg)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
+ logger.info(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
}
test("debug enabled with String message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.DEBUG)).thenReturn(true)
- val logger = new Logger(mockLogger)
- logger.debug(stringMsg)
- verify(mockLogger).logMessage(anyString(), eqv(Level.DEBUG), eqv(null), any[Message], eqv(null))
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.DEBUG)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
+ logger.debug(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.DEBUG), eqv(null), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
}
test("debug disabled with String message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.DEBUG)).thenReturn(false)
- val logger = new Logger(mockLogger)
- logger.debug(stringMsg)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.DEBUG)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
+ logger.debug(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
}
test("trace enabled with String message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.TRACE)).thenReturn(true)
- val logger = new Logger(mockLogger)
- logger.trace(stringMsg)
- verify(mockLogger).logMessage(anyString(), eqv(Level.TRACE), eqv(null), any[Message], eqv(null))
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
+ logger.trace(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.TRACE), eqv(null), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
}
test("trace disabled with String message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.TRACE)).thenReturn(false)
- val logger = new Logger(mockLogger)
- logger.trace(stringMsg)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
+ logger.trace(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
}
test("log enabled with Message message and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, marker, msg)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), eqv(msg), eqv(null))
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), eqv(msg), eqv(null))
}
test("log disabled with Message message and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, marker, msg)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
}
test("log enabled with String message and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
- val logger = new Logger(mockLogger)
- logger.log(Level.INFO, marker, stringMsg)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null))
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
+ logger.log(Level.INFO, marker, s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
}
test("log disabled with String message and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
- val logger = new Logger(mockLogger)
- logger.log(Level.INFO, marker, stringMsg)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
+ logger.log(Level.INFO, marker, s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
}
test("log enabled with CharSequence message and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, marker, cseqMsg)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null))
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null))
}
test("log disabled with CharSequence message and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, marker, cseqMsg)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
}
test("log enabled with Object message and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, marker, objectMsg)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null))
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null))
}
test("log disabled with Object message and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, marker, objectMsg)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
}
test("log enabled with Message message and cause and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, marker, msg, cause)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), eqv(msg), eqv(cause))
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), eqv(msg), eqv(cause))
}
test("log disabled with Message message and cause and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, marker, msg, cause)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
}
test("log enabled with String message and cause and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
- val logger = new Logger(mockLogger)
- logger.log(Level.INFO, marker, stringMsg, cause)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause))
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
+ logger.log(Level.INFO, marker, s"string msg with value: ${f.manager.fetchValue()}", cause)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause))
+ verify(f.manager).fetchValue()
}
test("log disabled with String message and cause and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
- val logger = new Logger(mockLogger)
- logger.log(Level.INFO, marker, stringMsg, cause)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
+ logger.log(Level.INFO, marker, s"string msg with value: ${f.manager.fetchValue()}", cause)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
}
test("log enabled with CharSequence message and cause and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, marker, cseqMsg, cause)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause))
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause))
}
test("log disabled with CharSequence message and cause and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, marker, cseqMsg, cause)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
}
test("log enabled with Object message and cause and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, marker, objectMsg, cause)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause))
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause))
}
test("log disabled with Object message and cause and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, marker, objectMsg, cause)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
}
test("log enabled with Message message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(true)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, msg)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), eqv(msg), eqv(null))
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), eqv(msg), eqv(null))
}
test("log disabled with Message message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(false)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, msg)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
}
test("log enabled with String message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(true)
- val logger = new Logger(mockLogger)
- logger.log(Level.INFO, stringMsg)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null))
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
+ logger.log(Level.INFO, s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
}
test("log disabled with String message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(false)
- val logger = new Logger(mockLogger)
- logger.log(Level.INFO, stringMsg)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
+ logger.log(Level.INFO, s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
}
test("log enabled with CharSequence message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(true)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, cseqMsg)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null))
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null))
}
test("log disabled with CharSequence message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(false)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, cseqMsg)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
}
test("log enabled with Object message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(true)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, objectMsg)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null))
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null))
}
test("log disabled with Object message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(false)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, objectMsg)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
}
test("log enabled with Message message and cause") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(true)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, msg, cause)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), eqv(msg), eqv(cause))
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), eqv(msg), eqv(cause))
}
test("log disabled with Message message and cause") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(false)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, msg, cause)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
}
test("log enabled with String message and cause") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(true)
- val logger = new Logger(mockLogger)
- logger.log(Level.INFO, stringMsg, cause)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause))
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
+ logger.log(Level.INFO, s"string msg with value: ${f.manager.fetchValue()}", cause)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause))
+ verify(f.manager).fetchValue()
}
test("log disabled with String message and cause") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(false)
- val logger = new Logger(mockLogger)
- logger.log(Level.INFO, stringMsg, cause)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
+ logger.log(Level.INFO, s"string msg with value: ${f.manager.fetchValue()}", cause)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
}
test("log enabled with CharSequence message and cause") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(true)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, cseqMsg, cause)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause))
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause))
}
test("log disabled with CharSequence message and cause") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(false)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, cseqMsg, cause)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
}
test("log enabled with Object message and cause") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(true)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, objectMsg, cause)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause))
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause))
}
test("log disabled with Object message and cause") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(false)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, objectMsg, cause)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
- }
-
-
- def buildMockLogger: ExtendedLogger = {
- val mockLogger = mock[ExtendedLogger]
- when(mockLogger.getMessageFactory).thenReturn(new ParameterizedMessageFactory)
- mockLogger
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
}
}
http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/ed201dff/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 ea8225c..1c3a126 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
@@ -28,374 +28,404 @@ import org.scalatest.{FunSuite, Matchers}
case class Custom(i: Int)
+trait Manager {
+ def fetchValue(): Int
+}
+
@RunWith(classOf[JUnitRunner])
class LoggerTest extends FunSuite with Matchers with MockitoSugar {
val msg = new ParameterizedMessage("msg {}", 17)
- val stringMsg = "string msg"
- val cseqMsg = new StringBuilder().append("cseq msg")
+ val cseqMsg: CharSequence = new StringBuilder().append("cseq msg")
val objectMsg = Custom(17)
val cause = new RuntimeException("cause")
val marker = MarkerManager.getMarker("marker")
+ def fixture =
+ new {
+ val mockLogger = {
+ val mockLogger = mock[ExtendedLogger]
+ when(mockLogger.getMessageFactory).thenReturn(new ParameterizedMessageFactory)
+ mockLogger
+ }
+ val manager = {
+ val mockManager = mock[Manager]
+ when(mockManager.fetchValue()).thenReturn(4711)
+ mockManager
+ }
+ }
+
test("fatal enabled with String message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.FATAL)).thenReturn(true)
- val logger = new Logger(mockLogger)
- logger.fatal(stringMsg)
- verify(mockLogger).logMessage(anyString(), eqv(Level.FATAL), eqv(null), any[Message], eqv(null))
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.FATAL)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
+ logger.fatal(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.FATAL), eqv(null), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
}
test("fatal disabled with String message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.FATAL)).thenReturn(false)
- val logger = new Logger(mockLogger)
- logger.fatal(stringMsg)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.FATAL)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
+ logger.fatal(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
}
test("error enabled with String message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.ERROR)).thenReturn(true)
- val logger = new Logger(mockLogger)
- logger.error(stringMsg)
- verify(mockLogger).logMessage(anyString(), eqv(Level.ERROR), eqv(null), any[Message], eqv(null))
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.ERROR)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
+ logger.error(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.ERROR), eqv(null), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
}
test("error disabled with String message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.ERROR)).thenReturn(false)
- val logger = new Logger(mockLogger)
- logger.error(stringMsg)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.ERROR)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
+ logger.error(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
}
test("warn enabled with String message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.WARN)).thenReturn(true)
- val logger = new Logger(mockLogger)
- logger.warn(stringMsg)
- verify(mockLogger).logMessage(anyString(), eqv(Level.WARN), eqv(null), any[Message], eqv(null))
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.WARN)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
+ logger.warn(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.WARN), eqv(null), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
}
test("warn disabled with String message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.WARN)).thenReturn(false)
- val logger = new Logger(mockLogger)
- logger.warn(stringMsg)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.WARN)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
+ logger.warn(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
}
test("info enabled with String message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(true)
- val logger = new Logger(mockLogger)
- logger.info(stringMsg)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null))
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
+ logger.info(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
}
test("info disabled with String message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(false)
- val logger = new Logger(mockLogger)
- logger.info(stringMsg)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
+ logger.info(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
}
test("debug enabled with String message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.DEBUG)).thenReturn(true)
- val logger = new Logger(mockLogger)
- logger.debug(stringMsg)
- verify(mockLogger).logMessage(anyString(), eqv(Level.DEBUG), eqv(null), any[Message], eqv(null))
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.DEBUG)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
+ logger.debug(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.DEBUG), eqv(null), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
}
test("debug disabled with String message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.DEBUG)).thenReturn(false)
- val logger = new Logger(mockLogger)
- logger.debug(stringMsg)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.DEBUG)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
+ logger.debug(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
}
test("trace enabled with String message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.TRACE)).thenReturn(true)
- val logger = new Logger(mockLogger)
- logger.trace(stringMsg)
- verify(mockLogger).logMessage(anyString(), eqv(Level.TRACE), eqv(null), any[Message], eqv(null))
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
+ logger.trace(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.TRACE), eqv(null), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
}
test("trace disabled with String message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.TRACE)).thenReturn(false)
- val logger = new Logger(mockLogger)
- logger.trace(stringMsg)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.TRACE)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
+ logger.trace(s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
}
test("log enabled with Message message and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, marker, msg)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), eqv(msg), eqv(null))
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), eqv(msg), eqv(null))
}
test("log disabled with Message message and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, marker, msg)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
}
test("log enabled with String message and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
- val logger = new Logger(mockLogger)
- logger.log(Level.INFO, marker, stringMsg)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null))
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
+ logger.log(Level.INFO, marker, s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
}
test("log disabled with String message and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
- val logger = new Logger(mockLogger)
- logger.log(Level.INFO, marker, stringMsg)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
+ logger.log(Level.INFO, marker, s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
}
test("log enabled with CharSequence message and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, marker, cseqMsg)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null))
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null))
}
test("log disabled with CharSequence message and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, marker, cseqMsg)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
}
test("log enabled with Object message and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, marker, objectMsg)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null))
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(null))
}
test("log disabled with Object message and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, marker, objectMsg)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
}
test("log enabled with Message message and cause and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, marker, msg, cause)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), eqv(msg), eqv(cause))
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), eqv(msg), eqv(cause))
}
test("log disabled with Message message and cause and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, marker, msg, cause)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
}
test("log enabled with String message and cause and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
- val logger = new Logger(mockLogger)
- logger.log(Level.INFO, marker, stringMsg, cause)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause))
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
+ logger.log(Level.INFO, marker, s"string msg with value: ${f.manager.fetchValue()}", cause)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause))
+ verify(f.manager).fetchValue()
}
test("log disabled with String message and cause and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
- val logger = new Logger(mockLogger)
- logger.log(Level.INFO, marker, stringMsg, cause)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
+ logger.log(Level.INFO, marker, s"string msg with value: ${f.manager.fetchValue()}", cause)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
}
test("log enabled with CharSequence message and cause and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, marker, cseqMsg, cause)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause))
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause))
}
test("log disabled with CharSequence message and cause and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, marker, cseqMsg, cause)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
}
test("log enabled with Object message and cause and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, marker, objectMsg, cause)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause))
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(marker), any[Message], eqv(cause))
}
test("log disabled with Object message and cause and Marker") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO, marker)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, marker, objectMsg, cause)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
}
test("log enabled with Message message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(true)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, msg)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), eqv(msg), eqv(null))
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), eqv(msg), eqv(null))
}
test("log disabled with Message message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(false)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, msg)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
}
test("log enabled with String message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(true)
- val logger = new Logger(mockLogger)
- logger.log(Level.INFO, stringMsg)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null))
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
+ logger.log(Level.INFO, s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null))
+ verify(f.manager).fetchValue()
}
test("log disabled with String message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(false)
- val logger = new Logger(mockLogger)
- logger.log(Level.INFO, stringMsg)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
+ logger.log(Level.INFO, s"string msg with value: ${f.manager.fetchValue()}")
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
}
test("log enabled with CharSequence message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(true)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, cseqMsg)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null))
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null))
}
test("log disabled with CharSequence message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(false)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, cseqMsg)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
}
test("log enabled with Object message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(true)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, objectMsg)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null))
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(null))
}
test("log disabled with Object message") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(false)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, objectMsg)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
}
test("log enabled with Message message and cause") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(true)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, msg, cause)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), eqv(msg), eqv(cause))
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), eqv(msg), eqv(cause))
}
test("log disabled with Message message and cause") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(false)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, msg, cause)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
}
test("log enabled with String message and cause") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(true)
- val logger = new Logger(mockLogger)
- logger.log(Level.INFO, stringMsg, cause)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause))
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
+ logger.log(Level.INFO, s"string msg with value: ${f.manager.fetchValue()}", cause)
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause))
+ verify(f.manager).fetchValue()
}
test("log disabled with String message and cause") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(false)
- val logger = new Logger(mockLogger)
- logger.log(Level.INFO, stringMsg, cause)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
+ logger.log(Level.INFO, s"string msg with value: ${f.manager.fetchValue()}", cause)
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.manager, never).fetchValue()
}
test("log enabled with CharSequence message and cause") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(true)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, cseqMsg, cause)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause))
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause))
}
test("log disabled with CharSequence message and cause") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(false)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, cseqMsg, cause)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
}
test("log enabled with Object message and cause") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(true)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(true)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, objectMsg, cause)
- verify(mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause))
+ verify(f.mockLogger).logMessage(anyString(), eqv(Level.INFO), eqv(null), any[Message], eqv(cause))
}
test("log disabled with Object message and cause") {
- val mockLogger = buildMockLogger
- when(mockLogger.isEnabled(Level.INFO)).thenReturn(false)
- val logger = new Logger(mockLogger)
+ val f = fixture
+ when(f.mockLogger.isEnabled(Level.INFO)).thenReturn(false)
+ val logger = new Logger(f.mockLogger)
logger.log(Level.INFO, objectMsg, cause)
- verify(mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
- }
-
-
- def buildMockLogger: ExtendedLogger = {
- val mockLogger = mock[ExtendedLogger]
- when(mockLogger.getMessageFactory).thenReturn(new ParameterizedMessageFactory)
- mockLogger
+ verify(f.mockLogger, never).logMessage(anyString(), any[Level], any[Marker], any[Message], any[Throwable])
}
}