mirror of
https://gitflic.ru/project/openide/openide.git
synced 2025-12-15 11:53:49 +07:00
710 lines
21 KiB
Kotlin
710 lines
21 KiB
Kotlin
package com.intellij.logging.resolve
|
|
|
|
import com.intellij.jvm.analysis.internal.testFramework.logging.LoggingArgumentSymbolReferenceProviderTestBase
|
|
import com.intellij.openapi.util.TextRange
|
|
import org.jetbrains.kotlin.idea.base.plugin.KotlinPluginModeProvider
|
|
|
|
abstract class KotlinLoggingArgumentSymbolReferenceProviderTest : LoggingArgumentSymbolReferenceProviderTestBase(), KotlinPluginModeProvider {
|
|
fun `test log4j2 info`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.apache.logging.log4j.*
|
|
class Logging {
|
|
val LOG: Logger = LogManager.getLogger()
|
|
fun m(i: Int) {
|
|
LOG.info("<caret>{}", i)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(TextRange(1, 3) to "i"))
|
|
}
|
|
|
|
fun `test log4j2 debug`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.apache.logging.log4j.*
|
|
class Logging {
|
|
val LOG: Logger = LogManager.getLogger()
|
|
fun m(i: Int) {
|
|
LOG.debug("<caret>{}", i)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(TextRange(1, 3) to "i"))
|
|
}
|
|
|
|
fun `test log4j2 trace`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.apache.logging.log4j.*
|
|
class Logging {
|
|
val LOG: Logger = LogManager.getLogger()
|
|
fun m(i: Int) {
|
|
LOG.trace("<caret>{}", i)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(TextRange(1, 3) to "i"))
|
|
}
|
|
|
|
fun `test log4j2 fatal`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.apache.logging.log4j.*
|
|
class Logging {
|
|
val LOG: Logger = LogManager.getLogger()
|
|
fun m(i: Int) {
|
|
LOG.fatal("<caret>{}", i)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(TextRange(1, 3) to "i"))
|
|
}
|
|
|
|
fun `test log4j2 error`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.apache.logging.log4j.*
|
|
class Logging {
|
|
val LOG: Logger = LogManager.getLogger()
|
|
fun m(i: Int) {
|
|
LOG.fatal("<caret>{}", i)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(TextRange(1, 3) to "i"))
|
|
}
|
|
|
|
fun `test log4j2 log`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.apache.logging.log4j.*
|
|
class Logging {
|
|
val LOG: Logger = LogManager.getLogger()
|
|
fun m(i: Int) {
|
|
LOG.log(Level.ALL, "<caret>{}", i)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(TextRange(1, 3) to "i"))
|
|
}
|
|
|
|
fun `test log4j2 formatted logger`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.apache.logging.log4j.*
|
|
class Logging {
|
|
val LOG: Logger = LogManager.getFormatterLogger()
|
|
fun m(i: Int) {
|
|
LOG.info("<caret>%d", i)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(TextRange(1, 3) to "i"))
|
|
}
|
|
|
|
fun `test log4j2 formatted logger with numbered placeholders simple`() {
|
|
val dollar = "$"
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.apache.logging.log4j.*
|
|
class Logging {
|
|
val LOG = LogManager.getFormatterLogger()
|
|
fun m(fst: Int, snd: Int) {
|
|
LOG.info("<caret>%2${dollar}s %1${dollar}s", fst, snd)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(emptyMap())
|
|
}
|
|
|
|
fun `test log4j2 formatted logger with numbered placeholders same index`() {
|
|
val dollar = "$"
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.apache.logging.log4j.*
|
|
class Logging {
|
|
val LOG = LogManager.getFormatterLogger()
|
|
fun m(fst: Int, snd: Int) {
|
|
LOG.info("<caret>%1${dollar}s %1${dollar}s", fst)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(emptyMap())
|
|
}
|
|
|
|
fun `test log4j2 formatted logger with numbered placeholders mix`() {
|
|
val dollar = "$"
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.apache.logging.log4j.*
|
|
class Logging {
|
|
val LOG = LogManager.getFormatterLogger()
|
|
fun m(fst: Int, snd: Int) {
|
|
LOG.info("<caret>%2${dollar}s %1${dollar}s %s %s", fst, snd)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(emptyMap())
|
|
}
|
|
|
|
fun `test log4j2 formatted logger with previous placeholder simple`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.apache.logging.log4j.*
|
|
class Logging {
|
|
val LOG = LogManager.getFormatterLogger()
|
|
fun m(fst: Int, snd: Int) {
|
|
LOG.info("<caret>%s %<s %<s", fst)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(TextRange(1, 3) to "fst", TextRange(4, 7) to "fst", TextRange(8, 11) to "fst"))
|
|
}
|
|
|
|
fun `test log4j2 formatted logger with previous placeholder mix`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.apache.logging.log4j.*
|
|
class Logging {
|
|
val LOG: Logger = LogManager.getFormatterLogger()
|
|
|
|
fun m(fst: Int, snd: Int) {
|
|
LOG.info("<caret>%s %<s %<s %s %<s %<s", fst, snd)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(TextRange(1, 3) to "fst", TextRange(4, 7) to "fst", TextRange(8, 11) to "fst",
|
|
TextRange(12, 14) to "snd", TextRange(15, 18) to "snd", TextRange(19, 22) to "snd"))
|
|
}
|
|
|
|
fun `test log4j2 formatted logger with numbered and previous placeholder`() {
|
|
val dollar = "$"
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.apache.logging.log4j.*
|
|
class Logging {
|
|
val LOG = LogManager.getFormatterLogger()
|
|
fun m(fst: Int) {
|
|
LOG.info("<caret>%1${dollar}s %<s", fst)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(emptyMap())
|
|
}
|
|
|
|
|
|
fun `test log4j2 default logger builder`() {
|
|
myFixture.configureByText("Logging.kt",
|
|
"""
|
|
import org.apache.logging.log4j.*
|
|
class Logging {
|
|
val LOG: Logger = LogManager.getLogger()
|
|
fun m(i: Int) {
|
|
LOG.atInfo().log("<caret>{}", i)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(TextRange(1, 3) to "i"))
|
|
}
|
|
|
|
fun `test log4j2 formatted logger builder`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.apache.logging.log4j.*
|
|
class Logging {
|
|
val LOG: Logger = LogManager.getFormatterLogger()
|
|
fun m(i: Int) {
|
|
LOG.atInfo().log("<caret>%d", i)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(TextRange(1, 3) to "i"))
|
|
}
|
|
|
|
fun `test log4j2 respects exception with multiple arguments`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.apache.logging.log4j.*
|
|
class Logging {
|
|
val LOG: Logger = LogManager.getLogger()
|
|
fun m(i: Int) {
|
|
LOG.info("<caret>{} {}", i, Exception())
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
|
|
doTest(mapOf(TextRange(1, 3) to "i", TextRange(4, 6) to "Exception()"))
|
|
}
|
|
|
|
fun `test log4j2 respects exception as single argument`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.apache.logging.log4j.*
|
|
class Logging {
|
|
val LOG: Logger = LogManager.getLogger()
|
|
fun m(i: Int) {
|
|
LOG.info("<caret>{}", Exception())
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
|
|
doTest(emptyMap())
|
|
}
|
|
|
|
fun `test log4j2 respects exception in builder logger with multiple arguments`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.apache.logging.log4j.*
|
|
class Logging {
|
|
val LOG: Logger = LogManager.getLogger()
|
|
fun m(i: Int) {
|
|
LOG.atInfo().log("<caret>{} {}", i, Exception())
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(TextRange(1, 3) to "i", TextRange(4, 6) to "Exception()"))
|
|
}
|
|
|
|
fun `test log4j2 respects exception in builder logger as single argument`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.apache.logging.log4j.*
|
|
class Logging {
|
|
val LOG: Logger = LogManager.getLogger()
|
|
fun m(i: Int) {
|
|
LOG.atInfo().log("<caret>{}", Exception())
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(TextRange(1, 3) to "Exception()"))
|
|
}
|
|
|
|
fun `test slf4j info`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.slf4j.*
|
|
class Logging {
|
|
val LOG: Logger = LoggerFactory.getLogger(Logging.class)
|
|
fun m(i: Int) {
|
|
LOG.info("<caret>{}", i)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(TextRange(1, 3) to "i"))
|
|
}
|
|
|
|
fun `test slf4j debug`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.slf4j.*
|
|
class Logging {
|
|
val LOG: Logger = LoggerFactory.getLogger(Logging.class)
|
|
fun m(i: Int) {
|
|
LOG.debug("<caret>{}", i)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(TextRange(1, 3) to "i"))
|
|
}
|
|
|
|
fun `test slf4j error`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.slf4j.*
|
|
class Logging {
|
|
val LOG: Logger = LoggerFactory.getLogger(Logging.class)
|
|
fun m(i: Int) {
|
|
LOG.error("<caret>{}", i)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(TextRange(1, 3) to "i"))
|
|
}
|
|
|
|
fun `test slf4j warn`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.slf4j.*
|
|
class Logging {
|
|
val LOG: Logger = LoggerFactory.getLogger(Logging.class)
|
|
fun m(i: Int) {
|
|
LOG.warn("<caret>{}", i)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(TextRange(1, 3) to "i"))
|
|
}
|
|
|
|
|
|
fun `test slf4j trace`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.slf4j.*
|
|
class Logging {
|
|
val LOG: Logger = LoggerFactory.getLogger(Logging.class)
|
|
fun m(i: Int) {
|
|
LOG.trace("<caret>{}", i)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(TextRange(1, 3) to "i"))
|
|
}
|
|
|
|
|
|
fun `test slf4j builder simple`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.slf4j.*
|
|
class Logging {
|
|
val LOG: Logger = LoggerFactory.getLogger(Logging.class)
|
|
fun m(i: Int) {
|
|
LOG.atInfo().log("<caret>{}", i)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(TextRange(1, 3) to "i"))
|
|
}
|
|
|
|
fun `test slf4j builder with setMessage`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.slf4j.*
|
|
class Logging {
|
|
val LOG: Logger = LoggerFactory.getLogger(Logging.class)
|
|
fun m(i: Int) {
|
|
LOG.atInfo().addArgument("foo").setMessage("<caret>{} {}").addArgument("bar").log()
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(TextRange(1, 3) to "\"foo\"", TextRange(4, 6) to "\"bar\""))
|
|
}
|
|
|
|
fun `test slf4j builder considers only last message`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.slf4j.*
|
|
class Logging {
|
|
val LOG: Logger = LoggerFactory.getLogger(Logging.class)
|
|
fun m(i: Int) {
|
|
LOG.atInfo().addArgument("foo").setMessage("<caret>{} {} {}").setMessage("{} {}").addArgument("bar").log()
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(emptyMap())
|
|
}
|
|
|
|
fun `test slf4j builder combined args`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.slf4j.*
|
|
class Logging {
|
|
val LOG: Logger = LoggerFactory.getLogger(Logging.class)
|
|
fun m(i: Int) {
|
|
LOG.atInfo().addArgument("foo").addArgument("bar").log("<caret>{} {} {}", "baz")
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(TextRange(1, 3) to "\"foo\"", TextRange(4, 6) to "\"bar\"", TextRange(7, 9) to "\"baz\""))
|
|
}
|
|
|
|
fun `test slf4j builder respects last argument as exception in log`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.slf4j.*
|
|
class Logging {
|
|
val LOG: Logger = LoggerFactory.getLogger(Logging.class)
|
|
fun m(i: Int) {
|
|
LOG.atInfo().addArgument("foo").addArgument("bar").log("<caret>{} {} {}", Throwable())
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(TextRange(1, 3) to "\"foo\"", TextRange(4, 6) to "\"bar\""))
|
|
}
|
|
|
|
fun `test slf4j builder respects last argument as exception in setCause`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.slf4j.*
|
|
class Logging {
|
|
val LOG: Logger = LoggerFactory.getLogger(Logging.class)
|
|
fun m(i: Int) {
|
|
LOG.atInfo().addArgument("foo").addArgument("bar").setCause(Throwable()).log("<caret>{} {} {}")
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(TextRange(1, 3) to "\"foo\"", TextRange(4, 6) to "\"bar\""))
|
|
}
|
|
|
|
fun `test should resolve in multiline string`() {
|
|
val multilineString = "\"\"\"\n" +
|
|
"<caret>{}\n" +
|
|
"\"\"\""
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.slf4j.*
|
|
class Logging {
|
|
val LOG: Logger = LoggerFactory.getLogger(Logging::class.java)
|
|
fun m(i: Int) {
|
|
LOG.info($multilineString, i)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(TextRange(4, 6) to "i"))
|
|
}
|
|
|
|
fun `test should resolve in strange multiline string`() {
|
|
val strangeMultilineString = "\"\"\"\n " +
|
|
" <caret>{} \n " +
|
|
" {} " +
|
|
" \"\"\""
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.slf4j.*
|
|
class Logging {
|
|
val LOG = LoggerFactory.getLogger(Logging::class.java)
|
|
fun m(i: Int) {
|
|
LOG.info($strangeMultilineString, i, i)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(TextRange(14, 16) to "i", TextRange(24, 26) to "i"))
|
|
}
|
|
|
|
fun `test should not resolve in multiline string with brace on next line`() {
|
|
val multilineString = "\"\"\"\n" +
|
|
"<caret>{\n}" +
|
|
"\"\"\""
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.slf4j.*
|
|
class Logging {
|
|
val Logger LOG = LoggerFactory.getLogger(Logging::class.java)
|
|
fun m(i: Int) {
|
|
LOG.info($multilineString, i)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(emptyMap())
|
|
}
|
|
|
|
|
|
fun `test should not resolve with interpolation`() {
|
|
val dollar = "$"
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.slf4j.*
|
|
class Logging {
|
|
val LOG = LoggerFactory.getLogger(Logging::class.java)
|
|
fun m(i: Int) {
|
|
LOG.info("${dollar}i {} <caret> {}", i, i)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(emptyMap())
|
|
}
|
|
|
|
fun `test should not resolve with string concatenation`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.slf4j.*
|
|
class Logging {
|
|
val LOG: Logger = LoggerFactory.getLogger(Logging.class)
|
|
fun m(i: Int) {
|
|
LOG.info("{} <caret>" + "}", i)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(emptyMap())
|
|
}
|
|
|
|
fun `test resolve with escape characters in simple string log4j2`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.apache.logging.log4j.*
|
|
class Logging {
|
|
val LOG: Logger = LogManager.getLogger(Logging.class)
|
|
fun m(i: Int) {
|
|
LOG.info("\"{} \'{<caret>} \${"$"}{} \t{} \b{} \n{} \r{} \\{}", 1, 2, 3, 4, 5, 6, 7, 8)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(
|
|
TextRange(3, 5) to "1",
|
|
TextRange(8, 10) to "2",
|
|
TextRange(13, 15) to "3",
|
|
TextRange(18, 20) to "4",
|
|
TextRange(23, 25) to "5",
|
|
TextRange(28, 30) to "6",
|
|
TextRange(33, 35) to "7",
|
|
TextRange(38, 40) to "8",
|
|
))
|
|
}
|
|
|
|
|
|
fun `test resolve with escape characters in multiline string log4j2`() {
|
|
val multilineString = "\"\"\"\n" +
|
|
"\\\"{} \\'{<caret>} \\t{} \\b{} \\n{} \\r{} \\\\{}" +
|
|
"\"\"\""
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.apache.logging.log4j.*
|
|
class Logging {
|
|
val LOG: Logger = LogManager.getLogger(Logging.class)
|
|
fun m(i: Int) {
|
|
LOG.info($multilineString, 1, 2, 3, 4, 5, 6, 7)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(
|
|
TextRange(6, 8) to "1",
|
|
TextRange(11, 13) to "2",
|
|
TextRange(16, 18) to "3",
|
|
TextRange(21, 23) to "4",
|
|
TextRange(26, 28) to "5",
|
|
TextRange(31, 33) to "6",
|
|
TextRange(36, 38) to "7",
|
|
))
|
|
}
|
|
|
|
fun `test should not resolve with consecutive escape characters in simple string log4j2`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.apache.logging.log4j.*
|
|
class Logging {
|
|
val LOG: Logger = LogManager.getLogger(Logging.class)
|
|
fun m(i: Int) {
|
|
LOG.info("\s\\{<caret>}", 1)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(TextRange(5, 7) to "1"))
|
|
}
|
|
|
|
fun `test should not resolve with consecutive escape characters in multiline string log4j2`() {
|
|
val multilineString = "\"\"\"\n" +
|
|
"\\s\\{<caret>}" +
|
|
"\"\"\""
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.apache.logging.log4j.*
|
|
class Logging {
|
|
val LOG: Logger = LogManager.getLogger(Logging.class)
|
|
fun m(i: Int) {
|
|
LOG.info($multilineString, 1)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(TextRange(7, 9) to "1"))
|
|
}
|
|
|
|
fun `test resolve with escape characters in simple string slf4j`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.slf4j.*
|
|
class Logging {
|
|
val LOG: Logger = LoggerFactory.getLogger()
|
|
fun m(i: Int) {
|
|
LOG.info("\"{} \'{<caret>} \${"$"}{} \t{} \b{} \n{} \r{} \\{}", 1, 2, 3, 4, 5, 6, 7)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(
|
|
TextRange(3, 5) to "1",
|
|
TextRange(8, 10) to "2",
|
|
TextRange(13, 15) to "3",
|
|
TextRange(18, 20) to "4",
|
|
TextRange(23, 25) to "5",
|
|
TextRange(28, 30) to "6",
|
|
TextRange(33, 35) to "7",
|
|
))
|
|
}
|
|
|
|
|
|
fun `test resolve with escape characters in multiline string slf4j`() {
|
|
val multilineString = "\"\"\"\n" +
|
|
"\\\"{} \\'{<caret>} \\t{} \\b{} \\n{} \\r{} \\\\{}" +
|
|
"\"\"\""
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.slf4j.*
|
|
class Logging {
|
|
val LOG: Logger = LoggerFactory.getLogger()
|
|
fun m(i: Int) {
|
|
LOG.info($multilineString, 1, 2, 3, 4, 5, 6, 7)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(
|
|
TextRange(6, 8) to "1",
|
|
TextRange(11, 13) to "2",
|
|
TextRange(16, 18) to "3",
|
|
TextRange(21, 23) to "4",
|
|
TextRange(26, 28) to "5",
|
|
TextRange(31, 33) to "6",
|
|
TextRange(36, 38) to "7",
|
|
))
|
|
}
|
|
|
|
fun `test should not resolve with consecutive escape characters in simple string slf4j`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.slf4j.*
|
|
class Logging {
|
|
val LOG: Logger = LoggerFactory.getLogger()
|
|
fun m(i: Int) {
|
|
LOG.info("\s\\{<caret>}", 1)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(emptyMap())
|
|
}
|
|
|
|
fun `test should not resolve with consecutive escape characters in multiline string slf4j`() {
|
|
val multilineString = "\"\"\"\n" +
|
|
"\\s\\{<caret>}" +
|
|
"\"\"\""
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.slf4j.*
|
|
class Logging {
|
|
val LOG: Logger = LoggerFactory.getLogger()
|
|
fun m(i: Int) {
|
|
LOG.info($multilineString, 1)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(emptyMap())
|
|
}
|
|
|
|
fun `test lazy init in init block`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.apache.logging.log4j.LogManager
|
|
import org.apache.logging.log4j.Logger
|
|
|
|
class Initialization {
|
|
init {
|
|
log.debug("{<caret>}", 1)
|
|
}
|
|
|
|
companion object {
|
|
private val log : Logger
|
|
init {
|
|
log = LogManager.getLogger()
|
|
}
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(TextRange(1, 3) to "1"))
|
|
}
|
|
|
|
fun `test lazy init in init block with condition`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.apache.logging.log4j.LogManager
|
|
import org.apache.logging.log4j.Logger
|
|
|
|
class StaticInitializerBuilder2 {
|
|
init {
|
|
log.log("{<caret>}", 1)
|
|
}
|
|
|
|
companion object {
|
|
private val log: LogBuilder
|
|
|
|
init {
|
|
if (1 == 1) {
|
|
log = LogManager.getLogger().atDebug()
|
|
} else {
|
|
log = LogManager.getFormatterLogger().atDebug()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(emptyMap())
|
|
}
|
|
|
|
fun `test lazy init in constructors`() {
|
|
myFixture.configureByText("Logging.kt", """
|
|
import org.apache.logging.log4j.LogManager
|
|
import org.apache.logging.log4j.Logger
|
|
|
|
internal class ConstructorInitializer {
|
|
private val log: Logger
|
|
|
|
constructor() {
|
|
log = LogManager.getLogger()
|
|
}
|
|
|
|
constructor(i) {
|
|
log = LogManager.getLogger()
|
|
}
|
|
|
|
fun test() {
|
|
log.info("{<caret>} {}", 1, 2)
|
|
}
|
|
}
|
|
""".trimIndent())
|
|
doTest(mapOf(
|
|
TextRange(1, 3) to "1",
|
|
TextRange(4, 6) to "2",))
|
|
}
|
|
} |