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 <[email protected]> AuthorDate: Sat Mar 18 17:17:49 2023 -0500 Add more Key-related tests Signed-off-by: Matt Sicker <[email protected]> --- .../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());
