From a871175d380e0d955c014a01aac76b5789522418 Mon Sep 17 00:00:00 2001 From: DmitriyMX Date: Thu, 7 Oct 2021 01:03:50 +0300 Subject: [PATCH 1/6] XLog -> BukkitLogger --- src/main/java/ghast/XLog.java | 4 + src/main/java/ghast/logger/BukkitLogger.java | 42 +++ .../java/ghast/logger/FormattingPair.java | 19 ++ src/main/java/ghast/logger/LoggerAdapter.java | 37 +++ .../java/ghast/logger/LoggerFormatter.java | 59 +++++ .../java/ghast/logger/StringFormatter.java | 240 ++++++++++++++++++ 6 files changed, 401 insertions(+) create mode 100644 src/main/java/ghast/logger/BukkitLogger.java create mode 100644 src/main/java/ghast/logger/FormattingPair.java create mode 100644 src/main/java/ghast/logger/LoggerAdapter.java create mode 100644 src/main/java/ghast/logger/LoggerFormatter.java create mode 100644 src/main/java/ghast/logger/StringFormatter.java diff --git a/src/main/java/ghast/XLog.java b/src/main/java/ghast/XLog.java index b0f83fb..07b08cb 100644 --- a/src/main/java/ghast/XLog.java +++ b/src/main/java/ghast/XLog.java @@ -6,8 +6,12 @@ import java.util.logging.Level; import static java.text.MessageFormat.format; +/** + * @deprecated use {@link ghast.logger.BukkitLogger} + */ @UtilityClass @SuppressWarnings("unused") +@Deprecated public class XLog { //region Debug diff --git a/src/main/java/ghast/logger/BukkitLogger.java b/src/main/java/ghast/logger/BukkitLogger.java new file mode 100644 index 0000000..e75728f --- /dev/null +++ b/src/main/java/ghast/logger/BukkitLogger.java @@ -0,0 +1,42 @@ +package ghast.logger; + +import lombok.RequiredArgsConstructor; + +import java.util.logging.Level; +import java.util.logging.Logger; + +@RequiredArgsConstructor +public class BukkitLogger extends LoggerAdapter { + + private final Logger originallLogger; + + @Override + public void debug(String message) { + originallLogger.log(Level.CONFIG, message); + } + + @Override + public void debug(String message, Throwable throwable) { + originallLogger.log(Level.CONFIG, message, throwable); + } + + @Override + public void info(String message) { + originallLogger.log(Level.INFO, message); + } + + @Override + public void warn(String message) { + originallLogger.log(Level.WARNING, message); + } + + @Override + public void error(String message) { + originallLogger.log(Level.SEVERE, message); + } + + @Override + public void error(String message, Throwable throwable) { + originallLogger.log(Level.SEVERE, message, throwable); + } +} diff --git a/src/main/java/ghast/logger/FormattingPair.java b/src/main/java/ghast/logger/FormattingPair.java new file mode 100644 index 0000000..c8e67e3 --- /dev/null +++ b/src/main/java/ghast/logger/FormattingPair.java @@ -0,0 +1,19 @@ +package ghast.logger; + +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.ToString; + +@RequiredArgsConstructor +@Getter +@ToString +public class FormattingPair { + + private final String message; + private final Throwable throwable; + + public FormattingPair(String message) { + this.message = message; + this.throwable = null; + } +} diff --git a/src/main/java/ghast/logger/LoggerAdapter.java b/src/main/java/ghast/logger/LoggerAdapter.java new file mode 100644 index 0000000..03c4685 --- /dev/null +++ b/src/main/java/ghast/logger/LoggerAdapter.java @@ -0,0 +1,37 @@ +package ghast.logger; + +public abstract class LoggerAdapter { + + public abstract void debug(String message); + public abstract void debug(String message, Throwable throwable); + public abstract void info(String message); + public abstract void warn(String message); + public abstract void error(String message); + public abstract void error(String message, Throwable throwable); + + public void debug(String pattern, Object... objects) { + FormattingPair formattingPair = LoggerFormatter.arrayFormat(pattern, objects); + if (formattingPair.getThrowable() != null) { + debug(formattingPair.getMessage(), formattingPair.getThrowable()); + } else { + debug(formattingPair.getMessage()); + } + } + + public void info(String pattern, Object... objects) { + info(StringFormatter.arrayFormat(pattern, objects)); + } + + public void warn(String pattern, Object... objects) { + warn(StringFormatter.arrayFormat(pattern, objects)); + } + + public void error(String pattern, Object... objects) { + FormattingPair formattingPair = LoggerFormatter.arrayFormat(pattern, objects); + if (formattingPair.getThrowable() != null) { + error(formattingPair.getMessage(), formattingPair.getThrowable()); + } else { + error(formattingPair.getMessage()); + } + } +} diff --git a/src/main/java/ghast/logger/LoggerFormatter.java b/src/main/java/ghast/logger/LoggerFormatter.java new file mode 100644 index 0000000..759498f --- /dev/null +++ b/src/main/java/ghast/logger/LoggerFormatter.java @@ -0,0 +1,59 @@ +package ghast.logger; + +/** + * Copy-Paste from org.slf4j.helpers.MessageFormatter + */ +public final class LoggerFormatter { + + public static FormattingPair arrayFormat(String messagePattern, Object[] argArray) { + Object[] args; + Throwable throwableCandidate = getThrowableCandidate(argArray); + if (throwableCandidate != null) { + args = trimmedCopy(argArray); + } else { + args = argArray; + } + + return arrayFormat(messagePattern, args, throwableCandidate); + } + + public static FormattingPair arrayFormat(String messagePattern, Object[] argArray, Throwable throwable) { + if (messagePattern == null) { + return new FormattingPair(null, throwable); + } + + if (argArray == null) { + return new FormattingPair(messagePattern); + } + + return new FormattingPair(StringFormatter.arrayFormat(messagePattern, argArray), throwable); + } + + private static Throwable getThrowableCandidate(Object[] argArray) { + if (argArray == null || argArray.length == 0) { + return null; + } + + Object lastEntry = argArray[argArray.length - 1]; + if (lastEntry instanceof Throwable) { + return (Throwable) lastEntry; + } + + return null; + } + + private static Object[] trimmedCopy(final Object[] argArray) { + if (argArray == null || argArray.length == 0) { + throw new IllegalStateException("non-sensical empty or null argument array"); + } + + int trimmedLen = argArray.length - 1; + Object[] trimmed = new Object[trimmedLen]; + + if (trimmedLen > 0) { + System.arraycopy(argArray, 0, trimmed, 0, trimmedLen); + } + + return trimmed; + } +} diff --git a/src/main/java/ghast/logger/StringFormatter.java b/src/main/java/ghast/logger/StringFormatter.java new file mode 100644 index 0000000..bde0513 --- /dev/null +++ b/src/main/java/ghast/logger/StringFormatter.java @@ -0,0 +1,240 @@ +package ghast.logger; + +import java.util.HashMap; +import java.util.Map; + +/** + * Copy-Paste from org.slf4j.helpers.MessageFormatter + */ +public final class StringFormatter { + private static final String EMPTY = ""; + private static final char DELIM_START = '{'; + private static final String DELIM_STR = "{}"; + private static final char ESCAPE_CHAR = '\\'; + + public static String arrayFormat(String messagePattern, Object[] argArray) { + if (messagePattern == null) { + return EMPTY; + } else if (argArray == null) { + return messagePattern; + } + + StringBuilder sb = new StringBuilder(messagePattern.length() + 50); + + int k = 0; + for (int i = 0; i < argArray.length; i++) { + int idx = messagePattern.indexOf(DELIM_STR, k); + + if (idx == -1) { + // no more variables + if (k == 0) { // this is a simple string + return messagePattern; + } else { // add the tail string which contains no variables and return + // the result. + sb.append(messagePattern, k, messagePattern.length()); + return sb.toString(); + } + } else { + if (isEscapedDelimeter(messagePattern, idx)) { + if (!isDoubleEscaped(messagePattern, idx)) { + i--; // DELIM_START was escaped, thus should not be incremented + sb.append(messagePattern, k, idx - 1); + sb.append(DELIM_START); + k = idx + 1; + } else { + // The escape character preceding the delimiter start is + // itself escaped: "abc x:\\{}" + // we have to consume one backward slash + sb.append(messagePattern, k, idx - 1); + deeplyAppendParameter(sb, argArray[i], new HashMap<>()); + k = idx + 2; + } + } else { + sb.append(messagePattern, k, idx); + deeplyAppendParameter(sb, argArray[i], new HashMap<>()); + k = idx + 2; + } + } + } + // append the characters following the last {} pair. + sb.append(messagePattern, k, messagePattern.length()); + return sb.toString(); + } + + private static boolean isEscapedDelimeter(String messagePattern, int delimeterStartIndex) { + if (delimeterStartIndex == 0) { + return false; + } + char potentialEscape = messagePattern.charAt(delimeterStartIndex - 1); + return potentialEscape == ESCAPE_CHAR; + } + + private static boolean isDoubleEscaped(String messagePattern, int delimeterStartIndex) { + return delimeterStartIndex >= 2 && messagePattern.charAt(delimeterStartIndex - 2) == ESCAPE_CHAR; + } + + // special treatment of array values was suggested by 'lizongbo' + private static void deeplyAppendParameter(StringBuilder sbuf, Object o, Map seenMap) { + if (o == null) { + sbuf.append("null"); + return; + } + if (!o.getClass().isArray()) { + safeObjectAppend(sbuf, o); + } else { + // check for primitive array types because they + // unfortunately cannot be cast to Object[] + if (o instanceof boolean[]) { + booleanArrayAppend(sbuf, (boolean[]) o); + } else if (o instanceof byte[]) { + byteArrayAppend(sbuf, (byte[]) o); + } else if (o instanceof char[]) { + charArrayAppend(sbuf, (char[]) o); + } else if (o instanceof short[]) { + shortArrayAppend(sbuf, (short[]) o); + } else if (o instanceof int[]) { + intArrayAppend(sbuf, (int[]) o); + } else if (o instanceof long[]) { + longArrayAppend(sbuf, (long[]) o); + } else if (o instanceof float[]) { + floatArrayAppend(sbuf, (float[]) o); + } else if (o instanceof double[]) { + doubleArrayAppend(sbuf, (double[]) o); + } else { + objectArrayAppend(sbuf, (Object[]) o, seenMap); + } + } + } + + private static void safeObjectAppend(StringBuilder sbuf, Object o) { + try { + String oAsString = o.toString(); + sbuf.append(oAsString); + } catch (Throwable t) { + throw new RuntimeException("Failed toString() invocation on an object of type [" + o.getClass().getName() + "]", t); + } + } + + @SuppressWarnings("DuplicatedCode") + private static void booleanArrayAppend(StringBuilder sbuf, boolean[] a) { + sbuf.append('['); + int len = a.length; + for (int i = 0; i < len; i++) { + sbuf.append(a[i]); + if (i != len - 1) { + sbuf.append(", "); + } + } + sbuf.append(']'); + } + + @SuppressWarnings("DuplicatedCode") + private static void byteArrayAppend(StringBuilder sbuf, byte[] a) { + sbuf.append('['); + int len = a.length; + for (int i = 0; i < len; i++) { + sbuf.append(a[i]); + if (i != len - 1) { + sbuf.append(", "); + } + } + sbuf.append(']'); + } + + @SuppressWarnings("DuplicatedCode") + private static void charArrayAppend(StringBuilder sbuf, char[] a) { + sbuf.append('['); + int len = a.length; + for (int i = 0; i < len; i++) { + sbuf.append(a[i]); + if (i != len - 1) { + sbuf.append(", "); + } + } + sbuf.append(']'); + } + + @SuppressWarnings("DuplicatedCode") + private static void shortArrayAppend(StringBuilder sbuf, short[] a) { + sbuf.append('['); + int len = a.length; + for (int i = 0; i < len; i++) { + sbuf.append(a[i]); + if (i != len - 1) { + sbuf.append(", "); + } + } + sbuf.append(']'); + } + + @SuppressWarnings("DuplicatedCode") + private static void intArrayAppend(StringBuilder sbuf, int[] a) { + sbuf.append('['); + int len = a.length; + for (int i = 0; i < len; i++) { + sbuf.append(a[i]); + if (i != len - 1) { + sbuf.append(", "); + } + } + sbuf.append(']'); + } + + @SuppressWarnings("DuplicatedCode") + private static void longArrayAppend(StringBuilder sbuf, long[] a) { + sbuf.append('['); + int len = a.length; + for (int i = 0; i < len; i++) { + sbuf.append(a[i]); + if (i != len - 1) { + sbuf.append(", "); + } + } + sbuf.append(']'); + } + + @SuppressWarnings("DuplicatedCode") + private static void floatArrayAppend(StringBuilder sbuf, float[] a) { + sbuf.append('['); + int len = a.length; + for (int i = 0; i < len; i++) { + sbuf.append(a[i]); + if (i != len - 1) { + sbuf.append(", "); + } + } + sbuf.append(']'); + } + + @SuppressWarnings("DuplicatedCode") + private static void doubleArrayAppend(StringBuilder sbuf, double[] a) { + sbuf.append('['); + int len = a.length; + for (int i = 0; i < len; i++) { + sbuf.append(a[i]); + if (i != len - 1) { + sbuf.append(", "); + } + } + sbuf.append(']'); + } + + private static void objectArrayAppend(StringBuilder sbuf, Object[] a, Map seenMap) { + sbuf.append('['); + if (!seenMap.containsKey(a)) { + seenMap.put(a, null); + int len = a.length; + for (int i = 0; i < len; i++) { + deeplyAppendParameter(sbuf, a[i], seenMap); + if (i != len - 1) { + sbuf.append(", "); + } + } + // allow repeats in siblings + seenMap.remove(a); + } else { + sbuf.append("..."); + } + sbuf.append(']'); + } +} From ba58bc463d1c1da20e719cd4af7a76c5db7d6dfb Mon Sep 17 00:00:00 2001 From: DmitriyMX Date: Thu, 7 Oct 2021 01:45:02 +0300 Subject: [PATCH 2/6] add JaCoCo --- build.gradle | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/build.gradle b/build.gradle index bc0e549..b6f9925 100644 --- a/build.gradle +++ b/build.gradle @@ -1,5 +1,6 @@ plugins { id 'java' + id 'jacoco' } def publishScript = file(rootProject.getProjectDir().getPath() + '/publish.gradle') @@ -76,4 +77,12 @@ dependencies { test { useJUnitPlatform() -} \ No newline at end of file +} + +jacoco { + toolVersion = '0.8.5' +} + +jacocoTestReport { + dependsOn test +} From 41fe79875705c8938ee5675f294ddbffd6d45c15 Mon Sep 17 00:00:00 2001 From: DmitriyMX Date: Thu, 7 Oct 2021 01:45:30 +0300 Subject: [PATCH 3/6] test: StringFormatter --- .../java/ghast/logger/StringFormatter.java | 4 +- .../ghast/logger/StringFormatterTest.java | 95 +++++++++++++++++++ 2 files changed, 97 insertions(+), 2 deletions(-) create mode 100644 src/test/java/ghast/logger/StringFormatterTest.java diff --git a/src/main/java/ghast/logger/StringFormatter.java b/src/main/java/ghast/logger/StringFormatter.java index bde0513..1e1f530 100644 --- a/src/main/java/ghast/logger/StringFormatter.java +++ b/src/main/java/ghast/logger/StringFormatter.java @@ -13,7 +13,7 @@ public final class StringFormatter { private static final char ESCAPE_CHAR = '\\'; public static String arrayFormat(String messagePattern, Object[] argArray) { - if (messagePattern == null) { + if (messagePattern == null || messagePattern.equals(EMPTY)) { return EMPTY; } else if (argArray == null) { return messagePattern; @@ -30,7 +30,7 @@ public final class StringFormatter { if (k == 0) { // this is a simple string return messagePattern; } else { // add the tail string which contains no variables and return - // the result. + // the result. sb.append(messagePattern, k, messagePattern.length()); return sb.toString(); } diff --git a/src/test/java/ghast/logger/StringFormatterTest.java b/src/test/java/ghast/logger/StringFormatterTest.java new file mode 100644 index 0000000..33ed046 --- /dev/null +++ b/src/test/java/ghast/logger/StringFormatterTest.java @@ -0,0 +1,95 @@ +package ghast.logger; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class StringFormatterTest { + + @Test + void emptyPattern() { + String actual = StringFormatter.arrayFormat(null, null); + assertEquals("", actual); + + actual = StringFormatter.arrayFormat("", null); + assertEquals("", actual); + } + + @Test + void nullArgArray() { + String pattern = "some pattern"; + String actual = StringFormatter.arrayFormat(pattern, null); + assertEquals(pattern, actual); + + pattern = "some pattern {}"; + actual = StringFormatter.arrayFormat(pattern, null); + assertEquals(pattern, actual); + } + + @Test + void dummyPattern() { + String actual = StringFormatter.arrayFormat("dummy pattern", new Object[]{"argument"}); + assertEquals("dummy pattern", actual); + } + + @Test + void escapePattern() { + String actual = StringFormatter.arrayFormat("Arg1: \\{}", new Object[]{"item1"}); + assertEquals("Arg1: {}", actual); + + actual = StringFormatter.arrayFormat("Arg1: {}, \\{}", new Object[]{"item1"}); + assertEquals("Arg1: item1, \\{}", actual); + } + + @Test + void simpleArg() { + String actual; + + actual = StringFormatter.arrayFormat("Arg1: {}", new Object[]{"item1"}); + assertEquals("Arg1: item1", actual); + + actual = StringFormatter.arrayFormat("Arg1: {}", new Object[]{11}); + assertEquals("Arg1: 11", actual); + + actual = StringFormatter.arrayFormat("Arg1: {}", new Object[]{11.5f}); + assertEquals("Arg1: 11.5", actual); + } + + @Test + void nullArg() { + String actual = StringFormatter.arrayFormat("Arg1: {}", new Object[]{null}); + assertEquals("Arg1: null", actual); + } + + @Test + void arrayArg() { + String actual; + + actual = StringFormatter.arrayFormat("Arg1: {}", new Object[]{new boolean[]{false, true}}); + assertEquals("Arg1: [false, true]", actual); + + actual = StringFormatter.arrayFormat("Arg1: {}", new Object[]{new byte[]{0b00, 0b01}}); + assertEquals("Arg1: [0, 1]", actual); + + actual = StringFormatter.arrayFormat("Arg1: {}", new Object[]{new char[]{'c', 'h'}}); + assertEquals("Arg1: [c, h]", actual); + + actual = StringFormatter.arrayFormat("Arg1: {}", new Object[]{new short[]{11, 12}}); + assertEquals("Arg1: [11, 12]", actual); + + actual = StringFormatter.arrayFormat("Arg1: {}", new Object[]{new int[]{11, 12}}); + assertEquals("Arg1: [11, 12]", actual); + + actual = StringFormatter.arrayFormat("Arg1: {}", new Object[]{new long[]{11L, 12L}}); + assertEquals("Arg1: [11, 12]", actual); + + actual = StringFormatter.arrayFormat("Arg1: {}", new Object[]{new float[]{11.2f, 12.3f}}); + assertEquals("Arg1: [11.2, 12.3]", actual); + + actual = StringFormatter.arrayFormat("Arg1: {}", new Object[]{new double[]{11.2d, 12.3d}}); + assertEquals("Arg1: [11.2, 12.3]", actual); + + actual = StringFormatter.arrayFormat("Arg1: {}", new Object[]{new String[]{"str-arr-1", "str-arr-2"}}); + assertEquals("Arg1: [str-arr-1, str-arr-2]", actual); + } +} \ No newline at end of file From 2e7f95b3234e16db1915ed9678456494659fd86e Mon Sep 17 00:00:00 2001 From: DmitriyMX Date: Thu, 7 Oct 2021 14:52:29 +0300 Subject: [PATCH 4/6] test: LoggerFormatter --- .../java/ghast/logger/LoggerFormatter.java | 4 - .../ghast/logger/LoggerFormatterTest.java | 84 +++++++++++++++++++ 2 files changed, 84 insertions(+), 4 deletions(-) create mode 100644 src/test/java/ghast/logger/LoggerFormatterTest.java diff --git a/src/main/java/ghast/logger/LoggerFormatter.java b/src/main/java/ghast/logger/LoggerFormatter.java index 759498f..08ad31f 100644 --- a/src/main/java/ghast/logger/LoggerFormatter.java +++ b/src/main/java/ghast/logger/LoggerFormatter.java @@ -43,10 +43,6 @@ public final class LoggerFormatter { } private static Object[] trimmedCopy(final Object[] argArray) { - if (argArray == null || argArray.length == 0) { - throw new IllegalStateException("non-sensical empty or null argument array"); - } - int trimmedLen = argArray.length - 1; Object[] trimmed = new Object[trimmedLen]; diff --git a/src/test/java/ghast/logger/LoggerFormatterTest.java b/src/test/java/ghast/logger/LoggerFormatterTest.java new file mode 100644 index 0000000..60fe5c7 --- /dev/null +++ b/src/test/java/ghast/logger/LoggerFormatterTest.java @@ -0,0 +1,84 @@ +package ghast.logger; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class LoggerFormatterTest { + + @Test + void arrayFormatNullPattern() { + Exception exception = new Exception("oops!"); + FormattingPair formattingPair = LoggerFormatter.arrayFormat(null, null, exception); + + assertNotNull(formattingPair); + assertNull(formattingPair.getMessage()); + assertNotNull(formattingPair.getThrowable()); + assertEquals(exception, formattingPair.getThrowable()); + + formattingPair = LoggerFormatter.arrayFormat(null, null, null); + assertNotNull(formattingPair); + assertNull(formattingPair.getMessage()); + assertNull(formattingPair.getThrowable()); + } + + @Test + void arrayFormatNullArgs() { + FormattingPair formattingPair = LoggerFormatter.arrayFormat("some pattern", null, null); + + assertNotNull(formattingPair); + assertNotNull(formattingPair.getMessage()); + assertEquals("some pattern", formattingPair.getMessage()); + assertNull(formattingPair.getThrowable()); + + formattingPair = LoggerFormatter.arrayFormat("some pattern {}", null, null); + assertNotNull(formattingPair); + assertNotNull(formattingPair.getMessage()); + assertEquals("some pattern {}", formattingPair.getMessage()); + assertNull(formattingPair.getThrowable()); + } + + @Test + void arrayFormat() { + Exception exception = new Exception("oops!"); + FormattingPair formattingPair = LoggerFormatter.arrayFormat("some pattern {}", new Object[]{"item-1"}, exception); + + assertNotNull(formattingPair); + assertNotNull(formattingPair.getMessage()); + assertEquals("some pattern item-1", formattingPair.getMessage()); + assertNotNull(formattingPair.getThrowable()); + assertEquals(exception, formattingPair.getThrowable()); + } + + @Test + void arrayFormatWithoutThrowable() { + FormattingPair formattingPair = LoggerFormatter.arrayFormat("Arg1: {}", new Object[]{ "item-1" }); + + assertNotNull(formattingPair); + assertNotNull(formattingPair.getMessage()); + assertEquals("Arg1: item-1", formattingPair.getMessage()); + assertNull(formattingPair.getThrowable()); + } + + @Test + void arrayFormatWithoutThrowableNullArgs() { + FormattingPair formattingPair = LoggerFormatter.arrayFormat("Arg1: {}", null); + + assertNotNull(formattingPair); + assertNotNull(formattingPair.getMessage()); + assertEquals("Arg1: {}", formattingPair.getMessage()); + assertNull(formattingPair.getThrowable()); + } + + @Test + void arrayFormatThrowableInArgs() { + Exception exception = new Exception("oops!"); + FormattingPair formattingPair = LoggerFormatter.arrayFormat("Arg1: {}", new Object[]{ "item-1", exception }); + + assertNotNull(formattingPair); + assertNotNull(formattingPair.getMessage()); + assertEquals("Arg1: item-1", formattingPair.getMessage()); + assertNotNull(formattingPair.getThrowable()); + assertEquals(exception, formattingPair.getThrowable()); + } +} \ No newline at end of file From 8cf2cbf951f38a354530d4ce8e6328b07bfc7932 Mon Sep 17 00:00:00 2001 From: DmitriyMX Date: Thu, 7 Oct 2021 16:16:25 +0300 Subject: [PATCH 5/6] test: LoggerAdapter --- .../java/ghast/logger/FormattingPair.java | 2 - .../java/ghast/logger/LoggerAdapterTest.java | 50 +++++++++++++++++++ 2 files changed, 50 insertions(+), 2 deletions(-) create mode 100644 src/test/java/ghast/logger/LoggerAdapterTest.java diff --git a/src/main/java/ghast/logger/FormattingPair.java b/src/main/java/ghast/logger/FormattingPair.java index c8e67e3..26283e2 100644 --- a/src/main/java/ghast/logger/FormattingPair.java +++ b/src/main/java/ghast/logger/FormattingPair.java @@ -2,11 +2,9 @@ package ghast.logger; import lombok.Getter; import lombok.RequiredArgsConstructor; -import lombok.ToString; @RequiredArgsConstructor @Getter -@ToString public class FormattingPair { private final String message; diff --git a/src/test/java/ghast/logger/LoggerAdapterTest.java b/src/test/java/ghast/logger/LoggerAdapterTest.java new file mode 100644 index 0000000..00eccd2 --- /dev/null +++ b/src/test/java/ghast/logger/LoggerAdapterTest.java @@ -0,0 +1,50 @@ +package ghast.logger; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +class LoggerAdapterTest { + + LoggerAdapter loggerAdapter; + + @BeforeEach + void before() { + loggerAdapter = mock(LoggerAdapter.class, CALLS_REAL_METHODS); + } + + @Test + void debug() { + loggerAdapter.debug("some pattern {}", "item-1"); + verify(loggerAdapter).debug("some pattern item-1"); + + Exception exception = new Exception("oops!"); + loggerAdapter.debug("some pattern {}", "item-1", exception); + verify(loggerAdapter).debug("some pattern item-1", exception); + } + + @Test + void info() { + loggerAdapter.info("some pattern {}", "item-1"); + verify(loggerAdapter).info("some pattern item-1"); + } + + @Test + void warn() { + loggerAdapter.warn("some pattern {}", "item-1"); + verify(loggerAdapter).warn("some pattern item-1"); + } + + @Test + void error() { + loggerAdapter.error("some pattern {}", "item-1"); + verify(loggerAdapter).error("some pattern item-1"); + + Exception exception = new Exception("oops!"); + loggerAdapter.error("some pattern {}", "item-1", exception); + verify(loggerAdapter).error("some pattern item-1", exception); + } +} \ No newline at end of file From df15d23988de9d50574eb60ed07c1e610fe8d858 Mon Sep 17 00:00:00 2001 From: DmitriyMX Date: Thu, 7 Oct 2021 16:26:27 +0300 Subject: [PATCH 6/6] test: BukkitLogger --- .../java/ghast/logger/BukkitLoggerTest.java | 54 +++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 src/test/java/ghast/logger/BukkitLoggerTest.java diff --git a/src/test/java/ghast/logger/BukkitLoggerTest.java b/src/test/java/ghast/logger/BukkitLoggerTest.java new file mode 100644 index 0000000..8e599e8 --- /dev/null +++ b/src/test/java/ghast/logger/BukkitLoggerTest.java @@ -0,0 +1,54 @@ +package ghast.logger; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.logging.Level; +import java.util.logging.Logger; + +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; + +class BukkitLoggerTest { + + Logger logger; + BukkitLogger bukkitLogger; + + @BeforeEach + void before() { + logger = mock(Logger.class); + bukkitLogger = new BukkitLogger(logger); + } + + @Test + void debug() { + bukkitLogger.debug("Some String"); + verify(logger).log(Level.CONFIG, "Some String"); + + Exception exception = new Exception("oops!"); + bukkitLogger.debug("Some String", exception); + verify(logger).log(Level.CONFIG, "Some String", exception); + } + + @Test + void info() { + bukkitLogger.info("some message"); + verify(logger).log(Level.INFO, "some message"); + } + + @Test + void warn() { + bukkitLogger.warn("some message"); + verify(logger).log(Level.WARNING, "some message"); + } + + @Test + void error() { + bukkitLogger.error("some message"); + verify(logger).log(Level.SEVERE, "some message"); + + Exception exception = new Exception("oops!"); + bukkitLogger.error("Some String", exception); + verify(logger).log(Level.SEVERE, "Some String", exception); + } +} \ No newline at end of file