You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@logging.apache.org by ma...@apache.org on 2023/03/18 23:50:18 UTC
[logging-log4j2] branch main updated (cafae5b1da -> 154a0ab13c)
This is an automated email from the ASF dual-hosted git repository.
mattsicker pushed a change to branch main
in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git
from cafae5b1da Update `log4j-changelog` XSD from 0.1.0 to 0.1.1
new 3e551ac9f0 Update Key to implement StringBuilderFormattable
new 154a0ab13c Add more Key-related tests
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../apache/logging/log4j/plugins/di/KeyTest.java | 87 ++++++++++++++++++++--
.../org/apache/logging/log4j/plugins/di/Key.java | 28 ++++++-
2 files changed, 107 insertions(+), 8 deletions(-)
[logging-log4j2] 01/02: Update Key to implement StringBuilderFormattable
Posted by ma...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
mattsicker pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git
commit 3e551ac9f0b44a54e15676d55169b697537e8141
Author: Matt Sicker <ma...@apache.org>
AuthorDate: Sat Mar 18 14:43:33 2023 -0500
Update Key to implement StringBuilderFormattable
Signed-off-by: Matt Sicker <ma...@apache.org>
---
.../org/apache/logging/log4j/plugins/di/Key.java | 28 +++++++++++++++++++---
1 file changed, 25 insertions(+), 3 deletions(-)
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/di/Key.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/di/Key.java
index e62d0f1c5f..ac5983129d 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/di/Key.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/di/Key.java
@@ -33,6 +33,7 @@ import org.apache.logging.log4j.plugins.QualifierType;
import org.apache.logging.log4j.plugins.util.AnnotationUtil;
import org.apache.logging.log4j.plugins.util.TypeUtil;
import org.apache.logging.log4j.util.Cast;
+import org.apache.logging.log4j.util.StringBuilderFormattable;
import org.apache.logging.log4j.util.Strings;
/**
@@ -41,7 +42,7 @@ import org.apache.logging.log4j.util.Strings;
*
* @param <T> type of key
*/
-public class Key<T> {
+public class Key<T> implements StringBuilderFormattable {
private final Type type;
private final Class<T> rawType;
private final Class<? extends Annotation> qualifierType;
@@ -192,12 +193,33 @@ public class Key<T> {
public final String toString() {
String string = toString;
if (string == null) {
- toString = string = String.format("Key{namespace='%s', name='%s', type=%s, qualifierType=%s}",
- namespace, name, type.getTypeName(), qualifierType != null ? qualifierType.getSimpleName() : Strings.EMPTY);
+ StringBuilder sb = new StringBuilder(32);
+ formatTo(sb);
+ toString = string = sb.toString();
}
return string;
}
+ @Override
+ public void formatTo(final StringBuilder buffer) {
+ buffer.append(TO_STRING_PREFIX).append(type.getTypeName());
+ if (!namespace.isEmpty()) {
+ buffer.append(NAMESPACE).append(namespace);
+ }
+ if (!name.isEmpty()) {
+ buffer.append(NAME).append(name);
+ }
+ if (qualifierType != null) {
+ buffer.append(QUALIFIER_TYPE).append(qualifierType.getSimpleName());
+ }
+ buffer.append(']');
+ }
+
+ private static final String TO_STRING_PREFIX = "Key[type: ";
+ private static final String NAMESPACE = "; namespace: ";
+ private static final String NAME = "; name: ";
+ private static final String QUALIFIER_TYPE = "; qualifierType: ";
+
/**
* Creates a Key for the class.
*/
[logging-log4j2] 02/02: Add more Key-related tests
Posted by ma...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
mattsicker pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git
commit 154a0ab13c31d587fe6bfac60d485f0a702f1117
Author: Matt Sicker <ma...@apache.org>
AuthorDate: Sat Mar 18 17:17:49 2023 -0500
Add more Key-related tests
Signed-off-by: Matt Sicker <ma...@apache.org>
---
.../apache/logging/log4j/plugins/di/KeyTest.java | 87 ++++++++++++++++++++--
1 file changed, 82 insertions(+), 5 deletions(-)
diff --git a/log4j-plugins-test/src/test/java/org/apache/logging/log4j/plugins/di/KeyTest.java b/log4j-plugins-test/src/test/java/org/apache/logging/log4j/plugins/di/KeyTest.java
index 4ae4dc6f1f..96cbe9cd72 100644
--- a/log4j-plugins-test/src/test/java/org/apache/logging/log4j/plugins/di/KeyTest.java
+++ b/log4j-plugins-test/src/test/java/org/apache/logging/log4j/plugins/di/KeyTest.java
@@ -14,21 +14,26 @@
* See the license for the specific language governing permissions and
* limitations under the license.
*/
-
package org.apache.logging.log4j.plugins.di;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+import java.util.Optional;
+
import org.apache.logging.log4j.plugins.Named;
import org.apache.logging.log4j.plugins.Namespace;
import org.apache.logging.log4j.plugins.Ordered;
+import org.apache.logging.log4j.plugins.QualifierType;
+import org.apache.logging.log4j.plugins.name.AnnotatedElementNameProvider;
+import org.apache.logging.log4j.plugins.name.NameProvider;
import org.junit.jupiter.api.Test;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-
import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
import static org.junit.jupiter.api.Assertions.assertEquals;
-// TODO: add tests for meta namespace annotations
// TODO: add tests for more complex types with generics etc
class KeyTest {
@@ -43,6 +48,7 @@ class KeyTest {
final Key<AnnotatedClass> key = Key.forClass(AnnotatedClass.class);
assertEquals("namespace", key.getNamespace());
assertEquals("name", key.getName());
+ assertEquals(Named.class, key.getQualifierType());
assertEquals(42, key.getOrder());
assertEquals(AnnotatedClass.class, key.getType());
assertEquals(AnnotatedClass.class, key.getRawType());
@@ -60,6 +66,7 @@ class KeyTest {
final Key<String> key = assertDoesNotThrow(() -> Key.forMethod(AnnotatedMethod.class.getMethod("string")));
assertEquals("foo", key.getNamespace());
assertEquals("bar", key.getName());
+ assertEquals(Named.class, key.getQualifierType());
assertEquals(10, key.getOrder());
assertEquals(String.class, key.getType());
assertEquals(String.class, key.getRawType());
@@ -75,6 +82,7 @@ class KeyTest {
final Key<String> key = Key.forParameter(method.getParameters()[0]);
assertEquals("foo", key.getNamespace());
assertEquals("bar", key.getName());
+ assertEquals(Named.class, key.getQualifierType());
assertEquals(0, key.getOrder());
assertEquals(String.class, key.getType());
assertEquals(String.class, key.getRawType());
@@ -92,6 +100,75 @@ class KeyTest {
final Key<String> key = Key.forField(field);
assertEquals("foo", key.getNamespace());
assertEquals("bar", key.getName());
+ assertEquals(Named.class, key.getQualifierType());
+ assertEquals(0, key.getOrder());
+ assertEquals(String.class, key.getType());
+ assertEquals(String.class, key.getRawType());
+ }
+
+ @Retention(RetentionPolicy.RUNTIME)
+ @QualifierType
+ @NameProvider(CustomQualifierNameProvider.class)
+ @interface CustomQualifier {
+ String value();
+ }
+
+ static class CustomQualifierNameProvider implements AnnotatedElementNameProvider<CustomQualifier> {
+ @Override
+ public Optional<String> getSpecifiedName(final CustomQualifier annotation) {
+ return Optional.of(annotation.value());
+ }
+ }
+
+ @Retention(RetentionPolicy.RUNTIME)
+ @Namespace("logical")
+ @interface LogicalNamespace {}
+
+ @LogicalNamespace
+ @CustomQualifier("class")
+ static class LogicallyAnnotatedClass {}
+
+ @Test
+ void classWithCustomQualifierAndNamespace() {
+ final Key<LogicallyAnnotatedClass> key = Key.forClass(LogicallyAnnotatedClass.class);
+ assertEquals("logical", key.getNamespace());
+ assertEquals("class", key.getName());
+ assertEquals(CustomQualifier.class, key.getQualifierType());
+ assertEquals(0, key.getOrder());
+ assertEquals(LogicallyAnnotatedClass.class, key.getType());
+ assertEquals(LogicallyAnnotatedClass.class, key.getRawType());
+ }
+
+ interface LogicallyAnnotatedMethod {
+ @LogicalNamespace
+ @CustomQualifier("method")
+ String string();
+ }
+
+ @Test
+ void methodWithCustomQualifierAndNamespace() {
+ final Method method = assertDoesNotThrow(() -> LogicallyAnnotatedMethod.class.getDeclaredMethod("string"));
+ final Key<String> key = Key.forMethod(method);
+ assertEquals("logical", key.getNamespace());
+ assertEquals("method", key.getName());
+ assertEquals(CustomQualifier.class, key.getQualifierType());
+ assertEquals(0, key.getOrder());
+ assertEquals(String.class, key.getType());
+ assertEquals(String.class, key.getRawType());
+ }
+
+ interface LogicallyAnnotatedParameter {
+ void inject(@LogicalNamespace @CustomQualifier("parameter") String argument);
+ }
+
+ @Test
+ void parameterWithCustomQualifierAndNamespace() {
+ final Parameter parameter = assertDoesNotThrow(() ->
+ LogicallyAnnotatedParameter.class.getDeclaredMethod("inject", String.class).getParameters()[0]);
+ final Key<String> key = Key.forParameter(parameter);
+ assertEquals("logical", key.getNamespace());
+ assertEquals("parameter", key.getName());
+ assertEquals(CustomQualifier.class, key.getQualifierType());
assertEquals(0, key.getOrder());
assertEquals(String.class, key.getType());
assertEquals(String.class, key.getRawType());