From 66700035cca146103642929e7ed0ec2f945e30f6 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Thu, 6 Nov 2025 14:31:59 +0800 Subject: [PATCH 01/79] Bump project version to 0.1.8-SNAPSHOT Updated the property in pom.xml to prepare for the next development iteration. --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index 2d4bac37e..3f1676d72 100644 --- a/pom.xml +++ b/pom.xml @@ -51,7 +51,7 @@ - 0.1.7-SNAPSHOT + 0.1.8-SNAPSHOT From 4099b4acc6a40db82de5e33c51687ef984cca2a8 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Tue, 3 Feb 2026 21:41:03 +0800 Subject: [PATCH 02/79] Add microsphere-jdk-tools module MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Introduce a new microsphere-jdk-tools Maven module. Adds pom.xml with dependencies (microsphere-java-core, JUnit, Mockito, Logback), maven-compiler config and maven-shade setup. Implements io.microsphere.jdk.tools.compiler.Compiler — a utility to programmatically compile Java sources, manage source/target paths, detect class/root/source locations, and configure processors/options/diagnostics. Includes unit tests (CompilerTest) covering constructors, default path detection, options, processors and compile flow, and a logback-test.xml for test logging. --- microsphere-jdk-tools/pom.xml | 90 ++++++ .../jdk/tools/compiler/Compiler.java | 279 ++++++++++++++++++ .../jdk/tools/compiler/CompilerTest.java | 188 ++++++++++++ .../src/test/resources/logback-test.xml | 15 + 4 files changed, 572 insertions(+) create mode 100644 microsphere-jdk-tools/pom.xml create mode 100644 microsphere-jdk-tools/src/main/java/io/microsphere/jdk/tools/compiler/Compiler.java create mode 100644 microsphere-jdk-tools/src/test/java/io/microsphere/jdk/tools/compiler/CompilerTest.java create mode 100644 microsphere-jdk-tools/src/test/resources/logback-test.xml diff --git a/microsphere-jdk-tools/pom.xml b/microsphere-jdk-tools/pom.xml new file mode 100644 index 000000000..d16b92c62 --- /dev/null +++ b/microsphere-jdk-tools/pom.xml @@ -0,0 +1,90 @@ + + + + io.github.microsphere-projects + microsphere-java-parent + ${revision} + ../microsphere-java-parent/pom.xml + + 4.0.0 + + io.github.microsphere-projects + microsphere-jdk-tools + ${revision} + jar + + Microsphere :: JDK :: Tools + Microsphere JDK Tools + + + + + + io.github.microsphere-projects + microsphere-java-core + ${revision} + + + + + org.junit.jupiter + junit-jupiter + test + + + + org.junit.jupiter + junit-jupiter-engine + test + + + + + org.mockito + mockito-core + test + + + + + ch.qos.logback + logback-classic + test + + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + + -proc:none + + + + org.apache.maven.plugins + maven-shade-plugin + + + package + + shade + + + + + io.github.microsphere-projects:microsphere-java-core + + + + + + + + + + \ No newline at end of file diff --git a/microsphere-jdk-tools/src/main/java/io/microsphere/jdk/tools/compiler/Compiler.java b/microsphere-jdk-tools/src/main/java/io/microsphere/jdk/tools/compiler/Compiler.java new file mode 100644 index 000000000..09ab04336 --- /dev/null +++ b/microsphere-jdk-tools/src/main/java/io/microsphere/jdk/tools/compiler/Compiler.java @@ -0,0 +1,279 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.jdk.tools.compiler; + +import io.microsphere.logging.Logger; + +import javax.annotation.processing.Processor; +import javax.tools.DiagnosticListener; +import javax.tools.JavaCompiler; +import javax.tools.JavaCompiler.CompilationTask; +import javax.tools.JavaFileObject; +import javax.tools.StandardJavaFileManager; +import java.io.File; +import java.io.IOException; +import java.net.URL; +import java.nio.charset.Charset; +import java.security.CodeSource; +import java.security.ProtectionDomain; +import java.util.List; +import java.util.Locale; +import java.util.Objects; +import java.util.Set; + +import static io.microsphere.collection.CollectionUtils.addAll; +import static io.microsphere.collection.CollectionUtils.first; +import static io.microsphere.collection.CollectionUtils.isEmpty; +import static io.microsphere.collection.Lists.ofList; +import static io.microsphere.collection.SetUtils.newLinkedHashSet; +import static io.microsphere.collection.Sets.ofSet; +import static io.microsphere.constants.FileConstants.JAVA_EXTENSION; +import static io.microsphere.constants.SymbolConstants.DOT_CHAR; +import static io.microsphere.io.scanner.SimpleFileScanner.INSTANCE; +import static io.microsphere.logging.LoggerFactory.getLogger; +import static io.microsphere.text.FormatUtils.format; +import static io.microsphere.util.ArrayUtils.ofArray; +import static io.microsphere.util.ClassUtils.getTypeName; +import static io.microsphere.util.StringUtils.substringBefore; +import static java.io.File.separatorChar; +import static java.util.Collections.emptyList; +import static java.util.Collections.emptySet; +import static java.util.Collections.singleton; +import static java.util.Collections.unmodifiableList; +import static java.util.Collections.unmodifiableSet; +import static java.util.stream.Stream.of; +import static javax.tools.StandardLocation.CLASS_OUTPUT; +import static javax.tools.StandardLocation.SOURCE_OUTPUT; +import static javax.tools.StandardLocation.SOURCE_PATH; +import static javax.tools.ToolProvider.getSystemJavaCompiler; + +/** + * The Java Compiler + * + * @author Mercy + * @since 1.0.0 + */ +public class Compiler { + + private static final Logger logger = getLogger(Compiler.class); + + public static final String[] DEFAULT_OPTIONS = ofArray("-parameters", "-Xlint:unchecked", "-nowarn", "-Xlint:deprecation"); + + private final Set sourcePaths; + + private final File targetDirectory; + + private final JavaCompiler javaCompiler; + + private Set processors; + + private List options; + + private DiagnosticListener diagnosticListener; + + private Locale locale; + + private Charset charset; + + public Compiler() { + this(defaultTargetDirectory()); + } + + public Compiler(File targetDirectory) { + this(defaultSourceDirectory(), targetDirectory); + } + + public Compiler(File defaultSourceDirectory, File targetDirectory) { + options(DEFAULT_OPTIONS); + this.sourcePaths = newLinkedHashSet(defaultSourceDirectory); + this.targetDirectory = targetDirectory; + this.javaCompiler = getSystemJavaCompiler(); + } + + public Compiler options(String... options) { + this.options = ofList(options); + return this; + } + + public Compiler sourcePaths(File... sourcePaths) { + addAll(this.sourcePaths, sourcePaths); + return this; + } + + public Compiler sourcePaths(Class... sourceClasses) { + for (Class sourceClass : sourceClasses) { + sourcePath(sourceClass); + } + return this; + } + + public Compiler sourcePath(Class sourceClass) { + File sourcePath = detectSourcePath(sourceClass); + if (sourcePath != null) { + return sourcePaths(sourcePath); + } + return this; + } + + public Compiler processors(Processor... processors) { + this.processors = ofSet(processors); + return this; + } + + public Compiler diagnosticListener(DiagnosticListener diagnosticListener) { + this.diagnosticListener = diagnosticListener; + return this; + } + + public Compiler locale(Locale locale) { + this.locale = locale; + return this; + } + + public Compiler charset(Charset charset) { + this.charset = charset; + return this; + } + + public boolean compile(Class... sourceClasses) throws IOException { + JavaCompiler javaCompiler = getJavaCompiler(); + StandardJavaFileManager javaFileManager = getJavaFileManager(); + CompilationTask task = javaCompiler.getTask(null, javaFileManager, + getDiagnosticListener(), getOptions(), null, getJavaFileObjects(javaFileManager, sourceClasses)); + task.setProcessors(this.getProcessors()); + return task.call(); + } + + public JavaCompiler getJavaCompiler() { + return this.javaCompiler; + } + + public StandardJavaFileManager getJavaFileManager() throws IOException { + StandardJavaFileManager javaFileManager = getJavaCompiler().getStandardFileManager(getDiagnosticListener(), getLocale(), getCharset()); + javaFileManager.setLocation(SOURCE_PATH, this.sourcePaths); + javaFileManager.setLocation(CLASS_OUTPUT, singleton(this.targetDirectory)); + javaFileManager.setLocation(SOURCE_OUTPUT, singleton(this.targetDirectory)); + return javaFileManager; + } + + public DiagnosticListener getDiagnosticListener() { + return this.diagnosticListener; + } + + public Locale getLocale() { + return this.locale; + } + + public Charset getCharset() { + return this.charset; + } + + public List getOptions() { + List options = this.options; + if (isEmpty(options)) { + return emptyList(); + } + return unmodifiableList(options); + } + + public Set getProcessors() { + Set processors = this.processors; + if (processors == null) { + return emptySet(); + } + return unmodifiableSet(processors); + } + + private Iterable getJavaFileObjects(StandardJavaFileManager javaFileManager, Class... sourceClasses) { + File[] javaFiles = of(sourceClasses) + .map(this::searchJavaSourceFile) + .filter(Objects::nonNull) + .toArray(File[]::new); + return javaFileManager.getJavaFileObjects(javaFiles); + } + + private File searchJavaSourceFile(Class sourceClass) { + String javaSourceFilePath = resolveJavaSourceFileRelativePath(sourceClass); + for (File sourceDirectory : this.sourcePaths) { + File javaSourceFile = new File(sourceDirectory, javaSourceFilePath); + if (javaSourceFile.exists()) { + return javaSourceFile; + } + } + return null; + } + + static File defaultSourceDirectory() { + return detectSourcePath(Compiler.class); + } + + static File defaultRootDirectory() { + return detectRootDirectory(Compiler.class); + } + + static File defaultTargetDirectory() { + File dir = new File(defaultRootDirectory(), "target/generated-classes"); + dir.mkdirs(); + return dir; + } + + public static File detectSourcePath(Class sourceClass) { + File rootDirectory = detectRootDirectory(sourceClass); + String javaSourceFileRelativePath = resolveJavaSourceFileRelativePath(sourceClass); + + Set sourceFiles = INSTANCE.scan(rootDirectory, true, + file -> file.getAbsolutePath().endsWith(javaSourceFileRelativePath)); + + File sourceFile = first(sourceFiles); + if (sourceFile == null) { + logger.trace("The source files of {} can't be found in the root directory[path :'{}']", sourceClass, rootDirectory); + return null; + } + + String javaSourceFilePath = sourceFile.getAbsolutePath(); + String javaSourcePath = substringBefore(javaSourceFilePath, javaSourceFileRelativePath); + File sourcePath = new File(javaSourcePath); + + logger.trace("The source file[path : '{}] of {} was found in the source directory[path :'{}']", sourceFile, sourceClass, sourcePath); + + return sourcePath; + } + + public static File detectRootDirectory(Class sourceClass) { + File classPath = detectClassPath(sourceClass); + // classPath : "${rootDirectory}/target/classes" + File rootDirectory = classPath.getParentFile().getParentFile(); + logger.trace("The root directory[path : '{}'] was found by the source class[name : '{}']", + rootDirectory.getAbsolutePath(), getTypeName(sourceClass)); + return rootDirectory; + } + + public static File detectClassPath(Class sourceClass) { + ProtectionDomain protectionDomain = sourceClass.getProtectionDomain(); + CodeSource codeSource = protectionDomain.getCodeSource(); + if (codeSource != null) { + URL location = codeSource.getLocation(); + return new File(location.getPath()); + } + String message = format("The source {} is based on the file system, the class path can't be detected.", sourceClass); + throw new UnsupportedOperationException(message); + } + + public static String resolveJavaSourceFileRelativePath(Class sourceClass) { + return sourceClass.getName().replace(DOT_CHAR, separatorChar).concat(JAVA_EXTENSION); + } +} \ No newline at end of file diff --git a/microsphere-jdk-tools/src/test/java/io/microsphere/jdk/tools/compiler/CompilerTest.java b/microsphere-jdk-tools/src/test/java/io/microsphere/jdk/tools/compiler/CompilerTest.java new file mode 100644 index 000000000..78023fafc --- /dev/null +++ b/microsphere-jdk-tools/src/test/java/io/microsphere/jdk/tools/compiler/CompilerTest.java @@ -0,0 +1,188 @@ +package io.microsphere.jdk.tools.compiler; + +import org.junit.jupiter.api.Test; + +import javax.annotation.processing.AbstractProcessor; +import javax.annotation.processing.Processor; +import javax.annotation.processing.RoundEnvironment; +import javax.lang.model.element.TypeElement; +import java.io.File; +import java.io.IOException; +import java.util.Set; + +import static io.microsphere.jdk.tools.compiler.Compiler.defaultRootDirectory; +import static io.microsphere.jdk.tools.compiler.Compiler.defaultSourceDirectory; +import static io.microsphere.jdk.tools.compiler.Compiler.defaultTargetDirectory; +import static io.microsphere.jdk.tools.compiler.Compiler.detectClassPath; +import static io.microsphere.jdk.tools.compiler.Compiler.detectRootDirectory; +import static io.microsphere.jdk.tools.compiler.Compiler.detectSourcePath; +import static io.microsphere.jdk.tools.compiler.Compiler.resolveJavaSourceFileRelativePath; +import static java.io.File.separatorChar; +import static java.nio.charset.StandardCharsets.UTF_8; +import static java.util.Locale.getDefault; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * Unit tests for the Compiler class + * + * @see Compiler + */ +class CompilerTest { + + @Test + void testDefaultConstructor() { + // Test default constructor which uses default target directory + Compiler compiler = new Compiler(); + + assertNotNull(compiler, "Compiler should be instantiated successfully"); + assertNotNull(compiler.getJavaCompiler(), "JavaCompiler should be initialized"); + } + + @Test + void testTargetDirectoryConstructor() { + File targetDir = new File("target/test-classes"); + targetDir.mkdirs(); // Ensure directory exists + + Compiler compiler = new Compiler(targetDir); + + assertNotNull(compiler, "Compiler should be instantiated successfully with target directory"); + assertNotNull(compiler.getJavaCompiler(), "JavaCompiler should be initialized"); + } + + @Test + void testSourceAndTargetDirectoryConstructor() { + File sourceDir = new File("src/test/java"); + File targetDir = new File("target/test-classes"); + targetDir.mkdirs(); // Ensure target directory exists + + Compiler compiler = new Compiler(sourceDir, targetDir); + + assertNotNull(compiler, "Compiler should be instantiated successfully with source and target directories"); + assertNotNull(compiler.getJavaCompiler(), "JavaCompiler should be initialized"); + } + + @Test + void testDefaultDirectories() { + // Test the static methods that determine default directories + File defaultSourceDir = defaultSourceDirectory(); + File defaultTargetDir = defaultTargetDirectory(); + File defaultRootDir = defaultRootDirectory(); + + // Root directory should exist (it's derived from the Compiler class location) + assertNotNull(defaultSourceDir, "Default source directory should not be null"); + assertNotNull(defaultRootDir, "Default root directory should not be null"); + assertTrue(defaultRootDir.exists(), "Default root directory should exist"); + + // Target directory should be created + assertNotNull(defaultTargetDir, "Default target directory should not be null"); + } + + @Test + void testDetectClassPath() { + File classPath = detectClassPath(Compiler.class); + + assertNotNull(classPath, "Detected class path should not be null"); + assertTrue(classPath.exists(), "Detected class path should exist"); + + assertThrows(UnsupportedOperationException.class, () -> detectClassPath(String.class)); + } + + @Test + void testResolveJavaSourceFileRelativePath() { + String expectedPath = Compiler.class.getName() + .replace('.', separatorChar) + .concat(".java"); + String actualPath = resolveJavaSourceFileRelativePath(Compiler.class); + + assertEquals(expectedPath, actualPath, + "Resolved Java source file relative path should match expected format"); + } + + @Test + void testSourcePathsMethod() { + File targetDir = new File("target/test-classes"); + targetDir.mkdirs(); + + Compiler compiler = new Compiler(targetDir); + + File testSourcePath = new File("src/main/java"); + Compiler result = compiler.sourcePaths(testSourcePath); + + // Verify method chaining returns the same instance + assertSame(compiler, result, "sourcePaths method should return the same instance for chaining"); + + result = compiler.sourcePaths(Compiler.class, Test.class); + assertSame(compiler, result, "sourcePaths method should return the same instance for chaining"); + } + + @Test + void testProcessorsMethod() { + File targetDir = new File("target/test-classes"); + targetDir.mkdirs(); + + Compiler compiler = new Compiler(targetDir); + Processor processor = new AbstractProcessor() { + @Override + public boolean process(Set annotations, RoundEnvironment roundEnv) { + return false; + } + }; + + Compiler result = compiler.processors(processor); + + // Verify method chaining returns the same instance + assertSame(compiler, result, "processors method should return the same instance for chaining"); + } + + @Test + void testCompile() throws IOException { + Compiler compiler = new Compiler(); + + // This would normally attempt compilation, but with mocked compiler it's safe to call + boolean result = compiler.compile(Compiler.class, Test.class); + + // For this test, we're primarily verifying the setup doesn't fail + // Actual compilation success depends on the mock setup + assertTrue(result, "Test setup completed without exceptions"); + + compiler.options() + .processors(new AbstractProcessor() { + + @Override + public boolean process(Set annotations, RoundEnvironment roundEnv) { + return false; + } + }) + .diagnosticListener(diagnostic -> { + }) + .locale(getDefault()) + .charset(UTF_8) + ; + + result = compiler.compile(Compiler.class); + + assertTrue(result, "Test setup completed without exceptions"); + } + + @Test + void testDetectRootDirectory() { + File rootDir = detectRootDirectory(Compiler.class); + + assertNotNull(rootDir, "Root directory should not be null"); + assertTrue(rootDir.exists(), "Root directory should exist"); + } + + @Test + void testDetectSourcePath() { + // This might be null if source path cannot be detected in test environment + // but the method should not throw exceptions + assertNotNull(detectSourcePath(Compiler.class), "Should be able to call detectSourcePath without errors"); + assertNotNull(detectSourcePath(CompilerTest.class), "Should be able to call detectSourcePath without errors"); + assertNull(detectSourcePath(Test.class), "Should be able to call detectSourcePath without errors"); + } +} diff --git a/microsphere-jdk-tools/src/test/resources/logback-test.xml b/microsphere-jdk-tools/src/test/resources/logback-test.xml new file mode 100644 index 000000000..e3375b74c --- /dev/null +++ b/microsphere-jdk-tools/src/test/resources/logback-test.xml @@ -0,0 +1,15 @@ + + + + + + + ${ENCODER_PATTERN} + + + + + + + + \ No newline at end of file From 3e9fae47bde58535c253b39492c562c34b3dd029 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Tue, 3 Feb 2026 22:26:30 +0800 Subject: [PATCH 03/79] Add Mockito and bump test dependency versions MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Introduce Mockito to the parent POM: add a mockito.version property and a mockito-core dependency so tests can use Mockito. Also update JUnit versions: bump the root junit.version 6.0.1 → 6.0.2 and the profile's junit.version 5.13.4 → 5.14.2. The profile also sets mockito.version (4.11.0) to override the parent value. --- microsphere-java-parent/pom.xml | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/microsphere-java-parent/pom.xml b/microsphere-java-parent/pom.xml index 25ab0a0db..4d1d66ae9 100644 --- a/microsphere-java-parent/pom.xml +++ b/microsphere-java-parent/pom.xml @@ -26,7 +26,8 @@ 2.0.17 1.5.22 - 6.0.1 + 6.0.2 + 5.14.2 1.37 @@ -82,6 +83,14 @@ ${junit.version} + + + org.mockito + mockito-core + ${mockito.version} + + + org.openjdk.jmh jmh-core @@ -126,7 +135,8 @@ 5.3.39 - 5.13.4 + 5.14.2 + 4.11.0 From e6d5a4a9699957deb0be30b0b21c5f766a1d9f50 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Tue, 3 Feb 2026 22:27:22 +0800 Subject: [PATCH 04/79] Add microsphere-java-test module Introduce a new microsphere-java-test Maven module providing testing utilities and fixtures. Adds pom.xml (compiler/shade configuration and test dependencies), a TestAnnotation and annotation-processing test infrastructure (AbstractAnnotationProcessingTest, AnnotationProcessingTestProcessor, CompilerInvocationInterceptor) that compiles test sources and runs processors during JUnit5 tests. Also adds a set of model classes, service interfaces/implementations, unit tests, logback-test.xml, and a service provider entry for annotation processors to support annotation-processing test cases. --- microsphere-java-test/pom.xml | 133 +++++++++++++ .../test/annotation/TestAnnotation.java | 73 +++++++ .../AbstractAnnotationProcessingTest.java | 153 +++++++++++++++ .../AnnotationProcessingTestProcessor.java | 87 +++++++++ .../CompilerInvocationInterceptor.java | 59 ++++++ .../io/microsphere/test/model/Ancestor.java | 38 ++++ .../test/model/ArrayTypeModel.java | 76 ++++++++ .../test/model/CollectionTypeModel.java | 82 ++++++++ .../java/io/microsphere/test/model/Color.java | 47 +++++ .../model/ConfigurationPropertyModel.java | 85 ++++++++ .../microsphere/test/model/MapTypeModel.java | 82 ++++++++ .../java/io/microsphere/test/model/Model.java | 90 +++++++++ .../io/microsphere/test/model/Parent.java | 66 +++++++ .../test/model/PrimitiveTypeModel.java | 74 +++++++ .../test/model/SimpleTypeModel.java | 162 ++++++++++++++++ .../test/model/StringArrayList.java | 30 +++ .../test/service/DefaultTestService.java | 58 ++++++ .../test/service/GenericTestService.java | 33 ++++ .../microsphere/test/service/TestService.java | 56 ++++++ .../test/service/TestServiceImpl.java | 101 ++++++++++ .../src/main/resources/logback-test.xml | 15 ++ .../processing/AnnotationProcessingTest.java | 71 +++++++ .../annotation/processing/TestProcessor.java | 48 +++++ .../microsphere/test/model/AncestorTest.java | 81 ++++++++ .../test/model/ArrayTypeModelTest.java | 122 ++++++++++++ .../test/model/CollectionTypeModelTest.java | 138 +++++++++++++ .../io/microsphere/test/model/ColorTest.java | 103 ++++++++++ .../model/ConfigurationPropertyModelTest.java | 152 +++++++++++++++ .../test/model/MapTypeModelTest.java | 138 +++++++++++++ .../io/microsphere/test/model/ModelTest.java | 116 +++++++++++ .../io/microsphere/test/model/ParentTest.java | 86 +++++++++ .../test/model/PrimitiveTypeModelTest.java | 81 ++++++++ .../test/model/SimpleTypeModelTest.java | 182 ++++++++++++++++++ .../test/model/StringArrayListTest.java | 137 +++++++++++++ .../test/service/DefaultTestServiceTest.java | 83 ++++++++ .../test/service/GenericTestServiceTest.java | 58 ++++++ .../javax.annotation.processing.Processor | 1 + 37 files changed, 3197 insertions(+) create mode 100644 microsphere-java-test/pom.xml create mode 100644 microsphere-java-test/src/main/java/io/microsphere/test/annotation/TestAnnotation.java create mode 100644 microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AbstractAnnotationProcessingTest.java create mode 100644 microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AnnotationProcessingTestProcessor.java create mode 100644 microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/CompilerInvocationInterceptor.java create mode 100644 microsphere-java-test/src/main/java/io/microsphere/test/model/Ancestor.java create mode 100644 microsphere-java-test/src/main/java/io/microsphere/test/model/ArrayTypeModel.java create mode 100644 microsphere-java-test/src/main/java/io/microsphere/test/model/CollectionTypeModel.java create mode 100644 microsphere-java-test/src/main/java/io/microsphere/test/model/Color.java create mode 100644 microsphere-java-test/src/main/java/io/microsphere/test/model/ConfigurationPropertyModel.java create mode 100644 microsphere-java-test/src/main/java/io/microsphere/test/model/MapTypeModel.java create mode 100644 microsphere-java-test/src/main/java/io/microsphere/test/model/Model.java create mode 100644 microsphere-java-test/src/main/java/io/microsphere/test/model/Parent.java create mode 100644 microsphere-java-test/src/main/java/io/microsphere/test/model/PrimitiveTypeModel.java create mode 100644 microsphere-java-test/src/main/java/io/microsphere/test/model/SimpleTypeModel.java create mode 100644 microsphere-java-test/src/main/java/io/microsphere/test/model/StringArrayList.java create mode 100644 microsphere-java-test/src/main/java/io/microsphere/test/service/DefaultTestService.java create mode 100644 microsphere-java-test/src/main/java/io/microsphere/test/service/GenericTestService.java create mode 100644 microsphere-java-test/src/main/java/io/microsphere/test/service/TestService.java create mode 100644 microsphere-java-test/src/main/java/io/microsphere/test/service/TestServiceImpl.java create mode 100644 microsphere-java-test/src/main/resources/logback-test.xml create mode 100644 microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/AnnotationProcessingTest.java create mode 100644 microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/TestProcessor.java create mode 100644 microsphere-java-test/src/test/java/io/microsphere/test/model/AncestorTest.java create mode 100644 microsphere-java-test/src/test/java/io/microsphere/test/model/ArrayTypeModelTest.java create mode 100644 microsphere-java-test/src/test/java/io/microsphere/test/model/CollectionTypeModelTest.java create mode 100644 microsphere-java-test/src/test/java/io/microsphere/test/model/ColorTest.java create mode 100644 microsphere-java-test/src/test/java/io/microsphere/test/model/ConfigurationPropertyModelTest.java create mode 100644 microsphere-java-test/src/test/java/io/microsphere/test/model/MapTypeModelTest.java create mode 100644 microsphere-java-test/src/test/java/io/microsphere/test/model/ModelTest.java create mode 100644 microsphere-java-test/src/test/java/io/microsphere/test/model/ParentTest.java create mode 100644 microsphere-java-test/src/test/java/io/microsphere/test/model/PrimitiveTypeModelTest.java create mode 100644 microsphere-java-test/src/test/java/io/microsphere/test/model/SimpleTypeModelTest.java create mode 100644 microsphere-java-test/src/test/java/io/microsphere/test/model/StringArrayListTest.java create mode 100644 microsphere-java-test/src/test/java/io/microsphere/test/service/DefaultTestServiceTest.java create mode 100644 microsphere-java-test/src/test/java/io/microsphere/test/service/GenericTestServiceTest.java create mode 100644 microsphere-java-test/src/test/resources/META-INF/services/javax.annotation.processing.Processor diff --git a/microsphere-java-test/pom.xml b/microsphere-java-test/pom.xml new file mode 100644 index 000000000..9d94d023b --- /dev/null +++ b/microsphere-java-test/pom.xml @@ -0,0 +1,133 @@ + + + + io.github.microsphere-projects + microsphere-java-parent + ${revision} + ../microsphere-java-parent/pom.xml + + 4.0.0 + + io.github.microsphere-projects + microsphere-java-test + ${revision} + jar + + Microsphere :: Java :: Test + Microsphere Java Test + + + 2.1 + 2.3.1 + + + + + + + io.github.microsphere-projects + microsphere-java-core + ${revision} + true + + + + + io.github.microsphere-projects + microsphere-jdk-tools + ${revision} + true + + + + + org.junit.jupiter + junit-jupiter + true + + + + + org.mockito + mockito-core + true + + + + org.junit.jupiter + junit-jupiter-engine + true + + + + + ch.qos.logback + logback-classic + true + + + + + javax.ws.rs + javax.ws.rs-api + ${javax.ws.rs.version} + true + + + + + javax.xml.ws + jaxws-api + ${jaxws-api.version} + true + + + + + org.springframework + spring-context + true + + + + org.springframework + spring-web + true + + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + + -proc:none + + + + org.apache.maven.plugins + maven-shade-plugin + + + package + + shade + + + + + io.github.microsphere-projects:microsphere-java-core + + + + + + + + + + \ No newline at end of file diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/annotation/TestAnnotation.java b/microsphere-java-test/src/main/java/io/microsphere/test/annotation/TestAnnotation.java new file mode 100644 index 000000000..5669e4936 --- /dev/null +++ b/microsphere-java-test/src/main/java/io/microsphere/test/annotation/TestAnnotation.java @@ -0,0 +1,73 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.test.annotation; + +import io.microsphere.annotation.ConfigurationProperty; +import io.microsphere.annotation.Since; + +import java.lang.annotation.Annotation; +import java.lang.annotation.Documented; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; +import java.util.concurrent.TimeUnit; + +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import static java.util.concurrent.TimeUnit.DAYS; + +/** + * The {@link Annotation} for testing + * + * @author Mercy + * @see Annotation + * @since 1.0.0 + */ +@Retention(RUNTIME) +@Target(TYPE) +@Documented +public @interface TestAnnotation { + + boolean z() default false; + + char c() default 'a'; + + byte b() default 1; + + short s() default 2; + + int i() default 3; + + long l() default 4L; + + float f() default 5.0f; + + double d() default 6.0d; + + String string() default "string"; + + Class type() default String.class; + + Class[] types() default {String.class, Integer.class}; + + TimeUnit timeUnit() default DAYS; + + Since since(); + + ConfigurationProperty[] properties() default {}; + +} \ No newline at end of file diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AbstractAnnotationProcessingTest.java b/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AbstractAnnotationProcessingTest.java new file mode 100644 index 000000000..2b1bcd330 --- /dev/null +++ b/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AbstractAnnotationProcessingTest.java @@ -0,0 +1,153 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.test.annotation.processing; + +import io.microsphere.test.service.TestServiceImpl; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.extension.ExtendWith; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.annotation.processing.RoundEnvironment; +import javax.lang.model.AnnotatedConstruct; +import javax.lang.model.element.AnnotationMirror; +import javax.lang.model.element.Element; +import javax.lang.model.element.ElementKind; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.Modifier; +import javax.lang.model.element.TypeElement; +import javax.lang.model.element.VariableElement; +import javax.lang.model.type.DeclaredType; +import javax.lang.model.type.TypeMirror; +import javax.lang.model.util.Elements; +import javax.lang.model.util.Types; +import java.lang.annotation.Annotation; +import java.lang.reflect.Type; +import java.util.Collection; +import java.util.List; +import java.util.Set; +import java.util.function.Predicate; + +/** + * Abstract {@link Annotation} Processing Test case + * + * @author Mercy + * @since 1.0.0 + */ +@ExtendWith(CompilerInvocationInterceptor.class) +public abstract class AbstractAnnotationProcessingTest { + + protected static final TypeMirror NULL_TYPE_MIRROR = null; + + protected static final TypeMirror[] EMPTY_TYPE_MIRROR_ARRAY = new TypeMirror[0]; + + protected static final TypeMirror[] NULL_TYPE_MIRROR_ARRAY = null; + + protected static final Collection[] EMPTY_COLLECTION_ARRAY = new Collection[0]; + + protected static final Collection NULL_COLLECTION = null; + + protected static final List NULL_LIST = null; + + protected static final Element NULL_ELEMENT = null; + + protected static final ElementKind NULL_ELEMENT_KIND = null; + + protected static final Element[] EMPTY_ELEMENT_ARRAY = new Element[0]; + + protected static final Element[] NULL_ELEMENT_ARRAY = null; + + protected static final TypeElement NULL_TYPE_ELEMENT = null; + + protected static final Type[] NULL_TYPE_ARRAY = null; + + protected static final Type[] EMPTY_TYPE_ARRAY = new Type[0]; + + protected static final Type NULL_TYPE = null; + + protected static final ProcessingEnvironment NULL_PROCESSING_ENVIRONMENT = null; + + protected static final String NULL_STRING = null; + + protected static final String[] NULL_STRING_ARRAY = null; + + protected static final Class NULL_CLASS = null; + + protected static final Class[] NULL_CLASS_ARRAY = null; + + protected static final AnnotatedConstruct NULL_ANNOTATED_CONSTRUCT = null; + + protected static final Predicate[] NULL_PREDICATE_ARRAY = null; + + protected static final VariableElement NULL_FIELD = null; + + protected static final Modifier NULL_MODIFIER = null; + + protected static final Modifier[] NULL_MODIFIER_ARRAY = null; + + protected static final ExecutableElement NULL_METHOD = null; + + protected static final ExecutableElement[] NULL_METHOD_ARRAY = null; + + protected static final AnnotationMirror NULL_ANNOTATION_MIRROR = null; + + static ThreadLocal testInstanceHolder = new ThreadLocal<>(); + + protected RoundEnvironment roundEnv; + + protected ProcessingEnvironment processingEnv; + + protected Elements elements; + + protected Types types; + + protected Class testClass; + + protected String testClassName; + + protected TypeElement testTypeElement; + + protected TypeMirror testTypeMirror; + + protected DeclaredType testDeclaredType; + + @BeforeEach + final void setUp() { + testInstanceHolder.set(this); + } + + @AfterEach + final void tearDown() { + testInstanceHolder.remove(); + } + + protected void addCompiledClasses(Set> compiledClasses) { + } + + protected void beforeTest() { + this.testClass = TestServiceImpl.class; + this.testClassName = TestServiceImpl.class.getName(); + this.elements = processingEnv.getElementUtils(); + this.testTypeElement = this.elements.getTypeElement(this.testClassName); + this.testTypeMirror = this.testTypeElement.asType(); + this.testDeclaredType = (DeclaredType) testTypeElement.asType(); + } + + protected void afterTest() { + } + +} \ No newline at end of file diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AnnotationProcessingTestProcessor.java b/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AnnotationProcessingTestProcessor.java new file mode 100644 index 000000000..51511cc5c --- /dev/null +++ b/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AnnotationProcessingTestProcessor.java @@ -0,0 +1,87 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.test.annotation.processing; + +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.InvocationInterceptor; +import org.junit.jupiter.api.extension.ReflectiveInvocationContext; + +import javax.annotation.processing.AbstractProcessor; +import javax.annotation.processing.RoundEnvironment; +import javax.annotation.processing.SupportedAnnotationTypes; +import javax.lang.model.SourceVersion; +import javax.lang.model.element.TypeElement; +import java.lang.reflect.Method; +import java.util.Set; + +import static io.microsphere.constants.SymbolConstants.WILDCARD; +import static javax.lang.model.SourceVersion.latestSupported; + +/** + * {@link AnnotationProcessingTestProcessor} + * + * @author Mercy + * @since 1.0.0 + */ +@SupportedAnnotationTypes(WILDCARD) +public class AnnotationProcessingTestProcessor extends AbstractProcessor { + + private final AbstractAnnotationProcessingTest abstractAnnotationProcessingTest; + + private final InvocationInterceptor.Invocation invocation; + + private final ReflectiveInvocationContext invocationContext; + + private final ExtensionContext extensionContext; + + public AnnotationProcessingTestProcessor(AbstractAnnotationProcessingTest abstractAnnotationProcessingTest, InvocationInterceptor.Invocation invocation, + ReflectiveInvocationContext invocationContext, + ExtensionContext extensionContext) { + this.abstractAnnotationProcessingTest = abstractAnnotationProcessingTest; + this.invocation = invocation; + this.invocationContext = invocationContext; + this.extensionContext = extensionContext; + } + + @Override + public boolean process(Set annotations, RoundEnvironment roundEnv) { + if (!roundEnv.processingOver()) { + prepare(roundEnv); + abstractAnnotationProcessingTest.beforeTest(); + try { + invocation.proceed(); + } catch (Throwable throwable) { + throw new RuntimeException(throwable); + } finally { + abstractAnnotationProcessingTest.afterTest(); + } + } + return false; + } + + protected void prepare(RoundEnvironment roundEnv) { + abstractAnnotationProcessingTest.roundEnv = roundEnv; + abstractAnnotationProcessingTest.processingEnv = super.processingEnv; + abstractAnnotationProcessingTest.elements = super.processingEnv.getElementUtils(); + abstractAnnotationProcessingTest.types = super.processingEnv.getTypeUtils(); + } + + @Override + public SourceVersion getSupportedSourceVersion() { + return latestSupported(); + } +} \ No newline at end of file diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/CompilerInvocationInterceptor.java b/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/CompilerInvocationInterceptor.java new file mode 100644 index 000000000..296ca9ac3 --- /dev/null +++ b/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/CompilerInvocationInterceptor.java @@ -0,0 +1,59 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.test.annotation.processing; + +import io.microsphere.jdk.tools.compiler.Compiler; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.InvocationInterceptor; +import org.junit.jupiter.api.extension.ReflectiveInvocationContext; + +import javax.annotation.processing.Processor; +import java.lang.reflect.Method; +import java.util.LinkedHashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Set; + +import static io.microsphere.test.annotation.processing.AbstractAnnotationProcessingTest.testInstanceHolder; +import static io.microsphere.util.ServiceLoaderUtils.loadServicesList; + + +/** + * {@link InvocationInterceptor} based on Java {@link Compiler} + * + * @author Mercy + * @since 1.0.0 + */ +public class CompilerInvocationInterceptor implements InvocationInterceptor { + + @Override + public void interceptTestMethod(Invocation invocation, + ReflectiveInvocationContext invocationContext, + ExtensionContext extensionContext) throws Throwable { + Set> compiledClasses = new LinkedHashSet<>(); + AbstractAnnotationProcessingTest abstractAnnotationProcessingTest = testInstanceHolder.get(); + Class testClass = extensionContext.getTestClass().get(); + compiledClasses.add(testClass); + abstractAnnotationProcessingTest.addCompiledClasses(compiledClasses); + Compiler compiler = new Compiler(); + compiler.sourcePaths(testClass); + List processors = new LinkedList<>(loadServicesList(Processor.class, testClass.getClassLoader())); + processors.add(new AnnotationProcessingTestProcessor(abstractAnnotationProcessingTest, invocation, invocationContext, extensionContext)); + compiler.processors(processors.toArray(new Processor[0])); + compiler.compile(compiledClasses.toArray(new Class[0])); + } +} \ No newline at end of file diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/model/Ancestor.java b/microsphere-java-test/src/main/java/io/microsphere/test/model/Ancestor.java new file mode 100644 index 000000000..cf0e07f70 --- /dev/null +++ b/microsphere-java-test/src/main/java/io/microsphere/test/model/Ancestor.java @@ -0,0 +1,38 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.test.model; + +import java.io.Serializable; + +/** + * Ancestor + * + * @author Mercy + * @since 1.0.0 + */ +public class Ancestor implements Serializable { + + private boolean z; + + public boolean isZ() { + return z; + } + + public void setZ(boolean z) { + this.z = z; + } +} \ No newline at end of file diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/model/ArrayTypeModel.java b/microsphere-java-test/src/main/java/io/microsphere/test/model/ArrayTypeModel.java new file mode 100644 index 000000000..d9588781e --- /dev/null +++ b/microsphere-java-test/src/main/java/io/microsphere/test/model/ArrayTypeModel.java @@ -0,0 +1,76 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.test.model; + +/** + * Array Type Model + * + * @author Mercy + * @since 1.0.0 + */ +public class ArrayTypeModel { + + private int[] integers; // Primitive type array + + private String[] strings; // Simple type array + + private PrimitiveTypeModel[] primitiveTypeModels; // Complex type array + + private Model[] models; // Hierarchical Complex type array + + private Color[] colors; // Enum type array + + public int[] getIntegers() { + return integers; + } + + public void setIntegers(int[] integers) { + this.integers = integers; + } + + public String[] getStrings() { + return strings; + } + + public void setStrings(String[] strings) { + this.strings = strings; + } + + public PrimitiveTypeModel[] getPrimitiveTypeModels() { + return primitiveTypeModels; + } + + public void setPrimitiveTypeModels(PrimitiveTypeModel[] primitiveTypeModels) { + this.primitiveTypeModels = primitiveTypeModels; + } + + public Model[] getModels() { + return models; + } + + public void setModels(Model[] models) { + this.models = models; + } + + public Color[] getColors() { + return colors; + } + + public void setColors(Color[] colors) { + this.colors = colors; + } +} \ No newline at end of file diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/model/CollectionTypeModel.java b/microsphere-java-test/src/main/java/io/microsphere/test/model/CollectionTypeModel.java new file mode 100644 index 000000000..414d65451 --- /dev/null +++ b/microsphere-java-test/src/main/java/io/microsphere/test/model/CollectionTypeModel.java @@ -0,0 +1,82 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.test.model; + +import java.util.Collection; +import java.util.Deque; +import java.util.List; +import java.util.Queue; +import java.util.Set; + +/** + * {@link Collection} Type Model + * + * @author Mercy + * @since 1.0.0 + */ +public class CollectionTypeModel { + + private Collection strings; // The composite element is simple type + + private List colors; // The composite element is Enum type + + private Queue primitiveTypeModels; // The composite element is POJO type + + private Deque models; // The composite element is hierarchical POJO type + + private Set modelArrays; // The composite element is hierarchical POJO type + + public Collection getStrings() { + return strings; + } + + public void setStrings(Collection strings) { + this.strings = strings; + } + + public List getColors() { + return colors; + } + + public void setColors(List colors) { + this.colors = colors; + } + + public Queue getPrimitiveTypeModels() { + return primitiveTypeModels; + } + + public void setPrimitiveTypeModels(Queue primitiveTypeModels) { + this.primitiveTypeModels = primitiveTypeModels; + } + + public Deque getModels() { + return models; + } + + public void setModels(Deque models) { + this.models = models; + } + + public Set getModelArrays() { + return modelArrays; + } + + public void setModelArrays(Set modelArrays) { + this.modelArrays = modelArrays; + } +} \ No newline at end of file diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/model/Color.java b/microsphere-java-test/src/main/java/io/microsphere/test/model/Color.java new file mode 100644 index 000000000..f362a8376 --- /dev/null +++ b/microsphere-java-test/src/main/java/io/microsphere/test/model/Color.java @@ -0,0 +1,47 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.test.model; + +/** + * Color enumeration + * + * @author Mercy + * @since 1.0.0 + */ +public enum Color { + + RED(1), + YELLOW(2), + BLUE(3); + + private final int value; + + Color(int value) { + this.value = value; + } + + @Override + public String toString() { + return "Color{" + + "value=" + value + + "} " + super.toString(); + } + + public int getValue() { + return value; + } +} \ No newline at end of file diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/model/ConfigurationPropertyModel.java b/microsphere-java-test/src/main/java/io/microsphere/test/model/ConfigurationPropertyModel.java new file mode 100644 index 000000000..a8e206bd0 --- /dev/null +++ b/microsphere-java-test/src/main/java/io/microsphere/test/model/ConfigurationPropertyModel.java @@ -0,0 +1,85 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.test.model; + +import io.microsphere.annotation.ConfigurationProperty; + +/** + * {@link ConfigurationProperty} Model + * + * @author Mercy + * @see ConfigurationProperty + * @since 1.0.0 + */ +public class ConfigurationPropertyModel { + + @ConfigurationProperty(name = "microsphere.annotation.processor.model.name") + private String name; + + @ConfigurationProperty(name = "microsphere.annotation.processor.model.type") + private Class type; + + @ConfigurationProperty(name = "microsphere.annotation.processor.model.default-value") + private String defaultValue; + + @ConfigurationProperty(name = "microsphere.annotation.processor.model.required") + private boolean required; + + @ConfigurationProperty(name = "microsphere.annotation.processor.model.description") + private String description; + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public Class getType() { + return type; + } + + public void setType(Class type) { + this.type = type; + } + + public String getDefaultValue() { + return defaultValue; + } + + public void setDefaultValue(String defaultValue) { + this.defaultValue = defaultValue; + } + + public boolean isRequired() { + return required; + } + + public void setRequired(boolean required) { + this.required = required; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } +} \ No newline at end of file diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/model/MapTypeModel.java b/microsphere-java-test/src/main/java/io/microsphere/test/model/MapTypeModel.java new file mode 100644 index 000000000..bf051c5b9 --- /dev/null +++ b/microsphere-java-test/src/main/java/io/microsphere/test/model/MapTypeModel.java @@ -0,0 +1,82 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.test.model; + +import java.util.HashMap; +import java.util.Map; +import java.util.NavigableMap; +import java.util.SortedMap; +import java.util.TreeMap; + +/** + * {@link Map} Type model + * + * @author Mercy + * @since 1.0.0 + */ +public class MapTypeModel { + + private Map strings; // The composite element is simple type + + private SortedMap colors; // The composite element is Enum type + + private NavigableMap primitiveTypeModels; // The composite element is POJO type + + private HashMap models; // The composite element is hierarchical POJO type + + private TreeMap modelArrays; // The composite element is hierarchical POJO type + + public Map getStrings() { + return strings; + } + + public void setStrings(Map strings) { + this.strings = strings; + } + + public SortedMap getColors() { + return colors; + } + + public void setColors(SortedMap colors) { + this.colors = colors; + } + + public NavigableMap getPrimitiveTypeModels() { + return primitiveTypeModels; + } + + public void setPrimitiveTypeModels(NavigableMap primitiveTypeModels) { + this.primitiveTypeModels = primitiveTypeModels; + } + + public HashMap getModels() { + return models; + } + + public void setModels(HashMap models) { + this.models = models; + } + + public TreeMap getModelArrays() { + return modelArrays; + } + + public void setModelArrays(TreeMap modelArrays) { + this.modelArrays = modelArrays; + } +} \ No newline at end of file diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/model/Model.java b/microsphere-java-test/src/main/java/io/microsphere/test/model/Model.java new file mode 100644 index 000000000..5d972f3c9 --- /dev/null +++ b/microsphere-java-test/src/main/java/io/microsphere/test/model/Model.java @@ -0,0 +1,90 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.test.model; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.concurrent.TimeUnit; + +/** + * Model Object + * + * @author Mercy + * @since 1.0.0 + */ +public class Model extends Parent { + + private float f; + + private double d; + + private TimeUnit tu; + + private String str; + + private BigInteger bi; + + private BigDecimal bd; + + public float getF() { + return f; + } + + public void setF(float f) { + this.f = f; + } + + public double getD() { + return d; + } + + public void setD(double d) { + this.d = d; + } + + public TimeUnit getTu() { + return tu; + } + + public void setTu(TimeUnit tu) { + this.tu = tu; + } + + public String getStr() { + return str; + } + + public void setStr(String str) { + this.str = str; + } + + public BigInteger getBi() { + return bi; + } + + public void setBi(BigInteger bi) { + this.bi = bi; + } + + public BigDecimal getBd() { + return bd; + } + + public void setBd(BigDecimal bd) { + this.bd = bd; + } +} \ No newline at end of file diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/model/Parent.java b/microsphere-java-test/src/main/java/io/microsphere/test/model/Parent.java new file mode 100644 index 000000000..f5e85fe1e --- /dev/null +++ b/microsphere-java-test/src/main/java/io/microsphere/test/model/Parent.java @@ -0,0 +1,66 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.test.model; + +/** + * Parent + * + * @author Mercy + * @since 1.0.0 + */ +public class Parent extends Ancestor { + + private byte b; + + private short s; + + private int i; + + private long l; + + public byte getB() { + return b; + } + + public void setB(byte b) { + this.b = b; + } + + public short getS() { + return s; + } + + public void setS(short s) { + this.s = s; + } + + public int getI() { + return i; + } + + public void setI(int i) { + this.i = i; + } + + public long getL() { + return l; + } + + public void setL(long l) { + this.l = l; + } +} \ No newline at end of file diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/model/PrimitiveTypeModel.java b/microsphere-java-test/src/main/java/io/microsphere/test/model/PrimitiveTypeModel.java new file mode 100644 index 000000000..5a1065fc7 --- /dev/null +++ b/microsphere-java-test/src/main/java/io/microsphere/test/model/PrimitiveTypeModel.java @@ -0,0 +1,74 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.test.model; + +/** + * Primitive Type model + * + * @author Mercy + * @since 1.0.0 + */ +public class PrimitiveTypeModel { + + private boolean z; + + private byte b; + + private char c; + + private short s; + + private int i; + + private long l; + + private float f; + + private double d; + + public boolean isZ() { + return z; + } + + public byte getB() { + return b; + } + + public char getC() { + return c; + } + + public short getS() { + return s; + } + + public int getI() { + return i; + } + + public long getL() { + return l; + } + + public float getF() { + return f; + } + + public double getD() { + return d; + } +} \ No newline at end of file diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/model/SimpleTypeModel.java b/microsphere-java-test/src/main/java/io/microsphere/test/model/SimpleTypeModel.java new file mode 100644 index 000000000..86a8b6b8b --- /dev/null +++ b/microsphere-java-test/src/main/java/io/microsphere/test/model/SimpleTypeModel.java @@ -0,0 +1,162 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License; Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing; software + * distributed under the License is distributed on an "AS IS" BASIS; + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND; either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.test.model; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.Date; + +/** + * Simple Type model + * + * @author Mercy + * @since 1.0.0 + */ +public class SimpleTypeModel { + + private Void v; + + private Boolean z; + + private Character c; + + private Byte b; + + private Short s; + + private Integer i; + + private Long l; + + private Float f; + + private Double d; + + private String str; + + private BigDecimal bd; + + private BigInteger bi; + + private Date dt; + + private int invalid; + + public Void getV() { + return v; + } + + public void setV(Void v) { + this.v = v; + } + + public Boolean getZ() { + return z; + } + + public void setZ(Boolean z) { + this.z = z; + } + + public Character getC() { + return c; + } + + public void setC(Character c) { + this.c = c; + } + + public Byte getB() { + return b; + } + + public void setB(Byte b) { + this.b = b; + } + + public Short getS() { + return s; + } + + public void setS(Short s) { + this.s = s; + } + + public Integer getI() { + return i; + } + + public void setI(Integer i) { + this.i = i; + } + + public Long getL() { + return l; + } + + public void setL(Long l) { + this.l = l; + } + + public Float getF() { + return f; + } + + public void setF(Float f) { + this.f = f; + } + + public Double getD() { + return d; + } + + public void setD(Double d) { + this.d = d; + } + + public String getStr() { + return str; + } + + public void setStr(String str) { + this.str = str; + } + + public BigDecimal getBd() { + return bd; + } + + public void setBd(BigDecimal bd) { + this.bd = bd; + } + + public BigInteger getBi() { + return bi; + } + + public void setBi(BigInteger bi) { + this.bi = bi; + } + + public Date getDt() { + return dt; + } + + public void setDt(Date dt) { + this.dt = dt; + } +} \ No newline at end of file diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/model/StringArrayList.java b/microsphere-java-test/src/main/java/io/microsphere/test/model/StringArrayList.java new file mode 100644 index 000000000..e7c115a09 --- /dev/null +++ b/microsphere-java-test/src/main/java/io/microsphere/test/model/StringArrayList.java @@ -0,0 +1,30 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.test.model; + +import java.util.ArrayList; + +/** + * String type {@link ArrayList} + * + * @author Mercy + * @see ArrayList + * @since 1.0.0 + */ +public class StringArrayList extends ArrayList { +} \ No newline at end of file diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/service/DefaultTestService.java b/microsphere-java-test/src/main/java/io/microsphere/test/service/DefaultTestService.java new file mode 100644 index 000000000..4ca1d694b --- /dev/null +++ b/microsphere-java-test/src/main/java/io/microsphere/test/service/DefaultTestService.java @@ -0,0 +1,58 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.test.service; + + +import io.microsphere.test.model.Model; + +import java.util.concurrent.TimeUnit; + +/** + * {@link TestService} Implementation + * + * @author Mercy + * @since 1.0.0 + */ +public class DefaultTestService implements TestService { + + private String name; + + @Override + public String echo(String message) { + return "[ECHO] " + message; + } + + @Override + public Model model(Model model) { + return model; + } + + @Override + public String testPrimitive(boolean z, int i) { + return null; + } + + @Override + public Model testEnum(TimeUnit timeUnit) { + return null; + } + + @Override + public String testArray(String[] strArray, int[] intArray, Model[] modelArray) { + return null; + } +} diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/service/GenericTestService.java b/microsphere-java-test/src/main/java/io/microsphere/test/service/GenericTestService.java new file mode 100644 index 000000000..d4a81a787 --- /dev/null +++ b/microsphere-java-test/src/main/java/io/microsphere/test/service/GenericTestService.java @@ -0,0 +1,33 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.test.service; + + +import java.util.EventListener; + +/** + * {@link TestService} Implementation + * + * @author Mercy + * @since 1.0.0 + */ +public class GenericTestService extends DefaultTestService implements TestService, EventListener { + @Override + public String echo(String message) { + return "[ECHO] " + message; + } +} \ No newline at end of file diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/service/TestService.java b/microsphere-java-test/src/main/java/io/microsphere/test/service/TestService.java new file mode 100644 index 000000000..22839bc80 --- /dev/null +++ b/microsphere-java-test/src/main/java/io/microsphere/test/service/TestService.java @@ -0,0 +1,56 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.test.service; + + +import io.microsphere.test.model.Model; + +import javax.ws.rs.DefaultValue; +import javax.ws.rs.GET; +import javax.ws.rs.POST; +import javax.ws.rs.PUT; +import javax.ws.rs.Path; +import javax.ws.rs.PathParam; +import java.util.concurrent.TimeUnit; + +/** + * Test Service + * + * @author Mercy + * @since 1.0.0 + */ +@Path("/echo") +public interface TestService { + + @GET + String echo(@PathParam("message") @DefaultValue("mercyblitz") String message); + + @POST + Model model(@PathParam("model") Model model); + + // Test primitive + @PUT + String testPrimitive(boolean z, int i); + + // Test enumeration + @PUT + Model testEnum(TimeUnit timeUnit); + + // Test Array + @GET + String testArray(String[] strArray, int[] intArray, Model[] modelArray); +} diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/service/TestServiceImpl.java b/microsphere-java-test/src/main/java/io/microsphere/test/service/TestServiceImpl.java new file mode 100644 index 000000000..a97658884 --- /dev/null +++ b/microsphere-java-test/src/main/java/io/microsphere/test/service/TestServiceImpl.java @@ -0,0 +1,101 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.test.service; + +import io.microsphere.annotation.ConfigurationProperty; +import io.microsphere.annotation.Since; +import io.microsphere.test.annotation.TestAnnotation; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.cache.annotation.Cacheable; +import org.springframework.context.ApplicationContext; +import org.springframework.context.annotation.ComponentScan; +import org.springframework.context.annotation.ComponentScans; +import org.springframework.core.env.Environment; +import org.springframework.stereotype.Service; + +import javax.xml.ws.ServiceMode; +import java.io.Serializable; + +import static java.util.concurrent.TimeUnit.HOURS; +import static org.springframework.context.annotation.FilterType.ASPECTJ; +import static org.springframework.context.annotation.ScopedProxyMode.INTERFACES; + +/** + * @author Mercy + * @since 1.0.0 + */ +@Service("testService") +@ServiceMode +@ComponentScans(value = { + @ComponentScan( + basePackages = "io.microsphere.annotation.processor.model", + scopedProxy = INTERFACES + ), + @ComponentScan( + basePackages = "io.microsphere.annotation.processor.util", + includeFilters = { + @ComponentScan.Filter( + type = ASPECTJ, + classes = {Object.class, CharSequence.class} + ) + }) +}) +@TestAnnotation( + z = true, + c = 'b', + b = 1, + s = 1, + i = 1, + l = 1, + f = 1, + d = 1, + string = "testService", + type = GenericTestService.class, + types = {TestService.class, AutoCloseable.class, Serializable.class}, + timeUnit = HOURS, + since = @Since("1.0.0"), + properties = { + @ConfigurationProperty(name = "key", type = String.class, defaultValue = "default-value", required = true, description = "description"), + @ConfigurationProperty(name = "key2", type = Integer.class, defaultValue = "default-value2", required = true, description = "description2"), + @ConfigurationProperty(name = "key3", type = Class.class, defaultValue = "default-value3", required = true, description = "description3") + } +) +public class TestServiceImpl extends GenericTestService implements TestService, AutoCloseable, Serializable { + + @Autowired + ApplicationContext context; + + Environment environment; + + public TestServiceImpl() { + this(null); + } + + public TestServiceImpl(@Autowired Environment environment) { + this.environment = environment; + } + + @Override + @Cacheable(cacheNames = {"cache-1", "cache-2"}) + public String echo(String message) { + return "[ECHO] " + message; + } + + @Override + public void close() throws Exception { + } +} diff --git a/microsphere-java-test/src/main/resources/logback-test.xml b/microsphere-java-test/src/main/resources/logback-test.xml new file mode 100644 index 000000000..e3375b74c --- /dev/null +++ b/microsphere-java-test/src/main/resources/logback-test.xml @@ -0,0 +1,15 @@ + + + + + + + ${ENCODER_PATTERN} + + + + + + + + \ No newline at end of file diff --git a/microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/AnnotationProcessingTest.java b/microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/AnnotationProcessingTest.java new file mode 100644 index 000000000..935b1e5f5 --- /dev/null +++ b/microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/AnnotationProcessingTest.java @@ -0,0 +1,71 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.test.annotation.processing; + +import org.junit.jupiter.api.Test; + +import javax.lang.model.element.Element; +import javax.lang.model.type.TypeMirror; +import java.lang.reflect.Type; +import java.util.Collection; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; + +/** + * {@link AbstractAnnotationProcessingTest} Test + * + * @author Mercy + * @see AbstractAnnotationProcessingTest + * @since 1.0.0 + */ +public class AnnotationProcessingTest extends AbstractAnnotationProcessingTest { + + @Test + void test() { + assertNull(NULL_TYPE_MIRROR); + assertArrayEquals(new TypeMirror[0], EMPTY_TYPE_MIRROR_ARRAY); + assertNull(NULL_TYPE_MIRROR_ARRAY); + assertArrayEquals(new Collection[0], EMPTY_COLLECTION_ARRAY); + assertNull(NULL_COLLECTION); + assertNull(NULL_LIST); + assertNull(NULL_ELEMENT); + assertNull(NULL_ELEMENT_KIND); + assertArrayEquals(new Element[0], EMPTY_ELEMENT_ARRAY); + assertNull(NULL_ELEMENT_ARRAY); + assertNull(NULL_TYPE_ELEMENT); + assertNull(NULL_TYPE_ARRAY); + assertArrayEquals(new Type[0], EMPTY_TYPE_ARRAY); + assertNull(NULL_TYPE); + assertNull(NULL_PROCESSING_ENVIRONMENT); + assertNull(NULL_STRING); + assertNull(NULL_STRING_ARRAY); + assertNull(NULL_CLASS); + assertNull(NULL_CLASS_ARRAY); + assertNull(NULL_ANNOTATED_CONSTRUCT); + assertNull(NULL_PREDICATE_ARRAY); + assertNull(NULL_FIELD); + assertNull(NULL_MODIFIER); + assertNull(NULL_MODIFIER_ARRAY); + assertNull(NULL_METHOD); + assertNull(NULL_METHOD_ARRAY); + assertNull(NULL_ANNOTATION_MIRROR); + assertNotNull(testInstanceHolder); + } +} diff --git a/microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/TestProcessor.java b/microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/TestProcessor.java new file mode 100644 index 000000000..e1ad024a5 --- /dev/null +++ b/microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/TestProcessor.java @@ -0,0 +1,48 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.test.annotation.processing; + +import javax.annotation.processing.AbstractProcessor; +import javax.annotation.processing.Processor; +import javax.annotation.processing.RoundEnvironment; +import javax.annotation.processing.SupportedAnnotationTypes; +import javax.lang.model.SourceVersion; +import javax.lang.model.element.TypeElement; +import java.util.Set; + +import static javax.lang.model.SourceVersion.latestSupported; + +/** + * Test {@link Processor} + * + * @author Mercy + * @see Processor + * @since 1.0.0 + */ +@SupportedAnnotationTypes("*") +public class TestProcessor extends AbstractProcessor { + @Override + public boolean process(Set annotations, RoundEnvironment roundEnv) { + return true; + } + + @Override + public SourceVersion getSupportedSourceVersion() { + return latestSupported(); + } +} \ No newline at end of file diff --git a/microsphere-java-test/src/test/java/io/microsphere/test/model/AncestorTest.java b/microsphere-java-test/src/test/java/io/microsphere/test/model/AncestorTest.java new file mode 100644 index 000000000..b96c57b36 --- /dev/null +++ b/microsphere-java-test/src/test/java/io/microsphere/test/model/AncestorTest.java @@ -0,0 +1,81 @@ +package io.microsphere.test.model; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * Unit tests for the Ancestor class + */ +class AncestorTest { + + private Ancestor ancestor; + + @BeforeEach + void setUp() { + ancestor = new Ancestor(); + } + + @Test + void testDefaultConstructor() { + // Verify that the default value of z is false + assertFalse(ancestor.isZ(), "Default value of z should be false"); + } + + @Test + void testSetZTrue() { + // Set z to true and verify + ancestor.setZ(true); + assertTrue(ancestor.isZ(), "Value of z should be true after setting it to true"); + } + + @Test + void testSetZFalse() { + // Explicitly set z to false and verify + ancestor.setZ(false); + assertFalse(ancestor.isZ(), "Value of z should be false after setting it to false"); + } + + @Test + void testSetZToggle() { + // Test toggling the value from default false to true and back to false + assertFalse(ancestor.isZ(), "Initial value should be false"); + + ancestor.setZ(true); + assertTrue(ancestor.isZ(), "Value should be true after first toggle"); + + ancestor.setZ(false); + assertFalse(ancestor.isZ(), "Value should be false after second toggle"); + } + + @Test + void testMultipleInstanceIndependence() { + // Create two instances and verify they maintain independent state + Ancestor ancestor1 = new Ancestor(); + Ancestor ancestor2 = new Ancestor(); + + // Initially both should have false + assertFalse(ancestor1.isZ(), "First instance should initially be false"); + assertFalse(ancestor2.isZ(), "Second instance should initially be false"); + + // Modify only the first instance + ancestor1.setZ(true); + + // Verify that only the first instance changed + assertTrue(ancestor1.isZ(), "First instance should be true after modification"); + assertFalse(ancestor2.isZ(), "Second instance should remain false"); + } + + @Test + void testSerializableImplementation() { + // Test that the class can be instantiated and used as a Serializable object + // This test verifies basic functionality without actual serialization + ancestor.setZ(true); + assertTrue(ancestor.isZ(), "Should properly handle boolean value when used as Serializable"); + + ancestor.setZ(false); + assertFalse(ancestor.isZ(), "Should properly handle boolean value when used as Serializable"); + } +} diff --git a/microsphere-java-test/src/test/java/io/microsphere/test/model/ArrayTypeModelTest.java b/microsphere-java-test/src/test/java/io/microsphere/test/model/ArrayTypeModelTest.java new file mode 100644 index 000000000..ebf9644af --- /dev/null +++ b/microsphere-java-test/src/test/java/io/microsphere/test/model/ArrayTypeModelTest.java @@ -0,0 +1,122 @@ +package io.microsphere.test.model; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static io.microsphere.test.model.Color.BLUE; +import static io.microsphere.test.model.Color.RED; +import static io.microsphere.test.model.Color.YELLOW; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; + +/** + * Unit tests for the ArrayTypeModel class + */ +class ArrayTypeModelTest { + + private ArrayTypeModel model; + + @BeforeEach + void setUp() { + model = new ArrayTypeModel(); + } + + @Test + void testDefaultValues() { + // Verify all array fields are null by default + assertNull(model.getIntegers(), "integers array should be null by default"); + assertNull(model.getStrings(), "strings array should be null by default"); + assertNull(model.getPrimitiveTypeModels(), "primitiveTypeModels array should be null by default"); + assertNull(model.getModels(), "models array should be null by default"); + assertNull(model.getColors(), "colors array should be null by default"); + } + + @Test + void testSetGetIntegers() { + int[] testArray = {1, 2, 3, 4, 5}; + + model.setIntegers(testArray); + assertSame(testArray, model.getIntegers(), "Should return the same array reference that was set"); + + // Verify the contents match + assertArrayEquals(testArray, model.getIntegers(), "Array contents should match the set value"); + } + + @Test + void testSetGetStrings() { + String[] testArray = {"hello", "world", "test"}; + + model.setStrings(testArray); + assertSame(testArray, model.getStrings(), "Should return the same array reference that was set"); + + // Verify the contents match + assertArrayEquals(testArray, model.getStrings(), "Array contents should match the set value"); + } + + @Test + void testSetGetPrimitiveTypeModels() { + PrimitiveTypeModel[] testArray = {new PrimitiveTypeModel(), new PrimitiveTypeModel()}; + + model.setPrimitiveTypeModels(testArray); + assertSame(testArray, model.getPrimitiveTypeModels(), "Should return the same array reference that was set"); + + // Verify the contents match + assertArrayEquals(testArray, model.getPrimitiveTypeModels(), "Array contents should match the set value"); + } + + @Test + void testSetGetModels() { + Model[] testArray = {new Model(), new Model()}; + + model.setModels(testArray); + assertSame(testArray, model.getModels(), "Should return the same array reference that was set"); + + // Verify the contents match + assertArrayEquals(testArray, model.getModels(), "Array contents should match the set value"); + } + + @Test + void testSetGetColors() { + Color[] testArray = {RED, BLUE, YELLOW}; + + model.setColors(testArray); + assertSame(testArray, model.getColors(), "Should return the same array reference that was set"); + + // Verify the contents match + assertArrayEquals(testArray, model.getColors(), "Array contents should match the set value"); + } + + @Test + void testSetNullValues() { + // Test setting each field to null + model.setIntegers(null); + assertNull(model.getIntegers(), "integers should be null after setting to null"); + + model.setStrings(null); + assertNull(model.getStrings(), "strings should be null after setting to null"); + + model.setPrimitiveTypeModels(null); + assertNull(model.getPrimitiveTypeModels(), "primitiveTypeModels should be null after setting to null"); + + model.setModels(null); + assertNull(model.getModels(), "models should be null after setting to null"); + + model.setColors(null); + assertNull(model.getColors(), "colors should be null after setting to null"); + } + + @Test + void testArrayMutability() { + int[] originalArray = {1, 2, 3}; + model.setIntegers(originalArray); + + // Modify the original array + originalArray[0] = 999; + + // Check if the change is reflected in the getter result + assertEquals(999, model.getIntegers()[0], + "Changes to the original array should be reflected since arrays are passed by reference"); + } +} \ No newline at end of file diff --git a/microsphere-java-test/src/test/java/io/microsphere/test/model/CollectionTypeModelTest.java b/microsphere-java-test/src/test/java/io/microsphere/test/model/CollectionTypeModelTest.java new file mode 100644 index 000000000..af3ae9098 --- /dev/null +++ b/microsphere-java-test/src/test/java/io/microsphere/test/model/CollectionTypeModelTest.java @@ -0,0 +1,138 @@ +package io.microsphere.test.model; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Deque; +import java.util.HashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Queue; +import java.util.Set; + +import static io.microsphere.test.model.Color.BLUE; +import static io.microsphere.test.model.Color.RED; +import static io.microsphere.test.model.Color.YELLOW; +import static java.util.Arrays.asList; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * Unit tests for the CollectionTypeModel class + */ +class CollectionTypeModelTest { + + private CollectionTypeModel model; + + @BeforeEach + void setUp() { + model = new CollectionTypeModel(); + } + + @Test + void testDefaultValues() { + // Verify all collection fields are null by default + assertNull(model.getStrings(), "strings collection should be null by default"); + assertNull(model.getColors(), "colors list should be null by default"); + assertNull(model.getPrimitiveTypeModels(), "primitiveTypeModels queue should be null by default"); + assertNull(model.getModels(), "models deque should be null by default"); + assertNull(model.getModelArrays(), "modelArrays set should be null by default"); + } + + @Test + void testSetGetStrings() { + Collection testCollection = asList("hello", "world", "test"); + + model.setStrings(testCollection); + assertSame(testCollection, model.getStrings(), "Should return the same collection reference that was set"); + + // Verify the contents match + assertEquals(testCollection, model.getStrings(), "Collection contents should match the set value"); + } + + @Test + void testSetGetColors() { + List testList = asList(RED, BLUE, YELLOW); + + model.setColors(testList); + assertSame(testList, model.getColors(), "Should return the same list reference that was set"); + + // Verify the contents match + assertEquals(testList, model.getColors(), "List contents should match the set value"); + } + + @Test + void testSetGetPrimitiveTypeModels() { + Queue testQueue = new LinkedList<>(); + testQueue.add(new PrimitiveTypeModel()); + testQueue.add(new PrimitiveTypeModel()); + + model.setPrimitiveTypeModels(testQueue); + assertSame(testQueue, model.getPrimitiveTypeModels(), "Should return the same queue reference that was set"); + + // Verify the contents match + assertEquals(testQueue, model.getPrimitiveTypeModels(), "Queue contents should match the set value"); + } + + @Test + void testSetGetModels() { + Deque testDeque = new LinkedList<>(); + testDeque.add(new Model()); + testDeque.add(new Model()); + + model.setModels(testDeque); + assertSame(testDeque, model.getModels(), "Should return the same deque reference that was set"); + + // Verify the contents match + assertEquals(testDeque, model.getModels(), "Deque contents should match the set value"); + } + + @Test + void testSetGetModelArrays() { + Set testSet = new HashSet<>(); + testSet.add(new Model[]{new Model(), new Model()}); + testSet.add(new Model[]{new Model()}); + + model.setModelArrays(testSet); + assertSame(testSet, model.getModelArrays(), "Should return the same set reference that was set"); + + // Verify the contents match + assertEquals(testSet, model.getModelArrays(), "Set contents should match the set value"); + } + + @Test + void testSetNullValues() { + // Test setting each field to null + model.setStrings(null); + assertNull(model.getStrings(), "strings should be null after setting to null"); + + model.setColors(null); + assertNull(model.getColors(), "colors should be null after setting to null"); + + model.setPrimitiveTypeModels(null); + assertNull(model.getPrimitiveTypeModels(), "primitiveTypeModels should be null after setting to null"); + + model.setModels(null); + assertNull(model.getModels(), "models should be null after setting to null"); + + model.setModelArrays(null); + assertNull(model.getModelArrays(), "modelArrays should be null after setting to null"); + } + + @Test + void testCollectionMutability() { + List originalList = new ArrayList<>(asList(RED, BLUE)); + model.setColors(originalList); + + // Modify the original collection + originalList.add(RED); + + // Check if the change is reflected in the getter result + assertTrue(model.getColors().contains(RED), + "Changes to the original collection should be reflected since collections are passed by reference"); + } +} diff --git a/microsphere-java-test/src/test/java/io/microsphere/test/model/ColorTest.java b/microsphere-java-test/src/test/java/io/microsphere/test/model/ColorTest.java new file mode 100644 index 000000000..9f8f0cfde --- /dev/null +++ b/microsphere-java-test/src/test/java/io/microsphere/test/model/ColorTest.java @@ -0,0 +1,103 @@ +package io.microsphere.test.model; + +import org.junit.jupiter.api.Test; + +import static io.microsphere.test.model.Color.BLUE; +import static io.microsphere.test.model.Color.RED; +import static io.microsphere.test.model.Color.YELLOW; +import static java.util.Arrays.asList; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * Unit tests for the Color enum + */ +class ColorTest { + + @Test + void testEnumValues() { + // Verify that all enum constants exist and are accessible + assertNotNull(RED, "RED color should exist"); + assertNotNull(YELLOW, "YELLOW color should exist"); + assertNotNull(BLUE, "BLUE color should exist"); + } + + @Test + void testGetValueMethod() { + // Verify the value associated with each color + assertEquals(1, RED.getValue(), "RED should have value 1"); + assertEquals(2, YELLOW.getValue(), "YELLOW should have value 2"); + assertEquals(3, BLUE.getValue(), "BLUE should have value 3"); + } + + @Test + void testToStringMethod() { + // Verify the string representation of each color + String redString = RED.toString(); + assertTrue(redString.contains("Color{value=1}"), "RED toString should contain value=1"); + assertTrue(redString.endsWith("RED"), "RED toString should end with RED"); + + String yellowString = YELLOW.toString(); + assertTrue(yellowString.contains("Color{value=2}"), "YELLOW toString should contain value=2"); + assertTrue(yellowString.endsWith("YELLOW"), "YELLOW toString should end with YELLOW"); + + String blueString = BLUE.toString(); + assertTrue(blueString.contains("Color{value=3}"), "BLUE toString should contain value=3"); + assertTrue(blueString.endsWith("BLUE"), "BLUE toString should end with BLUE"); + } + + @Test + void testEnumOrdinality() { + // Verify that enum constants have expected ordinal positions + assertEquals(0, RED.ordinal(), "RED should be at ordinal position 0"); + assertEquals(1, YELLOW.ordinal(), "YELLOW should be at ordinal position 1"); + assertEquals(2, BLUE.ordinal(), "BLUE should be at ordinal position 2"); + } + + @Test + void testEnumName() { + // Verify that enum constants have correct names + assertEquals("RED", RED.name(), "RED name should be 'RED'"); + assertEquals("YELLOW", YELLOW.name(), "YELLOW name should be 'YELLOW'"); + assertEquals("BLUE", BLUE.name(), "BLUE name should be 'BLUE'"); + } + + @Test + void testEnumEquality() { + // Verify that enum equality works correctly + assertEquals(RED, RED, "RED should equal itself"); + assertEquals(YELLOW, YELLOW, "YELLOW should equal itself"); + assertEquals(BLUE, BLUE, "BLUE should equal itself"); + + assertNotEquals(RED, BLUE, "RED should not equal BLUE"); + assertNotEquals(RED, YELLOW, "RED should not equal YELLOW"); + assertNotEquals(BLUE, YELLOW, "BLUE should not equal YELLOW"); + } + + @Test + void testValueImmutability() { + // Verify that the value cannot be changed (as it's final) + int redValue = RED.getValue(); + int yellowValue = YELLOW.getValue(); + int blueValue = BLUE.getValue(); + + // Values should remain constant across multiple calls + assertEquals(redValue, RED.getValue(), "RED value should be immutable"); + assertEquals(yellowValue, YELLOW.getValue(), "YELLOW value should be immutable"); + assertEquals(blueValue, BLUE.getValue(), "BLUE value should be immutable"); + } + + @Test + void testAllEnumConstantsExist() { + // Verify that we can retrieve all enum constants + Color[] allColors = Color.values(); + assertEquals(3, allColors.length, "There should be exactly 3 color constants"); + + // Verify that all expected colors are present + assertTrue(asList(allColors).contains(RED), "All colors should include RED"); + assertTrue(asList(allColors).contains(YELLOW), "All colors should include YELLOW"); + assertTrue(asList(allColors).contains(BLUE), "All colors should include BLUE"); + } +} diff --git a/microsphere-java-test/src/test/java/io/microsphere/test/model/ConfigurationPropertyModelTest.java b/microsphere-java-test/src/test/java/io/microsphere/test/model/ConfigurationPropertyModelTest.java new file mode 100644 index 000000000..4218d3d43 --- /dev/null +++ b/microsphere-java-test/src/test/java/io/microsphere/test/model/ConfigurationPropertyModelTest.java @@ -0,0 +1,152 @@ +package io.microsphere.test.model; + +import io.microsphere.annotation.ConfigurationProperty; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * Unit tests for the ConfigurationPropertyModel class + */ +class ConfigurationPropertyModelTest { + + private ConfigurationPropertyModel model; + + @BeforeEach + void setUp() { + model = new ConfigurationPropertyModel(); + } + + @Test + void testDefaultValues() { + // Verify all fields have their default values + assertNull(model.getName(), "name should be null by default"); + assertNull(model.getType(), "type should be null by default"); + assertNull(model.getDefaultValue(), "defaultValue should be null by default"); + assertFalse(model.isRequired(), "required should be false by default"); + assertNull(model.getDescription(), "description should be null by default"); + } + + @Test + void testSetNameAndGet() { + String testName = "test.config.property"; + model.setName(testName); + assertEquals(testName, model.getName(), "getName should return the set value"); + } + + @Test + void testSetTypeAndGet() { + Class testType = String.class; + model.setType(testType); + assertEquals(testType, model.getType(), "getType should return the set value"); + } + + @Test + void testSetDefaultValueAndGet() { + String testDefaultValue = "default_value"; + model.setDefaultValue(testDefaultValue); + assertEquals(testDefaultValue, model.getDefaultValue(), "getDefaultValue should return the set value"); + } + + @Test + void testSetRequiredAndGet() { + model.setRequired(true); + assertTrue(model.isRequired(), "isRequired should return true after setting to true"); + + model.setRequired(false); + assertFalse(model.isRequired(), "isRequired should return false after setting to false"); + } + + @Test + void testSetDescriptionAndGet() { + String testDescription = "This is a test configuration property"; + model.setDescription(testDescription); + assertEquals(testDescription, model.getDescription(), "getDescription should return the set value"); + } + + @Test + void testConfigurationPropertyAnnotations() { + // Test that the ConfigurationProperty annotations are present on the fields + java.lang.reflect.Field[] fields = ConfigurationPropertyModel.class.getDeclaredFields(); + + boolean hasNameAnnotation = false; + boolean hasTypeAnnotation = false; + boolean hasDefaultValueAnnotation = false; + boolean hasRequiredAnnotation = false; + boolean hasDescriptionAnnotation = false; + + for (java.lang.reflect.Field field : fields) { + if (field.isAnnotationPresent(ConfigurationProperty.class)) { + ConfigurationProperty annotation = field.getAnnotation(ConfigurationProperty.class); + + switch (field.getName()) { + case "name": + if ("microsphere.annotation.processor.model.name".equals(annotation.name())) { + hasNameAnnotation = true; + } + break; + case "type": + if ("microsphere.annotation.processor.model.type".equals(annotation.name())) { + hasTypeAnnotation = true; + } + break; + case "defaultValue": + if ("microsphere.annotation.processor.model.default-value".equals(annotation.name())) { + hasDefaultValueAnnotation = true; + } + break; + case "required": + if ("microsphere.annotation.processor.model.required".equals(annotation.name())) { + hasRequiredAnnotation = true; + } + break; + case "description": + if ("microsphere.annotation.processor.model.description".equals(annotation.name())) { + hasDescriptionAnnotation = true; + } + break; + } + } + } + + assertTrue(hasNameAnnotation, "name field should have ConfigurationProperty annotation with correct name"); + assertTrue(hasTypeAnnotation, "type field should have ConfigurationProperty annotation with correct name"); + assertTrue(hasDefaultValueAnnotation, "defaultValue field should have ConfigurationProperty annotation with correct name"); + assertTrue(hasRequiredAnnotation, "required field should have ConfigurationProperty annotation with correct name"); + assertTrue(hasDescriptionAnnotation, "description field should have ConfigurationProperty annotation with correct name"); + } + + @Test + void testSetAllProperties() { + // Test setting all properties and verifying they are returned correctly + model.setName("full.test.name"); + model.setType(Integer.class); + model.setDefaultValue("42"); + model.setRequired(true); + model.setDescription("Complete test configuration"); + + assertEquals("full.test.name", model.getName(), "Name should match set value"); + assertEquals(Integer.class, model.getType(), "Type should match set value"); + assertEquals("42", model.getDefaultValue(), "DefaultValue should match set value"); + assertTrue(model.isRequired(), "Required should match set value"); + assertEquals("Complete test configuration", model.getDescription(), "Description should match set value"); + } + + @Test + void testNullValueHandling() { + // Test setting fields to null + model.setName(null); + model.setType(null); + model.setDefaultValue(null); + model.setDescription(null); + + assertNull(model.getName(), "Name should be null"); + assertNull(model.getType(), "Type should be null"); + assertNull(model.getDefaultValue(), "DefaultValue should be null"); + assertNull(model.getDescription(), "Description should be null"); + } +} diff --git a/microsphere-java-test/src/test/java/io/microsphere/test/model/MapTypeModelTest.java b/microsphere-java-test/src/test/java/io/microsphere/test/model/MapTypeModelTest.java new file mode 100644 index 000000000..9640d802c --- /dev/null +++ b/microsphere-java-test/src/test/java/io/microsphere/test/model/MapTypeModelTest.java @@ -0,0 +1,138 @@ +package io.microsphere.test.model; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.HashMap; +import java.util.Map; +import java.util.NavigableMap; +import java.util.SortedMap; +import java.util.TreeMap; + +import static io.microsphere.test.model.Color.BLUE; +import static io.microsphere.test.model.Color.RED; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * Unit tests for the MapTypeModel class + */ +class MapTypeModelTest { + + private MapTypeModel model; + + @BeforeEach + void setUp() { + model = new MapTypeModel(); + } + + @Test + void testDefaultValues() { + // Verify all map fields are null by default + assertNull(model.getStrings(), "strings map should be null by default"); + assertNull(model.getColors(), "colors sorted map should be null by default"); + assertNull(model.getPrimitiveTypeModels(), "primitiveTypeModels navigable map should be null by default"); + assertNull(model.getModels(), "models hash map should be null by default"); + assertNull(model.getModelArrays(), "modelArrays tree map should be null by default"); + } + + @Test + void testSetGetStrings() { + Map testMap = new HashMap<>(); + testMap.put("key1", "value1"); + testMap.put("key2", "value2"); + + model.setStrings(testMap); + assertSame(testMap, model.getStrings(), "Should return the same map reference that was set"); + + // Verify the contents match + assertEquals(testMap, model.getStrings(), "Map contents should match the set value"); + } + + @Test + void testSetGetColors() { + SortedMap testMap = new TreeMap<>(); + testMap.put("red_key", RED); + testMap.put("blue_key", BLUE); + + model.setColors(testMap); + assertSame(testMap, model.getColors(), "Should return the same map reference that was set"); + + // Verify the contents match + assertEquals(testMap, model.getColors(), "SortedMap contents should match the set value"); + } + + @Test + void testSetGetPrimitiveTypeModels() { + NavigableMap testMap = new TreeMap<>(); + testMap.put(RED, new PrimitiveTypeModel()); + testMap.put(BLUE, new PrimitiveTypeModel()); + + model.setPrimitiveTypeModels(testMap); + assertSame(testMap, model.getPrimitiveTypeModels(), "Should return the same map reference that was set"); + + // Verify the contents match + assertEquals(testMap, model.getPrimitiveTypeModels(), "NavigableMap contents should match the set value"); + } + + @Test + void testSetGetModels() { + HashMap testMap = new HashMap<>(); + testMap.put("model1", new Model()); + testMap.put("model2", new Model()); + + model.setModels(testMap); + assertSame(testMap, model.getModels(), "Should return the same map reference that was set"); + + // Verify the contents match + assertEquals(testMap, model.getModels(), "HashMap contents should match the set value"); + } + + @Test + void testSetGetModelArrays() { + TreeMap testMap = new TreeMap<>((a, b) -> 1); // Using custom comparator to avoid issues with PrimitiveTypeModel not implementing Comparable + testMap.put(new PrimitiveTypeModel(), new Model[]{new Model()}); + testMap.put(new PrimitiveTypeModel(), new Model[]{new Model(), new Model()}); + + model.setModelArrays(testMap); + assertSame(testMap, model.getModelArrays(), "Should return the same map reference that was set"); + + // Verify the contents match + assertEquals(testMap, model.getModelArrays(), "TreeMap contents should match the set value"); + } + + @Test + void testSetNullValues() { + // Test setting each field to null + model.setStrings(null); + assertNull(model.getStrings(), "strings should be null after setting to null"); + + model.setColors(null); + assertNull(model.getColors(), "colors should be null after setting to null"); + + model.setPrimitiveTypeModels(null); + assertNull(model.getPrimitiveTypeModels(), "primitiveTypeModels should be null after setting to null"); + + model.setModels(null); + assertNull(model.getModels(), "models should be null after setting to null"); + + model.setModelArrays(null); + assertNull(model.getModelArrays(), "modelArrays should be null after setting to null"); + } + + @Test + void testMapMutability() { + Map originalMap = new HashMap<>(); + originalMap.put("initial", "value"); + model.setStrings(originalMap); + + // Modify the original map + originalMap.put("added", "new_value"); + + // Check if the change is reflected in the getter result + assertTrue(model.getStrings().containsKey("added"), + "Changes to the original map should be reflected since maps are passed by reference"); + } +} diff --git a/microsphere-java-test/src/test/java/io/microsphere/test/model/ModelTest.java b/microsphere-java-test/src/test/java/io/microsphere/test/model/ModelTest.java new file mode 100644 index 000000000..5a9b63b28 --- /dev/null +++ b/microsphere-java-test/src/test/java/io/microsphere/test/model/ModelTest.java @@ -0,0 +1,116 @@ +package io.microsphere.test.model; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.concurrent.TimeUnit; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * Unit tests for the Model class + */ +class ModelTest { + + private Model model; + + @BeforeEach + void setUp() { + model = new Model(); + } + + @Test + void testDefaultValues() { + // Verify all primitive fields have their default values + assertEquals(0.0f, model.getF(), "float field f should be 0.0f by default"); + assertEquals(0.0d, model.getD(), "double field d should be 0.0d by default"); + + // Verify all object fields are null by default + assertNull(model.getTu(), "TimeUnit field tu should be null by default"); + assertNull(model.getStr(), "String field str should be null by default"); + assertNull(model.getBi(), "BigInteger field bi should be null by default"); + assertNull(model.getBd(), "BigDecimal field bd should be null by default"); + } + + @Test + void testSetGetFloat() { + float testValue = 3.14f; + model.setF(testValue); + assertEquals(testValue, model.getF(), "getF should return the set value"); + } + + @Test + void testSetGetDouble() { + double testValue = 2.71828d; + model.setD(testValue); + assertEquals(testValue, model.getD(), "getD should return the set value"); + } + + @Test + void testSetGetTimeUnit() { + TimeUnit testValue = TimeUnit.SECONDS; + model.setTu(testValue); + assertEquals(testValue, model.getTu(), "getTu should return the set value"); + } + + @Test + void testSetGetString() { + String testValue = "Hello World"; + model.setStr(testValue); + assertEquals(testValue, model.getStr(), "getStr should return the set value"); + } + + @Test + void testSetGetBigInteger() { + BigInteger testValue = new BigInteger("123456789012345678901234567890"); + model.setBi(testValue); + assertEquals(testValue, model.getBi(), "getBi should return the set value"); + } + + @Test + void testSetGetBigDecimal() { + BigDecimal testValue = new BigDecimal("1234567890.12345678901234567890"); + model.setBd(testValue); + assertEquals(testValue, model.getBd(), "getBd should return the set value"); + } + + @Test + void testInheritanceFromParent() { + // Verify that the model inherits from Parent class + assertTrue(model instanceof Parent, "Model should extend Parent class"); + } + + @Test + void testMultipleValueChanges() { + // Test changing values multiple times + model.setF(1.0f); + assertEquals(1.0f, model.getF(), "f should be 1.0f"); + + model.setF(2.0f); + assertEquals(2.0f, model.getF(), "f should be 2.0f after second assignment"); + + model.setD(10.0d); + assertEquals(10.0d, model.getD(), "d should be 10.0d"); + + model.setD(20.0d); + assertEquals(20.0d, model.getD(), "d should be 20.0d after second assignment"); + } + + @Test + void testNullHandling() { + // Test setting object fields to null + model.setTu(null); + model.setStr(null); + model.setBi(null); + model.setBd(null); + + assertNull(model.getTu(), "tu should be null after setting to null"); + assertNull(model.getStr(), "str should be null after setting to null"); + assertNull(model.getBi(), "bi should be null after setting to null"); + assertNull(model.getBd(), "bd should be null after setting to null"); + } +} diff --git a/microsphere-java-test/src/test/java/io/microsphere/test/model/ParentTest.java b/microsphere-java-test/src/test/java/io/microsphere/test/model/ParentTest.java new file mode 100644 index 000000000..30d489e6e --- /dev/null +++ b/microsphere-java-test/src/test/java/io/microsphere/test/model/ParentTest.java @@ -0,0 +1,86 @@ +package io.microsphere.test.model; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * Unit tests for the Parent class + */ +class ParentTest { + + private Parent parent; + + @BeforeEach + void setUp() { + parent = new Parent(); + } + + @Test + void testDefaultValues() { + // Verify all primitive fields have their default values + assertEquals((byte) 0, parent.getB(), "byte field b should be 0 by default"); + assertEquals((short) 0, parent.getS(), "short field s should be 0 by default"); + assertEquals(0, parent.getI(), "int field i should be 0 by default"); + assertEquals(0L, parent.getL(), "long field l should be 0L by default"); + } + + @Test + void testSetGetByte() { + byte testValue = (byte) 42; + parent.setB(testValue); + assertEquals(testValue, parent.getB(), "getB should return the set value"); + } + + @Test + void testSetGetShort() { + short testValue = (short) 1000; + parent.setS(testValue); + assertEquals(testValue, parent.getS(), "getS should return the set value"); + } + + @Test + void testSetGetInt() { + int testValue = 123456; + parent.setI(testValue); + assertEquals(testValue, parent.getI(), "getI should return the set value"); + } + + @Test + void testSetGetLong() { + long testValue = 9876543210L; + parent.setL(testValue); + assertEquals(testValue, parent.getL(), "getL should return the set value"); + } + + @Test + void testInheritanceFromAncestor() { + // Verify that the parent inherits from Ancestor class + assertTrue(parent instanceof Ancestor, "Parent should extend Ancestor class"); + + // Test inherited functionality + assertFalse(parent.isZ(), "Should inherit default z value of false from Ancestor"); + + parent.setZ(true); + assertTrue(parent.isZ(), "Should be able to modify inherited z field"); + } + + @Test + void testMultipleValueChanges() { + // Test changing values multiple times + parent.setB((byte) 1); + assertEquals((byte) 1, parent.getB(), "b should be 1"); + + parent.setB((byte) 2); + assertEquals((byte) 2, parent.getB(), "b should be 2 after second assignment"); + + parent.setI(100); + assertEquals(100, parent.getI(), "i should be 100"); + + parent.setI(200); + assertEquals(200, parent.getI(), "i should be 200 after second assignment"); + } +} diff --git a/microsphere-java-test/src/test/java/io/microsphere/test/model/PrimitiveTypeModelTest.java b/microsphere-java-test/src/test/java/io/microsphere/test/model/PrimitiveTypeModelTest.java new file mode 100644 index 000000000..1f28bcb4d --- /dev/null +++ b/microsphere-java-test/src/test/java/io/microsphere/test/model/PrimitiveTypeModelTest.java @@ -0,0 +1,81 @@ +package io.microsphere.test.model; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; + +/** + * Unit tests for the PrimitiveTypeModel class + */ +class PrimitiveTypeModelTest { + + private PrimitiveTypeModel model; + + @BeforeEach + void setUp() { + model = new PrimitiveTypeModel(); + } + + @Test + void testDefaultValues() { + // Verify all primitive fields have their default values + assertFalse(model.isZ(), "boolean field z should be false by default"); + assertEquals((byte) 0, model.getB(), "byte field b should be 0 by default"); + assertEquals('\u0000', model.getC(), "char field c should be null character by default"); + assertEquals((short) 0, model.getS(), "short field s should be 0 by default"); + assertEquals(0, model.getI(), "int field i should be 0 by default"); + assertEquals(0L, model.getL(), "long field l should be 0L by default"); + assertEquals(0.0f, model.getF(), "float field f should be 0.0f by default"); + assertEquals(0.0d, model.getD(), "double field d should be 0.0d by default"); + } + + @Test + void testBooleanField() { + // Test boolean field specifically since it uses 'is' prefix instead of 'get' + assertFalse(model.isZ(), "Initial value should be false"); + } + + @Test + void testPrimitiveTypesRange() { + // Test various ranges for different primitive types + PrimitiveTypeModel testModel = new PrimitiveTypeModel(); + + // Boolean + // Cannot set values directly as there are no setters, but we can verify the default + + // Byte range (-128 to 127) + byte minByte = Byte.MIN_VALUE; + byte maxByte = Byte.MAX_VALUE; + + // Char range (0 to 65535) + char minChar = Character.MIN_VALUE; + char maxChar = Character.MAX_VALUE; + + // Short range (-32768 to 32767) + short minShort = Short.MIN_VALUE; + short maxShort = Short.MAX_VALUE; + + // Int range + int minInt = Integer.MIN_VALUE; + int maxInt = Integer.MAX_VALUE; + + // Long range + long minLong = Long.MIN_VALUE; + long maxLong = Long.MAX_VALUE; + + // Float range + float minFloat = Float.MIN_VALUE; + float maxFloat = Float.MAX_VALUE; + + // Double range + double minDouble = Double.MIN_VALUE; + double maxDouble = Double.MAX_VALUE; + + // These are just to ensure the getters work with different possible values + // Since there are no setters, we're just validating the getters return values + assertEquals(0, testModel.getI(), "Integer field should have default value"); + assertEquals(0.0f, testModel.getF(), "Float field should have default value"); + } +} diff --git a/microsphere-java-test/src/test/java/io/microsphere/test/model/SimpleTypeModelTest.java b/microsphere-java-test/src/test/java/io/microsphere/test/model/SimpleTypeModelTest.java new file mode 100644 index 000000000..6a0d24251 --- /dev/null +++ b/microsphere-java-test/src/test/java/io/microsphere/test/model/SimpleTypeModelTest.java @@ -0,0 +1,182 @@ +package io.microsphere.test.model; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.Date; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; + +/** + * Unit tests for the SimpleTypeModel class + */ +class SimpleTypeModelTest { + + private SimpleTypeModel model; + + @BeforeEach + void setUp() { + model = new SimpleTypeModel(); + } + + @Test + void testDefaultValues() { + // Verify all object fields are null by default + assertNull(model.getV(), "Void field v should be null by default"); + assertNull(model.getZ(), "Boolean field z should be null by default"); + assertNull(model.getC(), "Character field c should be null by default"); + assertNull(model.getB(), "Byte field b should be null by default"); + assertNull(model.getS(), "Short field s should be null by default"); + assertNull(model.getI(), "Integer field i should be null by default"); + assertNull(model.getL(), "Long field l should be null by default"); + assertNull(model.getF(), "Float field f should be null by default"); + assertNull(model.getD(), "Double field d should be null by default"); + assertNull(model.getStr(), "String field str should be null by default"); + assertNull(model.getBd(), "BigDecimal field bd should be null by default"); + assertNull(model.getBi(), "BigInteger field bi should be null by default"); + assertNull(model.getDt(), "Date field dt should be null by default"); + } + + @Test + void testSetGetVoid() { + // Void is always null, so setting it to null should work + model.setV(null); + assertNull(model.getV(), "Void should always be null"); + } + + @Test + void testSetGetBoolean() { + Boolean testValue = Boolean.TRUE; + model.setZ(testValue); + assertEquals(testValue, model.getZ(), "getZ should return the set value"); + + model.setZ(Boolean.FALSE); + assertEquals(Boolean.FALSE, model.getZ(), "getZ should return the set value"); + } + + @Test + void testSetGetCharacter() { + Character testValue = 'A'; + model.setC(testValue); + assertEquals(testValue, model.getC(), "getC should return the set value"); + } + + @Test + void testSetGetByte() { + Byte testValue = (byte) 42; + model.setB(testValue); + assertEquals(testValue, model.getB(), "getB should return the set value"); + } + + @Test + void testSetGetShort() { + Short testValue = (short) 1000; + model.setS(testValue); + assertEquals(testValue, model.getS(), "getS should return the set value"); + } + + @Test + void testSetGetInteger() { + Integer testValue = 123456; + model.setI(testValue); + assertEquals(testValue, model.getI(), "getI should return the set value"); + } + + @Test + void testSetGetLong() { + Long testValue = 9876543210L; + model.setL(testValue); + assertEquals(testValue, model.getL(), "getL should return the set value"); + } + + @Test + void testSetGetFloat() { + Float testValue = 3.14f; + model.setF(testValue); + assertEquals(testValue, model.getF(), "getF should return the set value"); + } + + @Test + void testSetGetDouble() { + Double testValue = 2.71828d; + model.setD(testValue); + assertEquals(testValue, model.getD(), "getD should return the set value"); + } + + @Test + void testSetGetString() { + String testValue = "Hello World"; + model.setStr(testValue); + assertEquals(testValue, model.getStr(), "getStr should return the set value"); + } + + @Test + void testSetGetBigDecimal() { + BigDecimal testValue = new BigDecimal("1234567890.12345678901234567890"); + model.setBd(testValue); + assertEquals(testValue, model.getBd(), "getBd should return the set value"); + } + + @Test + void testSetGetBigInteger() { + BigInteger testValue = new BigInteger("123456789012345678901234567890"); + model.setBi(testValue); + assertEquals(testValue, model.getBi(), "getBi should return the set value"); + } + + @Test + void testSetGetDate() { + Date testValue = new Date(); + model.setDt(testValue); + assertEquals(testValue, model.getDt(), "getDt should return the set value"); + } + + @Test + void testNullHandling() { + // Test setting all fields to null + model.setZ(null); + model.setC(null); + model.setB(null); + model.setS(null); + model.setI(null); + model.setL(null); + model.setF(null); + model.setD(null); + model.setStr(null); + model.setBd(null); + model.setBi(null); + model.setDt(null); + + assertNull(model.getZ(), "z should be null after setting to null"); + assertNull(model.getC(), "c should be null after setting to null"); + assertNull(model.getB(), "b should be null after setting to null"); + assertNull(model.getS(), "s should be null after setting to null"); + assertNull(model.getI(), "i should be null after setting to null"); + assertNull(model.getL(), "l should be null after setting to null"); + assertNull(model.getF(), "f should be null after setting to null"); + assertNull(model.getD(), "d should be null after setting to null"); + assertNull(model.getStr(), "str should be null after setting to null"); + assertNull(model.getBd(), "bd should be null after setting to null"); + assertNull(model.getBi(), "bi should be null after setting to null"); + assertNull(model.getDt(), "dt should be null after setting to null"); + } + + @Test + void testMultipleValueChanges() { + // Test changing values multiple times + model.setI(100); + assertEquals(Integer.valueOf(100), model.getI(), "i should be 100"); + + model.setI(200); + assertEquals(Integer.valueOf(200), model.getI(), "i should be 200 after second assignment"); + + model.setStr("first"); + assertEquals("first", model.getStr(), "str should be 'first'"); + + model.setStr("second"); + assertEquals("second", model.getStr(), "str should be 'second' after second assignment"); + } +} diff --git a/microsphere-java-test/src/test/java/io/microsphere/test/model/StringArrayListTest.java b/microsphere-java-test/src/test/java/io/microsphere/test/model/StringArrayListTest.java new file mode 100644 index 000000000..cc417fa20 --- /dev/null +++ b/microsphere-java-test/src/test/java/io/microsphere/test/model/StringArrayListTest.java @@ -0,0 +1,137 @@ +package io.microsphere.test.model; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Iterator; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * Unit tests for the StringArrayList class + */ +class StringArrayListTest { + + private StringArrayList stringArrayList; + + @BeforeEach + void setUp() { + stringArrayList = new StringArrayList(); + } + + @Test + void testDefaultConstructor() { + // Verify that the StringArrayList can be instantiated and is empty initially + assertNotNull(stringArrayList, "StringArrayList should be instantiated successfully"); + assertTrue(stringArrayList.isEmpty(), "StringArrayList should be empty by default"); + assertEquals(0, stringArrayList.size(), "StringArrayList size should be 0 by default"); + } + + @Test + void testAddAndGetSize() { + // Test adding elements and checking size + stringArrayList.add("element1"); + assertEquals(1, stringArrayList.size(), "Size should be 1 after adding one element"); + + stringArrayList.add("element2"); + assertEquals(2, stringArrayList.size(), "Size should be 2 after adding two elements"); + } + + @Test + void testAddAndGetElements() { + // Test adding elements and retrieving them + String element1 = "Hello"; + String element2 = "World"; + String element3 = "Test"; + + stringArrayList.add(element1); + stringArrayList.add(element2); + stringArrayList.add(element3); + + assertEquals(element1, stringArrayList.get(0), "Element at index 0 should match added value"); + assertEquals(element2, stringArrayList.get(1), "Element at index 1 should match added value"); + assertEquals(element3, stringArrayList.get(2), "Element at index 2 should match added value"); + } + + @Test + void testAddAll() { + // Test adding multiple elements at once + String[] elements = {"item1", "item2", "item3"}; + + boolean result = stringArrayList.addAll(Arrays.asList(elements)); + assertTrue(result, "addAll should return true when elements are added"); + + assertEquals(3, stringArrayList.size(), "Size should match number of added elements"); + assertEquals("item1", stringArrayList.get(0), "First element should match"); + assertEquals("item2", stringArrayList.get(1), "Second element should match"); + assertEquals("item3", stringArrayList.get(2), "Third element should match"); + } + + @Test + void testRemoveElement() { + // Test removing elements + stringArrayList.add("element1"); + stringArrayList.add("element2"); + + boolean removed = stringArrayList.remove("element1"); + assertTrue(removed, "Should return true when element is successfully removed"); + assertEquals(1, stringArrayList.size(), "Size should decrease after removal"); + assertEquals("element2", stringArrayList.get(0), "Remaining element should still be accessible"); + } + + @Test + void testClear() { + // Test clearing all elements + stringArrayList.add("element1"); + stringArrayList.add("element2"); + stringArrayList.add("element3"); + + assertEquals(3, stringArrayList.size(), "Size should be 3 before clear"); + + stringArrayList.clear(); + + assertTrue(stringArrayList.isEmpty(), "List should be empty after clear"); + assertEquals(0, stringArrayList.size(), "Size should be 0 after clear"); + } + + @Test + void testContains() { + // Test contains functionality + String element = "test_element"; + stringArrayList.add(element); + + assertTrue(stringArrayList.contains(element), "List should contain the added element"); + assertFalse(stringArrayList.contains("non_existent"), "List should not contain non-existent element"); + } + + @Test + void testIterator() { + // Test iterator functionality + String[] elements = {"a", "b", "c"}; + stringArrayList.addAll(Arrays.asList(elements)); + + Iterator iterator = stringArrayList.iterator(); + int index = 0; + + while (iterator.hasNext() && index < elements.length) { + String nextElement = iterator.next(); + assertEquals(elements[index], nextElement, "Iterator should return elements in order"); + index++; + } + + assertFalse(iterator.hasNext(), "Iterator should be exhausted after processing all elements"); + } + + @Test + void testInheritanceFromArrayList() { + // Verify that StringArrayList properly extends ArrayList + assertTrue(stringArrayList instanceof ArrayList, "StringArrayList should extend ArrayList"); + assertTrue(stringArrayList instanceof java.util.List, "StringArrayList should implement List interface"); + assertTrue(stringArrayList instanceof java.util.Collection, "StringArrayList should implement Collection interface"); + } +} diff --git a/microsphere-java-test/src/test/java/io/microsphere/test/service/DefaultTestServiceTest.java b/microsphere-java-test/src/test/java/io/microsphere/test/service/DefaultTestServiceTest.java new file mode 100644 index 000000000..a7713e79a --- /dev/null +++ b/microsphere-java-test/src/test/java/io/microsphere/test/service/DefaultTestServiceTest.java @@ -0,0 +1,83 @@ +package io.microsphere.test.service; + +import io.microsphere.test.model.Model; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.concurrent.TimeUnit; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; + +/** + * Unit tests for the DefaultTestService class. + */ +class DefaultTestServiceTest { + + private DefaultTestService defaultTestService; + + @BeforeEach + void setUp() { + defaultTestService = new DefaultTestService(); + } + + /** + * Test the echo method. + * Verifies that the method correctly prefixes the input message with "[ECHO] ". + */ + @Test + void testEcho() { + String input = "Hello, World!"; + String expectedOutput = "[ECHO] Hello, World!"; + String actualOutput = defaultTestService.echo(input); + assertEquals(expectedOutput, actualOutput, "The echo method should prefix the message with '[ECHO] '."); + } + + /** + * Test the model method. + * Verifies that the method returns the same Model object that was passed in. + */ + @Test + void testModel() { + Model inputModel = new Model(); + Model outputModel = defaultTestService.model(inputModel); + assertSame(inputModel, outputModel, "The model method should return the same Model object."); + } + + /** + * Test the testPrimitive method. + * Currently, this method returns null, so the test verifies that null is returned. + */ + @Test + void testTestPrimitive() { + boolean z = true; + int i = 42; + String result = defaultTestService.testPrimitive(z, i); + assertNull(result, "The testPrimitive method should return null."); + } + + /** + * Test the testEnum method. + * Currently, this method returns null, so the test verifies that null is returned. + */ + @Test + void testTestEnum() { + TimeUnit timeUnit = TimeUnit.SECONDS; + Model result = defaultTestService.testEnum(timeUnit); + assertNull(result, "The testEnum method should return null."); + } + + /** + * Test the testArray method. + * Currently, this method returns null, so the test verifies that null is returned. + */ + @Test + void testTestArray() { + String[] strArray = {"a", "b", "c"}; + int[] intArray = {1, 2, 3}; + Model[] modelArray = {new Model(), new Model()}; + String result = defaultTestService.testArray(strArray, intArray, modelArray); + assertNull(result, "The testArray method should return null."); + } +} diff --git a/microsphere-java-test/src/test/java/io/microsphere/test/service/GenericTestServiceTest.java b/microsphere-java-test/src/test/java/io/microsphere/test/service/GenericTestServiceTest.java new file mode 100644 index 000000000..d97ca6011 --- /dev/null +++ b/microsphere-java-test/src/test/java/io/microsphere/test/service/GenericTestServiceTest.java @@ -0,0 +1,58 @@ +package io.microsphere.test.service; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * Unit tests for the GenericTestService class. + */ +class GenericTestServiceTest { + + private GenericTestService genericTestService; + + @BeforeEach + void setUp() { + genericTestService = new GenericTestService(); + } + + /** + * Test the echo method. + * Verifies that the method correctly prefixes the input message with "[ECHO] ". + */ + @Test + void testEcho() { + String input = "Hello, World!"; + String expectedOutput = "[ECHO] Hello, World!"; + String actualOutput = genericTestService.echo(input); + assertEquals(expectedOutput, actualOutput, "The echo method should prefix the message with '[ECHO] '."); + } + + /** + * Test inheritance from DefaultTestService. + * Verifies that methods from the parent class are accessible and functional. + */ + @Test + void testInheritedMethods() { + // Example: Testing a method inherited from DefaultTestService + // Assuming DefaultTestService has a method like model(Model model) + // Uncomment and adapt the following lines if such a method exists: + /* + Model inputModel = new Model(); + Model outputModel = genericTestService.model(inputModel); + assertSame(inputModel, outputModel, "The inherited model method should return the same Model object."); + */ + } + + /** + * Test implementation of EventListener interface. + * Verifies that the class correctly implements the EventListener marker interface. + */ + @Test + void testEventListenerImplementation() { + assertTrue(genericTestService instanceof java.util.EventListener, + "GenericTestService should implement the EventListener interface."); + } +} diff --git a/microsphere-java-test/src/test/resources/META-INF/services/javax.annotation.processing.Processor b/microsphere-java-test/src/test/resources/META-INF/services/javax.annotation.processing.Processor new file mode 100644 index 000000000..6b85e96b8 --- /dev/null +++ b/microsphere-java-test/src/test/resources/META-INF/services/javax.annotation.processing.Processor @@ -0,0 +1 @@ +io.microsphere.test.annotation.processing.TestProcessor \ No newline at end of file From 54ce8d03d0dded837d35285c333e5fb80f23542f Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 17:44:35 +0800 Subject: [PATCH 05/79] Use Invocation API for annotation processing tests Refactor annotation-processing test harness to use JUnit 5 reflective invocation API. AbstractAnnotationProcessingTest: remove ThreadLocal holder and @BeforeEach/@AfterEach, change beforeTest/afterTest signatures to accept ReflectiveInvocationContext and ExtensionContext (afterTest also receives result and failure), add necessary imports and reflection types. AnnotationProcessingTestProcessor: make package-private, use Invocation type directly, call beforeTest/afterTest with contexts and pass result/failure, and populate processingEnv, Elements/Types and test type information during prepare. CompilerInvocationInterceptor: make package-private, obtain test instance from invocationContext target, use the test class loader, and load SPI Processor implementations via ServiceLoader (merging them with the test processor). Also cleanup imports/usages in test class (remove assertion referencing removed holder). Overall adjusts lifecycle integration so the annotation processor drives the test invocation and reporting. --- .../AbstractAnnotationProcessingTest.java | 31 +++---------- .../AnnotationProcessingTestProcessor.java | 44 ++++++++++++++----- .../CompilerInvocationInterceptor.java | 15 ++++--- .../processing/AnnotationProcessingTest.java | 2 - 4 files changed, 50 insertions(+), 42 deletions(-) diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AbstractAnnotationProcessingTest.java b/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AbstractAnnotationProcessingTest.java index 2b1bcd330..5a4d5d826 100644 --- a/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AbstractAnnotationProcessingTest.java +++ b/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AbstractAnnotationProcessingTest.java @@ -16,10 +16,10 @@ */ package io.microsphere.test.annotation.processing; -import io.microsphere.test.service.TestServiceImpl; -import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.BeforeEach; +import io.microsphere.annotation.Nullable; import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.ReflectiveInvocationContext; import javax.annotation.processing.ProcessingEnvironment; import javax.annotation.processing.RoundEnvironment; @@ -36,6 +36,7 @@ import javax.lang.model.util.Elements; import javax.lang.model.util.Types; import java.lang.annotation.Annotation; +import java.lang.reflect.Method; import java.lang.reflect.Type; import java.util.Collection; import java.util.List; @@ -105,8 +106,6 @@ public abstract class AbstractAnnotationProcessingTest { protected static final AnnotationMirror NULL_ANNOTATION_MIRROR = null; - static ThreadLocal testInstanceHolder = new ThreadLocal<>(); - protected RoundEnvironment roundEnv; protected ProcessingEnvironment processingEnv; @@ -125,29 +124,13 @@ public abstract class AbstractAnnotationProcessingTest { protected DeclaredType testDeclaredType; - @BeforeEach - final void setUp() { - testInstanceHolder.set(this); - } - - @AfterEach - final void tearDown() { - testInstanceHolder.remove(); - } - protected void addCompiledClasses(Set> compiledClasses) { } - protected void beforeTest() { - this.testClass = TestServiceImpl.class; - this.testClassName = TestServiceImpl.class.getName(); - this.elements = processingEnv.getElementUtils(); - this.testTypeElement = this.elements.getTypeElement(this.testClassName); - this.testTypeMirror = this.testTypeElement.asType(); - this.testDeclaredType = (DeclaredType) testTypeElement.asType(); + protected void beforeTest(ReflectiveInvocationContext invocationContext, ExtensionContext extensionContext) { } - protected void afterTest() { + protected void afterTest(ReflectiveInvocationContext invocationContext, ExtensionContext extensionContext, + @Nullable Object result, @Nullable Throwable failure) { } - } \ No newline at end of file diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AnnotationProcessingTestProcessor.java b/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AnnotationProcessingTestProcessor.java index 51511cc5c..25b359469 100644 --- a/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AnnotationProcessingTestProcessor.java +++ b/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AnnotationProcessingTestProcessor.java @@ -17,14 +17,19 @@ package io.microsphere.test.annotation.processing; import org.junit.jupiter.api.extension.ExtensionContext; -import org.junit.jupiter.api.extension.InvocationInterceptor; +import org.junit.jupiter.api.extension.InvocationInterceptor.Invocation; import org.junit.jupiter.api.extension.ReflectiveInvocationContext; import javax.annotation.processing.AbstractProcessor; +import javax.annotation.processing.ProcessingEnvironment; import javax.annotation.processing.RoundEnvironment; import javax.annotation.processing.SupportedAnnotationTypes; import javax.lang.model.SourceVersion; import javax.lang.model.element.TypeElement; +import javax.lang.model.type.DeclaredType; +import javax.lang.model.type.TypeMirror; +import javax.lang.model.util.Elements; +import javax.lang.model.util.Types; import java.lang.reflect.Method; import java.util.Set; @@ -38,17 +43,17 @@ * @since 1.0.0 */ @SupportedAnnotationTypes(WILDCARD) -public class AnnotationProcessingTestProcessor extends AbstractProcessor { +class AnnotationProcessingTestProcessor extends AbstractProcessor { private final AbstractAnnotationProcessingTest abstractAnnotationProcessingTest; - private final InvocationInterceptor.Invocation invocation; + private final Invocation invocation; private final ReflectiveInvocationContext invocationContext; private final ExtensionContext extensionContext; - public AnnotationProcessingTestProcessor(AbstractAnnotationProcessingTest abstractAnnotationProcessingTest, InvocationInterceptor.Invocation invocation, + public AnnotationProcessingTestProcessor(AbstractAnnotationProcessingTest abstractAnnotationProcessingTest, Invocation invocation, ReflectiveInvocationContext invocationContext, ExtensionContext extensionContext) { this.abstractAnnotationProcessingTest = abstractAnnotationProcessingTest; @@ -59,25 +64,42 @@ public AnnotationProcessingTestProcessor(AbstractAnnotationProcessingTest abstra @Override public boolean process(Set annotations, RoundEnvironment roundEnv) { + ReflectiveInvocationContext invocationContext = this.invocationContext; + ExtensionContext extensionContext = this.extensionContext; if (!roundEnv.processingOver()) { prepare(roundEnv); - abstractAnnotationProcessingTest.beforeTest(); + Object result = null; + Throwable failure = null; + abstractAnnotationProcessingTest.beforeTest(invocationContext, extensionContext); try { - invocation.proceed(); + result = invocation.proceed(); } catch (Throwable throwable) { - throw new RuntimeException(throwable); + failure = throwable; } finally { - abstractAnnotationProcessingTest.afterTest(); + abstractAnnotationProcessingTest.afterTest(invocationContext, extensionContext, result, failure); } } return false; } protected void prepare(RoundEnvironment roundEnv) { + ProcessingEnvironment processingEnv = super.processingEnv; + Elements elements = processingEnv.getElementUtils(); + Types types = processingEnv.getTypeUtils(); + Class testClass = this.invocationContext.getTargetClass(); + String testClassName = testClass.getName(); + TypeElement testTypeElement = elements.getTypeElement(testClassName); + TypeMirror testType = testTypeElement.asType(); + abstractAnnotationProcessingTest.roundEnv = roundEnv; - abstractAnnotationProcessingTest.processingEnv = super.processingEnv; - abstractAnnotationProcessingTest.elements = super.processingEnv.getElementUtils(); - abstractAnnotationProcessingTest.types = super.processingEnv.getTypeUtils(); + abstractAnnotationProcessingTest.processingEnv = processingEnv; + abstractAnnotationProcessingTest.elements = elements; + abstractAnnotationProcessingTest.types = types; + abstractAnnotationProcessingTest.testClass = testClass; + abstractAnnotationProcessingTest.testClassName = testClassName; + abstractAnnotationProcessingTest.testTypeElement = testTypeElement; + abstractAnnotationProcessingTest.testTypeMirror = testType; + abstractAnnotationProcessingTest.testDeclaredType = (DeclaredType) testType; } @Override diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/CompilerInvocationInterceptor.java b/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/CompilerInvocationInterceptor.java index 296ca9ac3..1d0b0518c 100644 --- a/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/CompilerInvocationInterceptor.java +++ b/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/CompilerInvocationInterceptor.java @@ -26,10 +26,10 @@ import java.util.LinkedHashSet; import java.util.LinkedList; import java.util.List; +import java.util.ServiceLoader; import java.util.Set; -import static io.microsphere.test.annotation.processing.AbstractAnnotationProcessingTest.testInstanceHolder; -import static io.microsphere.util.ServiceLoaderUtils.loadServicesList; +import static java.util.ServiceLoader.load; /** @@ -38,21 +38,26 @@ * @author Mercy * @since 1.0.0 */ -public class CompilerInvocationInterceptor implements InvocationInterceptor { +class CompilerInvocationInterceptor implements InvocationInterceptor { @Override public void interceptTestMethod(Invocation invocation, ReflectiveInvocationContext invocationContext, ExtensionContext extensionContext) throws Throwable { Set> compiledClasses = new LinkedHashSet<>(); - AbstractAnnotationProcessingTest abstractAnnotationProcessingTest = testInstanceHolder.get(); + AbstractAnnotationProcessingTest abstractAnnotationProcessingTest = (AbstractAnnotationProcessingTest) invocationContext.getTarget().get(); Class testClass = extensionContext.getTestClass().get(); + ClassLoader classLoader = testClass.getClassLoader(); compiledClasses.add(testClass); abstractAnnotationProcessingTest.addCompiledClasses(compiledClasses); Compiler compiler = new Compiler(); compiler.sourcePaths(testClass); - List processors = new LinkedList<>(loadServicesList(Processor.class, testClass.getClassLoader())); + + List processors = new LinkedList<>(); processors.add(new AnnotationProcessingTestProcessor(abstractAnnotationProcessingTest, invocation, invocationContext, extensionContext)); + // Loads the SPI instances of Processor + ServiceLoader loadedProcessors = load(Processor.class, classLoader); + loadedProcessors.forEach(processors::add); compiler.processors(processors.toArray(new Processor[0])); compiler.compile(compiledClasses.toArray(new Class[0])); } diff --git a/microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/AnnotationProcessingTest.java b/microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/AnnotationProcessingTest.java index 935b1e5f5..51e158304 100644 --- a/microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/AnnotationProcessingTest.java +++ b/microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/AnnotationProcessingTest.java @@ -25,7 +25,6 @@ import java.util.Collection; import static org.junit.jupiter.api.Assertions.assertArrayEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNull; /** @@ -66,6 +65,5 @@ void test() { assertNull(NULL_METHOD); assertNull(NULL_METHOD_ARRAY); assertNull(NULL_ANNOTATION_MIRROR); - assertNotNull(testInstanceHolder); } } From 8f0905632acb5f58e686998e9ab7169c82ea7917 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 17:48:59 +0800 Subject: [PATCH 06/79] Add TestServiceImpl tests; adjust annotation processor Add a new JUnit test class TestServiceImplTest (Mockito-based) to validate TestServiceImpl behavior (echo, close, constructors and DI). Make small API/encapsulation adjustments to the annotation-processing test infra: add Javadoc/comments for addCompiledClasses, beforeTest and afterTest in AbstractAnnotationProcessingTest; reduce visibility of AnnotationProcessingTestProcessor constructor and prepare method to package-private; and rename local variables in CompilerInvocationInterceptor to improve clarity and pass the test instance into the processor. These changes improve test coverage and tighten processor APIs. --- .../AbstractAnnotationProcessingTest.java | 19 +++++ .../AnnotationProcessingTestProcessor.java | 8 +- .../CompilerInvocationInterceptor.java | 9 +-- .../test/service/TestServiceImplTest.java | 75 +++++++++++++++++++ 4 files changed, 102 insertions(+), 9 deletions(-) create mode 100644 microsphere-java-test/src/test/java/io/microsphere/test/service/TestServiceImplTest.java diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AbstractAnnotationProcessingTest.java b/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AbstractAnnotationProcessingTest.java index 5a4d5d826..0979eab68 100644 --- a/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AbstractAnnotationProcessingTest.java +++ b/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AbstractAnnotationProcessingTest.java @@ -124,12 +124,31 @@ public abstract class AbstractAnnotationProcessingTest { protected DeclaredType testDeclaredType; + /** + * The classes to be compiled. + * + * @param compiledClasses the mutable {@link Set} for classes to be compiled + */ protected void addCompiledClasses(Set> compiledClasses) { } + /** + * Before Test + * + * @param invocationContext {@link ReflectiveInvocationContext} + * @param extensionContext {@link ExtensionContext} + */ protected void beforeTest(ReflectiveInvocationContext invocationContext, ExtensionContext extensionContext) { } + /** + * After Test + * + * @param invocationContext {@link ReflectiveInvocationContext} + * @param extensionContext {@link ExtensionContext} + * @param result the result after test method returning + * @param failure the failure after the test methods' execution + */ protected void afterTest(ReflectiveInvocationContext invocationContext, ExtensionContext extensionContext, @Nullable Object result, @Nullable Throwable failure) { } diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AnnotationProcessingTestProcessor.java b/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AnnotationProcessingTestProcessor.java index 25b359469..abc23576e 100644 --- a/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AnnotationProcessingTestProcessor.java +++ b/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AnnotationProcessingTestProcessor.java @@ -53,9 +53,9 @@ class AnnotationProcessingTestProcessor extends AbstractProcessor { private final ExtensionContext extensionContext; - public AnnotationProcessingTestProcessor(AbstractAnnotationProcessingTest abstractAnnotationProcessingTest, Invocation invocation, - ReflectiveInvocationContext invocationContext, - ExtensionContext extensionContext) { + AnnotationProcessingTestProcessor(AbstractAnnotationProcessingTest abstractAnnotationProcessingTest, Invocation invocation, + ReflectiveInvocationContext invocationContext, + ExtensionContext extensionContext) { this.abstractAnnotationProcessingTest = abstractAnnotationProcessingTest; this.invocation = invocation; this.invocationContext = invocationContext; @@ -82,7 +82,7 @@ public boolean process(Set annotations, RoundEnvironment return false; } - protected void prepare(RoundEnvironment roundEnv) { + void prepare(RoundEnvironment roundEnv) { ProcessingEnvironment processingEnv = super.processingEnv; Elements elements = processingEnv.getElementUtils(); Types types = processingEnv.getTypeUtils(); diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/CompilerInvocationInterceptor.java b/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/CompilerInvocationInterceptor.java index 1d0b0518c..a0d113350 100644 --- a/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/CompilerInvocationInterceptor.java +++ b/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/CompilerInvocationInterceptor.java @@ -41,20 +41,19 @@ class CompilerInvocationInterceptor implements InvocationInterceptor { @Override - public void interceptTestMethod(Invocation invocation, - ReflectiveInvocationContext invocationContext, + public void interceptTestMethod(Invocation invocation, ReflectiveInvocationContext invocationContext, ExtensionContext extensionContext) throws Throwable { Set> compiledClasses = new LinkedHashSet<>(); - AbstractAnnotationProcessingTest abstractAnnotationProcessingTest = (AbstractAnnotationProcessingTest) invocationContext.getTarget().get(); + AbstractAnnotationProcessingTest test = (AbstractAnnotationProcessingTest) invocationContext.getTarget().get(); Class testClass = extensionContext.getTestClass().get(); ClassLoader classLoader = testClass.getClassLoader(); compiledClasses.add(testClass); - abstractAnnotationProcessingTest.addCompiledClasses(compiledClasses); + test.addCompiledClasses(compiledClasses); Compiler compiler = new Compiler(); compiler.sourcePaths(testClass); List processors = new LinkedList<>(); - processors.add(new AnnotationProcessingTestProcessor(abstractAnnotationProcessingTest, invocation, invocationContext, extensionContext)); + processors.add(new AnnotationProcessingTestProcessor(test, invocation, invocationContext, extensionContext)); // Loads the SPI instances of Processor ServiceLoader loadedProcessors = load(Processor.class, classLoader); loadedProcessors.forEach(processors::add); diff --git a/microsphere-java-test/src/test/java/io/microsphere/test/service/TestServiceImplTest.java b/microsphere-java-test/src/test/java/io/microsphere/test/service/TestServiceImplTest.java new file mode 100644 index 000000000..272aba056 --- /dev/null +++ b/microsphere-java-test/src/test/java/io/microsphere/test/service/TestServiceImplTest.java @@ -0,0 +1,75 @@ +package io.microsphere.test.service; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.springframework.context.ApplicationContext; +import org.springframework.core.env.Environment; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.mockito.Mockito.*; + +/** + * Unit tests for the TestServiceImpl class. + */ +class TestServiceImplTest { + + private TestServiceImpl testService; + private ApplicationContext mockContext; + private Environment mockEnvironment; + + @BeforeEach + void setUp() { + // Mock dependencies + mockContext = mock(ApplicationContext.class); + mockEnvironment = mock(Environment.class); + + // Initialize the service with mocked dependencies + testService = new TestServiceImpl(mockEnvironment); + testService.context = mockContext; // Inject mocked ApplicationContext + } + + /** + * Test the echo method. + * Verifies that the method correctly prefixes the input message with "[ECHO] ". + */ + @Test + void testEcho() { + String input = "Hello, World!"; + String expectedOutput = "[ECHO] Hello, World!"; + String actualOutput = testService.echo(input); + assertEquals(expectedOutput, actualOutput, "The echo method should prefix the message with '[ECHO] '."); + } + + /** + * Test the close method. + * Verifies that the method does not throw any exceptions. + */ + @Test + void testClose() { + assertDoesNotThrow(() -> testService.close(), "The close method should not throw any exceptions."); + } + + /** + * Test constructor with Environment parameter. + * Verifies that the environment is properly injected. + */ + @Test + void testConstructorWithEnvironment() { + assertNotNull(testService.environment, "The environment should be injected via constructor."); + assertSame(mockEnvironment, testService.environment, "The injected environment should match the mocked instance."); + } + + /** + * Test default constructor. + * Verifies that the service can be instantiated without an Environment. + */ + @Test + void testDefaultConstructor() { + TestServiceImpl service = new TestServiceImpl(); + assertNull(service.environment, "The environment should be null when using the default constructor."); + } +} From 658ea193b164a99fd477dfb0c1abf4b05349ce87 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 17:49:15 +0800 Subject: [PATCH 07/79] Add ThrowableUtils utility class Introduce io.microsphere.util.ThrowableUtils: a new utility class (with ASF license header and author info) providing getRootCause(Throwable) to traverse and return the deepest cause in a throwable chain. The class implements Utils and has a private constructor to prevent instantiation. --- .../io/microsphere/util/ThrowableUtils.java | 40 +++++++++++++++++++ 1 file changed, 40 insertions(+) create mode 100644 microsphere-java-core/src/main/java/io/microsphere/util/ThrowableUtils.java diff --git a/microsphere-java-core/src/main/java/io/microsphere/util/ThrowableUtils.java b/microsphere-java-core/src/main/java/io/microsphere/util/ThrowableUtils.java new file mode 100644 index 000000000..8f6d32c23 --- /dev/null +++ b/microsphere-java-core/src/main/java/io/microsphere/util/ThrowableUtils.java @@ -0,0 +1,40 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.util; + +/** + * The uitlities class for {@link Throwable} + * + * @author Mercy + * @see Throwable + * @since 1.0.0 + */ +public abstract class ThrowableUtils implements Utils { + + public static Throwable getRootCause(Throwable throwable) { + Throwable rootCause = throwable; + while (rootCause.getCause() != null) { + rootCause = rootCause.getCause(); + } + return rootCause; + } + + + private ThrowableUtils() { + } +} From 866143aa7d3c88b2a2bb86a7105b1ef19ce9d4f8 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 17:49:29 +0800 Subject: [PATCH 08/79] Add ThrowableUtils unit tests Add JUnit 5 tests for ThrowableUtils#getRootCause. The new test file verifies retrieving the root cause from a nested Throwable, checks behavior when using ThrowableAction.execute to handle thrown exceptions, and ensures rethrowing the root cause yields the expected NullPointerException. --- .../microsphere/util/ThrowableUtilsTest.java | 64 +++++++++++++++++++ 1 file changed, 64 insertions(+) create mode 100644 microsphere-java-core/src/test/java/io/microsphere/util/ThrowableUtilsTest.java diff --git a/microsphere-java-core/src/test/java/io/microsphere/util/ThrowableUtilsTest.java b/microsphere-java-core/src/test/java/io/microsphere/util/ThrowableUtilsTest.java new file mode 100644 index 000000000..883f8e5e1 --- /dev/null +++ b/microsphere-java-core/src/test/java/io/microsphere/util/ThrowableUtilsTest.java @@ -0,0 +1,64 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.util; + + +import io.microsphere.lang.function.ThrowableAction; +import org.junit.jupiter.api.Test; + +import static io.microsphere.lang.function.ThrowableAction.execute; +import static io.microsphere.util.ThrowableUtils.getRootCause; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; + +/** + * {@link ThrowableUtils} Test + * + * @author Mercy + * @see ThrowableUtils + * @since 1.0.0 + */ +class ThrowableUtilsTest { + + @Test + void testGetRootCause() { + Throwable rootCause = new Throwable("Root Cause"); + Throwable throwable = new Throwable("Throwable", rootCause); + assertSame(rootCause, getRootCause(throwable)); + + ThrowableAction action = () -> { + throw throwable; + }; + + execute(action, e -> { + assertSame(rootCause, getRootCause(e)); + }); + + assertThrows(NullPointerException.class, () -> { + try { + ThrowableAction a = () -> { + String s = null; + s.toString(); + }; + a.execute(); + } catch (Throwable e) { + throw getRootCause(e); + } + }); + } +} \ No newline at end of file From 86253ae58bbd99a192c0c44861b7e116a7cf4b2b Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 18:25:10 +0800 Subject: [PATCH 09/79] Add test and afterTest failure assertion Introduce a failing test and verify test lifecycle failure handling. Adds testOnFailure() which throws a RuntimeException("For testing") and overrides afterTest(ReflectiveInvocationContext, ExtensionContext, Object, Throwable) to assert the failure message when a failure is present. Also adds the required imports and an assertEquals assertion. --- .../processing/AnnotationProcessingTest.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/AnnotationProcessingTest.java b/microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/AnnotationProcessingTest.java index 51e158304..287fb77f9 100644 --- a/microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/AnnotationProcessingTest.java +++ b/microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/AnnotationProcessingTest.java @@ -18,13 +18,17 @@ package io.microsphere.test.annotation.processing; import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.ReflectiveInvocationContext; import javax.lang.model.element.Element; import javax.lang.model.type.TypeMirror; +import java.lang.reflect.Method; import java.lang.reflect.Type; import java.util.Collection; import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNull; /** @@ -66,4 +70,17 @@ void test() { assertNull(NULL_METHOD_ARRAY); assertNull(NULL_ANNOTATION_MIRROR); } + + @Test + void testOnFailure() { + throw new RuntimeException("For testing"); + } + + @Override + protected void afterTest(ReflectiveInvocationContext invocationContext, ExtensionContext extensionContext, Object result, Throwable failure) { + super.afterTest(invocationContext, extensionContext, result, failure); + if (failure != null) { + assertEquals("For testing", failure.getMessage()); + } + } } From ade92cf79cd4b8a682adb565bdddabcb82e6bd1b Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 19:02:02 +0800 Subject: [PATCH 10/79] Add test deps; adapt annotation processing tests Add Microsphere test libraries to the module POM (microsphere-lang-model, microsphere-jdk-tools (test scope), and microsphere-java-test (test scope)). Update unit tests to extend AbstractAnnotationProcessingTest and adjust lifecycle hooks: beforeTest/afterTest signatures now accept ReflectiveInvocationContext and ExtensionContext (and afterTest includes result/failure). Import necessary classes (ReflectiveInvocationContext, ExtensionContext, Method) and update test setup/teardown to use the new testing extension API. --- microsphere-annotation-processor/pom.xml | 23 +++++++++++++++++++ .../processor/FilerProcessorTest.java | 7 +++++- .../processor/ResourceProcessorTest.java | 8 +++++-- 3 files changed, 35 insertions(+), 3 deletions(-) diff --git a/microsphere-annotation-processor/pom.xml b/microsphere-annotation-processor/pom.xml index 0af57d196..e5558b6fe 100644 --- a/microsphere-annotation-processor/pom.xml +++ b/microsphere-annotation-processor/pom.xml @@ -32,6 +32,13 @@ ${revision} + + + io.github.microsphere-projects + microsphere-lang-model + ${revision} + + org.junit.jupiter @@ -45,6 +52,22 @@ test + + + io.github.microsphere-projects + microsphere-jdk-tools + ${revision} + test + + + + + io.github.microsphere-projects + microsphere-java-test + ${revision} + test + + ch.qos.logback diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/FilerProcessorTest.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/FilerProcessorTest.java index 47588edde..132685903 100644 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/FilerProcessorTest.java +++ b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/FilerProcessorTest.java @@ -18,11 +18,16 @@ package io.microsphere.annotation.processor; +import io.microsphere.test.annotation.processing.AbstractAnnotationProcessingTest; import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.ReflectiveInvocationContext; import javax.tools.JavaFileManager; import javax.tools.JavaFileObject; +import java.lang.reflect.Method; + import static io.microsphere.annotation.processor.ResourceProcessor.exists; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNotNull; @@ -40,7 +45,7 @@ class FilerProcessorTest extends AbstractAnnotationProcessingTest { private FilerProcessor processor; @Override - protected void beforeTest() { + protected void beforeTest(ReflectiveInvocationContext invocationContext, ExtensionContext extensionContext) { this.processor = new FilerProcessor(super.processingEnv); } diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/ResourceProcessorTest.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/ResourceProcessorTest.java index 35ad93340..868022463 100644 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/ResourceProcessorTest.java +++ b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/ResourceProcessorTest.java @@ -18,9 +18,13 @@ package io.microsphere.annotation.processor; +import io.microsphere.test.annotation.processing.AbstractAnnotationProcessingTest; import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.ReflectiveInvocationContext; import javax.tools.FileObject; +import java.lang.reflect.Method; import java.util.Optional; import static io.microsphere.annotation.processor.ResourceProcessor.FOR_READING; @@ -56,14 +60,14 @@ class ResourceProcessorTest extends AbstractAnnotationProcessingTest { private String randomResourceName; @Override - protected void beforeTest() { + protected void beforeTest(ReflectiveInvocationContext invocationContext, ExtensionContext extensionContext) { this.classOutputProcessor = new ResourceProcessor(super.processingEnv, CLASS_OUTPUT); this.sourcePathProcessor = new ResourceProcessor(super.processingEnv, SOURCE_PATH); this.randomResourceName = "test/" + currentTimeMillis() + ".txt"; } @Override - protected void afterTest() { + protected void afterTest(ReflectiveInvocationContext invocationContext, ExtensionContext extensionContext, Object result, Throwable failure) { this.classOutputProcessor.getResource(this.randomResourceName, FOR_WRITING).ifPresent(FileObject::delete); } From 3b27a3d4c05af403a04e7575f554fac4cd94b177 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 19:03:08 +0800 Subject: [PATCH 11/79] Remove microsphere-annotation-processor module Delete the entire microsphere-annotation-processor module: remove source files under src/main/java (annotation model elements, visitors and various utility classes such as AnnotationUtils, ClassUtils, ConstructorUtils, ElementUtils, ExecutableElementComparator, FieldUtils, LoggerUtils, MemberUtils, MessagerUtils, MethodUtils, TypeUtils, etc.) and corresponding unit tests under src/test/java. This change removes the annotation processing implementation and its tests from the repository. --- .../model/element/StringAnnotationValue.java | 50 - .../util/JSONAnnotationValueVisitor.java | 197 -- .../model/util/JSONElementVisitor.java | 221 -- .../ResolvableAnnotationValueVisitor.java | 200 -- .../processor/util/AnnotationUtils.java | 1871 ------------ .../annotation/processor/util/ClassUtils.java | 109 - .../processor/util/ConstructorUtils.java | 293 -- .../processor/util/ElementUtils.java | 734 ----- .../util/ExecutableElementComparator.java | 93 - .../annotation/processor/util/FieldUtils.java | 763 ----- .../processor/util/LoggerUtils.java | 54 - .../processor/util/MemberUtils.java | 423 --- .../processor/util/MessagerUtils.java | 310 -- .../processor/util/MethodUtils.java | 1165 -------- .../annotation/processor/util/TypeUtils.java | 2505 ----------------- .../AbstractAnnotationProcessingTest.java | 202 -- .../AnnotationProcessingTestProcessor.java | 86 - .../annotation/processor/Compiler.java | 214 -- .../CompilerInvocationInterceptor.java | 57 - .../processor/DefaultTestService.java | 58 - .../processor/GenericTestService.java | 33 - .../annotation/processor/TestAnnotation.java | 73 - .../annotation/processor/TestService.java | 55 - .../annotation/processor/TestServiceImpl.java | 100 - .../annotation/processor/model/Ancestor.java | 35 - .../processor/model/ArrayTypeModel.java | 36 - .../processor/model/CollectionTypeModel.java | 42 - .../annotation/processor/model/Color.java | 46 - .../model/ConfigurationPropertyModel.java | 47 - .../processor/model/MapTypeModel.java | 41 - .../annotation/processor/model/Model.java | 87 - .../annotation/processor/model/Parent.java | 63 - .../processor/model/PrimitiveTypeModel.java | 73 - .../processor/model/SimpleTypeModel.java | 161 -- .../processor/model/StringArrayList.java | 30 - .../element/StringAnnotationValueTest.java | 53 - .../util/JSONAnnotationValueVisitorTest.java | 133 - .../model/util/JSONElementVisitorTest.java | 254 -- .../ResolvableAnnotationValueVisitorTest.java | 214 -- .../processor/util/AnnotationUtilsTest.java | 776 ----- .../processor/util/ClassUtilsTest.java | 52 - .../processor/util/ConstructorUtilsTest.java | 150 - .../processor/util/ElementUtilsTest.java | 350 --- .../util/ExecutableElementComparatorTest.java | 76 - .../processor/util/FieldUtilsTest.java | 413 --- .../processor/util/LoggerUtilsTest.java | 76 - .../processor/util/MemberUtilsTest.java | 174 -- .../processor/util/MessagerUtilsTest.java | 79 - .../processor/util/MethodUtilsTest.java | 506 ---- .../processor/util/TypeUtilsTest.java | 1877 ------------ 50 files changed, 15710 deletions(-) delete mode 100644 microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/element/StringAnnotationValue.java delete mode 100644 microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/JSONAnnotationValueVisitor.java delete mode 100644 microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/JSONElementVisitor.java delete mode 100644 microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/ResolvableAnnotationValueVisitor.java delete mode 100644 microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/AnnotationUtils.java delete mode 100644 microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/ClassUtils.java delete mode 100644 microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/ConstructorUtils.java delete mode 100644 microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/ElementUtils.java delete mode 100644 microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/ExecutableElementComparator.java delete mode 100644 microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/FieldUtils.java delete mode 100644 microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/LoggerUtils.java delete mode 100644 microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/MemberUtils.java delete mode 100644 microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/MessagerUtils.java delete mode 100644 microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/MethodUtils.java delete mode 100644 microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/TypeUtils.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/AbstractAnnotationProcessingTest.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/AnnotationProcessingTestProcessor.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/Compiler.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/CompilerInvocationInterceptor.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/DefaultTestService.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/GenericTestService.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/TestAnnotation.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/TestService.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/TestServiceImpl.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/Ancestor.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/ArrayTypeModel.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/CollectionTypeModel.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/Color.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/ConfigurationPropertyModel.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/MapTypeModel.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/Model.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/Parent.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/PrimitiveTypeModel.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/SimpleTypeModel.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/StringArrayList.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/element/StringAnnotationValueTest.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/util/JSONAnnotationValueVisitorTest.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/util/JSONElementVisitorTest.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/util/ResolvableAnnotationValueVisitorTest.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/AnnotationUtilsTest.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/ClassUtilsTest.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/ConstructorUtilsTest.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/ElementUtilsTest.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/ExecutableElementComparatorTest.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/FieldUtilsTest.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/LoggerUtilsTest.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/MemberUtilsTest.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/MessagerUtilsTest.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/MethodUtilsTest.java delete mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/TypeUtilsTest.java diff --git a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/element/StringAnnotationValue.java b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/element/StringAnnotationValue.java deleted file mode 100644 index 42a583f75..000000000 --- a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/element/StringAnnotationValue.java +++ /dev/null @@ -1,50 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package io.microsphere.annotation.processor.model.element; - -import io.microsphere.annotation.Immutable; - -import javax.lang.model.element.AnnotationValue; -import javax.lang.model.element.AnnotationValueVisitor; - -/** - * {@link AnnotationValue} for String type - * - * @author Mercy - * @see AnnotationValue - * @since 1.0.0 - */ -@Immutable -public class StringAnnotationValue implements AnnotationValue { - - private final String value; - - public StringAnnotationValue(String value) { - this.value = value; - } - - @Override - public Object getValue() { - return this.value; - } - - @Override - public R accept(AnnotationValueVisitor v, P p) { - return v.visitString(this.value, p); - } -} diff --git a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/JSONAnnotationValueVisitor.java b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/JSONAnnotationValueVisitor.java deleted file mode 100644 index 327c954b0..000000000 --- a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/JSONAnnotationValueVisitor.java +++ /dev/null @@ -1,197 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package io.microsphere.annotation.processor.model.util; - -import javax.lang.model.element.AnnotationMirror; -import javax.lang.model.element.AnnotationValue; -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.VariableElement; -import javax.lang.model.type.TypeMirror; -import javax.lang.model.util.SimpleAnnotationValueVisitor6; -import java.util.Iterator; -import java.util.List; -import java.util.Map; -import java.util.Map.Entry; - -import static io.microsphere.annotation.processor.util.AnnotationUtils.getAttributeName; -import static io.microsphere.annotation.processor.util.AnnotationUtils.getElementValues; -import static io.microsphere.annotation.processor.util.TypeUtils.getTypeName; -import static io.microsphere.constants.SymbolConstants.COMMA_CHAR; -import static io.microsphere.constants.SymbolConstants.LEFT_CURLY_BRACE_CHAR; -import static io.microsphere.constants.SymbolConstants.LEFT_SQUARE_BRACKET_CHAR; -import static io.microsphere.constants.SymbolConstants.RIGHT_CURLY_BRACE_CHAR; -import static io.microsphere.constants.SymbolConstants.RIGHT_SQUARE_BRACKET_CHAR; -import static io.microsphere.json.JSONUtils.append; -import static io.microsphere.json.JSONUtils.appendName; - -/** - * A visitor implementation for converting {@link AnnotationValue} objects into JSON-formatted strings. - * This class extends {@link SimpleAnnotationValueVisitor6} and is designed to work with Java annotation - * processing tools to generate JSON representations of annotation values. - * - *

Example Usage

- * 
{@code
- * // Example 1: Visiting a simple annotation value
- * AnnotationValue value = ...; // e.g., a String, int, or boolean value
- * ExecutableElement method = ...; // the method corresponding to the annotation attribute
- * StringBuilder jsonBuilder = new StringBuilder();
- * JSONAnnotationValueVisitor visitor = new JSONAnnotationValueVisitor(jsonBuilder);
- * visitor.visit(value, method); // Result: appends JSON key-value pair to jsonBuilder
- *
- * // Example 2: Visiting an array annotation value
- * List arrayValues = ...; // list of annotation values
- * visitor.visitArray(arrayValues, method); // Result: appends JSON array to jsonBuilder
- *
- * // Example 3: Visiting a nested annotation
- * AnnotationMirror annotationMirror = ...;
- * visitor.visitAnnotation(annotationMirror, method); // Result: appends JSON object to jsonBuilder
- * }
- * - *

This visitor is typically used during annotation processing to serialize annotation values - * into a structured JSON format, useful for configuration or metadata generation purposes. - * - * @author Mercy - * @see SimpleAnnotationValueVisitor6 - * @since 1.0.0 - */ -public class JSONAnnotationValueVisitor extends SimpleAnnotationValueVisitor6 { - - private final StringBuilder jsonBuilder; - - public JSONAnnotationValueVisitor(StringBuilder jsonBuilder) { - super(jsonBuilder); - this.jsonBuilder = jsonBuilder; - } - - - @Override - public StringBuilder visitBoolean(boolean value, ExecutableElement attributeMethod) { - append(jsonBuilder, getAttributeName(attributeMethod), value); - return jsonBuilder; - } - - @Override - public StringBuilder visitByte(byte value, ExecutableElement attributeMethod) { - append(jsonBuilder, getAttributeName(attributeMethod), value); - return jsonBuilder; - } - - @Override - public StringBuilder visitChar(char value, ExecutableElement attributeMethod) { - append(jsonBuilder, getAttributeName(attributeMethod), value); - return jsonBuilder; - } - - @Override - public StringBuilder visitDouble(double value, ExecutableElement attributeMethod) { - append(jsonBuilder, getAttributeName(attributeMethod), value); - return jsonBuilder; - } - - @Override - public StringBuilder visitFloat(float value, ExecutableElement attributeMethod) { - append(jsonBuilder, getAttributeName(attributeMethod), value); - return jsonBuilder; - } - - @Override - public StringBuilder visitInt(int value, ExecutableElement attributeMethod) { - append(jsonBuilder, getAttributeName(attributeMethod), value); - return jsonBuilder; - } - - @Override - public StringBuilder visitLong(long value, ExecutableElement attributeMethod) { - append(jsonBuilder, getAttributeName(attributeMethod), value); - return jsonBuilder; - } - - @Override - public StringBuilder visitShort(short value, ExecutableElement attributeMethod) { - append(jsonBuilder, getAttributeName(attributeMethod), value); - return jsonBuilder; - } - - @Override - public StringBuilder visitString(String value, ExecutableElement attributeMethod) { - append(jsonBuilder, getAttributeName(attributeMethod), value); - return jsonBuilder; - } - - @Override - public StringBuilder visitType(TypeMirror value, ExecutableElement attributeMethod) { - append(jsonBuilder, getAttributeName(attributeMethod), getTypeName(value)); - return jsonBuilder; - } - - @Override - public StringBuilder visitEnumConstant(VariableElement value, ExecutableElement attributeMethod) { - append(jsonBuilder, getAttributeName(attributeMethod), value.getSimpleName().toString()); - return jsonBuilder; - } - - @Override - public StringBuilder visitAnnotation(AnnotationMirror value, ExecutableElement attributeMethod) { - Map elementValues = getElementValues(value); - Iterator> iterator = elementValues.entrySet().iterator(); - StringBuilder annotationJsonBuilder = new StringBuilder(); - annotationJsonBuilder.append(LEFT_CURLY_BRACE_CHAR); - JSONAnnotationValueVisitor visitor = new JSONAnnotationValueVisitor(annotationJsonBuilder); - while (iterator.hasNext()) { - Entry entry = iterator.next(); - AnnotationValue annotationValue = entry.getValue(); - visitor.visit(annotationValue, entry.getKey()); - if (iterator.hasNext()) { - annotationJsonBuilder.append(COMMA_CHAR); - } - } - annotationJsonBuilder.append(RIGHT_CURLY_BRACE_CHAR); - - return doAppend(attributeMethod, annotationJsonBuilder); - } - - @Override - public StringBuilder visitArray(List values, ExecutableElement attributeMethod) { - StringBuilder arrayJsonBuilder = new StringBuilder(); - - arrayJsonBuilder.append(LEFT_SQUARE_BRACKET_CHAR); - int size = values.size(); - JSONAnnotationValueVisitor visitor = new JSONAnnotationValueVisitor(arrayJsonBuilder); - for (int i = 0; i < size; i++) { - AnnotationValue annotationValue = values.get(i); - annotationValue.accept(visitor, null); - if (i < size - 1) { - arrayJsonBuilder.append(COMMA_CHAR); - } - } - arrayJsonBuilder.append(RIGHT_SQUARE_BRACKET_CHAR); - - return doAppend(attributeMethod, arrayJsonBuilder); - } - - @Override - public StringBuilder visitUnknown(AnnotationValue annotationValue, ExecutableElement attributeMethod) { - return jsonBuilder; - } - - protected StringBuilder doAppend(ExecutableElement attributeMethod, StringBuilder value) { - appendName(this.jsonBuilder, getAttributeName(attributeMethod)) - .append(value); - return this.jsonBuilder; - } -} diff --git a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/JSONElementVisitor.java b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/JSONElementVisitor.java deleted file mode 100644 index 99856edb3..000000000 --- a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/JSONElementVisitor.java +++ /dev/null @@ -1,221 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package io.microsphere.annotation.processor.model.util; - -import javax.lang.model.element.Element; -import javax.lang.model.element.ElementVisitor; -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.PackageElement; -import javax.lang.model.element.TypeElement; -import javax.lang.model.element.TypeParameterElement; -import javax.lang.model.element.VariableElement; -import javax.lang.model.util.AbstractElementVisitor6; -import javax.lang.model.util.ElementKindVisitor6; -import java.util.List; - -import static java.lang.Boolean.FALSE; - -/** - * A specialized {@link ElementVisitor} implementation that traverses Java elements and generates JSON - * representations of the elements' metadata. - * - *

This abstract class extends {@link ElementKindVisitor6} to provide a foundation for creating - * JSON-based representations of various Java language elements such as packages, types, methods, - * fields, and type parameters. - * - *

Example Usage

- * 
{@code
- * public class CustomJSONElementVisitor extends JSONElementVisitor {
- *     // Implement specific visit methods to customize JSON generation
- * }
- * }
- * - *

Subclasses should implement or override the appropriate visit methods to customize how - * different Java elements are represented in JSON. - * - * @author Mercy - * @see ElementVisitor - * @see ElementKindVisitor6 - * @see AbstractElementVisitor6 - * @since 1.0.0 - */ -public abstract class JSONElementVisitor extends ElementKindVisitor6 { - - public JSONElementVisitor() { - super(FALSE); - } - - @Override - public final Boolean visitPackage(PackageElement e, StringBuilder jsonBuilder) { - return supportsPackage(e) && doVisitPackage(e, jsonBuilder); - } - - @Override - public final Boolean visitVariable(VariableElement e, StringBuilder stringBuilder) { - return supportsVariable(e) && super.visitVariable(e, stringBuilder); - } - - @Override - public final Boolean visitExecutable(ExecutableElement e, StringBuilder jsonBuilder) { - return supportsExecutable(e) && super.visitExecutable(e, jsonBuilder); - } - - @Override - public final Boolean visitType(TypeElement e, StringBuilder jsonBuilder) { - boolean appended = false; - if (supportsType(e) && super.visitType(e, jsonBuilder)) { - appended = true; - } - - // The declared members of the type element - if (visitMembers(e.getEnclosedElements(), jsonBuilder)) { - appended = true; - } - - return appended; - } - - @Override - public final Boolean visitTypeParameter(TypeParameterElement e, StringBuilder jsonBuilder) { - if (!supports(e)) { - return FALSE; - } - - boolean appended = false; - if (supportsTypeParameter(e) && doVisitTypeParameter(e, jsonBuilder)) { - appended = true; - } - - // The declared members of the type element - if (visitMembers(e.getEnclosedElements(), jsonBuilder)) { - appended = true; - } - - return appended; - } - - protected boolean visitMembers(List members, StringBuilder jsonBuilder) { - boolean appended = false; - for (Element member : members) { - if (member.accept(this, jsonBuilder)) { - appended = true; - } - } - return appended; - } - - /** - * Determines whether the specified element is supported for processing. - * - *

This method can be overridden to provide custom logic for deciding - * if an element should be processed by this visitor.

- * - * @param e the element to check - * @return {@code true} if the element is supported; {@code false} otherwise - */ - protected boolean supports(Element e) { - return true; - } - - /** - * Determines whether the specified package element is supported for processing. - * - *

This method can be overridden to provide custom logic for deciding - * if a package element should be processed by this visitor.

- * - * @param e the package element to check - * @return {@code true} if the package element is supported; {@code false} otherwise - */ - protected boolean supportsPackage(PackageElement e) { - return supports(e); - } - - /** - * Determines whether the specified variable element is supported for processing. - * - *

This method can be overridden to provide custom logic for deciding - * if a variable element should be processed by this visitor.

- * - * @param e the variable element to check - * @return {@code true} if the variable element is supported; {@code false} otherwise - */ - protected boolean supportsVariable(VariableElement e) { - return supports(e); - } - - /** - * Determines whether the specified executable element is supported for processing. - * - *

This method can be overridden to provide custom logic for deciding - * if an executable element should be processed by this visitor.

- * - * @param e the executable element to check - * @return {@code true} if the executable element is supported; {@code false} otherwise - */ - protected boolean supportsExecutable(ExecutableElement e) { - return supports(e); - } - - /** - * Determines whether the specified type element is supported for processing. - * - *

This method can be overridden to provide custom logic for deciding - * if a type element should be processed by this visitor.

- * - * @param e the type element to check - * @return {@code true} if the type element is supported; {@code false} otherwise - */ - protected boolean supportsType(TypeElement e) { - return supports(e); - } - - /** - * Determines whether the specified type parameter element is supported for processing. - * - *

This method can be overridden to provide custom logic for deciding - * if a type parameter element should be processed by this visitor.

- * - * @param e the type parameter element to check - * @return {@code true} if the type parameter element is supported; {@code false} otherwise - */ - protected boolean supportsTypeParameter(TypeParameterElement e) { - return supports(e); - } - - /** - * Visits a package element and appends its JSON representation to the builder. - * - * @param e the package element to visit - * @param jsonBuilder the string builder used to construct the JSON output - * @return {@code true} if any content was appended; {@code false} otherwise - */ - protected boolean doVisitPackage(PackageElement e, StringBuilder jsonBuilder) { - return super.visitPackage(e, jsonBuilder); - } - - /** - * Visits a type parameter element and appends its JSON representation to the builder. - * - * @param e the type parameter element to visit - * @param jsonBuilder the string builder used to construct the JSON output - * @return {@code true} if any content was appended; {@code false} otherwise - */ - protected boolean doVisitTypeParameter(TypeParameterElement e, StringBuilder jsonBuilder) { - return super.visitTypeParameter(e, jsonBuilder); - } -} diff --git a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/ResolvableAnnotationValueVisitor.java b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/ResolvableAnnotationValueVisitor.java deleted file mode 100644 index 888c2f7aa..000000000 --- a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/ResolvableAnnotationValueVisitor.java +++ /dev/null @@ -1,200 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package io.microsphere.annotation.processor.model.util; - -import javax.lang.model.element.AnnotationMirror; -import javax.lang.model.element.AnnotationValue; -import javax.lang.model.element.AnnotationValueVisitor; -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.VariableElement; -import javax.lang.model.type.ArrayType; -import javax.lang.model.type.TypeMirror; -import javax.lang.model.util.SimpleAnnotationValueVisitor6; -import java.lang.reflect.Method; -import java.util.List; -import java.util.Map; -import java.util.Map.Entry; - -import static io.microsphere.annotation.processor.util.AnnotationUtils.getAttributeName; -import static io.microsphere.annotation.processor.util.AnnotationUtils.getElementValues; -import static io.microsphere.annotation.processor.util.ClassUtils.loadClass; -import static io.microsphere.collection.MapUtils.newFixedLinkedHashMap; -import static io.microsphere.reflect.MethodUtils.findMethod; -import static io.microsphere.reflect.MethodUtils.invokeStaticMethod; -import static io.microsphere.util.ArrayUtils.newArray; -import static io.microsphere.util.ClassLoaderUtils.resolveClass; -import static java.lang.Enum.valueOf; -import static java.lang.reflect.Array.set; - -/** - * A visitor for resolving annotation values into their corresponding runtime representations. - * - *

This class extends {@link SimpleAnnotationValueVisitor6} to process annotation values and convert - * them into appropriate Java objects such as primitives, strings, enums, classes, annotations, and arrays. - * - *

Example Usage

- * 
{@code
- * // Create an instance with default settings
- * ResolvableAnnotationValueVisitor visitor = new ResolvableAnnotationValueVisitor();
- *
- * // Visit an annotation value
- * AnnotationValue annotationValue = ...; // Obtain from an annotation mirror
- * Object resolvedValue = annotationValue.accept(visitor, executableElement);
- * }
- * - *

Custom behavior examples

- * 
{@code
- * // Create an instance that represents Class values as strings
- * ResolvableAnnotationValueVisitor visitor = new ResolvableAnnotationValueVisitor(true);
- *
- * // Create an instance that handles nested annotations as maps
- * ResolvableAnnotationValueVisitor visitor = new ResolvableAnnotationValueVisitor(false, true);
- * }
- * - * @author Mercy - * @see AnnotationValueVisitor - * @since 1.0.0 - */ -public class ResolvableAnnotationValueVisitor extends SimpleAnnotationValueVisitor6 { - - private static final Class ANNOTATION_PARSER_CLASS = resolveClass("sun.reflect.annotation.AnnotationParser"); - - private static final Method annotationForMapMethod = findMethod(ANNOTATION_PARSER_CLASS, "annotationForMap", Class.class, Map.class); - - private static final boolean DEFAULT_CLASS_VALUES_AS_STRING = false; - - private static final boolean DEFAULT_NESTED_ANNOTATIONS_AS_MAP = false; - - private final boolean classValuesAsString; - - private final boolean nestedAnnotationsAsMap; - - public ResolvableAnnotationValueVisitor() { - this(DEFAULT_CLASS_VALUES_AS_STRING, DEFAULT_NESTED_ANNOTATIONS_AS_MAP); - } - - public ResolvableAnnotationValueVisitor(boolean classValuesAsString) { - this(classValuesAsString, DEFAULT_NESTED_ANNOTATIONS_AS_MAP); - } - - public ResolvableAnnotationValueVisitor(boolean classValuesAsString, boolean nestedAnnotationsAsMap) { - this.classValuesAsString = classValuesAsString; - this.nestedAnnotationsAsMap = nestedAnnotationsAsMap; - } - - @Override - public Object visitBoolean(boolean b, ExecutableElement attributeMethod) { - return b; - } - - @Override - public Object visitByte(byte b, ExecutableElement attributeMethod) { - return b; - } - - @Override - public Object visitChar(char c, ExecutableElement attributeMethod) { - return c; - } - - @Override - public Object visitDouble(double d, ExecutableElement attributeMethod) { - return d; - } - - @Override - public Object visitFloat(float f, ExecutableElement attributeMethod) { - return f; - } - - @Override - public Object visitInt(int i, ExecutableElement attributeMethod) { - return i; - } - - @Override - public Object visitLong(long i, ExecutableElement attributeMethod) { - return i; - } - - @Override - public Object visitShort(short s, ExecutableElement attributeMethod) { - return s; - } - - @Override - public Object visitString(String s, ExecutableElement attributeMethod) { - return s; - } - - @Override - public Object visitType(TypeMirror t, ExecutableElement attributeMethod) { - return classValuesAsString ? t.toString() : loadClass(t); - } - - @Override - public Object visitEnumConstant(VariableElement c, ExecutableElement attributeMethod) { - Class enumClass = loadClass(c.asType()); - return valueOf(enumClass, c.toString()); - } - - @Override - public Object visitAnnotation(AnnotationMirror a, ExecutableElement attributeMethod) { - Map elementValues = getElementValues(a); - Map attributesMap = newFixedLinkedHashMap(elementValues.size()); - for (Entry entry : elementValues.entrySet()) { - ExecutableElement method = entry.getKey(); - String attributeName = getAttributeName(method); - Object attributeValue = entry.getValue().accept(this, method); - attributesMap.put(attributeName, attributeValue); - } - - if (nestedAnnotationsAsMap) { - return attributesMap; - } - - Class annotationClass = loadClass(a.getAnnotationType()); - return invokeStaticMethod(annotationForMapMethod, annotationClass, attributesMap); - } - - @Override - public Object visitArray(List values, ExecutableElement attributeMethod) { - int size = values.size(); - Class componentType = getComponentType(attributeMethod); - Object array = newArray(componentType, size); - for (int i = 0; i < size; i++) { - AnnotationValue value = values.get(i); - Object attributeValue = value.accept(this, attributeMethod); - set(array, i, attributeValue); - } - return array; - } - - Class getComponentType(ExecutableElement attributeMethod) { - if (classValuesAsString) { - return String.class; - } - ArrayType arrayType = (ArrayType) attributeMethod.getReturnType(); - return loadClass(arrayType.getComponentType()); - } - - @Override - public Object visitUnknown(AnnotationValue av, ExecutableElement attributeMethod) { - return av; - } -} diff --git a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/AnnotationUtils.java b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/AnnotationUtils.java deleted file mode 100644 index 4df0bdfc6..000000000 --- a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/AnnotationUtils.java +++ /dev/null @@ -1,1871 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor.util; - -import io.microsphere.annotation.Immutable; -import io.microsphere.annotation.Nonnull; -import io.microsphere.annotation.Nullable; -import io.microsphere.annotation.processor.model.util.ResolvableAnnotationValueVisitor; -import io.microsphere.util.Utils; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.AnnotatedConstruct; -import javax.lang.model.element.AnnotationMirror; -import javax.lang.model.element.AnnotationValue; -import javax.lang.model.element.AnnotationValueVisitor; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.TypeElement; -import javax.lang.model.type.DeclaredType; -import javax.lang.model.type.TypeMirror; -import java.lang.annotation.Annotation; -import java.lang.annotation.ElementType; -import java.lang.annotation.Target; -import java.lang.reflect.Type; -import java.util.Collection; -import java.util.List; -import java.util.Map; -import java.util.Map.Entry; -import java.util.Objects; -import java.util.function.Predicate; - -import static io.microsphere.annotation.processor.util.MethodUtils.findDeclaredMethods; -import static io.microsphere.annotation.processor.util.MethodUtils.getDeclaredMethods; -import static io.microsphere.annotation.processor.util.MethodUtils.getMethodName; -import static io.microsphere.annotation.processor.util.TypeUtils.getAllTypeElements; -import static io.microsphere.annotation.processor.util.TypeUtils.getTypeElement; -import static io.microsphere.annotation.processor.util.TypeUtils.isSameType; -import static io.microsphere.annotation.processor.util.TypeUtils.ofTypeElement; -import static io.microsphere.collection.CollectionUtils.isEmpty; -import static io.microsphere.collection.CollectionUtils.size; -import static io.microsphere.collection.MapUtils.immutableEntry; -import static io.microsphere.collection.MapUtils.isEmpty; -import static io.microsphere.collection.MapUtils.newFixedLinkedHashMap; -import static io.microsphere.lang.function.Predicates.EMPTY_PREDICATE_ARRAY; -import static io.microsphere.lang.function.Streams.filterAll; -import static io.microsphere.util.ArrayUtils.isNotEmpty; -import static io.microsphere.util.StringUtils.isBlank; -import static java.util.Collections.emptyList; -import static java.util.Collections.emptyMap; -import static java.util.Collections.unmodifiableList; -import static java.util.Collections.unmodifiableMap; -import static java.util.stream.Collectors.toList; - -/** - * A utility interface for working with annotations in the {@code javax.lang.model.*} package. - *

- * This interface provides methods to retrieve, filter, and check annotations and their attributes - * from various constructs such as {@link Element}, {@link TypeMirror}, and others commonly used - * in annotation processing. - *

- * - *

Example Usage

- * 
{@code
- * // Retrieve a specific annotation from an element
- * AnnotationMirror annotation = AnnotationUtils.getAnnotation(element, MyAnnotation.class);
- *
- * // Retrieve all annotations from a type
- * List annotations = AnnotationUtils.getAnnotations(typeMirror);
- *
- * // Check if an annotation is present on an element
- * boolean present = AnnotationUtils.isAnnotationPresent(element, MyAnnotation.class);
- *
- * // Find meta-annotations on an annotation
- * AnnotationMirror metaAnnotation = AnnotationUtils.findMetaAnnotation(annotation, MyMetaAnnotation.class);
- * }
- * - *

- * This interface is intended to be implemented by classes that provide static utility methods - * for handling annotations during annotation processing. It helps in organizing and reusing - * common operations related to annotations. - *

- * - * @author Mercy - * @since 1.0.0 - */ -public interface AnnotationUtils extends Utils { - - /** - * The name of the attribute method : value() - */ - String VALUE_ATTRIBUTE_NAME = "value"; - - /** - * The default {@link AnnotationValueVisitor} - */ - AnnotationValueVisitor DEFAULT_ANNOTATION_VALUE_VISITOR = new ResolvableAnnotationValueVisitor(); - - /** - * The empty {@link ElementType} array - */ - @Immutable - ElementType[] EMPTY_ELEMENT_TYPE_ARRAY = new ElementType[0]; - - boolean WITH_DEFAULT = true; - - /** - * Retrieves the first {@link AnnotationMirror} of the specified annotation class from the given - * {@link AnnotatedConstruct}. If either the construct or the annotation class is {@code null}, - * this method returns {@code null}. - * - *

Example Usage

- * 
{@code
-     * // Get an annotation directly present on a class
-     * TypeElement typeElement = ...; // obtain a TypeElement
-     * AnnotationMirror annotation = AnnotationUtils.getAnnotation(typeElement, MyAnnotation.class);
-     *
-     * // Get an annotation from an element that may inherit annotations from its parent
-     * Element element = ...; // obtain an Element
-     * annotation = AnnotationUtils.getAnnotation(element, MyAnnotation.class);
-     * }
- * - * @param annotatedConstruct the annotated construct to search for annotations, may be {@code null} - * @param annotationClass the annotation class to look for, may be {@code null} - * @return the first matching {@link AnnotationMirror}, or {@code null} if none found - */ - static AnnotationMirror getAnnotation(AnnotatedConstruct annotatedConstruct, Class annotationClass) { - if (annotatedConstruct == null || annotationClass == null) { - return null; - } - return getAnnotation(annotatedConstruct, annotationClass.getName()); - } - - /** - * Retrieves the first {@link AnnotationMirror} of the specified annotation class name from the given - * {@link AnnotatedConstruct}. If either the construct or the annotation class name is {@code null}, - * this method returns {@code null}. - * - *

Example Usage

- * 
{@code
-     * // Get an annotation by its class name from an element
-     * TypeElement typeElement = ...; // obtain a TypeElement
-     * String annotationClassName = "com.example.MyAnnotation";
-     * AnnotationMirror annotation = AnnotationUtils.getAnnotation(typeElement, annotationClassName);
-     *
-     * // Get an annotation from a method element
-     * Element methodElement = ...; // obtain a method Element
-     * annotation = AnnotationUtils.getAnnotation(methodElement, "com.example.AnotherAnnotation");
-     * }
- * - * @param annotatedConstruct the annotated construct to search for annotations, may be {@code null} - * @param annotationClassName the fully qualified class name of the annotation to look for, may be {@code null} - * @return the first matching {@link AnnotationMirror}, or {@code null} if none found - */ - static AnnotationMirror getAnnotation(AnnotatedConstruct annotatedConstruct, CharSequence annotationClassName) { - if (annotatedConstruct == null || annotationClassName == null) { - return null; - } - List annotations = getAnnotations(annotatedConstruct, annotationClassName); - return annotations.isEmpty() ? null : annotations.get(0); - } - - /** - * Retrieves all {@link AnnotationMirror} instances from the given {@link AnnotatedConstruct}. - * If the annotated construct is {@code null}, this method returns an empty list. - * - *

Example Usage

- * 
{@code
-     * // Retrieve all annotations from a class element
-     * TypeElement typeElement = ...; // obtain a TypeElement
-     * List annotations = AnnotationUtils.getAnnotations(typeElement);
-     *
-     * // Retrieve annotations from a method element
-     * Element methodElement = ...; // obtain a method Element
-     * annotations = AnnotationUtils.getAnnotations(methodElement);
-     * }
- * - * @param annotatedConstruct the annotated construct to search for annotations, may be {@code null} - * @return a non-null immutable list of {@link AnnotationMirror} instances; never {@code null} - */ - @Nonnull - @Immutable - static List getAnnotations(AnnotatedConstruct annotatedConstruct) { - if (annotatedConstruct == null) { - return emptyList(); - } - return findAnnotations(annotatedConstruct, EMPTY_PREDICATE_ARRAY); - } - - /** - * Retrieves all {@link AnnotationMirror} instances of the specified annotation class from the given - * {@link AnnotatedConstruct}. If either the construct or the annotation class is {@code null}, - * this method returns an empty list. - * - *

Example Usage

- * 
{@code
-     * // Retrieve all annotations of a specific type from a class element
-     * TypeElement typeElement = ...; // obtain a TypeElement
-     * List annotations = AnnotationUtils.getAnnotations(typeElement, MyAnnotation.class);
-     *
-     * // Retrieve annotations from a method element
-     * Element methodElement = ...; // obtain a method Element
-     * annotations = AnnotationUtils.getAnnotations(methodElement, AnotherAnnotation.class);
-     * }
- * - * @param annotatedConstruct the annotated construct to search for annotations, may be {@code null} - * @param annotationClass the annotation class to look for, may be {@code null} - * @return a non-null immutable list of {@link AnnotationMirror} instances; never {@code null} - */ - @Nonnull - @Immutable - static List getAnnotations(AnnotatedConstruct annotatedConstruct, Class annotationClass) { - if (annotatedConstruct == null || annotationClass == null) { - return emptyList(); - } - return getAnnotations(annotatedConstruct, annotationClass.getTypeName()); - } - - /** - * Retrieves all {@link AnnotationMirror} instances of the specified annotation class name from the given - * {@link AnnotatedConstruct}. If either the construct or the annotation class name is {@code null}, - * this method returns an empty list. - * - *

Example Usage

- * 
{@code
-     * // Retrieve annotations by their class name from a class element
-     * TypeElement typeElement = ...; // obtain a TypeElement
-     * String annotationClassName = "com.example.MyAnnotation";
-     * List annotations = AnnotationUtils.getAnnotations(typeElement, annotationClassName);
-     *
-     * // Retrieve annotations from a method element
-     * Element methodElement = ...; // obtain a method Element
-     * annotations = AnnotationUtils.getAnnotations(methodElement, "com.example.AnotherAnnotation");
-     * }
- * - * @param annotatedConstruct the annotated construct to search for annotations, may be {@code null} - * @param annotationClassName the fully qualified class name of the annotation to look for, may be {@code null} - * @return a non-null immutable list of {@link AnnotationMirror} instances; never {@code null} - */ - @Nonnull - @Immutable - static List getAnnotations(AnnotatedConstruct annotatedConstruct, CharSequence annotationClassName) { - if (annotatedConstruct == null || annotationClassName == null) { - return emptyList(); - } - return findAnnotations(annotatedConstruct, annotation -> matchesAnnotationTypeName(annotation, annotationClassName)); - } - - /** - * Retrieves all {@link AnnotationMirror} instances from the given {@link TypeMirror}. - * If the type mirror is {@code null}, this method returns an empty list. - * - *

Example Usage

- * 
{@code
-     * // Retrieve all annotations from a type mirror
-     * TypeMirror type = ...; // obtain a TypeMirror
-     * List annotations = AnnotationUtils.getAllAnnotations(type);
-     *
-     * // Handle cases where the type might be null
-     * annotations = AnnotationUtils.getAllAnnotations(null); // returns empty list
-     * }
- * - * @param type the type mirror to search for annotations, may be {@code null} - * @return a non-null immutable list of {@link AnnotationMirror} instances; never {@code null} - */ - @Nonnull - @Immutable - static List getAllAnnotations(TypeMirror type) { - if (type == null) { - return emptyList(); - } - return getAllAnnotations(ofTypeElement(type)); - } - - /** - * Retrieves all {@link AnnotationMirror} instances from the given {@link Element}. - * If the element is {@code null}, this method returns an empty list. - * - *

This method is designed to provide a consistent way of retrieving annotations - * across different constructs in the annotation processing framework.

- * - *

Example Usage

- * 
{@code
-     * // Retrieve all annotations from a class element
-     * TypeElement typeElement = ...; // obtain a TypeElement
-     * List annotations = AnnotationUtils.getAllAnnotations(typeElement);
-     *
-     * // Retrieve annotations from a method element
-     * Element methodElement = ...; // obtain a method Element
-     * annotations = AnnotationUtils.getAllAnnotations(methodElement);
-     *
-     * // Handle cases where the element might be null
-     * annotations = AnnotationUtils.getAllAnnotations(null); // returns empty list
-     * }
- * - * @param element the annotated element to search for annotations, may be {@code null} - * @return a non-null immutable list of {@link AnnotationMirror} instances; never {@code null} - */ - @Nonnull - @Immutable - static List getAllAnnotations(Element element) { - if (element == null) { - return emptyList(); - } - return findAllAnnotations(element, EMPTY_PREDICATE_ARRAY); - } - - /** - * Retrieves all {@link AnnotationMirror} instances of the specified annotation class from the given - * {@link TypeMirror}. If either the type or the annotation class is {@code null}, this method returns an empty list. - * - *

Example Usage

- * 
{@code
-     * // Retrieve annotations from a type mirror
-     * TypeMirror type = ...; // obtain a TypeMirror
-     * List annotations = AnnotationUtils.getAllAnnotations(type, MyAnnotation.class);
-     *
-     * // Handle cases where the type might be null
-     * annotations = AnnotationUtils.getAllAnnotations(null, MyAnnotation.class); // returns empty list
-     *
-     * // Handle cases where the annotation class might be null
-     * annotations = AnnotationUtils.getAllAnnotations(type, null); // returns empty list
-     * }
- * - * @param type the type mirror to search for annotations, may be {@code null} - * @param annotationClass the annotation class to look for, may be {@code null} - * @return a non-null immutable list of {@link AnnotationMirror} instances; never {@code null} - */ - @Nonnull - @Immutable - static List getAllAnnotations(TypeMirror type, Class annotationClass) { - if (type == null || annotationClass == null) { - return emptyList(); - } - return getAllAnnotations(ofTypeElement(type), annotationClass); - } - - /** - * Retrieves all {@link AnnotationMirror} instances of the specified annotation class from the given - * {@link Element}. If either the element or the annotation class is {@code null}, - * this method returns an empty list. - * - *

Example Usage

- * 
{@code
-     * // Retrieve annotations from a class element
-     * TypeElement typeElement = ...; // obtain a TypeElement
-     * List annotations = AnnotationUtils.getAllAnnotations(typeElement, MyAnnotation.class);
-     *
-     * // Retrieve annotations from a method element
-     * Element methodElement = ...; // obtain a method Element
-     * annotations = AnnotationUtils.getAllAnnotations(methodElement, AnotherAnnotation.class);
-     *
-     * // Handle cases where the element might be null
-     * annotations = AnnotationUtils.getAllAnnotations(null, MyAnnotation.class); // returns empty list
-     *
-     * // Handle cases where the annotation class might be null
-     * annotations = AnnotationUtils.getAllAnnotations(typeElement, null); // returns empty list
-     * }
- * - * @param element the annotated element to search for annotations, may be {@code null} - * @param annotationClass the annotation class to look for, may be {@code null} - * @return a non-null immutable list of {@link AnnotationMirror} instances; never {@code null} - */ - @Nonnull - @Immutable - static List getAllAnnotations(Element element, Class annotationClass) { - if (element == null || annotationClass == null) { - return emptyList(); - } - return getAllAnnotations(element, annotationClass.getTypeName()); - } - - /** - * Retrieves all {@link AnnotationMirror} instances of the specified annotation class name from the given - * {@link TypeMirror}. If either the type or the annotation class name is {@code null}, - * this method returns an empty list. - * - *

Example Usage

- * 
{@code
-     * // Retrieve annotations from a type mirror
-     * TypeMirror type = ...; // obtain a TypeMirror
-     * String annotationClassName = "com.example.MyAnnotation";
-     * List annotations = AnnotationUtils.getAllAnnotations(type, annotationClassName);
-     *
-     * // Handle cases where the type might be null
-     * annotations = AnnotationUtils.getAllAnnotations(null, annotationClassName); // returns empty list
-     *
-     * // Handle cases where the annotation class name might be null
-     * annotations = AnnotationUtils.getAllAnnotations(type, null); // returns empty list
-     * }
- * - * @param type the type mirror to search for annotations, may be {@code null} - * @param annotationClassName the fully qualified class name of the annotation to look for, may be {@code null} - * @return a non-null immutable list of {@link AnnotationMirror} instances; never {@code null} - */ - @Nonnull - @Immutable - static List getAllAnnotations(TypeMirror type, CharSequence annotationClassName) { - if (type == null || annotationClassName == null) { - return emptyList(); - } - return getAllAnnotations(ofTypeElement(type), annotationClassName); - } - - /** - * Retrieves all {@link AnnotationMirror} instances of the specified annotation class name from the given - * {@link Element}. If either the element or the annotation class name is {@code null}, - * this method returns an empty list. - * - *

Example Usage

- * 
{@code
-     * // Retrieve annotations by their class name from a class element
-     * TypeElement typeElement = ...; // obtain a TypeElement
-     * String annotationClassName = "com.example.MyAnnotation";
-     * List annotations = AnnotationUtils.getAllAnnotations(typeElement, annotationClassName);
-     *
-     * // Retrieve annotations from a method element
-     * Element methodElement = ...; // obtain a method Element
-     * annotations = AnnotationUtils.getAllAnnotations(methodElement, "com.example.AnotherAnnotation");
-     *
-     * // Handle cases where the element might be null
-     * annotations = AnnotationUtils.getAllAnnotations(null, annotationClassName); // returns empty list
-     *
-     * // Handle cases where the annotation class name might be null
-     * annotations = AnnotationUtils.getAllAnnotations(typeElement, null); // returns empty list
-     * }
- * - * @param element the annotated element to search for annotations, may be {@code null} - * @param annotationClassName the fully qualified class name of the annotation to look for, may be {@code null} - * @return a non-null immutable list of {@link AnnotationMirror} instances; never {@code null} - */ - @Nonnull - @Immutable - static List getAllAnnotations(Element element, CharSequence annotationClassName) { - if (element == null || annotationClassName == null) { - return emptyList(); - } - return findAllAnnotations(element, annotation -> matchesAnnotationTypeName(annotation, annotationClassName)); - } - - /** - * Retrieves all {@link AnnotationMirror} instances of the specified annotated type from the given - * {@link ProcessingEnvironment}. If either the processing environment or the annotated type is {@code null}, - * this method returns an empty list. - * - *

Example Usage

- * 
{@code
-     * // Retrieve annotations for a specific type from the processing environment
-     * ProcessingEnvironment processingEnv = ...; // obtain a ProcessingEnvironment instance
-     * Type annotatedType = MyAnnotation.class; // specify the annotation type
-     * List annotations = AnnotationUtils.getAllAnnotations(processingEnv, annotatedType);
-     *
-     * // Handle cases where the processing environment might be null
-     * annotations = AnnotationUtils.getAllAnnotations(null, annotatedType); // returns empty list
-     *
-     * // Handle cases where the annotated type might be null
-     * annotations = AnnotationUtils.getAllAnnotations(processingEnv, null); // returns empty list
-     * }
- * - * @param processingEnv the processing environment used to retrieve annotations, may be {@code null} - * @param annotatedType the annotated type to search for annotations, may be {@code null} - * @return a non-null immutable list of {@link AnnotationMirror} instances; never {@code null} - */ - @Nonnull - @Immutable - static List getAllAnnotations(ProcessingEnvironment processingEnv, Type annotatedType) { - if (processingEnv == null || annotatedType == null) { - return emptyList(); - } - return findAllAnnotations(processingEnv, annotatedType, EMPTY_PREDICATE_ARRAY); - } - - /** - * Retrieves the first {@link AnnotationMirror} of the specified annotation class from the given - * {@link TypeMirror}. If either the type or the annotation class is {@code null}, - * this method returns {@code null}. - * - *

Example Usage

- * 
{@code
-     * // Retrieve an annotation from a type mirror
-     * TypeMirror type = ...; // obtain a TypeMirror instance
-     * AnnotationMirror annotation = AnnotationUtils.findAnnotation(type, MyAnnotation.class);
-     *
-     * // Handle cases where the type might be null
-     * annotation = AnnotationUtils.findAnnotation(null, MyAnnotation.class); // returns null
-     *
-     * // Handle cases where the annotation class might be null
-     * annotation = AnnotationUtils.findAnnotation(type, null); // returns null
-     * }
- * - * @param type the type mirror to search for annotations, may be {@code null} - * @param annotationClass the annotation class to look for, may be {@code null} - * @return the first matching {@link AnnotationMirror}, or {@code null} if none found - */ - static AnnotationMirror findAnnotation(TypeMirror type, Class annotationClass) { - if (type == null || annotationClass == null) { - return null; - } - return findAnnotation(type, annotationClass.getTypeName()); - } - - /** - * Retrieves the first {@link AnnotationMirror} of the specified annotation class name from the given - * {@link TypeMirror}. If either the type or the annotation class name is {@code null}, - * this method returns {@code null}. - * - *

Example Usage

- * 
{@code
-     * // Retrieve an annotation by its class name from a type mirror
-     * TypeMirror type = ...; // obtain a TypeMirror instance
-     * String annotationClassName = "com.example.MyAnnotation";
-     * AnnotationMirror annotation = AnnotationUtils.findAnnotation(type, annotationClassName);
-     *
-     * // Handle cases where the type might be null
-     * annotation = AnnotationUtils.findAnnotation(null, annotationClassName); // returns null
-     *
-     * // Handle cases where the annotation class name might be null
-     * annotation = AnnotationUtils.findAnnotation(type, null); // returns null
-     * }
- * - * @param type the type mirror to search for annotations, may be {@code null} - * @param annotationClassName the fully qualified class name of the annotation to look for, may be {@code null} - * @return the first matching {@link AnnotationMirror}, or {@code null} if none found - */ - static AnnotationMirror findAnnotation(TypeMirror type, CharSequence annotationClassName) { - if (type == null || annotationClassName == null) { - return null; - } - return findAnnotation(ofTypeElement(type), annotationClassName); - } - - /** - * Retrieves the first {@link AnnotationMirror} of the specified annotation class from the given - * {@link Element}. If either the element or the annotation class is {@code null}, - * this method returns {@code null}. - * - *

Example Usage

- * 
{@code
-     * // Retrieve an annotation from a class element
-     * TypeElement typeElement = ...; // obtain a TypeElement
-     * AnnotationMirror annotation = AnnotationUtils.findAnnotation(typeElement, MyAnnotation.class);
-     *
-     * // Retrieve an annotation from a method element
-     * Element methodElement = ...; // obtain a method Element
-     * annotation = AnnotationUtils.findAnnotation(methodElement, AnotherAnnotation.class);
-     *
-     * // Handle cases where the element might be null
-     * annotation = AnnotationUtils.findAnnotation(null, MyAnnotation.class); // returns null
-     *
-     * // Handle cases where the annotation class might be null
-     * annotation = AnnotationUtils.findAnnotation(typeElement, null); // returns null
-     * }
- * - * @param element the annotated element to search for annotations, may be {@code null} - * @param annotationClass the annotation class to look for, may be {@code null} - * @return the first matching {@link AnnotationMirror}, or {@code null} if none found - */ - static AnnotationMirror findAnnotation(Element element, Class annotationClass) { - if (element == null || annotationClass == null) { - return null; - } - return findAnnotation(element, annotationClass.getTypeName()); - } - - /** - * Retrieves the first {@link AnnotationMirror} of the specified annotation class name from the given - * {@link Element}. If either the element or the annotation class name is {@code null}, - * this method returns {@code null}. - * - *

Example Usage

- * 
{@code
-     * // Retrieve an annotation by its class name from a class element
-     * TypeElement typeElement = ...; // obtain a TypeElement
-     * String annotationClassName = "com.example.MyAnnotation";
-     * AnnotationMirror annotation = AnnotationUtils.findAnnotation(typeElement, annotationClassName);
-     *
-     * // Retrieve an annotation from a method element
-     * Element methodElement = ...; // obtain a method Element
-     * annotation = AnnotationUtils.findAnnotation(methodElement, "com.example.AnotherAnnotation");
-     *
-     * // Handle cases where the element might be null
-     * annotation = AnnotationUtils.findAnnotation(null, annotationClassName); // returns null
-     *
-     * // Handle cases where the annotation class name might be null
-     * annotation = AnnotationUtils.findAnnotation(typeElement, null); // returns null
-     * }
- * - * @param element the annotated element to search for annotations, may be {@code null} - * @param annotationClassName the fully qualified class name of the annotation to look for, may be {@code null} - * @return the first matching {@link AnnotationMirror}, or {@code null} if none found - */ - static AnnotationMirror findAnnotation(Element element, CharSequence annotationClassName) { - if (element == null || annotationClassName == null) { - return null; - } - List annotations = findAllAnnotations(element, annotation -> matchesAnnotationTypeName(annotation, annotationClassName)); - return isEmpty(annotations) ? null : annotations.get(0); - } - - /** - * Retrieves the first meta-annotation of the specified meta-annotation class from the given annotated element. - * A meta-annotation is an annotation that is present on another annotation. If either the annotated element - * or the meta-annotation class is {@code null}, this method returns {@code null}. - * - *

Example Usage

- * 
{@code
-     * // Retrieve a meta-annotation from an annotation on a class element
-     * TypeElement typeElement = ...; // obtain a TypeElement
-     * AnnotationMirror metaAnnotation = AnnotationUtils.findMetaAnnotation(typeElement, MyMetaAnnotation.class);
-     *
-     * // Retrieve a meta-annotation from an annotation on a method element
-     * Element methodElement = ...; // obtain a method Element
-     * metaAnnotation = AnnotationUtils.findMetaAnnotation(methodElement, AnotherMetaAnnotation.class);
-     *
-     * // Handle cases where the element might be null
-     * metaAnnotation = AnnotationUtils.findMetaAnnotation(null, MyMetaAnnotation.class); // returns null
-     *
-     * // Handle cases where the meta-annotation class might be null
-     * metaAnnotation = AnnotationUtils.findMetaAnnotation(typeElement, null); // returns null
-     * }
- * - * @param annotatedConstruct the annotated element to search for meta-annotations, may be {@code null} - * @param metaAnnotationClass the annotation class to look for as a meta-annotation, may be {@code null} - * @return the first matching meta-{@link AnnotationMirror}, or {@code null} if none found - */ - static AnnotationMirror findMetaAnnotation(Element annotatedConstruct, Class metaAnnotationClass) { - if (annotatedConstruct == null || metaAnnotationClass == null) { - return null; - } - return findMetaAnnotation(annotatedConstruct, metaAnnotationClass.getName()); - } - - /** - * Retrieves the first meta-annotation of the specified meta-annotation class name from the given annotated element. - * A meta-annotation is an annotation that is present on another annotation. If either the annotated element - * or the meta-annotation class name is {@code null}, this method returns {@code null}. - * - *

Example Usage

- * 
{@code
-     * // Retrieve a meta-annotation by its class name from a class element
-     * TypeElement typeElement = ...; // obtain a TypeElement
-     * String metaAnnotationClassName = "com.example.MyMetaAnnotation";
-     * AnnotationMirror metaAnnotation = AnnotationUtils.findMetaAnnotation(typeElement, metaAnnotationClassName);
-     *
-     * // Retrieve a meta-annotation from a method element
-     * Element methodElement = ...; // obtain a method Element
-     * metaAnnotation = AnnotationUtils.findMetaAnnotation(methodElement, "com.example.AnotherMetaAnnotation");
-     *
-     * // Handle cases where the element might be null
-     * metaAnnotation = AnnotationUtils.findMetaAnnotation(null, metaAnnotationClassName); // returns null
-     *
-     * // Handle cases where the meta-annotation class name might be null
-     * metaAnnotation = AnnotationUtils.findMetaAnnotation(typeElement, null); // returns null
-     * }
- * - * @param annotatedConstruct the annotated element to search for meta-annotations, may be {@code null} - * @param metaAnnotationClassName the fully qualified class name of the meta-annotation to look for, may be {@code null} - * @return the first matching meta-{@link AnnotationMirror}, or {@code null} if none found - */ - static AnnotationMirror findMetaAnnotation(Element annotatedConstruct, CharSequence metaAnnotationClassName) { - if (annotatedConstruct == null || metaAnnotationClassName == null) { - return null; - } - - AnnotationMirror metaAnnotation = null; - - List annotations = getAllAnnotations(annotatedConstruct); - int size = size(annotations); - - for (int i = 0; i < size; i++) { - AnnotationMirror annotation = annotations.get(i); - if ((metaAnnotation = findAnnotation(annotation.getAnnotationType(), metaAnnotationClassName)) != null) { - break; - } - } - - return metaAnnotation; - } - - /** - * Checks if the specified annotation is present on the given element, either directly or as a meta-annotation. - * - *

Example Usage

- * 
{@code
-     * // Check if an annotation is present on a class element
-     * TypeElement typeElement = ...; // obtain a TypeElement
-     * boolean present = AnnotationUtils.isAnnotationPresent(typeElement, MyAnnotation.class);
-     *
-     * // Check if an annotation is present on a method element
-     * Element methodElement = ...; // obtain a method Element
-     * present = AnnotationUtils.isAnnotationPresent(methodElement, AnotherAnnotation.class);
-     *
-     * // Handle cases where the element might be null
-     * present = AnnotationUtils.isAnnotationPresent(null, MyAnnotation.class); // returns false
-     *
-     * // Handle cases where the annotation class might be null
-     * present = AnnotationUtils.isAnnotationPresent(typeElement, null); // returns false
-     * }
- * - * @param element the element to check for the presence of the annotation; may be {@code null} - * @param annotationClass the annotation class to look for; may be {@code null} - * @return {@code true} if the annotation is present (either directly or as a meta-annotation), - * {@code false} otherwise or if either parameter is {@code null} - */ - static boolean isAnnotationPresent(Element element, Class annotationClass) { - if (element == null || annotationClass == null) { - return false; - } - return findAnnotation(element, annotationClass) != null || findMetaAnnotation(element, annotationClass) != null; - } - - /** - * Checks if the specified annotation (by class name) is present on the given element, either directly or as a meta-annotation. - * - *

Example Usage

- * 
{@code
-     * // Check if an annotation is present on a class element
-     * TypeElement typeElement = ...; // obtain a TypeElement
-     * String annotationClassName = "com.example.MyAnnotation";
-     * boolean present = AnnotationUtils.isAnnotationPresent(typeElement, annotationClassName);
-     *
-     * // Check if an annotation is present on a method element
-     * Element methodElement = ...; // obtain a method Element
-     * present = AnnotationUtils.isAnnotationPresent(methodElement, "com.example.AnotherAnnotation");
-     *
-     * // Handle cases where the element might be null
-     * present = AnnotationUtils.isAnnotationPresent(null, annotationClassName); // returns false
-     *
-     * // Handle cases where the annotation class name might be null
-     * present = AnnotationUtils.isAnnotationPresent(typeElement, null); // returns false
-     * }
- * - * @param element the element to check for the presence of the annotation; may be {@code null} - * @param annotationClassName the fully qualified class name of the annotation to look for; may be {@code null} - * @return {@code true} if the annotation is present (either directly or as a meta-annotation), - * {@code false} otherwise or if either parameter is {@code null} - */ - static boolean isAnnotationPresent(Element element, CharSequence annotationClassName) { - if (element == null || annotationClassName == null) { - return false; - } - return findAnnotation(element, annotationClassName) != null || findMetaAnnotation(element, annotationClassName) != null; - } - - /** - * Retrieves all {@link AnnotationMirror} instances from the given {@link AnnotatedConstruct} - * that match the provided annotation filters. - * - *

If the annotated construct is {@code null}, this method returns an empty list. - * If no annotation filters are provided, all annotations present on the construct are returned. - * Otherwise, only annotations that satisfy all the provided predicates are included in the result.

- * - *

Example Usage

- * 
{@code
-     * // Retrieve all annotations from a class element
-     * TypeElement typeElement = ...; // obtain a TypeElement
-     * List allAnnotations = AnnotationUtils.findAnnotations(typeElement);
-     *
-     * // Retrieve annotations that match a specific condition
-     * List filteredAnnotations = AnnotationUtils.findAnnotations(typeElement,
-     *     annotation -> "com.example.MyAnnotation".contentEquals(annotation.getAnnotationType().asElement().toString()));
-     *
-     * // Retrieve annotations that match multiple conditions
-     * List multiFilteredAnnotations = AnnotationUtils.findAnnotations(typeElement,
-     *     annotation -> isAnnotationPresent(annotation, "com.example.MetaAnnotation"),
-     *     annotation -> annotation.getElementValues().size() > 1);
-     *
-     * // Handle cases where the annotated construct is null
-     * List annotations = AnnotationUtils.findAnnotations(null); // returns empty list
-     * }
- * - * @param annotatedConstruct the annotated construct to search for annotations, may be {@code null} - * @param annotationFilters a varargs array of predicates used to filter annotations; may be empty or {@code null} - * @return a non-null immutable list of matching {@link AnnotationMirror} instances; never {@code null} - */ - @Nonnull - @Immutable - static List findAnnotations(AnnotatedConstruct annotatedConstruct, Predicate... annotationFilters) { - if (annotatedConstruct == null) { - return emptyList(); - } - - List annotations = (List) annotatedConstruct.getAnnotationMirrors(); - if (isEmpty(annotations)) { - return emptyList(); - } - - if (isNotEmpty(annotationFilters)) { - annotations = filterAll(annotations, annotationFilters); - } - - return annotations.isEmpty() ? emptyList() : unmodifiableList(annotations); - } - - /** - * Retrieves all {@link AnnotationMirror} instances from the given {@link TypeMirror}, applying the specified - * annotation filters to narrow down the results. If the type mirror is {@code null}, this method returns an empty list. - * - *

This method delegates to {@link #findAllAnnotations(TypeElement, Predicate[])} after converting the - * {@link TypeMirror} to a {@link TypeElement} using {@link TypeUtils#ofTypeElement(TypeMirror)}. - * - * @param type the type mirror to search for annotations, may be {@code null} - * @param annotationFilters a varargs array of predicates used to filter annotations; may be empty or {@code null} - * @return a non-null immutable list of matching {@link AnnotationMirror} instances; never {@code null} - */ - @Nonnull - @Immutable - static List findAllAnnotations(TypeMirror type, Predicate... annotationFilters) { - if (type == null) { - return emptyList(); - } - return findAllAnnotations(ofTypeElement(type), annotationFilters); - } - - @Nonnull - @Immutable - static List findAllAnnotations(TypeElement element, Predicate... annotationFilters) { - if (element == null) { - return emptyList(); - } - List typeElements = getAllTypeElements(element); - - List annotations = typeElements.stream() - .map(AnnotationUtils::getAnnotations) - .flatMap(Collection::stream) - .collect(toList()); - - if (isNotEmpty(annotationFilters)) { - annotations = filterAll(annotations, annotationFilters); - } - - return isEmpty(annotations) ? emptyList() : unmodifiableList(annotations); - } - - /** - * Retrieves all {@link AnnotationMirror} instances from the given {@link Element}, applying the specified - * annotation filters to narrow down the results. If the element is {@code null}, this method returns an empty list. - * - *

This method attempts to resolve the element into a {@link TypeElement}. If successful, it delegates to - * {@link #findAllAnnotations(TypeElement, Predicate[])} to retrieve annotations from the type hierarchy. - * Otherwise, it falls back to using {@link #findAnnotations(AnnotatedConstruct, Predicate[])} directly on the element.

- * - * @param element the annotated element to search for annotations, may be {@code null} - * @param annotationFilters a varargs array of predicates used to filter annotations; may be empty or {@code null} - * @return a non-null immutable list of matching {@link AnnotationMirror} instances; never {@code null} - */ - @Nonnull - @Immutable - static List findAllAnnotations(Element element, Predicate... annotationFilters) { - if (element == null) { - return emptyList(); - } - - TypeElement typeElement = ofTypeElement(element); - - if (typeElement == null) { - return findAnnotations(element, annotationFilters); - } - - return findAllAnnotations(typeElement, annotationFilters); - } - - /** - * Retrieves all {@link AnnotationMirror} instances of the specified annotated type from the given - * {@link ProcessingEnvironment}. If either the processing environment or the annotated type is {@code null}, - * this method returns an empty list. - * - *

This method uses the fully qualified type name of the provided {@link Type} to locate the corresponding - * annotations. It delegates to the overloaded method that accepts a {@link CharSequence} for the type name.

- * - * @param processingEnv the processing environment used to retrieve annotations, may be {@code null} - * @param annotatedType the annotated type to search for annotations, may be {@code null} - * @param annotationFilters a varargs array of predicates used to filter annotations; may be empty or {@code null} - * @return a non-null immutable list of {@link AnnotationMirror} instances; never {@code null} - */ - @Nonnull - @Immutable - static List findAllAnnotations(ProcessingEnvironment processingEnv, Type annotatedType, Predicate... annotationFilters) { - if (processingEnv == null || annotatedType == null) { - return emptyList(); - } - return findAllAnnotations(processingEnv, annotatedType.getTypeName(), annotationFilters); - } - - /** - * Retrieves all {@link AnnotationMirror} instances of the specified annotated type name from the given - * {@link ProcessingEnvironment}. If either the processing environment or the annotated type name is {@code null}, - * this method returns an empty list. - * - *

This method resolves the annotated type by delegating to {@link TypeUtils#getTypeElement(ProcessingEnvironment, CharSequence)}, - * and then uses the resolved type to find annotations with the provided filters.

- * - * @param processingEnv the processing environment used to retrieve annotations, may be {@code null} - * @param annotatedTypeName the fully qualified class name of the annotation to look for, may be {@code null} - * @param annotationFilters a varargs array of predicates used to filter annotations; may be empty or {@code null} - * @return a non-null immutable list of matching {@link AnnotationMirror} instances; never {@code null} - */ - @Nonnull - @Immutable - static List findAllAnnotations(ProcessingEnvironment processingEnv, CharSequence annotatedTypeName, Predicate... annotationFilters) { - if (processingEnv == null || annotatedTypeName == null) { - return emptyList(); - } - return findAllAnnotations(getTypeElement(processingEnv, annotatedTypeName), annotationFilters); - } - - /** - * Checks if the given annotation mirror has the same type as the specified {@link Type}. - * - *

This method compares the fully qualified name of the annotation mirror's type with - * the provided type's name. Returns {@code false} if either parameter is {@code null}.

- * - *

Example Usage

- * 
{@code
-     * AnnotationMirror annotationMirror = ...; // obtain an AnnotationMirror instance
-     * Type annotationType = ...; // obtain a Type instance
-     *
-     * // Check if both are non-null and the types match
-     * boolean isMatch = AnnotationUtils.matchesAnnotationType(annotationMirror, annotationType);
-     *
-     * // Handle cases where the annotation mirror might be null
-     * isMatch = AnnotationUtils.matchesAnnotationType(null, annotationType); // returns false
-     *
-     * // Handle cases where the annotation type might be null
-     * isMatch = AnnotationUtils.matchesAnnotationType(annotationMirror, null); // returns false
-     * }
- * - * @param annotationMirror the annotation mirror to compare; may be {@code null} - * @param annotationType the target type to match against; may be {@code null} - * @return {@code true} if both parameters are non-null and their types match by name; - * {@code false} otherwise - */ - static boolean matchesAnnotationType(AnnotationMirror annotationMirror, Type annotationType) { - if (annotationMirror == null || annotationType == null) { - return false; - } - return matchesAnnotationTypeName(annotationMirror, annotationType.getTypeName()); - } - - /** - * Checks if the given annotation mirror has the same type as the specified annotation class name. - * - *

This method compares the fully qualified name of the annotation mirror's type with - * the provided annotation class name. Returns {@code false} if either parameter is {@code null}.

- * - *

Example Usage

- * 
{@code
-     * AnnotationMirror annotationMirror = ...; // obtain an AnnotationMirror instance
-     * String annotationClassName = "com.example.MyAnnotation";
-     *
-     * // Check if both are non-null and the types match
-     * boolean isMatch = AnnotationUtils.matchesAnnotationTypeName(annotationMirror, annotationClassName);
-     *
-     * // Handle cases where the annotation mirror might be null
-     * isMatch = AnnotationUtils.matchesAnnotationTypeName(null, annotationClassName); // returns false
-     *
-     * // Handle cases where the annotation class name might be null
-     * isMatch = AnnotationUtils.matchesAnnotationTypeName(annotationMirror, null); // returns false
-     * }
- * - * @param annotationMirror the annotation mirror to compare; may be {@code null} - * @param annotationTypeName the target annotation class name to match against; may be {@code null} - * @return {@code true} if both parameters are non-null and their types match by name; - * {@code false} otherwise - */ - static boolean matchesAnnotationTypeName(AnnotationMirror annotationMirror, CharSequence annotationTypeName) { - if (annotationMirror == null || annotationTypeName == null) { - return false; - } - return isSameType(annotationMirror.getAnnotationType(), annotationTypeName); - } - - /** - * Retrieves the name of the attribute method from the given {@link ExecutableElement}. - * - *

This method is typically used to extract the attribute name from an annotation method declaration. - * The returned name corresponds to the method's simple name as defined in the annotation interface.

- * - *

Example Usage

- * 
{@code
-     * // Given an annotation interface:
-     * public @interface MyAnnotation {
-     *     String value();
-     *     int priority() default 0;
-     * }
-     *
-     * // Retrieve attribute names from methods
-     * ExecutableElement valueMethod = ...; // method representing 'value()'
-     * ExecutableElement priorityMethod = ...; // method representing 'priority()'
-     *
-     * String valueName = AnnotationUtils.getAttributeName(valueMethod); // returns "value"
-     * String priorityName = AnnotationUtils.getAttributeName(priorityMethod); // returns "priority"
-     *
-     * // Handle cases where the executable element is null
-     * String name = AnnotationUtils.getAttributeName(null); // returns null
-     * }
- * - * @param attributeMethod the executable element representing the annotation attribute method, may be {@code null} - * @return the name of the attribute method, or {@code null} if the provided element is {@code null} - */ - static String getAttributeName(ExecutableElement attributeMethod) { - return getMethodName(attributeMethod); - } - - /** - * Checks if the provided executable element represents an annotation attribute method - * with the specified name. - * - *

Example Usage

- * 
{@code
-     * // Given an annotation interface:
-     * public @interface MyAnnotation {
-     *     String value();
-     *     int priority() default 0;
-     * }
-     *
-     * // Check if the executable element corresponds to the "value" method
-     * ExecutableElement valueMethod = ...; // method representing 'value()'
-     * boolean isValueMethod = AnnotationUtils.matchesAttributeMethod(valueMethod, "value"); // returns true
-     *
-     * // Check if the executable element corresponds to the "priority" method
-     * ExecutableElement priorityMethod = ...; // method representing 'priority()'
-     * boolean isPriorityMethod = AnnotationUtils.matchesAttributeMethod(priorityMethod, "priority"); // returns true
-     *
-     * // Handle cases where the executable element is null
-     * boolean result = AnnotationUtils.matchesAttributeMethod(null, "value"); // returns false
-     *
-     * // Handle cases where the attribute name is null or blank
-     * result = AnnotationUtils.matchesAttributeMethod(valueMethod, null); // returns false
-     * result = AnnotationUtils.matchesAttributeMethod(valueMethod, ""); // returns false
-     * }
- * - * @param attributeMethod the executable element to check, may be {@code null} - * @param attributeName the expected name of the attribute method, may be {@code null} or blank - * @return {@code true} if the method is not null and its name matches the given attribute name; - * {@code false} otherwise - */ - static boolean matchesAttributeMethod(ExecutableElement attributeMethod, String attributeName) { - return attributeMethod != null && Objects.equals(getAttributeName(attributeMethod), attributeName); - } - - /** - * Checks if two given {@link AnnotationValue} instances are equal by comparing their values. - * - *

This method performs a deep comparison of the values contained within the annotation values. - * If both values are {@code null}, they are considered equal. If only one is {@code null}, they are not equal. - * Otherwise, the method compares the actual values using {@link Objects#equals(Object, Object)}.

- * - *

Example Usage

- * 
{@code
-     * AnnotationValue value1 = ...; // obtain an AnnotationValue instance
-     * AnnotationValue value2 = ...; // obtain another AnnotationValue instance
-     *
-     * // Check if both annotation values are equal
-     * boolean isEqual = AnnotationUtils.matchesAttributeValue(value1, value2);
-     *
-     * // Handle cases where either value is null
-     * isEqual = AnnotationUtils.matchesAttributeValue(null, value2); // returns false
-     * isEqual = AnnotationUtils.matchesAttributeValue(value1, null); // returns false
-     * }
- * - * @param one the first annotation value to compare; may be {@code null} - * @param another the second annotation value to compare; may be {@code null} - * @return {@code true} if both annotation values are either {@code null} or their contents are equal; - * {@code false} otherwise - */ - static boolean matchesAttributeValue(AnnotationValue one, AnnotationValue another) { - if (one == another) { - return true; - } - if (one == null || another == null) { - return false; - } - Object oneValue = one.getValue(); - Object anotherValue = another.getValue(); - return Objects.equals(oneValue, anotherValue); - } - - /** - * Checks if the value of the given {@link AnnotationValue} matches the specified attribute value. - * - *

This method compares the actual value extracted from the annotation value with the provided - * attribute value. Returns {@code false} if either parameter is {@code null} or if the values do not match.

- * - *

Example Usage

- * 
{@code
-     * AnnotationValue annotationValue = ...; // obtain an AnnotationValue instance
-     * String expectedValue = "example";
-     * boolean isMatch = AnnotationUtils.matchesAttributeValue(annotationValue, expectedValue); // returns true if values match
-     *
-     * // Handle cases where the annotation value is null
-     * boolean result = AnnotationUtils.matchesAttributeValue(null, expectedValue); // returns false
-     *
-     * // Handle cases where the attribute value is null
-     * result = AnnotationUtils.matchesAttributeValue(annotationValue, null); // returns false
-     * }
- * - * @param annotationValue the annotation value to compare; may be {@code null} - * @param attributeValue the target value to match against; may be {@code null} - * @return {@code true} if both parameters are non-null and their values match; - * {@code false} otherwise - */ - static boolean matchesAttributeValue(AnnotationValue annotationValue, Object attributeValue) { - return annotationValue != null && Objects.equals(annotationValue.getValue(), attributeValue); - } - - /** - * Checks if the provided annotation value matches the default value of the specified attribute method. - * - *

This method is useful when determining if an attribute value in an annotation is explicitly set or - * if it falls back to the default value declared in the annotation interface.

- * - *

Example Usage

- * 
{@code
-     * public @interface MyAnnotation {
-     *     String value() default "default";
-     * }
-     *
-     * AnnotationMirror annotation = ...; // obtained from an annotated element
-     * ExecutableElement attributeMethod = getAttributeMethod(annotation, "value");
-     * AnnotationValue annotationValue = getAttributeValue(annotation, "value");
-     *
-     * boolean isDefaultValue = matchesDefaultAttributeValue(attributeMethod, annotationValue);
-     * }

- * - * @param attributeMethod the executable element representing the annotation attribute method, may be {@code null} - * @param annotationValue the annotation value to compare against the default, may be {@code null} - * @return {@code true} if both the attribute method and annotation value are non-null and the value matches the default; - * {@code false} otherwise - */ - static boolean matchesDefaultAttributeValue(ExecutableElement attributeMethod, AnnotationValue annotationValue) { - return attributeMethod != null && matchesAttributeValue(attributeMethod.getDefaultValue(), annotationValue); - } - - /** - * Retrieves a map of attribute names to their corresponding values from the first matching annotation of the specified class - * on the given annotated construct. This includes both explicitly set values and default values for attributes. - * - *

Example Usage

- * 
{@code
-     * // Given an annotation interface:
-     * public @interface MyAnnotation {
-     *     String value() default "default";
-     *     int priority() default 0;
-     * }
-     *
-     * // Retrieve attributes from an annotated class
-     * TypeElement typeElement = ...; // obtain a TypeElement
-     * Map attributes = AnnotationUtils.getAttributesMap(typeElement, MyAnnotation.class);
-     *
-     * // Example output if MyAnnotation is applied with value="custom"
-     * // attributes will contain:
-     * // {
-     * //     "value" = "custom",
-     * //     "priority" = 0
-     * // }
-     *
-     * // Handle cases where the annotated construct is null
-     * attributes = AnnotationUtils.getAttributesMap(null, MyAnnotation.class); // returns empty map
-     *
-     * // Handle cases where the annotation class is null
-     * attributes = AnnotationUtils.getAttributesMap(typeElement, null); // returns empty map
-     * }
- * - * @param annotatedConstruct the annotated construct (e.g., a class, method, or field) that may contain the annotation, - * may be {@code null} - * @param annotationClass the annotation class used to locate the annotation on the construct, must not be {@code null} - * @return a non-null immutable map of attribute names to their corresponding values; never {@code null}, - * returns an empty map if no annotation is found, the construct is {@code null}, or the annotation class is {@code null} - */ - @Nonnull - @Immutable - static Map getAttributesMap(AnnotatedConstruct annotatedConstruct, Class annotationClass) { - return getAttributesMap(annotatedConstruct, annotationClass, WITH_DEFAULT); - } - - /** - * Retrieves a map of attribute names to their corresponding values from the first matching annotation of the specified class - * on the given annotated construct. This includes both explicitly set values and default values for attributes if the - * {@code withDefault} flag is set to {@code true}. - * - *

Example Usage

- * 
{@code
-     * // Given an annotation interface:
-     * public @interface MyAnnotation {
-     *     String value() default "default";
-     *     int priority() default 0;
-     * }
-     *
-     * // Retrieve attributes from an annotated class
-     * TypeElement typeElement = ...; // obtain a TypeElement
-     * Map attributes = AnnotationUtils.getAttributesMap(typeElement, MyAnnotation.class, true);
-     *
-     * // Example output if MyAnnotation is applied with value="custom"
-     * // attributes will contain:
-     * // {
-     * //     "value" = "custom",
-     * //     "priority" = 0
-     * // }
-     *
-     * // Handle cases where the annotated construct is null
-     * attributes = AnnotationUtils.getAttributesMap(null, MyAnnotation.class, true); // returns empty map
-     *
-     * // Handle cases where the annotation class is null
-     * attributes = AnnotationUtils.getAttributesMap(typeElement, null, true); // returns empty map
-     * }
- * - * @param annotatedConstruct the annotated construct (e.g., a class, method, or field) that may contain the annotation, - * may be {@code null} - * @param annotationClass the annotation class used to locate the annotation on the construct, must not be {@code null} - * @param withDefault flag indicating whether to include default values for attributes that are not explicitly set; - * if {@code true}, default values will be included where applicable - * @return a non-null immutable map of attribute names to their corresponding values; never {@code null}, - * returns an empty map if no annotation is found, the construct is {@code null}, or the annotation class is {@code null} - */ - @Nonnull - @Immutable - static Map getAttributesMap(AnnotatedConstruct annotatedConstruct, Class annotationClass, boolean withDefault) { - return getAttributesMap(getAnnotation(annotatedConstruct, annotationClass), withDefault); - } - - /** - * Retrieves a map of attribute names to their corresponding values from the specified annotation. - * This includes both explicitly set values and default values for attributes. - * - *

Example Usage

- * 
{@code
-     * // Given an annotation interface:
-     * public @interface MyAnnotation {
-     *     String value() default "default";
-     *     int priority() default 0;
-     * }
-     *
-     * // Retrieve attributes from an annotation instance
-     * AnnotationMirror annotation = ...; // obtain an AnnotationMirror instance
-     * Map attributes = AnnotationUtils.getAttributesMap(annotation);
-     *
-     * // Example output if MyAnnotation is applied with value="custom"
-     * // attributes will contain:
-     * // {
-     * //     "value" = "custom",
-     * //     "priority" = 0
-     * // }
-     *
-     * // Handle cases where the annotation is null
-     * Map emptyMap = AnnotationUtils.getAttributesMap(null); // returns empty map
-     * }
- * - * @param annotation the specified annotation, may be {@code null} - * @return a non-null immutable map of attribute names to their corresponding values; never {@code null}, - * returns an empty map if the annotation is {@code null} - */ - @Nonnull - @Immutable - static Map getAttributesMap(AnnotationMirror annotation) { - return getAttributesMap(annotation, WITH_DEFAULT); - } - - /** - * Retrieves a map of attribute names to their corresponding values from the specified annotation. - * This includes both explicitly set values and default values for attributes if the - * {@code withDefault} flag is set to {@code true}. - * - *

Example Usage

- * 
{@code
-     * // Given an annotation interface:
-     * public @interface MyAnnotation {
-     *     String value() default "default";
-     *     int priority() default 0;
-     * }
-     *
-     * // Retrieve attributes from an annotation instance with default values
-     * AnnotationMirror annotation = ...; // obtain an AnnotationMirror instance
-     * Map attributes = AnnotationUtils.getAttributesMap(annotation, true);
-     *
-     * // Example output if MyAnnotation is applied with value="custom"
-     * // attributes will contain:
-     * // {
-     * //     "value" = "custom",
-     * //     "priority" = 0
-     * // }
-     *
-     * // Retrieve attributes without including default values
-     * Map explicitAttributes = AnnotationUtils.getAttributesMap(annotation, false);
-     *
-     * // Handle cases where the annotation is null
-     * Map emptyMap = AnnotationUtils.getAttributesMap(null, true); // returns empty map
-     * }
- * - * @param annotation the specified annotation, may be {@code null} - * @param withDefault flag indicating whether to include default values for attributes that are not explicitly set; - * if {@code true}, default values will be included where applicable - * @return a non-null immutable map of attribute names to their corresponding values; never {@code null}, - * returns an empty map if the annotation is {@code null} - */ - @Nonnull - @Immutable - static Map getAttributesMap(AnnotationMirror annotation, boolean withDefault) { - Map attributes = getElementValues(annotation, withDefault); - int size = attributes.size(); - if (size < 1) { - return emptyMap(); - } - Map attributesMap = newFixedLinkedHashMap(size); - for (Entry entry : attributes.entrySet()) { - ExecutableElement attributeMethod = entry.getKey(); - String attributeName = getAttributeName(attributeMethod); - Object attributeValue = getAttribute(entry); - attributesMap.put(attributeName, attributeValue); - } - return unmodifiableMap(attributesMap); - } - - /** - * Retrieves the map of annotation attribute methods to their corresponding values from the specified - * {@link AnnotatedConstruct} and annotation class. This method finds the first matching annotation on the construct - * and returns all its declared attribute values, including default values. - * - *

This method is a convenience overload that defaults to including default values. If the annotated construct - * is {@code null} or the annotation class is not present, an empty map is returned. - * - *

Example Usage

- * 
{@code
-     * // Given an annotation interface:
-     * public @interface MyAnnotation {
-     *     String value() default "default";
-     *     int priority() default 0;
-     * }
-     *
-     * // Retrieve attribute values from an annotated class
-     * TypeElement typeElement = ...; // obtain a TypeElement
-     * Map attributes = AnnotationUtils.getElementValues(typeElement, MyAnnotation.class);
-     *
-     * // Example output if MyAnnotation is applied with value="custom"
-     * // attributes will contain:
-     * // {
-     * //     value(): "custom",
-     * //     priority(): 0
-     * // }
-     *
-     * // Handle cases where the annotated construct is null
-     * Map emptyMap = AnnotationUtils.getElementValues(null, MyAnnotation.class); // returns empty map
-     *
-     * // Handle cases where the annotation class is null
-     * emptyMap = AnnotationUtils.getElementValues(typeElement, null); // returns empty map
-     * }
- * - * @param annotatedConstruct the annotated construct (e.g., a class, method, or field) that may contain the annotation, - * may be {@code null} - * @param annotationClass the annotation class used to locate the annotation on the construct, must not be {@code null} - * @return a non-null immutable map of executable elements (attribute methods) to their annotation values; never {@code null}, - * returns an empty map if no annotation is found or if the construct is {@code null} - */ - @Nonnull - @Immutable - static Map getElementValues(AnnotatedConstruct annotatedConstruct, Class annotationClass) { - return getElementValues(annotatedConstruct, annotationClass, WITH_DEFAULT); - } - - /** - * Retrieves the map of annotation attribute methods to their corresponding values from the specified - * {@link AnnotatedConstruct} and annotation class. This method finds the first matching annotation on the construct - * and returns all its declared attribute values, including default values if enabled. - * - *

If the annotated construct is {@code null} or the annotation class is not present, an empty map is returned. - * If the {@code withDefault} flag is set to {@code true}, this method includes default values for attributes - * that are not explicitly set.

- * - *

Example Usage

- * 
{@code
-     * // Given an annotation interface:
-     * public @interface MyAnnotation {
-     *     String value() default "default";
-     *     int priority() default 0;
-     * }
-     *
-     * // Retrieve attribute values from an annotated class with default values
-     * TypeElement typeElement = ...; // obtain a TypeElement
-     * Map attributes = AnnotationUtils.getElementValues(typeElement, MyAnnotation.class, true);
-     *
-     * // Example output if MyAnnotation is applied with value="custom"
-     * // attributes will contain:
-     * // {
-     * //     value(): "custom",
-     * //     priority(): 0
-     * // }
-     *
-     * // Retrieve attribute values without including default values
-     * Map explicitAttributes = AnnotationUtils.getElementValues(typeElement, MyAnnotation.class, false);
-     *
-     * // Handle cases where the annotated construct is null
-     * Map emptyMap = AnnotationUtils.getElementValues(null, MyAnnotation.class, true); // returns empty map
-     *
-     * // Handle cases where the annotation class is null
-     * emptyMap = AnnotationUtils.getElementValues(typeElement, null, true); // returns empty map
-     * }
- * - * @param annotatedConstruct the annotated construct (e.g., a class, method, or field) that may contain the annotation, - * may be {@code null} - * @param annotationClass the annotation class used to locate the annotation on the construct, must not be {@code null} - * @param withDefault flag indicating whether to include default values for attributes that are not explicitly set; - * if {@code true}, default values will be included where applicable - * @return a non-null immutable map of executable elements (attribute methods) to their annotation values; never {@code null}, - * returns an empty map if no annotation is found or if the construct is {@code null} - */ - @Nonnull - @Immutable - static Map getElementValues(AnnotatedConstruct annotatedConstruct, Class annotationClass, boolean withDefault) { - return getElementValues(getAnnotation(annotatedConstruct, annotationClass), withDefault); - } - - /** - * Retrieves a map of annotation attribute methods to their corresponding values from the specified - * {@link AnnotationMirror}. This method includes both explicitly set values and default values for attributes. - * - *

If the provided annotation is {@code null}, an empty map is returned.

- * - *

Example Usage

- * 
{@code
-     * // Given an annotation interface:
-     * public @interface MyAnnotation {
-     *     String value() default "default";
-     *     int priority() default 0;
-     * }
-     *
-     * // Retrieve attribute values from an annotation instance
-     * AnnotationMirror annotation = ...; // obtain an AnnotationMirror instance
-     * Map attributes = AnnotationUtils.getElementValues(annotation);
-     *
-     * // Example output if MyAnnotation is applied with value="custom"
-     * // attributes will contain:
-     * // {
-     * //     value(): "custom",
-     * //     priority(): 0
-     * // }
-     *
-     * // Handle cases where the annotation is null
-     * Map emptyMap = AnnotationUtils.getElementValues(null); // returns empty map
-     * }
- * - * @param annotation the annotation mirror to extract attribute values from, may be {@code null} - * @return a non-null immutable map of executable elements (attribute methods) to their annotation values; - * never {@code null}, returns an empty map if the annotation is {@code null} - */ - @Nonnull - @Immutable - static Map getElementValues(AnnotationMirror annotation) { - return getElementValues(annotation, WITH_DEFAULT); - } - - /** - * Retrieves a map of annotation attribute methods to their corresponding values from the specified - * {@link AnnotationMirror}. This method includes both explicitly set values and default values for attributes - * if the {@code withDefault} flag is set to {@code true}. - * - *

If the provided annotation is {@code null}, an empty map is returned.

- * - *

Example Usage

- * 
{@code
-     * // Given an annotation interface:
-     * public @interface MyAnnotation {
-     *     String value() default "default";
-     *     int priority() default 0;
-     * }
-     *
-     * // Retrieve attribute values from an annotation instance with default values
-     * AnnotationMirror annotation = ...; // obtain an AnnotationMirror instance
-     * Map attributes = AnnotationUtils.getElementValues(annotation, true);
-     *
-     * // Example output if MyAnnotation is applied with value="custom"
-     * // attributes will contain:
-     * // {
-     * //     value(): "custom",
-     * //     priority(): 0
-     * // }
-     *
-     * // Retrieve attribute values without including default values
-     * Map explicitAttributes = AnnotationUtils.getElementValues(annotation, false);
-     *
-     * // Handle cases where the annotation is null
-     * Map emptyMap = AnnotationUtils.getElementValues(null, true); // returns empty map
-     * }
- * - * @param annotation the annotation mirror to extract attribute values from, may be {@code null} - * @param withDefault flag indicating whether to include default values for attributes that are not explicitly set; - * if {@code true}, default values will be included where applicable - * @return a non-null immutable map of executable elements (attribute methods) to their annotation values; - * never {@code null}, returns an empty map if the annotation is {@code null} - */ - @Nonnull - @Immutable - static Map getElementValues(AnnotationMirror annotation, boolean withDefault) { - if (annotation == null) { - return emptyMap(); - } - DeclaredType annotationType = annotation.getAnnotationType(); - List attributeMethods = getDeclaredMethods(annotationType); - int size = attributeMethods.size(); - Map attributes = newFixedLinkedHashMap(size); - Map elementValues = annotation.getElementValues(); - for (int i = 0; i < size; i++) { - ExecutableElement attributeMethod = attributeMethods.get(i); - AnnotationValue annotationValue = elementValues.get(attributeMethod); - if (withDefault && annotationValue == null) { - annotationValue = attributeMethod.getDefaultValue(); - } - if (annotationValue != null) { - attributes.put(attributeMethod, annotationValue); - } - } - return unmodifiableMap(attributes); - } - - /** - * Retrieves the attribute method and its corresponding annotation value from the specified annotation - * based on the given attribute name. If no explicit value is found and {@code withDefault} is true, - * it attempts to find and return the default value for the attribute. - * - *

If the provided annotation is null or the attribute name is blank, this method returns null.

- * - *

Example Usage

- * 
{@code
-     * AnnotationMirror annotation = ...; // obtain an AnnotationMirror instance
-     * String attributeName = "value"; // the name of the attribute to retrieve
-     *
-     * // Retrieve an attribute with default value lookup enabled
-     * Map.Entry attributeEntry = AnnotationUtils.getElementValue(annotation, attributeName, true);
-     *
-     * if (attributeEntry != null) {
-     *     ExecutableElement attributeMethod = attributeEntry.getKey();
-     *     AnnotationValue annotationValue = attributeEntry.getValue();
-     *     // process attribute method and value
-     * }
-     *
-     * // Retrieve an attribute without default value lookup
-     * attributeEntry = AnnotationUtils.getElementValue(annotation, attributeName, false);
-     *
-     * // Handle cases where the annotation is null
-     * attributeEntry = AnnotationUtils.getElementValue(null, attributeName, true); // returns null
-     *
-     * // Handle cases where the attribute name is blank or null
-     * attributeEntry = AnnotationUtils.getElementValue(annotation, null, true); // returns null
-     * }
- * - * @param annotation the annotation mirror to extract the attribute value from, may be {@code null} - * @param attributeName the name of the attribute method to look for, may be blank - * @param withDefault flag indicating whether to include the default value if the attribute is not explicitly set; - * if true, the method will attempt to find and return the default value - * @return an entry containing the executable element (attribute method) and its corresponding annotation value; - * returns null if the annotation is null, the attribute name is blank, or the attribute method cannot be found - */ - @Nullable - @Immutable - static Entry getElementValue(AnnotationMirror annotation, String attributeName, boolean withDefault) { - if (annotation == null || isBlank(attributeName)) { - return null; - } - - ExecutableElement attributeMethod = null; - AnnotationValue annotationValue = null; - Map elementValues = annotation.getElementValues(); - for (Entry entry : elementValues.entrySet()) { - attributeMethod = entry.getKey(); - if (matchesAttributeMethod(attributeMethod, attributeName)) { - annotationValue = entry.getValue(); - break; - } - } - - if (withDefault && annotationValue == null) { // not found if the default value is required - DeclaredType annotationType = annotation.getAnnotationType(); - List attributeMethods = findDeclaredMethods(annotationType, method -> !elementValues.containsKey(method)); - int size = attributeMethods.size(); - for (int i = 0; i < size; i++) { - attributeMethod = attributeMethods.get(i); - if (matchesAttributeMethod(attributeMethod, attributeName)) { - annotationValue = attributeMethod.getDefaultValue(); - break; - } - } - } - - return immutableEntry(attributeMethod, annotationValue); - } - - /** - * Retrieves the attribute method and its corresponding annotation value from the specified element values map - * based on the given attribute name. - * - *

This method searches through the provided map of executable elements (attribute methods) to their annotation - * values to find a matching attribute by name. If no match is found, it returns {@code null}.

- * - *

Example Usage

- * 
{@code
-     * // Given an annotation interface:
-     * public @interface MyAnnotation {
-     *     String value() default "default";
-     *     int priority() default 0;
-     * }
-     *
-     * // Assume elementValues contains:
-     * // {
-     * //     value(): "custom",
-     * //     priority(): 5
-     * // }
-     *
-     * // Retrieve an existing attribute
-     * Entry entry = AnnotationUtils.getElementValue(elementValues, "value");
-     * if (entry != null) {
-     *     String value = (String) entry.getValue().getValue(); // returns "custom"
-     * }
-     *
-     * // Retrieve a non-existent attribute
-     * entry = AnnotationUtils.getElementValue(elementValues, "nonExistent"); // returns null
-     *
-     * // Handle cases where the element values map is null or empty
-     * entry = AnnotationUtils.getElementValue(null, "value"); // returns null
-     * }
- * - * @param elementValues the map of executable elements (attribute methods) to their annotation values; - * may be {@code null} or empty - * @param attributeName the name of the attribute method to look for; may be {@code null} or blank - * @return an entry containing the executable element (attribute method) and its corresponding annotation value; - * returns {@code null} if the element values map is empty, the attribute name is blank, or no matching - * attribute is found - */ - @Nullable - static Entry getElementValue(Map elementValues, String attributeName) { - if (isEmpty(elementValues)) { - return null; - } - for (Entry entry : elementValues.entrySet()) { - if (matchesAttributeMethod(entry.getKey(), attributeName)) { - return entry; - } - } - return null; - } - - /** - * Retrieves the value of the specified attribute from the given annotation. - * - *

This method attempts to find the attribute by name in the provided annotation. If the attribute is not explicitly set, - * it will attempt to retrieve the default value associated with that attribute. If the attribute cannot be resolved or no value is found, - * this method returns {@code null}.

- * - *

Example Usage

- * 
{@code
-     * // Given an annotation interface:
-     * public @interface MyAnnotation {
-     *     String value() default "default";
-     *     int priority() default 0;
-     * }
-     *
-     * // Retrieve the value of the "value" attribute
-     * AnnotationMirror annotation = ...; // obtain an AnnotationMirror instance
-     * String value = AnnotationUtils.getAttribute(annotation, "value"); // returns "default" or explicit value
-     *
-     * // Retrieve the value of the "priority" attribute
-     * int priority = AnnotationUtils.getAttribute(annotation, "priority"); // returns 0 or explicit value
-     *
-     * // Handle cases where the annotation is null
-     * String result = AnnotationUtils.getAttribute(null, "value"); // returns null
-     *
-     * // Handle cases where the attribute name is blank or null
-     * result = AnnotationUtils.getAttribute(annotation, null); // returns null
-     * }
- * - * @param the type of the attribute value to return - * @param annotation the annotation mirror to extract the attribute value from; may be {@code null} - * @param attributeName the name of the attribute method to look for; may be blank or {@code null} - * @return the value of the specified attribute if found, or the default value if available; - * returns {@code null} if the annotation is {@code null}, the attribute name is blank, - * or the attribute cannot be resolved - */ - @Nullable - static T getAttribute(AnnotationMirror annotation, String attributeName) { - return getAttribute(annotation, attributeName, WITH_DEFAULT); - } - - /** - * Retrieves the value of the specified attribute from the given annotation, optionally including the default value. - * - *

This method attempts to find the attribute by name in the provided annotation. If the attribute is not explicitly set, - * and the {@code withDefault} flag is set to {@code true}, it will attempt to retrieve the default value associated - * with that attribute. If the attribute cannot be resolved or no value is found, this method returns {@code null}.

- * - *

Example Usage

- * 
{@code
-     * // Given an annotation interface:
-     * public @interface MyAnnotation {
-     *     String value() default "default";
-     *     int priority() default 0;
-     * }
-     *
-     * // Retrieve the value of the "value" attribute including default
-     * AnnotationMirror annotation = ...; // obtain an AnnotationMirror instance
-     * String value = AnnotationUtils.getAttribute(annotation, "value", true); // returns "default" or explicit value
-     *
-     * // Retrieve the value of the "priority" attribute without default lookup
-     * int priority = AnnotationUtils.getAttribute(annotation, "priority", false); // returns 0 only if explicitly set
-     *
-     * // Handle cases where the annotation is null
-     * String result = AnnotationUtils.getAttribute(null, "value", true); // returns null
-     *
-     * // Handle cases where the attribute name is blank or null
-     * result = AnnotationUtils.getAttribute(annotation, null, true); // returns null
-     * }
- * - * @param the type of the attribute value to return - * @param annotation the annotation mirror to extract the attribute value from; may be {@code null} - * @param attributeName the name of the attribute method to look for; may be blank or {@code null} - * @param withDefault flag indicating whether to include the default value if the attribute is not explicitly set; - * if {@code true}, the method will attempt to find and return the default value - * @return the value of the specified attribute if found, or the default value if available; - * returns {@code null} if the annotation is {@code null}, the attribute name is blank, - * or the attribute cannot be resolved - */ - @Nullable - static T getAttribute(AnnotationMirror annotation, String attributeName, boolean withDefault) { - Entry attributeEntry = getElementValue(annotation, attributeName, withDefault); - return getAttribute(attributeEntry); - } - - /** - * Retrieves the value of the specified attribute from the provided entry containing the attribute method - * and its corresponding annotation value. - * - *

If the entry is null or either the attribute method or annotation value is unresolved, this method returns {@code null}. - * Otherwise, it delegates to the default {@link AnnotationValueVisitor} to extract the attribute value.

- * - *

Example Usage

- * 
{@code
-     * // Given an annotation interface:
-     * public @interface MyAnnotation {
-     *     String value() default "default";
-     *     int priority() default 0;
-     * }
-     *
-     * // Assume elementValue contains the entry for "value" attribute
-     * Entry elementValue = ...; // obtain from AnnotationUtils.getElementValue()
-     * String value = AnnotationUtils.getAttribute(elementValue); // returns "default" or explicit value
-     *
-     * // Handle cases where the element value entry is null
-     * String result = AnnotationUtils.getAttribute(null); // returns null
-     * }
- * - * @param the expected type of the attribute value - * @param elementValue an entry containing the attribute method and its corresponding annotation value; - * may be {@code null} - * @return the resolved value of the attribute if found; returns {@code null} if the entry is null, - * or if either the attribute method or annotation value is unresolved - */ - @Nullable - static T getAttribute(Entry elementValue) { - if (elementValue == null) { - return null; - } - - ExecutableElement attributeMethod = elementValue.getKey(); - AnnotationValue annotationValue = elementValue.getValue(); - - return (T) annotationValue.accept(DEFAULT_ANNOTATION_VALUE_VISITOR, attributeMethod); - } - - /** - * Retrieves the value of the default attribute method named {@code "value"} from the specified annotation. - * - *

This method delegates to {@link #getAttribute(AnnotationMirror, String)} to obtain the value of the annotation's - * {@code value()} method. Returns {@code null} if the annotation is {@code null} or if the value cannot be resolved.

- * - *

Example Usage

- * 
{@code
-     * // Given an annotation interface:
-     * public @interface MyAnnotation {
-     *     String value() default "default";
-     * }
-     *
-     * // Retrieve the "value" attribute from an annotation instance
-     * AnnotationMirror annotation = ...; // obtain an AnnotationMirror instance
-     * String value = AnnotationUtils.getValue(annotation); // returns "default" or explicit value
-     *
-     * // Handle cases where the annotation is null
-     * String result = AnnotationUtils.getValue(null); // returns null
-     * }
- * - * @param the expected type of the attribute value - * @param annotation the annotation mirror to extract the value from; may be {@code null} - * @return the resolved value of the annotation's {@code value()} method if found; - * returns {@code null} if the annotation is {@code null} or the value cannot be resolved - */ - @Nullable - static T getValue(AnnotationMirror annotation) { - return getAttribute(annotation, VALUE_ATTRIBUTE_NAME); - } - - /** - * Retrieves the {@link ElementType} array from the specified annotation. - * - * @param annotation the specified annotation, may be {@code null} - * @return a non-null array of {@link ElementType}; never {@code null}, returns an empty array if the annotation is {@code null} - */ - /** - * Retrieves the {@link ElementType} array from the specified annotation. - * - *

This method checks the annotation's type for the presence of a {@link Target} annotation, - * which defines the element types the annotation can be applied to. If the provided annotation - * is {@code null}, this method returns an empty array.

- * - *

Example Usage

- * 
{@code
-     * AnnotationMirror annotation = ...; // obtain an AnnotationMirror instance
-     * ElementType[] elementTypes = AnnotationUtils.getElementTypes(annotation);
-     *
-     * // Handle cases where the annotation is null
-     * ElementType[] emptyTypes = AnnotationUtils.getElementTypes(null); // returns empty array
-     * }
- * - * @param annotation the specified annotation, may be {@code null} - * @return a non-null array of {@link ElementType}; never {@code null}, returns an empty array if the annotation is {@code null} - */ - @Nonnull - static ElementType[] getElementTypes(AnnotationMirror annotation) { - return annotation == null ? EMPTY_ELEMENT_TYPE_ARRAY : getElementTypes(annotation.getAnnotationType()); - } - - /** - * Retrieves the {@link ElementType} array from the specified annotation type by checking - * the {@link Target} annotation associated with it. If the annotation type does not have a - * {@link Target} annotation, an empty array is returned. - * - *

Example Usage

- * 
{@code
-     * // Given an annotation type:
-     * public @interface MyAnnotation {
-     * }
-     *
-     * DeclaredType annotationType = ...; // obtain a DeclaredType for MyAnnotation
-     * ElementType[] elementTypes = AnnotationUtils.getElementTypes(annotationType);
-     *
-     * // If MyAnnotation is annotated with @Target(ElementType.TYPE)
-     * // elementTypes will contain: { ElementType.TYPE }
-     *
-     * // Handle cases where the annotation type does not have a @Target annotation
-     * ElementType[] emptyTypes = AnnotationUtils.getElementTypes(annotationType); // returns empty array
-     * }
- * - * @param annotationType the declared type of the annotation - * @return a non-null immutable array of {@link ElementType}; never {@code null}, - * returns an empty array if no {@link Target} annotation is present - */ - @Nonnull - static ElementType[] getElementTypes(DeclaredType annotationType) { - AnnotationMirror targetAnnotation = findAnnotation(annotationType, Target.class); - ElementType[] elementTypes = getValue(targetAnnotation); - return elementTypes == null ? EMPTY_ELEMENT_TYPE_ARRAY : elementTypes; - } -} diff --git a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/ClassUtils.java b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/ClassUtils.java deleted file mode 100644 index 77988604c..000000000 --- a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/ClassUtils.java +++ /dev/null @@ -1,109 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package io.microsphere.annotation.processor.util; - -import io.microsphere.util.Utils; - -import javax.lang.model.type.TypeMirror; - -import static io.microsphere.annotation.processor.util.TypeUtils.ofTypeElement; -import static io.microsphere.constants.SymbolConstants.DOLLAR_CHAR; -import static io.microsphere.constants.SymbolConstants.DOT_CHAR; -import static io.microsphere.util.ClassLoaderUtils.getClassLoader; -import static io.microsphere.util.ClassLoaderUtils.resolveClass; - -/** - * The utilities class for {@link Class} - * - * @author Mercy - * @see Class - * @since 1.0.0 - */ -public interface ClassUtils extends Utils { - - /** - * Gets the fully qualified class name from the given {@link TypeMirror}. - * - *

- * This method is useful when working with annotation processors or other - * compile-time code analysis tools that deal with type information represented - * as a {@link TypeMirror}. - *

- * - *

Example Usage

- * 
-     * TypeMirror type = processingEnv.getElementUtils().getTypeElement("com.example.MyClass").asType();
-     * String className = getClassName(type); // returns "com.example.MyClass"
-     *
- * - * @param type the type mirror to extract the class name from - * @return the fully qualified class name as a String - */ - static String getClassName(TypeMirror type) { - return ofTypeElement(type).getQualifiedName().toString(); - } - - /** - * Loads the class represented by the given {@link TypeMirror}. - * - *

This method derives the fully qualified class name from the type mirror and - * delegates to the other {@link #loadClass(String)} method for class loading. - * It is particularly useful in annotation processors or compile-time tools where - * types are primarily accessed via their mirror representations. - * - *

Example Usage

- * 
-     * TypeMirror type = processingEnv.getElementUtils().getTypeElement("com.example.MyClass").asType();
-     * Class clazz = ClassUtils.loadClass(type); // loads com.example.MyClass
-     *
- * - * @param type the type mirror representing the class to load - * @return the resolved {@link Class}, or {@code null} if the class cannot be found - */ - static Class loadClass(TypeMirror type) { - return loadClass(getClassName(type)); - } - - /** - * Loads the class represented by the given fully qualified class name. - * - *

This method attempts to resolve the class using the provided class name and the class loader - * obtained from {@link ClassUtils}. If the class is not found, an attempt is made to resolve it - * as a nested or inner class by replacing the last dot ({@code .}) with a dollar sign ({@code $}). - * - *

Example Usage

- * 
-     * Class clazz = ClassUtils.loadClass("com.example.MyClass");
-     * // If MyClass is an inner class, this may also attempt to load "com.example.My$Class"
-     *
- * - * @param className the fully qualified name of the class to load - * @return the resolved {@link Class}, or {@code null} if the class cannot be found - */ - static Class loadClass(String className) { - ClassLoader classLoader = getClassLoader(ClassUtils.class); - Class klass = resolveClass(className, classLoader); - if (klass == null) { - int index = className.lastIndexOf(DOT_CHAR); - if (index > 0) { - className = className.substring(0, index) + DOLLAR_CHAR + className.substring(index + 1); - } - } - return resolveClass(className, classLoader); - } -} diff --git a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/ConstructorUtils.java b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/ConstructorUtils.java deleted file mode 100644 index e19f43845..000000000 --- a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/ConstructorUtils.java +++ /dev/null @@ -1,293 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package io.microsphere.annotation.processor.util; - -import io.microsphere.annotation.Immutable; -import io.microsphere.annotation.Nonnull; -import io.microsphere.annotation.Nullable; -import io.microsphere.util.Utils; - -import javax.lang.model.element.Element; -import javax.lang.model.element.ElementKind; -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.TypeElement; -import javax.lang.model.type.TypeMirror; -import java.lang.reflect.Constructor; -import java.lang.reflect.Type; -import java.util.List; -import java.util.function.Predicate; - -import static io.microsphere.annotation.processor.util.ElementUtils.filterElements; -import static io.microsphere.annotation.processor.util.ElementUtils.matchParameterTypes; -import static io.microsphere.annotation.processor.util.MemberUtils.getDeclaredMembers; -import static io.microsphere.collection.CollectionUtils.isEmpty; -import static io.microsphere.collection.ListUtils.first; -import static io.microsphere.lang.function.Predicates.EMPTY_PREDICATE_ARRAY; -import static java.util.Collections.emptyList; -import static javax.lang.model.util.ElementFilter.constructorsIn; - -/** - * The utils class for {@link Constructor constructor} - * - * @author Mercy - * @see Constructor - * @see ExecutableElement - * @see ElementKind#CONSTRUCTOR - * @since 1.0.0 - */ -public interface ConstructorUtils extends Utils { - - /** - * Retrieves the list of declared constructors from the provided {@link TypeElement}. - *

- * This method provides a null-safe way to obtain the constructors of a given type. - * If the input {@code type} is {@code null}, an empty list is returned. - *

- * - *

Example Usage

- * 
{@code
-     * TypeElement typeElement = ...; // Obtain a valid TypeElement
-     * List constructors = getDeclaredConstructors(typeElement);
-     * if (!constructors.isEmpty()) {
-     *     for (ExecutableElement constructor : constructors) {
-     *         System.out.println("Constructor: " + constructor);
-     *     }
-     * } else {
-     *     System.out.println("No constructors found.");
-     * }
-     * }
- * - *

- * This method is particularly useful when processing annotations during compilation, - * where it is necessary to inspect the constructors of a class without throwing exceptions - * for null inputs. - *

- * - * @param type the {@link TypeElement} representing the type to retrieve constructors from - * @return a {@link List} of {@link ExecutableElement} objects representing the declared constructors; - * never {@code null}, but may be empty if no constructors are found or if the input is {@code null} - */ - @Nonnull - @Immutable - static List getDeclaredConstructors(TypeElement type) { - return type == null ? emptyList() : getDeclaredConstructors(type.asType()); - } - - /** - * Retrieves the list of declared constructors from the provided {@link TypeMirror}. - *

- * This method provides a null-safe way to obtain the constructors of a given type. - * If the input {@code type} is {@code null}, an empty list is returned. - *

- * - *

Example Usage

- * 
{@code
-     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror
-     * List constructors = getDeclaredConstructors(typeMirror);
-     * if (!constructors.isEmpty()) {
-     *     for (ExecutableElement constructor : constructors) {
-     *         System.out.println("Constructor: " + constructor);
-     *     }
-     * } else {
-     *     System.out.println("No constructors found.");
-     * }
-     * }
- * - *

- * This method is particularly useful when processing annotations during compilation, - * where it is necessary to inspect the constructors of a class without throwing exceptions - * for null inputs. - *

- * - * @param type the {@link TypeMirror} representing the type to retrieve constructors from - * @return a {@link List} of {@link ExecutableElement} objects representing the declared constructors; - * never {@code null}, but may be empty if no constructors are found or if the input is {@code null} - */ - @Nonnull - @Immutable - static List getDeclaredConstructors(TypeMirror type) { - return type == null ? emptyList() : findDeclaredConstructors(type, EMPTY_PREDICATE_ARRAY); - } - - /** - * Finds a declared constructor in the specified {@link TypeElement} that matches the given parameter types. - *

- * This method provides a null-safe way to locate a constructor based on its parameter types. - * If the input {@code type} is {@code null}, or no matching constructor is found, {@code null} is returned. - *

- * - *

Example Usage

- * 
{@code
-     * TypeElement typeElement = ...; // Obtain a valid TypeElement
-     * Type[] paramTypes = new Type[] { String.class, int.class };
-     * ExecutableElement constructor = findConstructor(typeElement, paramTypes);
-     * if (constructor != null) {
-     *     System.out.println("Found constructor: " + constructor);
-     * } else {
-     *     System.out.println("Constructor not found.");
-     * }
-     * }
- * - * @param type the {@link TypeElement} representing the type to search for constructors - * @param parameterTypes the array of {@link Type} objects representing the parameter types to match - * @return the matched {@link ExecutableElement} representing the constructor; may be {@code null} - */ - @Nullable - static ExecutableElement findConstructor(TypeElement type, Type... parameterTypes) { - return type == null ? null : findConstructor(type.asType(), parameterTypes); - } - - /** - * Finds a declared constructor in the specified {@link TypeMirror} that matches the given parameter types. - *

- * This method provides a null-safe way to locate a constructor based on its parameter types. - * If the input {@code type} is {@code null}, or no matching constructor is found, {@code null} is returned. - *

- * - *

Example Usage

- * 
{@code
-     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror
-     * Type[] paramTypes = new Type[] { String.class, int.class };
-     * ExecutableElement constructor = findConstructor(typeMirror, paramTypes);
-     * if (constructor != null) {
-     *     System.out.println("Found constructor: " + constructor);
-     * } else {
-     *     System.out.println("Constructor not found.");
-     * }
-     * }
- * - * @param type the {@link TypeMirror} representing the type to search for constructors - * @param parameterTypes the array of {@link Type} objects representing the parameter types to match - * @return the matched {@link ExecutableElement} representing the constructor; may be {@code null} - */ - @Nullable - static ExecutableElement findConstructor(TypeMirror type, Type... parameterTypes) { - if (type == null) { - return null; - } - return first(findDeclaredConstructors(type, constructor -> matchParameterTypes(constructor, parameterTypes))); - } - - /** - * Retrieves and filters the list of declared constructors from the provided {@link TypeElement}. - *

- * This method provides a null-safe way to obtain the constructors of a given type. - * If the input {@code type} is {@code null}, an empty list is returned. - * The provided filters can be used to selectively include only those constructors that match the criteria. - *

- * - *

Example Usage

- * 
{@code
-     * TypeElement typeElement = ...; // Obtain a valid TypeElement
-     * // Get all declared constructors
-     * List allConstructors = findDeclaredConstructors(typeElement);
-     *
-     * // Get only constructors with specific parameter types
-     * List filteredConstructors = findDeclaredConstructors(typeElement,
-     *     constructor -> matchParameterTypes(constructor, String.class, int.class));
-     *
-     * if (!filteredConstructors.isEmpty()) {
-     *     for (ExecutableElement constructor : filteredConstructors) {
-     *         System.out.println("Matching Constructor: " + constructor);
-     *     }
-     * } else {
-     *     System.out.println("No matching constructors found.");
-     * }
-     * }
- * - * @param type the {@link TypeElement} representing the type to retrieve constructors from - * @param constructorFilters optional predicates to filter the constructors; if none are provided, all constructors are included - * @return a {@link List} of {@link ExecutableElement} objects representing the filtered declared constructors; - * never {@code null}, but may be empty if no matching constructors are found or if the input is {@code null} - */ - @Nonnull - @Immutable - static List findDeclaredConstructors(TypeElement type, Predicate... constructorFilters) { - return type == null ? emptyList() : findDeclaredConstructors(type.asType(), constructorFilters); - } - - /** - * Retrieves and filters the list of declared constructors from the provided {@link TypeMirror}. - *

- * This method provides a null-safe way to obtain the constructors of a given type. - * If the input {@code type} is {@code null}, an empty list is returned. - * The provided filters can be used to selectively include only those constructors that match the criteria. - *

- * - * @param type the {@link TypeMirror} representing the type to retrieve constructors from - * @param constructorFilters optional predicates to filter the constructors; if none are provided, all constructors are included - * @return a {@link List} of {@link ExecutableElement} objects representing the filtered declared constructors; - * never {@code null}, but may be empty if no matching constructors are found or if the input is {@code null} - */ - @Nonnull - @Immutable - static List findDeclaredConstructors(TypeMirror type, Predicate... constructorFilters) { - return filterDeclaredConstructors(type, constructorFilters); - } - - /** - * Filters and retrieves the list of declared constructors from the provided {@link TypeMirror}. - *

- * This method is responsible for extracting all declared constructors from the given type - * and applying the specified filters to narrow down the results. If the input {@code type} - * is {@code null}, an empty list is returned. - *

- * - *

Example Usage

- * 
{@code
-     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror
-     *
-     * // Get all declared constructors
-     * List allConstructors = filterDeclaredConstructors(typeMirror);
-     *
-     * // Get only constructors with specific parameter types
-     * List filteredConstructors = filterDeclaredConstructors(typeMirror,
-     *     constructor -> matchParameterTypes(constructor, String.class, int.class));
-     *
-     * if (!filteredConstructors.isEmpty()) {
-     *     for (ExecutableElement constructor : filteredConstructors) {
-     *         System.out.println("Matching Constructor: " + constructor);
-     *     }
-     * } else {
-     *     System.out.println("No matching constructors found.");
-     * }
-     * }
- * - * @param type the {@link TypeMirror} representing the type to retrieve constructors from - * @param constructorFilters optional predicates to filter the constructors; if none are provided, all constructors are included - * @return a {@link List} of {@link ExecutableElement} objects representing the filtered declared constructors; - * never {@code null}, but may be empty if no matching constructors are found or if the input is {@code null} - */ - @Nonnull - @Immutable - static List filterDeclaredConstructors(TypeMirror type, Predicate... constructorFilters) { - if (type == null) { - return emptyList(); - } - - List declaredMembers = getDeclaredMembers(type, false); - if (isEmpty(declaredMembers)) { - return emptyList(); - } - - List constructors = constructorsIn(declaredMembers); - - return filterElements(constructors, constructorFilters); - } - -} diff --git a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/ElementUtils.java b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/ElementUtils.java deleted file mode 100644 index a6d7db851..000000000 --- a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/ElementUtils.java +++ /dev/null @@ -1,734 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package io.microsphere.annotation.processor.util; - -import io.microsphere.annotation.Immutable; -import io.microsphere.annotation.Nonnull; -import io.microsphere.util.Utils; - -import javax.lang.model.element.Element; -import javax.lang.model.element.ElementKind; -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.Modifier; -import javax.lang.model.element.VariableElement; -import java.lang.annotation.ElementType; -import java.lang.reflect.Type; -import java.util.List; -import java.util.Set; -import java.util.function.Predicate; - -import static io.microsphere.annotation.processor.util.TypeUtils.isSameType; -import static io.microsphere.collection.CollectionUtils.isEmpty; -import static io.microsphere.lang.function.Predicates.and; -import static io.microsphere.reflect.TypeUtils.getTypeNames; -import static io.microsphere.util.ArrayUtils.isNotEmpty; -import static io.microsphere.util.ArrayUtils.length; -import static java.util.Collections.emptyList; -import static java.util.Collections.unmodifiableList; -import static java.util.stream.Collectors.toList; -import static javax.lang.model.element.ElementKind.CLASS; -import static javax.lang.model.element.ElementKind.OTHER; -import static javax.lang.model.element.ElementKind.valueOf; -import static javax.lang.model.element.Modifier.PUBLIC; -import static javax.lang.model.element.Modifier.STATIC; - -/** - * The utility class for {@link Element} - * - * @author Mercy - * @see Element - * @see Enum - * @since 1.0.0 - */ -public interface ElementUtils extends Utils { - - /** - * Returns {@code true} if the specified {@link ElementKind} represents a class-like element, - * including: - *
    - *
  • {@link ElementKind#CLASS}
    • - *
  • {@link ElementKind#ENUM}
    • - *
  • {@link ElementKind#RECORD}
    • - *
- * - *

This method serves as a convenience wrapper around {@link ElementKind#isClass()}. - * It also guards against null input by returning {@code false} when the argument is null. - * - *

Example Usage

- * 
{@code
-     * ElementKind classKind = ElementKind.CLASS;
-     * boolean result = isClass(classKind); // returns true
-     *
-     * ElementKind methodKind = ElementKind.METHOD;
-     * result = isClass(methodKind); // returns false
-     *
-     * result = isClass(null); // returns false
-     * }
- * - * @param kind the ElementKind to check, may be null - * @return {@code true} if the kind is a class-like element, {@code false} otherwise - * @see ElementKind#isClass() - */ - static boolean isClass(ElementKind kind) { - return kind != null && kind.isClass(); - } - - /** - * Returns {@code true} if this is a kind of interface: - * either {@code INTERFACE} or {@code ANNOTATION_TYPE}. - * - *

- * This method serves as a convenience wrapper around {@link ElementKind#isInterface()}. - * It also guards against null input by returning {@code false} when the argument is null. - *

- * - *

Example Usage

- * 
{@code
-     * ElementKind interfaceKind = ElementKind.INTERFACE;
-     * boolean result = isInterface(interfaceKind); // returns true
-     *
-     * ElementKind annotationKind = ElementKind.ANNOTATION_TYPE;
-     * result = isInterface(annotationKind); // returns true
-     *
-     * ElementKind classKind = ElementKind.CLASS;
-     * result = isInterface(classKind); // returns false
-     *
-     * result = isInterface(null); // returns false
-     * }
- * - * @param kind the ElementKind to check, may be null - * @return {@code true} if the kind is an interface-like element, {@code false} otherwise - * @see ElementKind#isInterface() - */ - static boolean isInterface(ElementKind kind) { - return kind != null && kind.isInterface(); - } - - /** - * Returns {@code true} if the specified {@link ElementKind} represents a declared type, - * which includes both {@linkplain #isClass(ElementKind) class-like} and - * {@linkplain #isInterface(ElementKind) interface-like} elements. - * - *

This method serves as a convenience wrapper that combines the checks for class and interface kinds. - * It also guards against null input by safely delegating to the respective methods. - * - *

Example Usage

- * 
{@code
-     * ElementKind classKind = ElementKind.CLASS;
-     * boolean result = isDeclaredType(classKind); // returns true
-     *
-     * ElementKind interfaceKind = ElementKind.INTERFACE;
-     * result = isDeclaredType(interfaceKind); // returns true
-     *
-     * ElementKind methodKind = ElementKind.METHOD;
-     * result = isDeclaredType(methodKind); // returns false
-     *
-     * result = isDeclaredType(null); // returns false
-     * }
- * - * @param kind the ElementKind to check, may be null - * @return {@code true} if the kind is a declared type, {@code false} otherwise - * @see #isClass(ElementKind) - * @see #isInterface(ElementKind) - */ - static boolean isDeclaredType(ElementKind kind) { - return isClass(kind) || isInterface(kind); - } - - /** - * Returns {@code true} if this is a kind of field: - * either {@code FIELD} or {@code ENUM_CONSTANT}. - * - *

- * This method serves as a convenience wrapper around {@link ElementKind#isField()}. - * It also guards against null input by returning {@code false} when the argument is null. - *

- * - *

Example Usage

- * 
{@code
-     * ElementKind fieldKind = ElementKind.FIELD;
-     * boolean result = isField(fieldKind); // returns true
-     *
-     * ElementKind enumConstantKind = ElementKind.ENUM_CONSTANT;
-     * result = isField(enumConstantKind); // returns true
-     *
-     * ElementKind methodKind = ElementKind.METHOD;
-     * result = isField(methodKind); // returns false
-     *
-     * result = isField(null); // returns false
-     * }
- * - * @param kind the ElementKind to check, may be null - * @return {@code true} if the kind is a field-like element, {@code false} otherwise - * @see ElementKind#isField() - */ - static boolean isField(ElementKind kind) { - return kind != null && kind.isField(); - } - - /** - * Returns {@code true} if this is a kind of executable: either - * {@code METHOD}, {@code CONSTRUCTOR}, {@code STATIC_INIT}, or - * {@code INSTANCE_INIT}. - * - *

This method serves as a convenience wrapper around {@link ElementKind#isExecutable()}. - * It also guards against null input by returning {@code false} when the argument is null. - * - *

Example Usage

- * 
{@code
-     * ElementKind methodKind = ElementKind.METHOD;
-     * boolean result = isExecutable(methodKind); // returns true
-     *
-     * ElementKind constructorKind = ElementKind.CONSTRUCTOR;
-     * result = isExecutable(constructorKind); // returns true
-     *
-     * ElementKind staticInitKind = ElementKind.STATIC_INIT;
-     * result = isExecutable(staticInitKind); // returns true
-     *
-     * ElementKind instanceInitKind = ElementKind.INSTANCE_INIT;
-     * result = isExecutable(instanceInitKind); // returns true
-     *
-     * ElementKind classKind = ElementKind.CLASS;
-     * result = isExecutable(classKind); // returns false
-     *
-     * result = isExecutable(null); // returns false
-     * }
- * - * @param kind the ElementKind to check, may be null - * @return {@code true} if the kind is an executable-like element, {@code false} otherwise - * @see ElementKind#isExecutable() - */ - static boolean isExecutable(ElementKind kind) { - if (kind != null) { - switch (kind) { - case METHOD: - case CONSTRUCTOR: - case STATIC_INIT: - case INSTANCE_INIT: - return true; - } - } - return false; - } - - /** - * Returns {@code true} if the specified {@link ElementKind} represents a member element, - * which includes both {@linkplain #isField(ElementKind) field-like} and - * {@linkplain #isExecutable(ElementKind) executable-like} elements. - * - *

This method serves as a convenience wrapper that combines the checks for field and executable kinds. - * It also guards against null input by safely delegating to the respective methods. - * - *

Example Usage

- * 
{@code
-     * ElementKind fieldKind = ElementKind.FIELD;
-     * boolean result = isMember(fieldKind); // returns true
-     *
-     * ElementKind methodKind = ElementKind.METHOD;
-     * result = isMember(methodKind); // returns true
-     *
-     * ElementKind classKind = ElementKind.CLASS;
-     * result = isMember(classKind); // returns false
-     *
-     * result = isMember(null); // returns false
-     * }
- * - * @param kind the ElementKind to check, may be null - * @return {@code true} if the kind is a member-like element, {@code false} otherwise - * @see #isField(ElementKind) - * @see #isExecutable(ElementKind) - */ - static boolean isMember(ElementKind kind) { - return isField(kind) || isExecutable(kind); - } - - /** - * Returns {@code true} if the specified {@link ElementKind} represents an initializer, - * either {@code STATIC_INIT} or {@code INSTANCE_INIT}. - * - *

- * This method serves as a convenience wrapper around {@link ElementKind#isInitializer()}. - * It also guards against null input by returning {@code false} when the argument is null. - *

- * - *

Example Usage

- * 
{@code
-     * ElementKind staticInitKind = ElementKind.STATIC_INIT;
-     * boolean result = isInitializer(staticInitKind); // returns true
-     *
-     * ElementKind instanceInitKind = ElementKind.INSTANCE_INIT;
-     * result = isInitializer(instanceInitKind); // returns true
-     *
-     * ElementKind methodKind = ElementKind.METHOD;
-     * result = isInitializer(methodKind); // returns false
-     *
-     * result = isInitializer(null); // returns false
-     * }
- * - * @param kind the ElementKind to check, may be null - * @return {@code true} if the kind is an initializer-like element, {@code false} otherwise - * @see ElementKind#isInitializer() - */ - static boolean isInitializer(ElementKind kind) { - if (kind != null) { - switch (kind) { - case STATIC_INIT: - case INSTANCE_INIT: - return true; - } - } - return false; - } - - /** - * Returns {@code true} if the specified {@link ElementKind} represents a variable-like element, - * including: - *
    - *
  • {@link ElementKind#ENUM_CONSTANT}
    • - *
  • {@link ElementKind#FIELD}
    • - *
  • {@link ElementKind#PARAMETER}
    • - *
  • {@link ElementKind#LOCAL_VARIABLE}
    • - *
  • {@link ElementKind#EXCEPTION_PARAMETER}
    • - *
  • {@link ElementKind#RESOURCE_VARIABLE}
    • - *
  • {@link ElementKind#BINDING_VARIABLE}
    • - *
- * - *

This method serves as a convenience wrapper around {@link ElementKind#isVariable()}. - * It also guards against null input by returning {@code false} when the argument is null. - * - *

Example Usage

- * 
{@code
-     * ElementKind enumConstantKind = ElementKind.ENUM_CONSTANT;
-     * boolean result = isVariable(enumConstantKind); // returns true
-     *
-     * ElementKind fieldKind = ElementKind.FIELD;
-     * result = isVariable(fieldKind); // returns true
-     *
-     * ElementKind parameterKind = ElementKind.PARAMETER;
-     * result = isVariable(parameterKind); // returns true
-     *
-     * ElementKind localVariableKind = ElementKind.LOCAL_VARIABLE;
-     * result = isVariable(localVariableKind); // returns true
-     *
-     * ElementKind exceptionParameterKind = ElementKind.EXCEPTION_PARAMETER;
-     * result = isVariable(exceptionParameterKind); // returns true
-     *
-     * ElementKind resourceVariableKind = ElementKind.RESOURCE_VARIABLE;
-     * result = isVariable(resourceVariableKind); // returns true
-     *
-     * ElementKind bindingVariableKind = ElementKind.BINDING_VARIABLE;
-     * result = isVariable(bindingVariableKind); // returns true
-     *
-     * ElementKind methodKind = ElementKind.METHOD;
-     * result = isVariable(methodKind); // returns false
-     *
-     * result = isVariable(null); // returns false
-     * }
- * - * @param kind the ElementKind to check, may be null - * @return {@code true} if the kind is a variable-like element, {@code false} otherwise - * @see ElementKind#isVariable() - */ - static boolean isVariable(ElementKind kind) { - if (kind != null) { - switch (kind) { - case ENUM_CONSTANT: - case FIELD: - case PARAMETER: - case LOCAL_VARIABLE: - case EXCEPTION_PARAMETER: - case RESOURCE_VARIABLE: - return true; - } - // To be compatible with JDK 16 - return "BINDING_VARIABLE".equals(kind.name()); - } - return false; - } - - /** - * Converts the specified {@link ElementType} to an equivalent {@link ElementKind}. - * - *

- * This method maps the provided {@link ElementType} to a corresponding {@link ElementKind}. - * If the provided {@code elementType} is {@code null}, this method returns {@link ElementKind#OTHER}. - *

- * - *

Example Usage

- * 
{@code
-     * ElementType typeElement = ElementType.TYPE;
-     * ElementKind result = toElementKind(typeElement); // returns ElementKind.CLASS
-     *
-     * ElementType typeUseElement = ElementType.TYPE_USE;
-     * result = toElementKind(typeUseElement); // returns ElementKind.CLASS
-     *
-     * ElementType fieldElement = ElementType.FIELD;
-     * result = toElementKind(fieldElement); // returns ElementKind.FIELD
-     *
-     * result = toElementKind(null); // returns ElementKind.OTHER
-     * }
- * - * @param elementType the ElementType to convert, may be {@code null} - * @return the corresponding ElementKind, never {@code null} - */ - static ElementKind toElementKind(ElementType elementType) { - if (elementType == null) { - return OTHER; - } - switch (elementType) { - case TYPE: - case TYPE_USE: - return CLASS; - default: - return valueOf(elementType.name()); - } - } - - /** - * Checks whether the specified {@link ElementKind} matches the specified {@link ElementType}. - * - *

- * This method compares the provided {@link ElementKind} with the result of converting the - * {@link ElementType} to an equivalent {@link ElementKind} using {@link #toElementKind(ElementType)}. - * If either argument is null, the comparison will return {@code false}. - *

- * - *

Example Usage

- * 
{@code
-     * ElementKind classKind = ElementKind.CLASS;
-     * ElementType typeElement = ElementType.TYPE;
-     * boolean result = matchesElementType(classKind, typeElement); // returns true
-     *
-     * ElementKind fieldKind = ElementKind.FIELD;
-     * ElementType typeUseElement = ElementType.TYPE_USE;
-     * result = matchesElementType(fieldKind, typeUseElement); // returns false
-     *
-     * result = matchesElementType(null, ElementType.TYPE); // returns false
-     * result = matchesElementType(ElementKind.CLASS, null); // returns false
-     * }
- * - * @param elementKind the ElementKind to check, may be {@code null} - * @param elementType the ElementType to compare against, may be {@code null} - * @return {@code true} if the ElementKind matches the converted ElementType, {@code false} otherwise - * @see #toElementKind(ElementType) - */ - static boolean matchesElementType(ElementKind elementKind, ElementType elementType) { - return elementKind == toElementKind(elementType); - } - - /** - * Checks whether the specified {@link ElementKind} matches any of the specified {@link ElementType}s. - * - *

- * This method converts each {@link ElementType} to its corresponding {@link ElementKind} - * using {@link #toElementKind(ElementType)}, and then compares it with the provided - * {@link ElementKind}. If any match is found, the method returns {@code true}. - *

- * - *

Example Usage

- * 
{@code
-     * ElementKind classKind = ElementKind.CLASS;
-     * boolean result = matchesElementType(classKind, ElementType.TYPE, ElementType.METHOD); // returns true
-     *
-     * result = matchesElementType(classKind, ElementType.FIELD, ElementType.CONSTRUCTOR); // returns false
-     *
-     * result = matchesElementType(null, ElementType.TYPE); // returns false
-     *
-     * result = matchesElementType(ElementKind.FIELD, (ElementType[]) null); // returns false
-     * }
- * - * @param elementKind the ElementKind to check, may be {@code null} - * @param elementTypes the array of ElementTypes to match against, may be {@code null} - * @return {@code true} if the ElementKind matches any of the converted ElementTypes, {@code false} otherwise - * @see #toElementKind(ElementType) - * @see #matchesElementType(ElementKind, ElementType) - */ - static boolean matchesElementType(ElementKind elementKind, ElementType... elementTypes) { - int length = length(elementTypes); - if (length < 1) { - return false; - } - for (int i = 0; i < length; i++) { - if (matchesElementType(elementKind, elementTypes[i])) { - return true; - } - } - return false; - } - - /** - * Checks whether the specified {@link Element} matches any of the specified {@link ElementType}s. - * - *

- * This method determines if the provided {@link Element} has a kind that matches any of the - * converted {@link ElementKind} values derived from the given {@link ElementType}s. - * It delegates to {@link #matchesElementType(ElementKind, ElementType...)} for the actual comparison. - *

- * - *

Example Usage

- * 
{@code
-     * Element element = ...; // an Element of kind CLASS
-     * boolean result = matchesElementType(element, ElementType.TYPE, ElementType.TYPE_USE); // returns true
-     *
-     * result = matchesElementType(element, ElementType.FIELD, ElementType.METHOD); // returns false
-     *
-     * result = matchesElementType(null, ElementType.TYPE); // returns false
-     *
-     * result = matchesElementType(element, (ElementType[]) null); // returns false
-     * }
- * - * @param element the Element to check, may be {@code null} - * @param elementTypes the array of ElementTypes to match against, may be {@code null} - * @return {@code true} if the element matches any of the converted ElementTypes, {@code false} otherwise - * @see #matchesElementType(ElementKind, ElementType...) - */ - static boolean matchesElementType(Element element, ElementType... elementTypes) { - return element != null && matchesElementType(element.getKind(), elementTypes); - } - - /** - * Checks whether the specified {@link Element} matches the specified {@link ElementKind}. - * - *

- * This method returns {@code false} if either the element or the kind is {@code null}. - * Otherwise, it compares the kind of the element with the provided {@link ElementKind}. - *

- * - *

Example Usage

- * 
{@code
-     * Element element = ...; // an Element of kind METHOD
-     * ElementKind methodKind = ElementKind.METHOD;
-     * boolean result = matchesElementKind(element, methodKind); // returns true
-     *
-     * result = matchesElementKind(null, methodKind); // returns false
-     * result = matchesElementKind(element, null); // returns false
-     * }
- * - * @param member the Element to check, may be {@code null} - * @param kind the ElementKind to match, may be {@code null} - * @return {@code true} if the element is not null and its kind matches the specified kind; otherwise, {@code false} - */ - static boolean matchesElementKind(Element member, ElementKind kind) { - return member == null || kind == null ? false : kind.equals(member.getKind()); - } - - /** - * Checks whether the specified {@link Element} is public and non-static. - * - *

This method verifies if the provided element has the {@link Modifier#PUBLIC} modifier - * and does not have the {@link Modifier#STATIC} modifier. - * - *

Example Usage

- * 
{@code
-     * Element methodElement = ...; // an Element with PUBLIC and non-STATIC modifiers
-     * boolean result = isPublicNonStatic(methodElement); // returns true
-     *
-     * Element staticMethodElement = ...; // an Element with PUBLIC and STATIC modifiers
-     * result = isPublicNonStatic(staticMethodElement); // returns false
-     *
-     * result = isPublicNonStatic(null); // returns false
-     * }
- * - * @param member the Element to check, may be null - * @return {@code true} if the element is public and non-static; otherwise, {@code false} - */ - static boolean isPublicNonStatic(Element member) { - return hasModifiers(member, PUBLIC) && !hasModifiers(member, STATIC); - } - - /** - * Checks whether the specified {@link Element} has all of the specified {@link Modifier}s. - * - *

- * This method returns {@code false} if the element is {@code null} or if the modifiers array is {@code null}. - * Otherwise, it verifies that the element contains all the provided modifiers. - *

- * - *

Example Usage

- * 
{@code
-     * Element methodElement = ...; // an Element with PUBLIC and STATIC modifiers
-     * boolean result = hasModifiers(methodElement, Modifier.PUBLIC, Modifier.STATIC); // returns true
-     *
-     * result = hasModifiers(methodElement, Modifier.PRIVATE); // returns false
-     *
-     * result = hasModifiers(null, Modifier.PUBLIC); // returns false
-     *
-     * result = hasModifiers(methodElement, (Modifier[]) null); // returns false
-     * }
- * - * @param member the {@link Element} to check, may be {@code null} - * @param modifiers the array of {@link Modifier}s to match, may be {@code null} - * @return {@code true} if the element is not null and contains all specified modifiers; otherwise, {@code false} - */ - static boolean hasModifiers(Element member, Modifier... modifiers) { - if (member == null || modifiers == null) { - return false; - } - Set actualModifiers = member.getModifiers(); - for (Modifier modifier : modifiers) { - if (!actualModifiers.contains(modifier)) { - return false; - } - } - return true; - } - - /** - * Filters the provided list of {@link Element} objects based on the given array of {@link Predicate} conditions. - * - *

This method applies a logical AND combination of all provided predicates to filter the elements. - * If the input list is empty or the predicates array is null or empty, an empty list is returned.

- * - *

Example Usage

- * 
{@code
-     * List elements = ...; // a list of Elements
-     *
-     * // Filter public and static methods
-     * List filtered = filterElements(elements,
-     *     element -> ElementUtils.hasModifiers(element, Modifier.PUBLIC),
-     *     element -> ElementUtils.hasModifiers(element, Modifier.STATIC)
-     * );
-     *
-     * // Returns an empty list if no elements match
-     * filtered = filterElements(elements,
-     *     element -> ElementUtils.hasModifiers(element, Modifier.PRIVATE)
-     * );
-     *
-     * // Returns an empty list if input is null or predicates are null
-     * filtered = filterElements(null, (Predicate[]) null); // returns empty list
-     * }
- * - * @param elements The list of elements to be filtered, may be {@code null} - * @param elementPredicates An array of predicates used to filter the elements, may be {@code null} - * @param The type of the elements, which must be a subclass of {@link Element} - * @return A filtered list of elements that match all the provided predicates. Returns an empty list if no elements match, - * or if the input list or predicate array is invalid. - */ - @Nonnull - @Immutable - static List filterElements(List elements, Predicate... elementPredicates) { - if (isEmpty(elements) || elementPredicates == null) { - return emptyList(); - } - if (isNotEmpty(elementPredicates)) { - Predicate predicate = and(elementPredicates); - elements = (List) elements.stream().filter(predicate).collect(toList()); - } - return elements.isEmpty() ? emptyList() : unmodifiableList(elements); - } - - /** - * Checks whether the parameter types of the given {@link ExecutableElement} match the specified {@link Type types}. - * - *

- * This method compares the types of the parameters declared in the executable element with the provided expected types. - * It uses {@link TypeUtils#isSameType(Element, CharSequence)} to perform type comparison. - *

- * - *

Example Usage

- * 
{@code
-     * ExecutableElement methodElement = ...; // an executable element with parameters
-     * boolean result = matchParameterTypes(methodElement, String.class, int.class); // returns true if parameter types match
-     *
-     * result = matchParameterTypes(null, String.class); // returns false
-     * result = matchParameterTypes(methodElement, (Type[]) null); // returns false
-     * }
- * - * @param executableElement the executable element whose parameters are to be checked, may be {@code null} - * @param parameterTypes the expected parameter types, may be {@code null} - * @return {@code true} if the parameter types match; {@code false} otherwise - */ - static boolean matchParameterTypes(ExecutableElement executableElement, Type... parameterTypes) { - return executableElement == null || parameterTypes == null ? false : - matchParameterTypeNames(executableElement.getParameters(), getTypeNames(parameterTypes)); - } - - /** - * Checks whether the parameter types of the given list of {@link VariableElement} parameters match the specified {@link Type types}. - * - *

- * This method compares each parameter's type with the corresponding expected type by their fully qualified type names. - * It uses {@link TypeUtils#isSameType(Element, CharSequence)} to perform the type comparison. - *

- * - *

Example Usage

- * 
{@code
-     * List parameters = executableElement.getParameters();
-     * boolean result = matchParameterTypes(parameters, String.class, int.class); // returns true if types match
-     *
-     * result = matchParameterTypes(null, String.class); // returns false
-     * result = matchParameterTypes(parameters, (Type[]) null); // returns false
-     * }
- * - * @param parameters the list of variable elements representing the parameters, may be {@code null} - * @param parameterTypes the expected parameter types, may be {@code null} - * @return {@code true} if all parameter types match their corresponding expected types; otherwise, {@code false} - */ - static boolean matchParameterTypes(List parameters, Type... parameterTypes) { - return parameters == null || parameterTypes == null ? false : matchParameterTypeNames(parameters, getTypeNames(parameterTypes)); - } - - /** - * Checks whether the parameter types of the given list of {@link VariableElement} parameters match the specified type names. - * - *

- * This method compares each parameter's type with the corresponding expected type name using - * {@link TypeUtils#isSameType(Element, CharSequence)}. It ensures that both the number of parameters and their respective - * types match the provided array of type names. - *

- * - *

Example Usage

- * 
{@code
-     * List parameters = executableElement.getParameters();
-     *
-     * // Check if the parameters match String and int
-     * boolean result = matchParameterTypeNames(parameters, "java.lang.String", "int"); // returns true if match
-     *
-     * // Returns false if either parameter list or type names are null
-     * result = matchParameterTypeNames(null, "java.lang.String"); // returns false
-     * result = matchParameterTypeNames(parameters, (CharSequence[]) null); // returns false
-     *
-     * // Returns false if the size of parameters and type names do not match
-     * result = matchParameterTypeNames(Arrays.asList(param1, param2), "java.lang.String"); // returns false
-     * }
- * - * @param parameters the list of variable elements representing the parameters, may be {@code null} - * @param parameterTypeNames the expected fully qualified type names of the parameters, may be {@code null} - * @return {@code true} if all parameter types match their corresponding type names; otherwise, {@code false} - */ - static boolean matchParameterTypeNames(List parameters, CharSequence... parameterTypeNames) { - if (parameters == null || parameterTypeNames == null) { - return false; - } - - int length = length(parameterTypeNames); - int size = parameters.size(); - - if (size != length) { - return false; - } - - for (int i = 0; i < size; i++) { - VariableElement parameter = parameters.get(i); - if (!isSameType(parameter, parameterTypeNames[i])) { - return false; - } - } - return true; - } -} diff --git a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/ExecutableElementComparator.java b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/ExecutableElementComparator.java deleted file mode 100644 index c7e561224..000000000 --- a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/ExecutableElementComparator.java +++ /dev/null @@ -1,93 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor.util; - -import io.microsphere.util.CharSequenceComparator; - -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.VariableElement; -import java.util.Comparator; -import java.util.List; - -/** - * The Comparator class for {@link ExecutableElement}, the comparison rule : - *
    - *
  1. Comparing to two {@link ExecutableElement#getSimpleName() element names} {@link String#compareTo(String) lexicographically}. - * If equals, go to step 2
    2. - *
  2. Comparing to the count of two parameters. If equals, go to step 3
    3. - *
  3. Comparing to the type names of parameters {@link String#compareTo(String) lexicographically}
    4. - *
- * - *

Example Usage

- * 
- * class Example {
- *     void methodA() {}
- *     void methodB() {}
- *     void methodB(String param1) {}
- *     void methodB(String param1, int param2) {}
- * }
- *
- * - *

When comparing methods:

- *
    - *
  • {@code methodA} vs {@code methodB}: the names are compared lexicographically.
    • - *
  • {@code methodB()} vs {@code methodB(String)}: the number of parameters is compared.
    • - *
  • {@code methodB(String)} vs {@code methodB(String, int)}: the parameter type names are compared lexicographically.
    • - *
- * - * @author Mercy - * @since 1.0.0 - */ -public class ExecutableElementComparator implements Comparator { - - /** - * The singleton instance - */ - public static final ExecutableElementComparator INSTANCE = new ExecutableElementComparator(); - - private ExecutableElementComparator() { - } - - @Override - public int compare(ExecutableElement e1, ExecutableElement e2) { - - if (e1.equals(e2)) { - return 0; - } - - // Step 1 - int value = CharSequenceComparator.INSTANCE.compare(e1.getSimpleName(), e2.getSimpleName()); - - if (value == 0) { // Step 2 - - List ps1 = e1.getParameters(); - List ps2 = e2.getParameters(); - - value = ps1.size() - ps2.size(); - - if (value == 0) { // Step 3 - for (int i = 0; i < ps1.size(); i++) { - value = CharSequenceComparator.INSTANCE.compare(ps1.get(i).asType().toString(), ps2.get(i).asType().toString()); - if (value != 0) { - break; - } - } - } - } - return value; - } -} diff --git a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/FieldUtils.java b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/FieldUtils.java deleted file mode 100644 index f1c195fd9..000000000 --- a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/FieldUtils.java +++ /dev/null @@ -1,763 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor.util; - -import io.microsphere.annotation.Immutable; -import io.microsphere.annotation.Nonnull; -import io.microsphere.annotation.Nullable; -import io.microsphere.util.Utils; - -import javax.lang.model.element.Element; -import javax.lang.model.element.ElementKind; -import javax.lang.model.element.Modifier; -import javax.lang.model.element.VariableElement; -import javax.lang.model.type.TypeMirror; -import java.util.List; -import java.util.function.Predicate; - -import static io.microsphere.annotation.processor.util.ElementUtils.filterElements; -import static io.microsphere.annotation.processor.util.ElementUtils.hasModifiers; -import static io.microsphere.annotation.processor.util.ElementUtils.matchesElementKind; -import static io.microsphere.annotation.processor.util.MemberUtils.getDeclaredMembers; -import static io.microsphere.annotation.processor.util.TypeUtils.isEnumType; -import static io.microsphere.collection.CollectionUtils.isEmpty; -import static io.microsphere.lang.function.Predicates.EMPTY_PREDICATE_ARRAY; -import static io.microsphere.lang.function.Streams.filterFirst; -import static java.util.Collections.emptyList; -import static javax.lang.model.element.ElementKind.ENUM_CONSTANT; -import static javax.lang.model.element.ElementKind.FIELD; -import static javax.lang.model.element.Modifier.STATIC; -import static javax.lang.model.util.ElementFilter.fieldsIn; - -/** - * A utility interface for working with fields in the context of Java annotation processing. - *

- * This interface provides a collection of static methods to retrieve, filter, and inspect - * {@link VariableElement fields} within a class or interface. It supports operations such as: - *

- * - *
    - *
  • Retrieving fields by name
    • - *
  • Finding fields with specific modifiers (e.g., static, public)
    • - *
  • Filtering fields based on custom predicates
    • - *
  • Checking if a field is an enum constant or a non-static field
    • - *
  • Getting all declared or non-static fields from a type or element
    • - *
- * - *

Example Usage

- * 
{@code
- * // Get a specific field by name
- * VariableElement field = FieldUtils.getDeclaredField(element, "myField");
- *
- * // Get all non-static fields
- * List nonStaticFields = FieldUtils.getNonStaticFields(type);
- *
- * // Find a field by name in the current class and its superclasses
- * VariableElement fieldInHierarchy = FieldUtils.findField(type, "myField");
- *
- * // Check if a field is non-static
- * boolean isNonStatic = FieldUtils.isNonStaticField(field);
- *
- * // Get all fields, including those from superclasses
- * List allFields = FieldUtils.getAllDeclaredFields(element);
- * }
- * - * @author Mercy - * @since 1.0.0 - */ -public interface FieldUtils extends Utils { - - /** - * Retrieves the declared field with the specified name from the given element. - * - *

If the provided {@link Element} is null, this method returns null. It's typically used - * to retrieve a specific field from a class or interface element. - * - *

Example Usage

- * 
{@code
-     * Element element = ...; // A class or interface element
-     * String fieldName = "myField";
-     * VariableElement field = getDeclaredField(element, fieldName);
-     * if (field != null) {
-     *     System.out.println("Found field: " + field.getSimpleName());
-     * } else {
-     *     System.out.println("Field not found.");
-     * }
-     * }
- * - * @param element the element to search for the field; if null, null is returned - * @param fieldName the name of the field to find - * @return the VariableElement representing the declared field, or null if not found - */ - @Nullable - static VariableElement getDeclaredField(Element element, String fieldName) { - return element == null ? null : getDeclaredField(element.asType(), fieldName); - } - - /** - * Retrieves the declared field with the specified name from the given type. - * - *

If the provided {@link TypeMirror} is null, this method returns null. - * It searches for a field with the exact specified name in the given type, - * and returns the first match found. - * - *

Example Usage

- * 
{@code
-     * TypeMirror type = element.asType(); // A valid type from an element
-     * String fieldName = "myField";
-     * VariableElement field = getDeclaredField(type, fieldName);
-     * if (field != null) {
-     *     System.out.println("Found field: " + field.getSimpleName());
-     * } else {
-     *     System.out.println("Field not found.");
-     * }
-     * }
- * - * @param type the type to search for the field; if null, null is returned - * @param fieldName the name of the field to find - * @return the VariableElement representing the declared field, or null if not found - */ - @Nullable - static VariableElement getDeclaredField(TypeMirror type, String fieldName) { - return filterFirst(findDeclaredFields(type, field -> fieldName.equals(field.getSimpleName().toString()))); - } - - /** - * Retrieves all declared fields from the given element without any filtering. - * - *

If the provided {@link Element} is null, this method returns an empty list. - * It's typically used to get all fields declared in a class or interface, - * excluding fields from superclasses or interfaces. - * - *

Example Usage

- * 
{@code
-     * Element element = ...; // A class or interface element
-     * List fields = getDeclaredFields(element);
-     * for (VariableElement field : fields) {
-     *     System.out.println("Field: " + field.getSimpleName());
-     * }
-     * }
- * - * @param element the element to retrieve declared fields from - * @return a list of VariableElement objects representing the declared fields, - * or an empty list if the element is null or no fields are found - */ - @Nonnull - @Immutable - static List getDeclaredFields(Element element) { - return findDeclaredFields(element, EMPTY_PREDICATE_ARRAY); - } - - /** - * Retrieves all declared fields from the given type without any filtering. - * - *

If the provided {@link TypeMirror} is null, this method returns an empty list. - * It's typically used to get all fields declared directly within a class or interface, - * excluding fields from superclasses or interfaces. - * - *

Example Usage

- * 
{@code
-     * TypeMirror type = element.asType(); // A valid type from an element
-     * List fields = getDeclaredFields(type);
-     * for (VariableElement field : fields) {
-     *     System.out.println("Declared field: " + field.getSimpleName());
-     * }
-     * }
- * - * @param type the type to retrieve declared fields from - * @return a list of VariableElement objects representing the declared fields, - * or an empty list if the type is null or no fields are found - */ - @Nonnull - @Immutable - static List getDeclaredFields(TypeMirror type) { - return findDeclaredFields(type, EMPTY_PREDICATE_ARRAY); - } - - /** - * Retrieves all declared fields from the given element, including those from hierarchical types (e.g., superclasses), - * without any filtering. - * - *

If the provided {@link Element} is null, this method returns an empty list. It's typically used - * to get all fields declared directly within a class or interface, as well as those inherited from superclasses. - * - *

Example Usage

- * 
{@code
-     * Element element = ...; // A class or interface element
-     * List fields = getAllDeclaredFields(element);
-     * for (VariableElement field : fields) {
-     *     System.out.println("Declared field (including hierarchical): " + field.getSimpleName());
-     * }
-     * }
- * - * @param element the element to retrieve all declared fields from - * @return a list of VariableElement objects representing all declared fields, - * or an empty list if the element is null or no fields are found - */ - @Nonnull - @Immutable - static List getAllDeclaredFields(Element element) { - return findAllDeclaredFields(element, EMPTY_PREDICATE_ARRAY); - } - - /** - * Retrieves all declared fields from the given type, including those from hierarchical types (e.g., superclasses), - * without any filtering. - * - *

If the provided {@link TypeMirror} is null, this method returns an empty list. It's typically used - * to get all fields declared directly within a class or interface, as well as those inherited from superclasses. - * - *

Example Usage

- * 
{@code
-     * TypeMirror type = element.asType(); // A valid type from an element
-     * List fields = getAllDeclaredFields(type);
-     * for (VariableElement field : fields) {
-     *     System.out.println("Declared field (including hierarchical): " + field.getSimpleName());
-     * }
-     * }
- * - * @param type the type to retrieve all declared fields from - * @return a list of VariableElement objects representing all declared fields, - * or an empty list if the type is null or no fields are found - */ - @Nonnull - @Immutable - static List getAllDeclaredFields(TypeMirror type) { - return findAllDeclaredFields(type, EMPTY_PREDICATE_ARRAY); - } - - /** - * Retrieves the first matching field with the specified name from the given element. - * - *

If the provided {@link Element} is null, this method returns null. - * It searches for a field with the exact specified name in the given element - * and returns the first match found. - * - *

Example Usage

- * 
{@code
-     * Element element = ...; // A valid class or interface element
-     * String fieldName = "myField";
-     * VariableElement field = findField(element, fieldName);
-     * if (field != null) {
-     *     System.out.println("Found field: " + field.getSimpleName());
-     * } else {
-     *     System.out.println("Field not found.");
-     * }
-     * }
- * - * @param element the element to search for the field; if null, null is returned - * @param fieldName the name of the field to find - * @return the VariableElement representing the first matching field, or null if not found - */ - @Nullable - static VariableElement findField(Element element, String fieldName) { - return element == null ? null : findField(element.asType(), fieldName); - } - - /** - * Retrieves the first matching field with the specified name from the given type. - * - *

This method searches for a field with the exact specified name in the given type, - * including all hierarchical types (e.g., superclasses), and returns the first match found. - * - *

Example Usage

- * 
{@code
-     * TypeMirror type = element.asType(); // A valid type from an element
-     * String fieldName = "myField";
-     * VariableElement field = findField(type, fieldName);
-     * if (field != null) {
-     *     System.out.println("Found field: " + field.getSimpleName());
-     * } else {
-     *     System.out.println("Field not found.");
-     * }
-     * }
- * - * @param type the type to search for fields; if null, null is returned - * @param fieldName the name of the field to find - * @return the VariableElement representing the first matching field, or null if not found - */ - @Nullable - static VariableElement findField(TypeMirror type, String fieldName) { - return filterFirst(findAllDeclaredFields(type, field -> equalsFieldName(field, fieldName))); - } - - /** - * Retrieves the declared fields from the given element after applying the provided filters. - * - *

If the provided {@link Element} is null, this method returns an empty list. It searches - * for fields directly declared in the given element (excluding fields from superclasses or interfaces) - * and applies the specified filters to narrow down the results. - * - *

Example Usage

- * 
{@code
-     * Element element = ...; // A class or interface element
-     * List allFields = findDeclaredFields(element); // Get all declared fields
-     *
-     * // Get only non-static fields
-     * List nonStaticFields = findDeclaredFields(element, FieldUtils::isNonStaticField);
-     *
-     * // Get fields matching a specific name
-     * String fieldName = "myField";
-     * List matchingFields = findDeclaredFields(element, field -> fieldName.equals(field.getSimpleName().toString()));
-     *
-     * // Get fields with multiple filters (e.g., non-static and public)
-     * List publicNonStaticFields = findDeclaredFields(element,
-     *     field -> field.getModifiers().contains(Modifier.PUBLIC),
-     *     FieldUtils::isNonStaticField
-     * );
-     * }
- * - * @param element the element to retrieve declared fields from; if null, an empty list is returned - * @param fieldFilters the predicates used to filter the fields; optional - * @return a list of VariableElement objects representing the filtered declared fields - */ - @Nonnull - @Immutable - static List findDeclaredFields(Element element, Predicate... fieldFilters) { - return element == null ? emptyList() : findDeclaredFields(element.asType(), fieldFilters); - } - - /** - * Retrieves the declared fields from the given type after applying the provided filters. - * - *

This method searches for fields directly declared in the given type, - * excluding fields from superclasses or interfaces. It allows filtering - * the fields using the provided predicates to narrow down the results. - * - *

Example Usage

- * 
{@code
-     * TypeMirror type = element.asType(); // A valid type from an element
-     *
-     * // Get all declared fields
-     * List allFields = findDeclaredFields(type);
-     *
-     * // Get only non-static fields
-     * List nonStaticFields = findDeclaredFields(type, FieldUtils::isNonStaticField);
-     *
-     * // Get fields matching a specific name
-     * String fieldName = "myField";
-     * List matchingFields = findDeclaredFields(type, field -> "myField".equals(field.getSimpleName().toString()));
-     *
-     * // Get fields with multiple filters (e.g., non-static and public)
-     * List publicNonStaticFields = findDeclaredFields(type,
-     *     field -> field.getModifiers().contains(Modifier.PUBLIC),
-     *     FieldUtils::isNonStaticField
-     * );
-     * }
- * - * @param type the type to retrieve declared fields from; if null, an empty list is returned - * @param fieldFilters the predicates used to filter the fields - * @return a list of VariableElement objects representing the filtered declared fields - */ - @Nonnull - @Immutable - static List findDeclaredFields(TypeMirror type, Predicate... fieldFilters) { - return filterDeclaredFields(type, false, fieldFilters); - } - - /** - * Retrieves all declared fields from the given element, including those from hierarchical types (e.g., superclasses), - * after applying the provided filters. - * - *

This method processes the given element and searches for all fields declared directly within it - * as well as those inherited from superclasses. The fields can be filtered using one or more predicates - * to narrow down the results. - * - *

Example Usage

- * 
{@code
-     * Element element = ...; // A valid class or interface element
-     *
-     * // Get all declared fields (including from superclasses)
-     * List allFields = findAllDeclaredFields(element);
-     *
-     * // Get only non-static fields
-     * List nonStaticFields = findAllDeclaredFields(element, FieldUtils::isNonStaticField);
-     *
-     * // Get fields matching a specific name
-     * String fieldName = "myField";
-     * List matchingFields = findAllDeclaredFields(element, field -> "myField".equals(field.getSimpleName().toString()));
-     *
-     * // Get fields with multiple filters (e.g., non-static and public)
-     * List publicNonStaticFields = findAllDeclaredFields(element,
-     *     field -> field.getModifiers().contains(Modifier.PUBLIC),
-     *     FieldUtils::isNonStaticField
-     * );
-     * }
- * - * @param element the element to retrieve all declared fields from; if null, an empty list is returned - * @param fieldFilters the predicates used to filter the fields; optional - * @return a list of VariableElement objects representing the filtered declared fields - */ - @Nonnull - @Immutable - static List findAllDeclaredFields(Element element, Predicate... fieldFilters) { - return element == null ? emptyList() : findAllDeclaredFields(element.asType(), fieldFilters); - } - - /** - * Retrieves all declared fields from the given type, including those from hierarchical types (e.g., superclasses), - * after applying the provided filters. - * - *

This method searches for fields directly declared in the given type as well as those inherited - * from superclasses. It allows filtering the fields using the provided predicates to narrow down the results. - * - *

Example Usage

- * 
{@code
-     * TypeMirror type = element.asType(); // A valid type from an element
-     *
-     * // Get all declared fields (including hierarchical)
-     * List allFields = findAllDeclaredFields(type);
-     *
-     * // Get only non-static fields
-     * List nonStaticFields = findAllDeclaredFields(type, FieldUtils::isNonStaticField);
-     *
-     * // Get fields matching a specific name
-     * String fieldName = "myField";
-     * List matchingFields = findAllDeclaredFields(type, field -> "myField".equals(field.getSimpleName().toString()));
-     *
-     * // Get fields with multiple filters (e.g., non-static and public)
-     * List publicNonStaticFields = findAllDeclaredFields(type,
-     *     field -> field.getModifiers().contains(Modifier.PUBLIC),
-     *     FieldUtils::isNonStaticField
-     * );
-     * }
- * - * @param type the type to retrieve all declared fields from; if null, an empty list is returned - * @param fieldFilters the predicates used to filter the fields - * @return a list of VariableElement objects representing the filtered declared fields - */ - @Nonnull - @Immutable - static List findAllDeclaredFields(TypeMirror type, Predicate... fieldFilters) { - return filterDeclaredFields(type, true, fieldFilters); - } - - /** - * Filters and retrieves the declared fields from the given type based on the provided criteria. - * - *

This method is used to retrieve fields declared in the given type, optionally including fields - * from its superclasses or interfaces. The fields can be further filtered using one or more predicates - * to narrow down the results. - * - *

Example Usage

- * 
{@code
-     * TypeMirror type = element.asType(); // A valid type from an element
-     *
-     * // Get all declared fields (excluding hierarchical)
-     * List declaredFields = filterDeclaredFields(type, false);
-     *
-     * // Get all declared fields including hierarchical ones
-     * List allFields = filterDeclaredFields(type, true);
-     *
-     * // Get only non-static fields
-     * List nonStaticFields = filterDeclaredFields(type, false, FieldUtils::isNonStaticField);
-     *
-     * // Get fields matching a specific name
-     * String fieldName = "myField";
-     * List matchingFields = filterDeclaredFields(type, false,
-     *     field -> "myField".equals(field.getSimpleName().toString()));
-     *
-     * // Get fields with multiple filters (e.g., non-static and public)
-     * List publicNonStaticFields = filterDeclaredFields(type, true,
-     *     field -> field.getModifiers().contains(Modifier.PUBLIC),
-     *     FieldUtils::isNonStaticField
-     * );
-     * }
- * - * @param type the type to retrieve declared fields from; if null, an empty list is returned - * @param includeHierarchicalTypes whether to include fields from hierarchical types (e.g., superclasses) - * @param fieldFilters the predicates used to filter the fields; optional - * @return a list of VariableElement objects representing the filtered declared fields - */ - @Nonnull - @Immutable - static List filterDeclaredFields(TypeMirror type, boolean includeHierarchicalTypes, Predicate... fieldFilters) { - if (type == null) { - return emptyList(); - } - - List declaredMembers = getDeclaredMembers(type, includeHierarchicalTypes); - if (isEmpty(declaredMembers)) { - return emptyList(); - } - - List fields = fieldsIn(declaredMembers); - - return filterElements(fields, fieldFilters); - } - - /** - * Determines whether the given field is an enum member field. - * - *

An enum member field is typically a public static final field that represents - * a constant within an enum declaration. This method checks if the field's enclosing - * element is an enum and if the field's kind matches {@link ElementKind#ENUM_CONSTANT}. - * - *

Example Usage

- * 
{@code
-     * VariableElement field = ...; // A valid field element
-     * boolean isEnumMember = FieldUtils.isEnumMemberField(field);
-     * if (isEnumMember) {
-     *     System.out.println("The field is an enum member field.");
-     * } else {
-     *     System.out.println("The field is not an enum member field.");
-     * }
-     * }
- * - * @param field the field to check; may be null - * @return true if the field is an enum member field, false otherwise - */ - static boolean isEnumMemberField(VariableElement field) { - if (field == null || !isEnumType(field.getEnclosingElement())) { - return false; - } - return ENUM_CONSTANT.equals(field.getKind()); - } - - /** - * Checks if the given field is a non-static field. - * - *

This method verifies whether the provided {@link VariableElement} represents a field - * that is not declared with the {@code static} modifier. It first checks if the element is - * a valid field (including enum constants) using the {@link #isField(VariableElement)} method, - * and then ensures that the field does not have the static modifier. - * - *

Example Usage

- * 
{@code
-     * VariableElement field = ...; // A valid field element
-     * boolean isNonStatic = FieldUtils.isNonStaticField(field);
-     * if (isNonStatic) {
-     *     System.out.println("The field is non-static.");
-     * } else {
-     *     System.out.println("The field is static or not a valid field.");
-     * }
-     * }
- * - * @param field the VariableElement to check; may be null - * @return true if the field is a valid field (as per {@link #isField(VariableElement)}) - * and does not have the 'static' modifier, false otherwise - */ - static boolean isNonStaticField(VariableElement field) { - return isField(field) && !hasModifiers(field, STATIC); - } - - /** - * Checks if the given element is a field or an enum constant. - * - *

This method determines whether the provided {@link VariableElement} represents a valid field - * or an enum constant. It returns {@code true} if the element's kind is either - * {@link ElementKind#FIELD} or {@link ElementKind#ENUM_CONSTANT}. - * - *

Example Usage

- * 
{@code
-     * VariableElement field = ...; // A valid field element
-     * boolean isValidField = FieldUtils.isField(field);
-     * if (isValidField) {
-     *     System.out.println("The element is a valid field or enum constant.");
-     * } else {
-     *     System.out.println("The element is not a field or enum constant.");
-     * }
-     * }
- * - * @param field the VariableElement to check; may be null - * @return true if the element is a field ({@link javax.lang.model.element.ElementKind#FIELD}) - * or an enum constant ({@link javax.lang.model.element.ElementKind#ENUM_CONSTANT}), false otherwise - */ - static boolean isField(VariableElement field) { - return matchesElementKind(field, FIELD) || isEnumMemberField(field); - } - - /** - * Checks if the given element is a field or an enum constant, and also has all the specified modifiers. - * - *

This method extends the {@link #isField(VariableElement)} method by additionally verifying that - * the field has all of the specified modifiers. It returns {@code true} only if the element is a valid field - * (including enum constants) and contains all the provided modifiers. - * - *

Example Usage

- * 
{@code
-     * VariableElement field = ...; // A valid field element
-     *
-     * // Check if it's a public static field
-     * boolean isPublicStaticField = FieldUtils.isField(field, Modifier.PUBLIC, Modifier.STATIC);
-     * if (isPublicStaticField) {
-     *     System.out.println("The field is a public static field.");
-     * } else {
-     *     System.out.println("The field is not a public static field.");
-     * }
-     *
-     * // Check if it's a private field
-     * boolean isPrivateField = FieldUtils.isField(field, Modifier.PRIVATE);
-     * if (isPrivateField) {
-     *     System.out.println("The field is a private field.");
-     * } else {
-     *     System.out.println("The field is not a private field.");
-     * }
-     * }
- * - * @param field the VariableElement to check; may be null - * @param modifiers the modifiers to match (e.g., Modifier.PUBLIC, Modifier.STATIC) - * @return true if the element is a field ({@link javax.lang.model.element.ElementKind#FIELD}) - * or an enum constant ({@link javax.lang.model.element.ElementKind#ENUM_CONSTANT}), - * and it has all of the specified modifiers, false otherwise - */ - static boolean isField(VariableElement field, Modifier... modifiers) { - return isField(field) && hasModifiers(field, modifiers); - } - - /** - * Retrieves all declared non-static fields from the given type. - * - *

This method returns a list of fields that are declared directly within the given type - * and are not marked as static. It does not include fields from superclasses or interfaces. - * If the provided {@link TypeMirror} is null, this method returns an empty list. - * - *

Example Usage

- * 
{@code
-     * TypeMirror type = element.asType(); // A valid type from an element
-     * List nonStaticFields = FieldUtils.getNonStaticFields(type);
-     * for (VariableElement field : nonStaticFields) {
-     *     System.out.println("Non-static field: " + field.getSimpleName());
-     * }
-     * }
- * - * @param type the type to search for non-static fields; if null, an empty list is returned - * @return a list of VariableElement objects representing the non-static fields, - * or an empty list if the type is null or no non-static fields are found - */ - @Nonnull - @Immutable - static List getNonStaticFields(TypeMirror type) { - return findDeclaredFields(type, FieldUtils::isNonStaticField); - } - - /** - * Retrieves all declared non-static fields from the given element. - * - *

This method processes the provided element and retrieves all fields directly declared - * within it that are not marked as static. It excludes fields from superclasses or interfaces. - * If the provided element is null, this method returns an empty list. - * - *

Example Usage

- * 
{@code
-     * Element element = ...; // A valid class or interface element
-     * List nonStaticFields = FieldUtils.getNonStaticFields(element);
-     * for (VariableElement field : nonStaticFields) {
-     *     System.out.println("Non-static field: " + field.getSimpleName());
-     * }
-     *
-     * // Handling null case
-     * List safeList = FieldUtils.getNonStaticFields(null);
-     * System.out.println(safeList.isEmpty()); // true
-     * }
- * - * @param element the element to search for non-static fields; if null, an empty list is returned - * @return a list of VariableElement objects representing the non-static fields, - * or an empty list if the element is null or no non-static fields are found - */ - @Nonnull - @Immutable - static List getNonStaticFields(Element element) { - return element == null ? emptyList() : getNonStaticFields(element.asType()); - } - - /** - * Retrieves all non-static fields from the given type, including those from hierarchical types (e.g., superclasses). - * - *

This method searches for all fields declared directly within the given type, as well as those inherited - * from its superclasses or interfaces, and filters out only the non-static fields. If the provided {@link TypeMirror} - * is null, this method returns an empty list. - * - *

Example Usage

- * 
{@code
-     * TypeMirror type = element.asType(); // A valid type from an element
-     * List nonStaticFields = FieldUtils.getAllNonStaticFields(type);
-     * for (VariableElement field : nonStaticFields) {
-     *     System.out.println("Non-static field (including hierarchical): " + field.getSimpleName());
-     * }
-     *
-     * // Handling null case
-     * List safeList = FieldUtils.getAllNonStaticFields(null);
-     * System.out.println(safeList.isEmpty()); // true
-     * }
- * - * @param type the type to retrieve all non-static fields from; if null, an empty list is returned - * @return a list of VariableElement objects representing all non-static fields, - * or an empty list if the type is null or no non-static fields are found - */ - @Nonnull - @Immutable - static List getAllNonStaticFields(TypeMirror type) { - return findAllDeclaredFields(type, FieldUtils::isNonStaticField); - } - - /** - * Retrieves all non-static fields from the given element, including those from superclasses and interfaces. - * - *

This method processes the provided element and retrieves all fields declared directly within it, - * as well as those inherited from superclasses or interfaces. It filters out only the non-static fields. - * If the provided element is null, this method returns an empty list. - * - *

Example Usage

- * 
{@code
-     * Element element = ...; // A valid class or interface element
-     * List nonStaticFields = FieldUtils.getAllNonStaticFields(element);
-     * for (VariableElement field : nonStaticFields) {
-     *     System.out.println("Non-static field: " + field.getSimpleName());
-     * }
-     *
-     * // Handling null case
-     * List safeList = FieldUtils.getAllNonStaticFields(null);
-     * System.out.println(safeList.isEmpty()); // true
-     * }
- * - * @param element the element to retrieve all non-static fields from; if null, an empty list is returned - * @return a list of VariableElement objects representing all non-static fields, - * or an empty list if the element is null or no non-static fields are found - */ - @Nonnull - @Immutable - static List getAllNonStaticFields(Element element) { - return element == null ? emptyList() : getAllNonStaticFields(element.asType()); - } - - /** - * Checks if the simple name of the given field matches the specified field name. - * - *

This method ensures both the {@link VariableElement} and the field name are non-null - * before comparing their string representations for equality. - * - *

Example Usage

- * 
{@code
-     * VariableElement field = ...; // A valid field element
-     * CharSequence fieldName = "myField";
-     * boolean isMatch = equalsFieldName(field, fieldName);
-     * if (isMatch) {
-     *     System.out.println("Field name matches: " + fieldName);
-     * } else {
-     *     System.out.println("Field name does not match.");
-     * }
-     * }
- * - * @param field the VariableElement representing the field; may be null - * @param fieldName the CharSequence representing the expected field name; may be null - * @return true if both the field and fieldName are non-null and their string representations match, false otherwise - */ - static boolean equalsFieldName(VariableElement field, CharSequence fieldName) { - return field != null && fieldName != null && field.getSimpleName().toString().equals(fieldName.toString()); - } -} diff --git a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/LoggerUtils.java b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/LoggerUtils.java deleted file mode 100644 index 17b69dbeb..000000000 --- a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/LoggerUtils.java +++ /dev/null @@ -1,54 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor.util; - - -import io.microsphere.logging.Logger; -import io.microsphere.util.Utils; - -import static io.microsphere.logging.LoggerFactory.getLogger; - -/** - * Logger Utils - * - * @author Mercy - * @since 1.0.0 - */ -public interface LoggerUtils extends Utils { - - Logger LOGGER = getLogger("microsphere-annotation-processor"); - - static void trace(String format, Object... args) { - LOGGER.trace(format, args); - } - - static void debug(String format, Object... args) { - LOGGER.debug(format, args); - } - - static void info(String format, Object... args) { - LOGGER.info(format, args); - } - - static void warn(String format, Object... args) { - LOGGER.warn(format, args); - } - - static void error(String format, Object... args) { - LOGGER.error(format, args); - } -} diff --git a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/MemberUtils.java b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/MemberUtils.java deleted file mode 100644 index 46c1d9270..000000000 --- a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/MemberUtils.java +++ /dev/null @@ -1,423 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor.util; - -import io.microsphere.annotation.Immutable; -import io.microsphere.annotation.Nonnull; -import io.microsphere.util.Utils; - -import javax.lang.model.element.Element; -import javax.lang.model.element.TypeElement; -import javax.lang.model.type.TypeMirror; -import java.util.Collection; -import java.util.List; -import java.util.function.Predicate; - -import static io.microsphere.annotation.processor.util.ElementUtils.filterElements; -import static io.microsphere.annotation.processor.util.TypeUtils.getAllDeclaredTypes; -import static io.microsphere.annotation.processor.util.TypeUtils.ofTypeElement; -import static io.microsphere.lang.function.Predicates.EMPTY_PREDICATE_ARRAY; -import static java.util.Collections.emptyList; -import static java.util.stream.Collectors.toList; - -/** - * A utility interface for handling members (such as fields, methods, constructors) from types - * in the {@link javax.lang.model} package. - * - *

Overview

- *

- * This interface provides a set of static methods to retrieve and filter members of a type, - * including direct members and those inherited from superclasses and interfaces. - * It is designed to simplify the process of working with type elements and their enclosed elements - * during annotation processing. - *

- * - *

Key Features

- *
    - *
  • {@link #getDeclaredMembers(TypeMirror) getDeclaredMembers(TypeMirror)} - Retrieves directly declared members of a type.
    • - *
  • {@link #getAllDeclaredMembers(TypeMirror) getAllDeclaredMembers(TypeMirror)} - Retrieves all declared members, including those from superclasses and interfaces.
    • - *
  • {@link #findDeclaredMembers(TypeMirror, Predicate...) findDeclaredMembers(TypeMirror, Predicate...)} - Retrieves and filters declared members based on provided predicates.
    • - *
  • {@link #findAllDeclaredMembers(TypeMirror, Predicate...) findAllDeclaredMembers(TypeMirror, Predicate...)} - Retrieves all declared members and applies filtering via predicates.
    • - *
- * - *

Example Usage

- * 
{@code
- * // Retrieve all declared methods from a TypeMirror
- * List methods = findDeclaredMembers(typeMirror,
- *     element -> element.getKind() == ElementKind.METHOD
- * );
- * }
- * - * 
{@code
- * // Retrieve all fields that start with "m_"
- * List filteredFields = findDeclaredMembers(typeElement,
- *     element -> element.getKind() == ElementKind.FIELD,
- *     element -> element.getSimpleName().toString().startsWith("m_")
- * );
- * }
- * - * @author Mercy - * @since 1.0.0 - */ -public interface MemberUtils extends Utils { - - /** - * Returns the directly declared members of the provided {@link TypeMirror}. - * If the given type is {@code null}, an empty list will be returned. - * - *

Example Usage

- * 
-     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror instance
-     * List members = getDeclaredMembers(typeMirror);
-     * if (!members.isEmpty()) {
-     *     for (Element member : members) {
-     *         System.out.println("Declared member: " + member);
-     *     }
-     * }
-     *
- * - * @param type the type mirror to retrieve declared members from - * @return a list of directly declared members, or an empty list if the type is {@code null} - */ - @Nonnull - @Immutable - static List getDeclaredMembers(TypeMirror type) { - return type == null ? emptyList() : getDeclaredMembers(ofTypeElement(type)); - } - - /** - * Returns the directly declared members of the provided {@link TypeElement}. - * If the given type is {@code null}, an empty list will be returned. - * - *

Example Usage

- * 
{@code
-     * TypeElement typeElement = ...; // Obtain a valid TypeElement instance
-     * List members = getDeclaredMembers(typeElement);
-     * if (!members.isEmpty()) {
-     *     for (Element member : members) {
-     *         System.out.println("Declared member: " + member);
-     *     }
-     * }
-     * }
- * - * @param type the type element to retrieve declared members from - * @return a list of directly declared members, or an empty list if the type is {@code null} - */ - @Nonnull - @Immutable - static List getDeclaredMembers(TypeElement type) { - return type == null ? emptyList() : findDeclaredMembers(type, EMPTY_PREDICATE_ARRAY); - } - - /** - * Returns all declared members (including those from superclasses and interfaces) of the provided {@link TypeMirror}. - * If the given type is {@code null}, an empty list will be returned. - * - *

Example Usage

- * 
{@code
-     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror instance
-     * List allMembers = getAllDeclaredMembers(typeMirror);
-     * if (!allMembers.isEmpty()) {
-     *     for (Element member : allMembers) {
-     *         System.out.println("All declared member: " + member);
-     *     }
-     * }
-     * }
- * - * @param type the type mirror to retrieve all declared members from - * @return a list of all declared members, or an empty list if the type is {@code null} - */ - @Nonnull - @Immutable - static List getAllDeclaredMembers(TypeMirror type) { - return type == null ? emptyList() : findAllDeclaredMembers(ofTypeElement(type), EMPTY_PREDICATE_ARRAY); - } - - /** - * Returns all declared members (including those from superclasses and interfaces) of the provided {@link TypeElement}. - * If the given type is {@code null}, an empty list will be returned. - * - *

Example Usage

- * 
{@code
-     * TypeElement typeElement = ...; // Obtain a valid TypeElement instance
-     * List allMembers = getAllDeclaredMembers(typeElement);
-     * if (!allMembers.isEmpty()) {
-     *     for (Element member : allMembers) {
-     *         System.out.println("All declared member: " + member);
-     *     }
-     * }
-     * }
- * - * @param type the type element to retrieve all declared members from - * @return a list of all declared members, or an empty list if the type is {@code null} - */ - @Nonnull - @Immutable - static List getAllDeclaredMembers(TypeElement type) { - return type == null ? emptyList() : findAllDeclaredMembers(type, EMPTY_PREDICATE_ARRAY); - } - - /** - * Returns the declared members of the provided {@link TypeMirror}, optionally including - * members from superclasses and interfaces. - * - *

If the given type is {@code null}, an empty list will be returned.

- * - *

Example Usage

- * 
{@code
-     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror instance
-     * boolean includeSuperMembers = true; // Include members from superclasses/interfaces
-     * List members = getDeclaredMembers(typeMirror, includeSuperMembers);
-     * for (Element member : members) {
-     *     System.out.println("Member: " + member);
-     * }
-     * }
- * - * @param type the type mirror to retrieve declared members from - * @param includeHierarchicalTypes whether to include members from superclasses and interfaces - * @return a list of declared members, or an empty list if the type is {@code null} - */ - @Nonnull - @Immutable - static List getDeclaredMembers(TypeMirror type, boolean includeHierarchicalTypes) { - return includeHierarchicalTypes ? getAllDeclaredMembers(type) : getDeclaredMembers(type); - } - - /** - * Returns the declared members of the provided {@link TypeElement}, optionally including - * members from superclasses and interfaces. - * - *

If the given type is {@code null}, an empty list will be returned.

- * - *

Example Usage

- * 
{@code
-     * TypeElement typeElement = ...; // Obtain a valid TypeElement instance
-     * boolean includeSuperMembers = true; // Include members from superclasses/interfaces
-     * List members = getDeclaredMembers(typeElement, includeSuperMembers);
-     * for (Element member : members) {
-     *     System.out.println("Member: " + member);
-     * }
-     * }
- * - * @param type the type element to retrieve declared members from - * @param includeHierarchicalTypes whether to include members from superclasses and interfaces - * @return a list of declared members, or an empty list if the type is {@code null} - */ - @Nonnull - @Immutable - static List getDeclaredMembers(TypeElement type, boolean includeHierarchicalTypes) { - return includeHierarchicalTypes ? getAllDeclaredMembers(type) : getDeclaredMembers(type); - } - - /** - * Returns the declared members of the provided {@link TypeMirror}, optionally filtered by one or more predicates. - * - *

If the given type is {@code null}, an empty list will be returned.

- * - *

Example Usage

- * 
{@code
-     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror instance
-     * List methods = findDeclaredMembers(typeMirror,
-     *     element -> element.getKind() == ElementKind.METHOD,
-     *     element -> element.getSimpleName().toString().startsWith("get")
-     * );
-     * for (Element method : methods) {
-     *     System.out.println("Matching method: " + method);
-     * }
-     * }
- * - * @param the type of elements to filter - * @param type the type mirror to retrieve declared members from - * @param memberFilters the predicates used to filter members - * @return a list of declared members matching the filters, or an empty list if the type is {@code null} - */ - @Nonnull - @Immutable - static List findDeclaredMembers(TypeMirror type, Predicate... memberFilters) { - return type == null ? emptyList() : findDeclaredMembers(ofTypeElement(type), memberFilters); - } - - /** - * Returns the directly declared members of the provided {@link TypeElement}, optionally filtered by one or more predicates. - * - *

If the given type is {@code null}, an empty list will be returned.

- * - *

Example Usage

- * 
{@code
-     * TypeElement typeElement = ...; // Obtain a valid TypeElement instance
-     * List fields = findDeclaredMembers(typeElement,
-     *     element -> element.getKind() == ElementKind.FIELD,
-     *     element -> element.getSimpleName().toString().startsWith("m_")
-     * );
-     * for (Element field : fields) {
-     *     System.out.println("Matching field: " + field);
-     * }
-     * }
- * - * @param the type of elements to filter - * @param type the type element to retrieve declared members from - * @param memberFilters the predicates used to filter members - * @return a list of declared members matching the filters, or an empty list if the type is {@code null} - */ - @Nonnull - @Immutable - static List findDeclaredMembers(TypeElement type, Predicate... memberFilters) { - if (type == null) { - return emptyList(); - } - return filterElements((List) type.getEnclosedElements(), memberFilters); - } - - /** - * Returns all declared members (including those from superclasses and interfaces) of the provided {@link TypeMirror}, - * optionally filtered by one or more predicates. - * - *

If the given type is {@code null}, an empty list will be returned.

- * - *

Example Usage

- * 
{@code
-     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror instance
-     * List methods = findAllDeclaredMembers(typeMirror,
-     *     element -> element.getKind() == ElementKind.METHOD,
-     *     element -> element.getSimpleName().toString().startsWith("get")
-     * );
-     * for (Element method : methods) {
-     *     System.out.println("Matching method: " + method);
-     * }
-     * }
- * - * @param the type of elements to filter - * @param type the type mirror to retrieve all declared members from - * @param memberFilters the predicates used to filter members - * @return a list of all declared members matching the filters, or an empty list if the type is {@code null} - */ - @Nonnull - @Immutable - static List findAllDeclaredMembers(TypeMirror type, Predicate... memberFilters) { - return type == null ? emptyList() : findAllDeclaredMembers(ofTypeElement(type), memberFilters); - } - - /** - * Retrieves all declared members (fields, methods, constructors, etc.) from the given {@link TypeElement}, - * including those inherited from superclasses and implemented interfaces. - * - *

This method collects all declared members by traversing the type hierarchy and applying - * the provided filters to narrow down the results. - * - *

Example Usage

- * 
{@code
-     * TypeElement typeElement = ...; // Obtain a valid TypeElement instance
-     * List fields = findAllDeclaredMembers(typeElement,
-     *     element -> element.getKind() == ElementKind.FIELD
-     * );
-     * for (Element field : fields) {
-     *     System.out.println("Field: " + field);
-     * }
-     * }
- * - * 
{@code
-     * List methods = findAllDeclaredMembers(typeElement,
-     *     element -> element.getKind() == ElementKind.METHOD,
-     *     element -> element.getSimpleName().toString().startsWith("get")
-     * );
-     * for (Element method : methods) {
-     *     System.out.println("Getter method: " + method);
-     * }
-     * }
- * - * @param the type of elements to filter - * @param type the type element to retrieve all declared members from - * @param memberFilters the predicates used to filter members - * @return a list of all declared members matching the filters, or an empty list if the type is {@code null} - */ - @Nonnull - @Immutable - static List findAllDeclaredMembers(TypeElement type, Predicate... memberFilters) { - if (type == null) { - return emptyList(); - } - List declaredMembers = (List) getAllDeclaredTypes(type) - .stream() - .map(MemberUtils::getDeclaredMembers) - .flatMap(Collection::stream) - .collect(toList()); - return filterElements(declaredMembers, memberFilters); - } - - /** - * Returns the declared members of the provided {@link TypeMirror}, optionally including - * members from superclasses and interfaces, and filtered by one or more predicates. - * - *

If the given type is {@code null}, an empty list will be returned.

- * - *

Example Usage

- * 
{@code
-     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror instance
-     * boolean includeSuperMembers = true; // Include members from superclasses/interfaces
-     * List methods = findDeclaredMembers(typeMirror, includeSuperMembers,
-     *     element -> element.getKind() == ElementKind.METHOD,
-     *     element -> element.getSimpleName().toString().startsWith("get")
-     * );
-     * for (Element method : methods) {
-     *     System.out.println("Matching method: " + method);
-     * }
-     * }
- * - * @param the type of elements to filter - * @param type the type mirror to retrieve declared members from - * @param includeHierarchicalTypes whether to include members from superclasses and interfaces - * @param memberFilters the predicates used to filter members - * @return a list of declared members matching the filters, or an empty list if the type is {@code null} - */ - @Nonnull - @Immutable - static List findDeclaredMembers(TypeMirror type, boolean includeHierarchicalTypes, Predicate... memberFilters) { - return includeHierarchicalTypes ? findAllDeclaredMembers(type, memberFilters) : findDeclaredMembers(type, memberFilters); - } - - /** - * Returns the declared members of the provided {@link TypeElement}, optionally including - * members from superclasses and interfaces, and filtered by one or more predicates. - * - *

If the given type is {@code null}, an empty list will be returned.

- * - *

Example Usage

- * 
{@code
-     * TypeElement typeElement = ...; // Obtain a valid TypeElement instance
-     * boolean includeSuperMembers = true; // Include members from superclasses/interfaces
-     * List fields = findDeclaredMembers(typeElement, includeSuperMembers,
-     *     element -> element.getKind() == ElementKind.FIELD,
-     *     element -> element.getSimpleName().toString().startsWith("m_")
-     * );
-     * for (Element field : fields) {
-     *     System.out.println("Matching field: " + field);
-     * }
-     * }
- * - * @param the type of elements to filter - * @param type the type element to retrieve declared members from - * @param all whether to include members from superclasses and interfaces - * @param memberFilters the predicates used to filter members - * @return a list of declared members matching the filters, or an empty list if the type is {@code null} - */ - @Nonnull - @Immutable - static List findDeclaredMembers(TypeElement type, boolean all, Predicate... memberFilters) { - return all ? findAllDeclaredMembers(type, memberFilters) : findDeclaredMembers(type, memberFilters); - } - -} diff --git a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/MessagerUtils.java b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/MessagerUtils.java deleted file mode 100644 index 7668c478d..000000000 --- a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/MessagerUtils.java +++ /dev/null @@ -1,310 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional inpatternion regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package io.microsphere.annotation.processor.util; - -import io.microsphere.util.Utils; - -import javax.annotation.processing.Messager; -import javax.annotation.processing.ProcessingEnvironment; -import javax.tools.Diagnostic.Kind; - -import static io.microsphere.annotation.processor.util.LoggerUtils.debug; -import static io.microsphere.annotation.processor.util.LoggerUtils.error; -import static io.microsphere.annotation.processor.util.LoggerUtils.info; -import static io.microsphere.annotation.processor.util.LoggerUtils.warn; -import static io.microsphere.text.FormatUtils.format; -import static javax.tools.Diagnostic.Kind.ERROR; -import static javax.tools.Diagnostic.Kind.MANDATORY_WARNING; -import static javax.tools.Diagnostic.Kind.NOTE; -import static javax.tools.Diagnostic.Kind.WARNING; - -/** - * {@link Messager} utilities class - * - * @author Mercy - * @see Messager - * @since 1.0.0 - */ -public interface MessagerUtils extends Utils { - - /** - * Prints a note message using the {@link ProcessingEnvironment}'s {@link Messager}. - * - *

- * This method formats the message using the provided pattern and arguments, - * and delegates to the underlying {@link Messager} obtained from the processing environment. - *

- * - *

Example Usage

- * 
-     * ProcessingEnvironment processingEnv = ...; // Obtain processing environment
-     * printNote(processingEnv, "Found {0} elements matching criteria", count);
-     *
- * - * @param processingEnv the processing environment to obtain the messager from - * @param pattern the message pattern to format (supports {@link String#format} syntax) - * @param args the arguments for the message pattern - */ - static void printNote(ProcessingEnvironment processingEnv, String pattern, Object... args) { - printNote(processingEnv.getMessager(), pattern, args); - } - - /** - * Prints a note message using the provided {@link Messager}. - * - *

- * This method formats the message using the provided pattern and arguments, - * and forwards it to the underlying {@link Messager}. - *

- * - *

Example Usage

- * 
-     * Messager messager = processingEnv.getMessager();
-     * printNote(messager, "Found {0} elements matching criteria", count);
-     *
- * - * @param messager the messager to use for printing the message - * @param pattern the message pattern to format (supports {@link String#format} syntax) - * @param args the arguments for the message pattern - */ - /** - * Prints a note message using the provided {@link Messager}. - * - *

- * This method formats the message using the provided pattern and arguments, - * and forwards it to the underlying {@link Messager}. - *

- * - *

Example Usage

- * 
-     * Messager messager = processingEnv.getMessager();
-     * printNote(messager, "Found {0} elements matching criteria", count);
-     *
- * - * @param messager the messager to use for printing the message - * @param pattern the message pattern to format (supports {@link String#format} syntax) - * @param args the arguments for the message pattern - */ - static void printNote(Messager messager, String pattern, Object... args) { - printMessage(messager, NOTE, pattern, args); - } - - /** - * Prints a warning message using the {@link ProcessingEnvironment}'s {@link Messager}. - * - *

- * This method formats the message using the provided pattern and arguments, - * and delegates to the underlying {@link Messager} obtained from the processing environment. - * The message will be logged at the warning level through both the {@link Messager} - * and internal logging utilities. - *

- * - *

Example Usage

- * 
-     * ProcessingEnvironment processingEnv = ...; // Obtain processing environment
-     * printWarning(processingEnv, "Found {0} deprecated elements", count);
-     *
- * - * @param processingEnv the processing environment to obtain the messager from - * @param pattern the message pattern to format (supports {@link String#format} syntax) - * @param args the arguments for the message pattern - */ - static void printWarning(ProcessingEnvironment processingEnv, String pattern, Object... args) { - printWarning(processingEnv.getMessager(), pattern, args); - } - - /** - * Prints a warning message using the provided {@link Messager}. - * - *

- * This method formats the message using the provided pattern and arguments, - * and forwards it to the underlying {@link Messager} as a warning level message. - * The message will also be logged through internal logging utilities at the warning level. - *

- * - *

Example Usage

- * 
-     * Messager messager = processingEnv.getMessager();
-     * printWarning(messager, "Found {0} deprecated elements", count);
-     *
- * - * @param messager the messager to use for printing the message - * @param pattern the message pattern to format (supports {@link String#format} syntax) - * @param args the arguments for the message pattern - */ - static void printWarning(Messager messager, String pattern, Object... args) { - printMessage(messager, WARNING, pattern, args); - } - - /** - * Prints a mandatory warning message using the {@link ProcessingEnvironment}'s {@link Messager}. - * - *

- * This method formats the message using the provided pattern and arguments, - * and delegates to the underlying {@link Messager} obtained from the processing environment. - * The message will be logged at the warning level through both the {@link Messager} - * and internal logging utilities. - *

- * - *

Example Usage

- * 
-     * ProcessingEnvironment processingEnv = ...; // Obtain processing environment
-     * printMandatoryWarning(processingEnv, "Found {0} obsolete elements", count);
-     *
- * - * @param processingEnv the processing environment to obtain the messager from - * @param pattern the message pattern to format (supports {@link String#format} syntax) - * @param args the arguments for the message pattern - */ - static void printMandatoryWarning(ProcessingEnvironment processingEnv, String pattern, Object... args) { - printMandatoryWarning(processingEnv.getMessager(), pattern, args); - } - - /** - * Prints a mandatory warning message using the provided {@link Messager}. - * - *

- * This method formats the message using the provided pattern and arguments, - * and forwards it to the underlying {@link Messager} as a mandatory warning level message. - * The message will also be logged through internal logging utilities at the warning level. - *

- * - *

Example Usage

- * 
-     * Messager messager = processingEnv.getMessager();
-     * printMandatoryWarning(messager, "Found {0} obsolete elements", count);
-     *
- * - * @param messager the messager to use for printing the message - * @param pattern the message pattern to format (supports {@link String#format} syntax) - * @param args the arguments for the message pattern - */ - static void printMandatoryWarning(Messager messager, String pattern, Object... args) { - printMessage(messager, MANDATORY_WARNING, pattern, args); - } - - /** - * Prints an error message using the {@link ProcessingEnvironment}'s {@link Messager}. - * - *

- * This method formats the message using the provided pattern and arguments, - * and delegates to the underlying {@link Messager} obtained from the processing environment. - * The message will be logged at the error level through both the {@link Messager} - * and internal logging utilities. - *

- * - *

Example Usage

- * 
-     * ProcessingEnvironment processingEnv = ...; // Obtain processing environment
-     * printError(processingEnv, "Failed to process {0} elements", count);
-     *
- * - * @param processingEnv the processing environment to obtain the messager from - * @param pattern the message pattern to format (supports {@link String#format} syntax) - * @param args the arguments for the message pattern - */ - static void printError(ProcessingEnvironment processingEnv, String pattern, Object... args) { - printError(processingEnv.getMessager(), pattern, args); - } - - /** - * Prints an error message using the provided {@link Messager}. - * - *

- * This method formats the message using the provided pattern and arguments, - * and forwards it to the underlying {@link Messager} as an error level message. - * The message will also be logged through internal logging utilities at the error level. - *

- * - *

Example Usage

- * 
-     * Messager messager = processingEnv.getMessager();
-     * printError(messager, "Failed to process {0} elements", count);
-     *
- * - * @param messager the messager to use for printing the message - * @param pattern the message pattern to format (supports {@link String#format} syntax) - * @param args the arguments for the message pattern - */ - static void printError(Messager messager, String pattern, Object... args) { - printMessage(messager, ERROR, pattern, args); - } - - /** - * Prints a message of the specified kind using the {@link ProcessingEnvironment}'s {@link Messager}. - * - *

- * This method retrieves the {@link Messager} from the provided {@link ProcessingEnvironment} - * and delegates to the {@link #printMessage(Messager, Kind, String, Object...)} method - * to handle message formatting and output. - *

- * - *

Example Usage

- * 
-     * ProcessingEnvironment processingEnv = ...; // Obtain processing environment
-     * printMessage(processingEnv, Kind.WARNING, "Found {0} deprecated elements", count);
-     *
- * - * @param processingEnv the processing environment to obtain the messager from - * @param kind the kind of message to print (e.g., error, warning, note) - * @param pattern the message pattern to format (supports {@link String#format} syntax) - * @param args the arguments for the message pattern - */ - static void printMessage(ProcessingEnvironment processingEnv, Kind kind, String pattern, Object... args) { - printMessage(processingEnv.getMessager(), kind, pattern, args); - } - - /** - * Prints a message of the specified kind using the provided {@link Messager}. - * - *

- * This method formats the message using the provided pattern and arguments, - * sends it to the annotation processor's messager, and also logs it using - * internal logging utilities at the appropriate level. - *

- * - *

Example Usage

- * 
-     * Messager messager = processingEnv.getMessager();
-     * printMessage(messager, Kind.ERROR, "Failed to process {0} elements", count);
-     *
- * - * @param messager the messager to use for printing the message - * @param kind the kind of message to print (e.g., error, warning, note) - * @param pattern the message pattern to format (supports {@link String#format} syntax) - * @param args the arguments for the message pattern - */ - static void printMessage(Messager messager, Kind kind, String pattern, Object... args) { - String message = format(pattern, args); - messager.printMessage(kind, message); - switch (kind) { - case ERROR: - error(pattern, args); - break; - case WARNING: - case MANDATORY_WARNING: - warn(pattern, args); - break; - case NOTE: - info(pattern, args); - break; - default: - debug(pattern, args); - } - } -} diff --git a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/MethodUtils.java b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/MethodUtils.java deleted file mode 100644 index 510f73f59..000000000 --- a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/MethodUtils.java +++ /dev/null @@ -1,1165 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor.util; - - -import io.microsphere.annotation.Immutable; -import io.microsphere.annotation.Nonnull; -import io.microsphere.annotation.Nullable; -import io.microsphere.util.Utils; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.TypeElement; -import javax.lang.model.element.VariableElement; -import javax.lang.model.type.TypeMirror; -import javax.lang.model.util.Elements; -import java.lang.reflect.Type; -import java.util.List; -import java.util.Objects; -import java.util.function.Predicate; - -import static io.microsphere.annotation.processor.util.ElementUtils.filterElements; -import static io.microsphere.annotation.processor.util.ElementUtils.isPublicNonStatic; -import static io.microsphere.annotation.processor.util.ElementUtils.matchParameterTypeNames; -import static io.microsphere.annotation.processor.util.ElementUtils.matchParameterTypes; -import static io.microsphere.annotation.processor.util.MemberUtils.getDeclaredMembers; -import static io.microsphere.annotation.processor.util.TypeUtils.isSameType; -import static io.microsphere.annotation.processor.util.TypeUtils.ofDeclaredType; -import static io.microsphere.collection.CollectionUtils.isEmpty; -import static io.microsphere.lang.function.Predicates.EMPTY_PREDICATE_ARRAY; -import static io.microsphere.lang.function.Predicates.and; -import static io.microsphere.lang.function.Streams.filterFirst; -import static io.microsphere.util.ArrayUtils.EMPTY_STRING_ARRAY; -import static io.microsphere.util.ArrayUtils.EMPTY_TYPE_ARRAY; -import static io.microsphere.util.ArrayUtils.isNotEmpty; -import static java.util.Collections.emptyList; -import static java.util.Collections.unmodifiableList; -import static java.util.stream.Collectors.toList; -import static javax.lang.model.element.ElementKind.METHOD; -import static javax.lang.model.util.ElementFilter.methodsIn; - -/** - * The utilities class for method in the package "javax.lang.model." - * - * @author Mercy - * @since 1.0.0 - */ -public interface MethodUtils extends Utils { - - /** - * Gets all declared methods of the specified {@link TypeElement}. - * - *

This method returns a list of methods directly declared in the given type element, - * excluding inherited methods. If the provided type element is {@code null}, an empty list is returned. - * - *

Example Usage

- * 
{@code
-     * TypeElement typeElement = ...; // Obtain a valid TypeElement
-     * List methods = getDeclaredMethods(typeElement);
-     * for (ExecutableElement method : methods) {
-     *     System.out.println("Declared Method: " + method.getSimpleName());
-     * }
-     * }
- * - * @param type the specified type element, may be null - * @return a list of executable elements representing all declared methods of the specified type, - * or an empty list if the input type is null - */ - @Nonnull - @Immutable - static List getDeclaredMethods(TypeElement type) { - return findDeclaredMethods(type, EMPTY_PREDICATE_ARRAY); - } - - /** - * Gets all declared methods of the specified {@link TypeMirror}. - * - *

This method returns a list of methods directly declared in the given type mirror, - * excluding inherited methods. If the provided type mirror is {@code null}, an empty list is returned. - * - *

Example Usage

- * 
{@code
-     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror
-     * List methods = getDeclaredMethods(typeMirror);
-     * for (ExecutableElement method : methods) {
-     *     System.out.println("Declared Method: " + method.getSimpleName());
-     * }
-     * }
- * - * @param type the specified type mirror, may be null - * @return a list of executable elements representing all declared methods of the specified type, - * or an empty list if the input type is null - */ - @Nonnull - @Immutable - static List getDeclaredMethods(TypeMirror type) { - return findDeclaredMethods(type, EMPTY_PREDICATE_ARRAY); - } - - /** - * Get all declared methods of the specified type element, including those inherited from superclasses and interfaces. - * - *

This method returns a list of methods directly declared in the given type element, including those - * inherited from superclasses and interfaces. If the provided type element is {@code null}, an empty list is returned. - * - *

Example Usage

- * 
{@code
-     * TypeElement typeElement = ...; // Obtain a valid TypeElement
-     * List methods = getAllDeclaredMethods(typeElement);
-     * for (ExecutableElement method : methods) {
-     *     System.out.println("Declared Method (including inherited): " + method.getSimpleName());
-     * }
-     * }
- * - * @param type the specified type element, may be null - * @return a list of executable elements representing all declared methods of the specified type, - * including those inherited from superclasses and interfaces, or an empty list if the input type is null - */ - @Nonnull - @Immutable - static List getAllDeclaredMethods(TypeElement type) { - return findAllDeclaredMethods(type, EMPTY_PREDICATE_ARRAY); - } - - /** - * Get all declared methods of the specified type mirror, including those inherited from superclasses and interfaces. - * - *

This method returns a list of methods directly declared in the given type mirror, including those - * inherited from superclasses and interfaces. If the provided type mirror is {@code null}, an empty list is returned. - * - *

Example Usage

- * 
{@code
-     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror
-     * List methods = getAllDeclaredMethods(typeMirror);
-     * for (ExecutableElement method : methods) {
-     *     System.out.println("Declared Method (including inherited): " + method.getSimpleName());
-     * }
-     * }
- * - * @param type the specified type mirror, may be null - * @return a list of executable elements representing all declared methods of the specified type, - * including those inherited from superclasses and interfaces, or an empty list if the input type is null - */ - @Nonnull - @Immutable - static List getAllDeclaredMethods(TypeMirror type) { - return findAllDeclaredMethods(type, EMPTY_PREDICATE_ARRAY); - } - - /** - * Find the declared methods of the specified {@link TypeElement}. - * - *

This method returns a list of methods directly declared in the given type element, - * excluding inherited methods. If the provided type element is {@code null}, an empty list is returned. - * Additional filters can be applied to narrow down the list of methods based on custom criteria. - * - *

Example Usage

- * 
{@code
-     * TypeElement typeElement = ...; // Obtain a valid TypeElement
-     * List methods = findDeclaredMethods(typeElement);
-     * for (ExecutableElement method : methods) {
-     *     System.out.println("Declared Method: " + method.getSimpleName());
-     * }
-     * }
- * - *

Filtering usage example: - * 

{@code
-     * List publicNonStaticMethods = findDeclaredMethods(typeElement, MethodUtils::isPublicNonStaticMethod);
-     * for (ExecutableElement method : publicNonStaticMethods) {
-     *     System.out.println("Public Non-Static Method: " + method.getSimpleName());
-     * }
-     * }
- * - * @param type the specified type element, may be null - * @param methodFilters the filters for method elements - * @return a list of executable elements representing all declared methods of the specified type, - * or an empty list if the input type is null - */ - @Nonnull - @Immutable - static List findDeclaredMethods(TypeElement type, Predicate... methodFilters) { - return type == null ? emptyList() : findDeclaredMethods(type.asType(), methodFilters); - } - - /** - * Find the declared methods of the specified type mirror. - * - *

This method returns a list of methods directly declared in the given type mirror, - * excluding inherited methods. If the provided type mirror is {@code null}, an empty list is returned. - * Additional filters can be applied to narrow down the list of methods based on custom criteria. - * - *

Example Usage

- * 
{@code
-     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror
-     * List methods = findDeclaredMethods(typeMirror);
-     * for (ExecutableElement method : methods) {
-     *     System.out.println("Declared Method: " + method.getSimpleName());
-     * }
-     * }
- * - *

Filtering usage example: - * 

{@code
-     * List publicNonStaticMethods = findDeclaredMethods(typeMirror, MethodUtils::isPublicNonStaticMethod);
-     * for (ExecutableElement method : publicNonStaticMethods) {
-     *     System.out.println("Public Non-Static Method: " + method.getSimpleName());
-     * }
-     * }
- * - * @param type the specified type mirror, may be null - * @param methodFilters the filters for method elements - * @return a list of executable elements representing all declared methods of the specified type, - * or an empty list if the input type is null - */ - @Nonnull - @Immutable - static List findDeclaredMethods(TypeMirror type, Predicate... methodFilters) { - return filterDeclaredMethods(type, false, methodFilters); - } - - /** - * Find all declared methods of the specified type element, including those inherited from superclasses and interfaces, - * and exclude methods declared in the specified excluded types. - * - *

Example Usage

- * 
{@code
-     * TypeElement typeElement = ...; // Obtain a valid TypeElement
-     * List methods = findAllDeclaredMethods(typeElement);
-     * for (ExecutableElement method : methods) {
-     *     System.out.println("Declared Method (including inherited): " + method.getSimpleName());
-     * }
-     * }
- * - *

Excluding methods from specific types: - * 

{@code
-     * List methodsExcludingObject = findAllDeclaredMethods(typeElement, Object.class);
-     * for (ExecutableElement method : methodsExcludingObject) {
-     *     System.out.println("Method excluding Object: " + method.getSimpleName());
-     * }
-     * }
- * - * @param type the specified type element, may be null - * @param excludedTypes the types whose methods should be excluded from the result, optional - * @return a list of executable elements representing all declared methods of the specified type, - * including those inherited from superclasses and interfaces, but excluding those declared - * in the excluded types, or an empty list if the input type is null - */ - @Nonnull - @Immutable - static List findAllDeclaredMethods(TypeElement type, Type... excludedTypes) { - return type == null ? emptyList() : findAllDeclaredMethods(type.asType(), excludedTypes); - } - - /** - * Find all declared methods of the specified type mirror, including those inherited from superclasses and interfaces, - * and exclude methods declared in the specified excluded types. - * - *

This method returns a list of methods directly declared in the given type mirror, - * including those inherited from superclasses and interfaces. If the provided type mirror is {@code null}, - * an empty list is returned. Additional filtering can be applied to exclude methods declared in specific types. - * - *

Example Usage

- * 
{@code
-     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror
-     * List methods = findAllDeclaredMethods(typeMirror);
-     * for (ExecutableElement method : methods) {
-     *     System.out.println("Declared Method (including inherited): " + method.getSimpleName());
-     * }
-     * }
- * - *

Excluding methods from specific types: - * 

{@code
-     * List methodsExcludingObject = findAllDeclaredMethods(typeMirror, Object.class);
-     * for (ExecutableElement method : methodsExcludingObject) {
-     *     System.out.println("Method excluding Object: " + method.getSimpleName());
-     * }
-     * }
- * - * @param type the specified type mirror, may be null - * @param excludedTypes the types whose methods should be excluded from the result, optional - * @return a list of executable elements representing all declared methods of the specified type, - * excluding those declared in the excluded types, or an empty list if the input type is null - */ - @Nonnull - @Immutable - static List findAllDeclaredMethods(TypeMirror type, Type... excludedTypes) { - if (type == null) { - return emptyList(); - } - return findAllDeclaredMethods(type, methodPredicateForExcludedTypes(excludedTypes)); - } - - /** - * Finds all public non-static methods declared in the specified {@link TypeElement}, excluding those inherited from superclasses or interfaces, - * and optionally excludes methods declared in the specified excluded types. - * - *

This method returns a list of executable elements representing public non-static methods directly declared in the given type element. - * If the provided type element is {@code null}, an empty list is returned. - * - *

Example Usage

- * 
{@code
-     * TypeElement typeElement = ...; // Obtain a valid TypeElement
-     * List methods = findPublicNonStaticMethods(typeElement);
-     * for (ExecutableElement method : methods) {
-     *     System.out.println("Public Non-Static Method: " + method.getSimpleName());
-     * }
-     * }
- * - *

Excluding methods from specific types: - * 

{@code
-     * List methodsExcludingObject = findPublicNonStaticMethods(typeElement, Object.class);
-     * for (ExecutableElement method : methodsExcludingObject) {
-     *     System.out.println("Public Non-Static Method (excluding Object): " + method.getSimpleName());
-     * }
-     * }
- * - * @param type the specified type element, may be null - * @param excludedTypes the types whose methods should be excluded from the result, optional - * @return a list of executable elements representing all public non-static methods declared in the specified type, - * or an empty list if the input type is null - */ - @Nonnull - @Immutable - static List findPublicNonStaticMethods(TypeElement type, Type... excludedTypes) { - return type == null ? emptyList() : findPublicNonStaticMethods(ofDeclaredType(type), excludedTypes); - } - - /** - * Find all public non-static methods declared in the specified type mirror, excluding those inherited from superclasses or interfaces, - * and optionally exclude methods declared in the specified excluded types. - * - *

This method returns a list of executable elements representing public non-static methods directly declared in the given type. - * If the provided type is {@code null}, an empty list is returned. - * - *

Example Usage

- * 
{@code
-     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror
-     * List methods = findPublicNonStaticMethods(typeMirror);
-     * for (ExecutableElement method : methods) {
-     *     System.out.println("Public Non-Static Method: " + method.getSimpleName());
-     * }
-     * }
- * - *

Excluding methods from specific types: - * 

{@code
-     * List methodsExcludingObject = findPublicNonStaticMethods(typeMirror, Object.class);
-     * for (ExecutableElement method : methodsExcludingObject) {
-     *     System.out.println("Public Non-Static Method (excluding Object): " + method.getSimpleName());
-     * }
-     * }
- * - * @param type the specified type mirror, may be null - * @param excludedTypes the types whose methods should be excluded from the result, optional - * @return a list of executable elements representing all public non-static methods declared in the specified type, - * excluding those declared in the excluded types, or an empty list if the input type is null - */ - @Nonnull - @Immutable - static List findPublicNonStaticMethods(TypeMirror type, Type... excludedTypes) { - if (type == null) { - return emptyList(); - } - - Predicate predicate = and(methodPredicateForExcludedTypes(excludedTypes), MethodUtils::isPublicNonStaticMethod); - - return findAllDeclaredMethods(type, predicate); - } - - /** - * Find all declared methods of the specified {@link TypeElement}, including those inherited from superclasses and interfaces, - * and optionally filter them using the provided predicates. - * - *

This method returns a list of methods directly declared in the given type element, - * including those inherited from superclasses and interfaces. If the provided type element is {@code null}, - * an empty list is returned. Additional filters can be applied to narrow down the list of methods based on custom criteria. - * - *

Example Usage

- * 
{@code
-     * TypeElement typeElement = ...; // Obtain a valid TypeElement
-     * List methods = findAllDeclaredMethods(typeElement);
-     * for (ExecutableElement method : methods) {
-     *     System.out.println("Declared Method (including inherited): " + method.getSimpleName());
-     * }
-     * }
- * - *

Filtering usage example: - * 

{@code
-     * List publicNonStaticMethods = findAllDeclaredMethods(typeElement, MethodUtils::isPublicNonStaticMethod);
-     * for (ExecutableElement method : publicNonStaticMethods) {
-     *     System.out.println("Public Non-Static Method: " + method.getSimpleName());
-     * }
-     * }
- * - * @param type the specified type element, may be null - * @param methodFilters the filters for method elements, optional - * @return a list of executable elements representing all declared methods of the specified type, - * including those inherited from superclasses and interfaces, or an empty list if the input type is null - */ - @Nonnull - @Immutable - static List findAllDeclaredMethods(TypeElement type, Predicate... methodFilters) { - return type == null ? emptyList() : findAllDeclaredMethods(type.asType(), methodFilters); - } - - /** - * Finds all declared methods of the specified type mirror, including those inherited from superclasses and interfaces, - * and optionally filters them using the provided predicates. - * - *

This method returns a list of methods directly declared in the given type mirror, including those - * inherited from superclasses and interfaces. If the provided type mirror is {@code null}, an empty list is returned. - * Additional filters can be applied to narrow down the list of methods based on custom criteria. - * - *

Example Usage

- * 
{@code
-     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror
-     * List methods = findAllDeclaredMethods(typeMirror);
-     * for (ExecutableElement method : methods) {
-     *     System.out.println("Declared Method (including inherited): " + method.getSimpleName());
-     * }
-     * }
- * - *

Filtering usage example: - * 

{@code
-     * List publicNonStaticMethods = findAllDeclaredMethods(typeMirror, MethodUtils::isPublicNonStaticMethod);
-     * for (ExecutableElement method : publicNonStaticMethods) {
-     *     System.out.println("Public Non-Static Method: " + method.getSimpleName());
-     * }
-     * }
- * - * @param type the specified type mirror, may be null - * @param methodFilters the filters for method elements, optional - * @return a list of executable elements representing all declared methods of the specified type, - * including those inherited from superclasses and interfaces, or an empty list if the input type is null - */ - @Nonnull - @Immutable - static List findAllDeclaredMethods(TypeMirror type, Predicate... methodFilters) { - return filterDeclaredMethods(type, true, methodFilters); - } - - /** - * Filters the declared methods of the specified type based on the given predicates. - * - *

This method returns a list of methods directly declared in the given type, - * optionally including those inherited from superclasses and interfaces. If the provided type is {@code null}, - * an empty list is returned. Additional filters can be applied to narrow down the list of methods based on custom criteria. - * - *

Example Usage

- * 
{@code
-     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror
-     * List methods = filterDeclaredMethods(typeMirror, false);
-     * for (ExecutableElement method : methods) {
-     *     System.out.println("Declared Method: " + method.getSimpleName());
-     * }
-     * }
- * - *

Filtering usage example: - * 

{@code
-     * List publicNonStaticMethods = filterDeclaredMethods(typeMirror, false, MethodUtils::isPublicNonStaticMethod);
-     * for (ExecutableElement method : publicNonStaticMethods) {
-     *     System.out.println("Public Non-Static Method: " + method.getSimpleName());
-     * }
-     * }
- * - * @param type the type whose declared methods are to be filtered, may be null - * @param includeHierarchicalTypes whether to include methods from superclasses and interfaces - * @param methodFilters the predicates used to filter the methods, optional - * @return a list of executable elements representing the filtered methods, - * or an empty list if the input type is null or no methods match the filters - */ - @Nonnull - @Immutable - static List filterDeclaredMethods(TypeMirror type, boolean includeHierarchicalTypes, Predicate... methodFilters) { - if (type == null) { - return emptyList(); - } - - List declaredMembers = getDeclaredMembers(type, includeHierarchicalTypes); - if (isEmpty(declaredMembers)) { - return emptyList(); - } - - List methods = methodsIn(declaredMembers); - - return filterElements(methods, methodFilters); - } - - /** - * Checks if the given executable element is a method. - * - *

This method determines whether the provided executable element represents a method. - * If the element is {@code null}, the method returns {@code false}. - * - *

Example Usage

- * 
{@code
-     * ExecutableElement executableElement = ...; // Obtain a valid ExecutableElement
-     * boolean isMethod = MethodUtils.isMethod(executableElement);
-     * if (isMethod) {
-     *     System.out.println("The element is a method.");
-     * } else {
-     *     System.out.println("The element is not a method.");
-     * }
-     * }
- * - * @param method the executable element to check, may be null - * @return true if the element is a method, false otherwise - */ - static boolean isMethod(ExecutableElement method) { - return method != null && METHOD.equals(method.getKind()); - } - - /** - * Checks whether the given method is a public non-static method. - * - *

This method verifies if the provided executable element represents a method that is both public and non-static. - * If the method is {@code null}, the method returns {@code false}. - * - *

Example Usage

- * 
{@code
-     * ExecutableElement method = ...; // Obtain a valid ExecutableElement
-     * boolean isPublicNonStatic = MethodUtils.isPublicNonStaticMethod(method);
-     * if (isPublicNonStatic) {
-     *     System.out.println("The method is a public non-static method.");
-     * } else {
-     *     System.out.println("The method is not a public non-static method.");
-     * }
-     * }
- * - * @param method the executable element to check, may be null - * @return true if the method is a public non-static method, false otherwise - */ - static boolean isPublicNonStaticMethod(ExecutableElement method) { - return isMethod(method) && isPublicNonStatic(method); - } - - /** - * Finds a method with the specified name in the given type element, using an empty parameter type array as default. - * - *

This method searches for a method with the specified name in the given type element. - * If no method with the specified name is found, it returns {@code null}. - * The search considers methods declared directly in the type, excluding inherited methods. - * - *

Example Usage

- * 
{@code
-     * TypeElement typeElement = ...; // Obtain a valid TypeElement
-     * String methodName = "myMethod";
-     * ExecutableElement method = MethodUtils.findMethod(typeElement, methodName);
-     *
-     * if (method != null) {
-     *     System.out.println("Found method: " + method.getSimpleName());
-     * } else {
-     *     System.out.println("Method not found.");
-     * }
-     * }
- * - * @param type the type element to search for the method - * @param methodName the name of the method to find - * @return the first matching executable element representing the method, or null if none is found - */ - @Nullable - static ExecutableElement findMethod(TypeElement type, String methodName) { - return findMethod(type, methodName, EMPTY_TYPE_ARRAY); - } - - /** - * Finds a method with the specified name in the given type mirror, using an empty parameter type array as default. - * - *

This method searches for a method with the specified name in the given type mirror. - * If no method with the specified name is found, it returns {@code null}. - * The search considers methods declared directly in the type, excluding inherited methods. - * - *

Example Usage

- * 
{@code
-     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror
-     * String methodName = "myMethod";
-     * ExecutableElement method = MethodUtils.findMethod(typeMirror, methodName);
-     *
-     * if (method != null) {
-     *     System.out.println("Found method: " + method.getSimpleName());
-     * } else {
-     *     System.out.println("Method not found.");
-     * }
-     * }
- * - * @param type the type mirror to search for the method - * @param methodName the name of the method to find - * @return the first matching executable element representing the method, or null if none is found - */ - @Nullable - static ExecutableElement findMethod(TypeMirror type, String methodName) { - return findMethod(type, methodName, EMPTY_TYPE_ARRAY); - } - - /** - * Finds a method with the specified name and parameter types in the given {@link TypeElement}. - * - *

This method searches for a method with the specified name and exact parameter types - * directly declared in the provided type element, excluding inherited methods. - * If no matching method is found, it returns {@code null}. - * - *

Example Usage

- * 
{@code
-     * TypeElement typeElement = ...; // Obtain a valid TypeElement
-     * String methodName = "myMethod";
-     * Type[] parameterTypes = new Type[] { String.class, int.class };
-     * ExecutableElement method = MethodUtils.findMethod(typeElement, methodName, parameterTypes);
-     *
-     * if (method != null) {
-     *     System.out.println("Found method: " + method.getSimpleName());
-     * } else {
-     *     System.out.println("Method not found.");
-     * }
-     * }
- * - * @param type the specified type element, may be null - * @param methodName the name of the method to find, must not be null - * @param parameterTypes the parameter types of the method to match, must not be null - * @return the first matching executable element representing the method, or null if none is found - */ - @Nullable - static ExecutableElement findMethod(TypeElement type, String methodName, Type... parameterTypes) { - return type == null ? null : findMethod(type.asType(), methodName, parameterTypes); - } - - /** - * Finds a method with the specified name and parameter types in the given type mirror. - * - *

This method searches for a method with the specified name and exact parameter types - * directly declared in the provided type mirror, excluding inherited methods. - * If no matching method is found, it returns {@code null}. - * - *

Example Usage

- * 
{@code
-     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror
-     * String methodName = "myMethod";
-     * Type[] parameterTypes = new Type[] { String.class, int.class };
-     * ExecutableElement method = MethodUtils.findMethod(typeMirror, methodName, parameterTypes);
-     *
-     * if (method != null) {
-     *     System.out.println("Found method: " + method.getSimpleName());
-     * }
-     * }
- * - * @param type the type mirror to search for the method, may be null - * @param methodName the name of the method to find, must not be null - * @param parameterTypes the parameter types of the method to match, must not be null - * @return the first matching executable element representing the method, or null if none is found - */ - @Nullable - static ExecutableElement findMethod(TypeMirror type, String methodName, Type... parameterTypes) { - if (type == null || methodName == null || parameterTypes == null) { - return null; - } - List allDeclaredMethods = findAllDeclaredMethods(type, method -> matches(method, methodName, parameterTypes)); - return allDeclaredMethods.isEmpty() ? null : allDeclaredMethods.get(0); - } - - /** - * Finds a method with the specified name and parameter type names in the given {@link TypeElement}. - * - *

This method searches for a method with the specified name and exact parameter type names - * directly declared in the provided type element, excluding inherited methods. - * If no matching method is found, it returns {@code null}. - * - *

Example Usage

- * 
{@code
-     * TypeElement typeElement = ...; // Obtain a valid TypeElement
-     * String methodName = "myMethod";
-     * CharSequence[] paramTypeNames = new CharSequence[] { "java.lang.String", "int" };
-     * ExecutableElement method = MethodUtils.findMethod(typeElement, methodName, paramTypeNames);
-     *
-     * if (method != null) {
-     *     System.out.println("Found method: " + method.getSimpleName());
-     * } else {
-     *     System.out.println("Method not found.");
-     * }
-     * }
- * - * @param type the type element to search for the method, may be null - * @param methodName the name of the method to find, must not be null - * @param parameterTypeNames the names of the parameter types of the method to match, must not be null - * @return the first matching executable element representing the method, or null if none is found - */ - @Nullable - static ExecutableElement findMethod(TypeElement type, String methodName, CharSequence... parameterTypeNames) { - return type == null ? null : findMethod(type.asType(), methodName, parameterTypeNames); - } - - /** - * Finds a method with the specified name and parameter type names in the given type mirror. - * - *

This method searches for a method with the specified name and exact parameter type names - * directly declared in the provided type mirror, excluding inherited methods. - * If no matching method is found, it returns {@code null}. - * - *

Example Usage

- * 
{@code
-     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror
-     * String methodName = "myMethod";
-     * CharSequence[] paramTypeNames = new CharSequence[] { "java.lang.String", "int" };
-     * ExecutableElement method = MethodUtils.findMethod(typeMirror, methodName, paramTypeNames);
-     *
-     * if (method != null) {
-     *     System.out.println("Found method: " + method.getSimpleName());
-     * }
-     * }
- * - * @param type the type mirror to search for the method, may be null - * @param methodName the name of the method to find, must not be null - * @param parameterTypeNames the names of the parameter types of the method to match, must not be null - * @return the first matching executable element representing the method, or null if none is found - */ - @Nullable - static ExecutableElement findMethod(TypeMirror type, String methodName, CharSequence... parameterTypeNames) { - if (type == null || methodName == null || parameterTypeNames == null) { - return null; - } - List allDeclaredMethods = findAllDeclaredMethods(type, method -> matches(method, methodName, parameterTypeNames)); - return allDeclaredMethods.isEmpty() ? null : allDeclaredMethods.get(0); - } - - /** - * Finds the overridden method in the specified type that corresponds to the given declaring method. - * - *

This method searches for a method in the provided type element that overrides the specified - * declaring method. It utilizes the processing environment to determine method overriding using - * the {@link Elements#overrides(ExecutableElement, ExecutableElement, TypeElement)} method. - * - *

Example Usage

- * 
{@code
-     * ProcessingEnvironment processingEnv = ...; // Obtain a valid ProcessingEnvironment
-     * TypeElement typeElement = ...; // The type in which to find the overridden method
-     * ExecutableElement declaringMethod = ...; // The method being overridden
-     *
-     * ExecutableElement overriddenMethod = getOverrideMethod(processingEnv, typeElement, declaringMethod);
-     *
-     * if (overriddenMethod != null) {
-     *     System.out.println("Overridden Method Found: " + overriddenMethod.getSimpleName());
-     * } else {
-     *     System.out.println("No overridden method found.");
-     * }
-     * }
- * - * @param processingEnv the processing environment used to determine overriding - * @param type the type element in which to search for the overridden method - * @param declaringMethod the method element whose override is to be found - * @return the overridden method in the specified type, or null if no such method exists - */ - @Nullable - static ExecutableElement getOverrideMethod(ProcessingEnvironment processingEnv, TypeElement type, ExecutableElement declaringMethod) { - Elements elements = processingEnv.getElementUtils(); - return filterFirst(getAllDeclaredMethods(type), method -> elements.overrides(method, declaringMethod, type)); - } - - /** - * Filters the given list of executable elements (methods) based on the provided predicates. - * - *

This method applies a set of filtering predicates to a list of methods and returns a new list - * containing only the methods that satisfy all the provided conditions. If no method matches, - * an empty list is returned. If no filters are provided, the original list is returned unchanged. - * - *

Example Usage

- * 
{@code
-     * List methods = MethodUtils.getDeclaredMethods(typeElement);
-     * List publicNonStaticMethods = MethodUtils.filterMethods(methods, MethodUtils::isPublicNonStaticMethod);
-     *
-     * for (ExecutableElement method : publicNonStaticMethods) {
-     *     System.out.println("Public Non-Static Method: " + method.getSimpleName());
-     * }
-     * }
- * - *

Multiple filters can be combined: - * 

{@code
-     * Predicate isPublic = method -> method.getModifiers().contains(Modifier.PUBLIC);
-     * Predicate isVoidReturnType = method -> "void".equals(TypeUtils.toString(method.getReturnType()));
-     *
-     * List filteredMethods = MethodUtils.filterMethods(methods, isPublic, isVoidReturnType);
-     * for (ExecutableElement method : filteredMethods) {
-     *     System.out.println("Public Method with Void Return Type: " + method.getSimpleName());
-     * }
-     * }
- * - * @param methods the list of executable elements (methods) to be filtered - * @param methodFilters the array of predicates used for filtering the methods - * @return a filtered list of executable elements matching all the provided predicates, - * or an empty list if the input list is null or empty, or no methods match the filters - */ - @Nonnull - @Immutable - static List filterMethods(List methods, Predicate... methodFilters) { - if (isEmpty(methods)) { - return emptyList(); - } - - List filteredMethods = methods; - if (isNotEmpty(methodFilters)) { - Predicate combinedPredicate = and(methodFilters); - filteredMethods = methods.stream() - .filter(combinedPredicate) - .collect(toList()); - } - - return filteredMethods.isEmpty() ? emptyList() : unmodifiableList(filteredMethods); - } - - /** - * Gets the simple name of the method as a string. - * - *

If the provided method is null, this method returns null. - * Otherwise, it returns the simple name of the method as a string. - * - *

Example Usage

- * 
{@code
-     * ExecutableElement method = ...; // Obtain a valid ExecutableElement representing a method
-     * String methodName = MethodUtils.getMethodName(method);
-     * if (methodName != null) {
-     *     System.out.println("Method Name: " + methodName);
-     * } else {
-     *     System.out.println("Method is null.");
-     * }
-     * }
- * - * @param method the executable element representing the method, may be null - * @return the simple name of the method as a string, or null if the method is null - */ - @Nullable - static String getMethodName(ExecutableElement method) { - return method == null ? null : method.getSimpleName().toString(); - } - - /** - * Gets the return type name of the given method. - * - *

If the provided method is null, this method returns null. - * Otherwise, it returns the fully qualified name of the method's return type. - * - *

Example Usage

- * 
{@code
-     * ExecutableElement method = ...; // Obtain a valid ExecutableElement representing a method
-     * String returnTypeName = MethodUtils.getReturnTypeName(method);
-     * if (returnTypeName != null) {
-     *     System.out.println("Return Type Name: " + returnTypeName);
-     * } else {
-     *     System.out.println("Method is null or has no return type.");
-     * }
-     * }
- * - * @param method the executable element representing the method, may be null - * @return the fully qualified name of the method's return type as a string, or null if the method is null - */ - @Nullable - static String getReturnTypeName(ExecutableElement method) { - return method == null ? null : TypeUtils.toString(method.getReturnType()); - } - - /** - * Gets the parameter type mirrors of the given method. - * - *

This method returns a list of type mirrors representing the parameter types of the provided method. - * If the method is {@code null} or has no parameters, an empty list is returned. - * - *

Example Usage

- * 
{@code
-     * ExecutableElement method = ...; // Obtain a valid ExecutableElement representing a method
-     * List parameterTypeMirrors = MethodUtils.getMethodParameterTypeMirrors(method);
-     *
-     * if (!parameterTypeMirrors.isEmpty()) {
-     *     for (TypeMirror typeMirror : parameterTypeMirrors) {
-     *         System.out.println("Parameter Type: " + TypeUtils.toString(typeMirror));
-     *     }
-     * } else {
-     *     System.out.println("Method is null or has no parameters.");
-     * }
-     * }
- * - * @param method the executable element representing the method, may be null - * @return a list of type mirrors representing the parameter types of the method, - * or an empty list if the method is null or has no parameters - */ - @Nonnull - @Immutable - static List getMethodParameterTypeMirrors(ExecutableElement method) { - if (method == null) { - return emptyList(); - } - - List parameters = method.getParameters(); - if (parameters.isEmpty()) { - return emptyList(); - } - - List parameterTypes = parameters.stream() - .map(VariableElement::asType) - .collect(toList()); - - return unmodifiableList(parameterTypes); - } - - /** - * Gets the parameter type names of the given method. - * - *

This method returns an array of strings representing the fully qualified names - * of the parameter types of the provided method. If the method is {@code null} or has no parameters, - * an empty array is returned. - * - *

Example Usage

- * 
{@code
-     * ExecutableElement method = ...; // Obtain a valid ExecutableElement representing a method
-     * String[] parameterTypeNames = MethodUtils.getMethodParameterTypeNames(method);
-     *
-     * if (parameterTypeNames.length > 0) {
-     *     for (String typeName : parameterTypeNames) {
-     *         System.out.println("Parameter Type: " + typeName);
-     *     }
-     * } else {
-     *     System.out.println("Method is null or has no parameters.");
-     * }
-     * }
- * - * @param method the executable element representing the method, may be null - * @return an array of strings representing the fully qualified names of the parameter types, - * or an empty array if the method is null or has no parameters - */ - static String[] getMethodParameterTypeNames(ExecutableElement method) { - List parameterTypes = getMethodParameterTypeMirrors(method); - return parameterTypes.isEmpty() ? EMPTY_STRING_ARRAY : - parameterTypes.stream().map(TypeUtils::toString).toArray(String[]::new); - } - - /** - * Checks if the given method matches the specified method name and parameter types. - * - *

This method determines whether the provided executable element (method) has the same name - * and parameter types as specified. If the method is null or any of the parameters are null, - * the result will be false. - * - *

Example Usage

- * 
{@code
-     * ExecutableElement method = ...; // Obtain a valid ExecutableElement
-     * boolean isMatch = matches(method, "myMethod", String.class, int.class);
-     * if (isMatch) {
-     *     System.out.println("The method matches the specified name and parameter types.");
-     * } else {
-     *     System.out.println("The method does not match.");
-     * }
-     * }
- * - * @param method the executable element representing the method to check - * @param methodName the name of the method to match - * @param parameterTypes the parameter types of the method to match - * @return true if the method matches the given name and parameter types, false otherwise - */ - static boolean matches(ExecutableElement method, String methodName, Type... parameterTypes) { - return matchesMethod(method, methodName, parameterTypes); - } - - /** - * Checks if the given method matches the specified method name and parameter type names. - * - *

This method determines whether the provided executable element (method) has the same name - * and parameter type names as specified. If the method is null or any of the parameters are null, - * the result will be false. - * - *

Example Usage

- * 
{@code
-     * ExecutableElement method = ...; // Obtain a valid ExecutableElement
-     * boolean isMatch = matches(method, "myMethod", "java.lang.String", "int");
-     * if (isMatch) {
-     *     System.out.println("The method matches the specified name and parameter type names.");
-     * } else {
-     *     System.out.println("The method does not match.");
-     * }
-     * }
- * - * @param method the executable element representing the method to check - * @param methodName the name of the method to match - * @param parameterTypeNames the names of the parameter types to match - * @return true if the method matches the given name and parameter type names, false otherwise - */ - static boolean matches(ExecutableElement method, String methodName, CharSequence... parameterTypeNames) { - return matchesMethod(method, methodName, parameterTypeNames); - } - - /** - * Checks if the given method has the specified method name. - * - *

This method compares the simple name of the provided executable element (method) - * with the given method name. If either the method or the method name is {@code null}, - * the comparison is performed using {@link Objects#equals(Object, Object)}. - * - *

Example Usage

- * 
{@code
-     * ExecutableElement method = ...; // Obtain a valid ExecutableElement
-     * boolean isMatch = MethodUtils.matchesMethodName(method, "myMethod");
-     *
-     * if (isMatch) {
-     *     System.out.println("The method name matches.");
-     * } else {
-     *     System.out.println("The method name does not match.");
-     * }
-     * }
- * - * @param method the executable element representing the method to check - * @param methodName the name of the method to match, may be null - * @return true if the method's name matches the given method name, false otherwise - */ - static boolean matchesMethodName(ExecutableElement method, String methodName) { - return Objects.equals(getMethodName(method), methodName); - } - - /** - * Checks if the given method matches the specified method name and parameter types. - * - *

This method determines whether the provided executable element (method) has the same name - * and parameter types as specified. If the method is null or any of the parameters are null, - * the result will be false. - * - *

Example Usage

- * 
{@code
-     * ExecutableElement method = ...; // Obtain a valid ExecutableElement
-     * boolean isMatch = MethodUtils.matchesMethod(method, "myMethod", String.class, int.class);
-     * if (isMatch) {
-     *     System.out.println("The method matches the specified name and parameter types.");
-     * } else {
-     *     System.out.println("The method does not match.");
-     * }
-     * }
- * - * @param method the executable element representing the method to check - * @param methodName the name of the method to match - * @param parameterTypes the parameter types of the method to match - * @return true if the method matches the given name and parameter types, false otherwise - */ - static boolean matchesMethod(ExecutableElement method, String methodName, Type... parameterTypes) { - if (method == null || methodName == null || parameterTypes == null) { - return false; - } - - // Check if the method name matches - if (!matchesMethodName(method, methodName)) { - return false; - } - - // Check if the parameter types match - if (!matchParameterTypes(method, parameterTypes)) { - return false; - } - - return true; - } - - /** - * Checks if the given method matches the specified method name and parameter type names. - * - *

This method determines whether the provided executable element (method) has the same name - * and parameter type names as specified. If the method is null or any of the parameters are null, - * the result will be false. - * - *

Example Usage

- * 
{@code
-     * ExecutableElement method = ...; // Obtain a valid ExecutableElement
-     * boolean isMatch = MethodUtils.matchesMethod(method, "myMethod", "java.lang.String", "int");
-     * if (isMatch) {
-     *     System.out.println("The method matches the specified name and parameter type names.");
-     * } else {
-     *     System.out.println("The method does not match.");
-     * }
-     * }
- * - * @param method the executable element representing the method to check - * @param methodName the name of the method to match - * @param parameterTypeNames the names of the parameter types to match - * @return true if the method matches the given name and parameter type names, false otherwise - */ - static boolean matchesMethod(ExecutableElement method, String methodName, CharSequence... parameterTypeNames) { - if (method == null || methodName == null || parameterTypeNames == null) { - return false; - } - - // matches the name of method - if (!Objects.equals(getMethodName(method), methodName)) { - return false; - } - - if (!matchParameterTypeNames(method.getParameters(), parameterTypeNames)) { - return false; - } - - return true; - } - - /** - * Returns the enclosing element of the given executable method. - * - *

This method retrieves the element that directly encloses the provided method. - * If the method is {@code null}, the method returns {@code null}. - * - *

Example Usage

- * 
{@code
-     * ExecutableElement method = ...; // Obtain a valid ExecutableElement
-     * Element enclosingElement = MethodUtils.getEnclosingElement(method);
-     * if (enclosingElement != null) {
-     *     System.out.println("Enclosing Element: " + enclosingElement.getSimpleName());
-     * } else {
-     *     System.out.println("Method is null or has no enclosing element.");
-     * }
-     * }
- * - * @param method the executable element representing the method, may be null - * @return the enclosing element of the method, or null if the method is null - */ - @Nullable - static Element getEnclosingElement(ExecutableElement method) { - return method == null ? null : method.getEnclosingElement(); - } - - /** - * Creates a predicate that filters out methods declared in the specified excluded types. - * - *

This predicate can be used to exclude methods that are declared in certain types, - * such as standard Java types like {@link Object}, when searching or filtering through methods. - * If no excluded types are provided, the predicate will allow all methods. - * - *

Example Usage

- * 
{@code
-     * Predicate excludeObjectMethods = methodPredicateForExcludedTypes(Object.class);
-     * List filteredMethods = findDeclaredMethods(typeMirror, excludeObjectMethods);
-     *
-     * for (ExecutableElement method : filteredMethods) {
-     *     System.out.println("Filtered Method: " + method.getSimpleName());
-     * }
-     * }
- * - * @param excludedTypes the types whose methods should be excluded from the result, optional - * @return a predicate that returns {@code true} for methods not declared in any of the excluded types - */ - @Nonnull - static Predicate methodPredicateForExcludedTypes(Type... excludedTypes) { - return method -> { - boolean excluded = true; - Element declaredType = getEnclosingElement(method); - for (Type excludedType : excludedTypes) { - if (isSameType(declaredType, excludedType)) { - excluded = false; - break; - } - } - return excluded; - }; - } -} diff --git a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/TypeUtils.java b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/TypeUtils.java deleted file mode 100644 index 829ed464c..000000000 --- a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/TypeUtils.java +++ /dev/null @@ -1,2505 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor.util; - -import io.microsphere.annotation.Immutable; -import io.microsphere.annotation.Nonnull; -import io.microsphere.annotation.Nullable; -import io.microsphere.util.TypeFinder; -import io.microsphere.util.Utils; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.lang.model.element.Element; -import javax.lang.model.element.TypeElement; -import javax.lang.model.element.TypeParameterElement; -import javax.lang.model.type.DeclaredType; -import javax.lang.model.type.TypeMirror; -import javax.lang.model.util.Elements; -import java.lang.reflect.Type; -import java.util.Collection; -import java.util.List; -import java.util.Objects; -import java.util.function.Function; -import java.util.function.Predicate; - -import static io.microsphere.collection.CollectionUtils.isEmpty; -import static io.microsphere.collection.Lists.ofList; -import static io.microsphere.constants.SymbolConstants.GREATER_THAN_CHAR; -import static io.microsphere.constants.SymbolConstants.LESS_THAN_CHAR; -import static io.microsphere.lang.function.Predicates.EMPTY_PREDICATE_ARRAY; -import static io.microsphere.lang.function.Predicates.and; -import static io.microsphere.lang.function.Streams.filterFirst; -import static io.microsphere.reflect.MethodUtils.invokeMethod; -import static io.microsphere.reflect.TypeUtils.getTypeNames; -import static io.microsphere.util.ArrayUtils.contains; -import static io.microsphere.util.ArrayUtils.isEmpty; -import static io.microsphere.util.Assert.assertNoNullElements; -import static io.microsphere.util.ClassUtils.SIMPLE_TYPES; -import static java.lang.String.valueOf; -import static java.util.Collections.emptyList; -import static java.util.Collections.unmodifiableList; -import static java.util.stream.Collectors.toList; -import static java.util.stream.Stream.of; -import static javax.lang.model.element.ElementKind.ANNOTATION_TYPE; -import static javax.lang.model.element.ElementKind.CLASS; -import static javax.lang.model.element.ElementKind.ENUM; -import static javax.lang.model.element.ElementKind.INTERFACE; -import static javax.lang.model.type.TypeKind.ARRAY; - -/** - * The utilities class for type in the package "javax.lang.model.*" - * - * @author Mercy - * @since 1.0.0 - */ -public interface TypeUtils extends Utils { - - /** - * A list of names representing simple types in Java. - * Simple types include primitive types, void, and commonly used basic classes like String, Number, etc. - */ - @Nonnull - @Immutable - List SIMPLE_TYPE_NAMES = ofList( - SIMPLE_TYPES - .stream() - .map(Class::getName) - .toArray(String[]::new) - ); - - /** - * Get the superclass of the specified type - */ - @Nonnull - Function TYPE_ELEMENT_GET_SUPERCLASS = type -> ofTypeElement(type.getSuperclass()); - - /** - * Get the interfaces of the specified type - */ - @Nonnull - Function TYPE_ELEMENT_GET_INTERFACES = type -> type.getInterfaces() - .stream() - .map(TypeUtils::ofTypeElement) - .toArray(TypeElement[]::new); - - - /** - * Checks if the given Element represents a simple type. - * A simple type is defined as a basic data type that can be directly represented without further resolution. - * - *

- * Examples of simple types include primitive types (e.g., int, boolean), - * built-in types like void, and commonly used basic classes like String or Number. - *

- * - *

Example Usage

- * 
{@code
-     * Element intElement = ...; // represents 'int'
-     * boolean isSimple = TypeUtils.isSimpleType(intElement); // returns true
-     *
-     * Element customClassElement = ...; // represents a custom class like 'MyClass'
-     * boolean isSimple = TypeUtils.isSimpleType(customClassElement); // returns false
-     * }
- * - * @param element the element to check, may be null - * @return true if the element is a simple type, false otherwise - */ - static boolean isSimpleType(Element element) { - return element != null && isSimpleType(element.asType()); - } - - /** - * Checks whether the given {@link TypeMirror} represents a simple type. - * A simple type is one that can be directly represented without further resolution, - * such as primitive types, built-in types like void, or commonly recognized basic types. - * - *

- * Examples of simple types include: - *

    - *
  • Primitive types: int, boolean, char, etc.
    • - *
  • Built-in types: void, java.lang.String, java.lang.Number
    • - *
- *

- * - *

Example Usage

- * 
{@code
-     * TypeMirror intType = ...; // represents 'int'
-     * boolean isSimple = TypeUtils.isSimpleType(intType); // returns true
-     *
-     * TypeMirror customType = ...; // represents a custom class like 'MyClass'
-     * boolean isSimple = TypeUtils.isSimpleType(customType); // returns false
-     * }
- * - * @param type the TypeMirror to check, may be null - * @return true if the type is a simple type; false otherwise - */ - static boolean isSimpleType(TypeMirror type) { - return type != null && SIMPLE_TYPE_NAMES.contains(type.toString()); - } - - /** - * Checks if the given Element and Type represent the same type. - * - *

- * This method compares the type information of the provided Element and Type objects - * to determine if they represent the same type. If either parameter is null, the comparison - * is made based on whether both are null. - *

- * - *

Example Usage

- * 
{@code
-     * Element element = ...; // represents a type like String
-     * Type type = ...; // represents the same type as the element
-     * boolean isSame = TypeUtils.isSameType(element, type); // returns true
-     *
-     * Element element2 = ...; // represents a different type
-     * Type type2 = ...; // represents a different type
-     * boolean isSame2 = TypeUtils.isSameType(element2, type2); // returns false
-     * }
- * - * @param element the Element to compare, may be null - * @param type the Type to compare, may be null - * @return true if both represent the same type; false otherwise - */ - static boolean isSameType(Element element, Type type) { - return isSameType(element == null ? null : element.asType(), type); - } - - /** - * Checks if the given Element and type name represent the same type. - * - *

- * This method compares the type information of the provided Element and the fully qualified class name - * to determine if they represent the same type. If either parameter is null, the comparison - * is made based on whether both are null. - *

- * - *

Example Usage

- * 
{@code
-     * Element stringElement = ...; // represents 'java.lang.String'
-     * boolean isSame = TypeUtils.isSameType(stringElement, "java.lang.String"); // returns true
-     *
-     * Element customElement = ...; // represents 'com.example.MyClass'
-     * boolean isSame2 = TypeUtils.isSameType(customElement, "com.example.OtherClass"); // returns false
-     * }
- * - * @param type the Element to compare, may be null - * @param typeName the fully qualified class name to compare, may be null - * @return true if both represent the same type; false otherwise - */ - static boolean isSameType(Element type, CharSequence typeName) { - return isSameType(type == null ? null : type.asType(), typeName); - } - - /** - * Checks if the given {@link TypeMirror} and {@link Type} represent the same type. - * - *

- * This method compares the fully qualified type name of the {@link TypeMirror} with the - * {@link Type#getTypeName() type name} of the provided {@link Type} to determine if they - * represent the same type. If both are {@code null}, they are considered the same. - *

- * - *

Example Usage

- * 
{@code
-     * TypeMirror stringTypeMirror = element.asType(); // represents 'java.lang.String'
-     * Type stringType = Class.forName("java.lang.String");
-     * boolean isSame = TypeUtils.isSameType(stringTypeMirror, stringType); // returns true
-     *
-     * TypeMirror intTypeMirror = processingEnv.getTypeUtils().getPrimitiveType(TypeKind.INT);
-     * Type intType = int.class;
-     * boolean isSamePrimitive = TypeUtils.isSameType(intTypeMirror, intType); // returns true
-     *
-     * TypeMirror customTypeMirror = ...; // represents 'com.example.MyClass'
-     * Type customType = Class.forName("com.example.OtherClass");
-     * boolean isSameCustom = TypeUtils.isSameType(customTypeMirror, customType); // returns false
-     * }
- * - * @param typeMirror the TypeMirror to compare, may be null - * @param type the Type to compare, may be null - * @return true if both represent the same type; false otherwise - */ - static boolean isSameType(TypeMirror typeMirror, Type type) { - return isSameType(typeMirror, type == null ? null : type.getTypeName()); - } - - /** - * Checks if the given TypeMirror and type name represent the same type. - * - *

- * This method compares the fully qualified type name of the TypeMirror with the provided - * typeName to determine if they represent the same type. If both are null, they are considered - * the same. - *

- * - *

Example Usage

- * 
{@code
-     * TypeMirror stringTypeMirror = element.asType(); // represents 'java.lang.String'
-     * boolean isSame = TypeUtils.isSameType(stringTypeMirror, "java.lang.String"); // returns true
-     *
-     * TypeMirror customTypeMirror = ...; // represents 'com.example.MyClass'
-     * boolean isSameCustom = TypeUtils.isSameType(customTypeMirror, "com.example.OtherClass"); // returns false
-     * }
- * - * @param type the TypeMirror to compare, may be null - * @param typeName the fully qualified class name to compare, may be null - * @return true if both represent the same type; false otherwise - */ - static boolean isSameType(TypeMirror type, CharSequence typeName) { - if (type == null && typeName == null) { - return true; - } - return Objects.equals(valueOf(type), valueOf(typeName)); - } - - /** - * Checks whether the given {@link TypeMirror} represents an array type. - * - *

- * This method determines if the provided TypeMirror corresponds to an array type - * by checking its kind against the array type kind defined in the Java language model. - * If the provided TypeMirror is null, the method returns false. - *

- * - *

Example Usage

- * 
{@code
-     * TypeMirror arrayTypeMirror = processingEnv.getTypeUtils().getArrayType(...); // represents an array type
-     * boolean isArray = TypeUtils.isArrayType(arrayTypeMirror); // returns true
-     *
-     * TypeMirror stringTypeMirror = element.asType(); // represents 'java.lang.String'
-     * boolean isArray = TypeUtils.isArrayType(stringTypeMirror); // returns false
-     * }
- * - * @param type the TypeMirror to check, may be null - * @return true if the type is an array type; false otherwise - */ - static boolean isArrayType(TypeMirror type) { - return type != null && ARRAY == type.getKind(); - } - - /** - * Checks whether the given Element represents an array type. - * - *

- * This method determines if the provided Element corresponds to an array type - * by checking its kind against the array type kind defined in the Java language model. - * If the provided Element is null, the method returns false. - *

- * - *

Example Usage

- * 
{@code
-     * Element arrayElement = ...; // represents an array type like String[]
-     * boolean isArray = TypeUtils.isArrayType(arrayElement); // returns true
-     *
-     * Element stringElement = ...; // represents 'java.lang.String'
-     * boolean isArray = TypeUtils.isArrayType(stringElement); // returns false
-     * }
- * - * @param element the Element to check, may be null - * @return true if the element represents an array type; false otherwise - */ - static boolean isArrayType(Element element) { - return element != null && isArrayType(element.asType()); - } - - /** - * Checks whether the given {@link TypeMirror} represents an enum type. - * - *

- * This method determines if the provided TypeMirror corresponds to an enum type - * by checking its kind via the underlying element's {@link Element#getKind()}. - * If the provided TypeMirror is null or cannot be resolved to a declared type, - * the method returns false. - *

- * - *

Example Usage

- * 
{@code
-     * TypeMirror enumTypeMirror = element.asType(); // represents an enum type like MyEnum
-     * boolean isEnum = TypeUtils.isEnumType(enumTypeMirror); // returns true
-     *
-     * TypeMirror stringTypeMirror = element.asType(); // represents 'java.lang.String'
-     * boolean isEnum = TypeUtils.isEnumType(stringTypeMirror); // returns false
-     * }
- * - * @param type the TypeMirror to check, may be null - * @return true if the type is an enum type; false otherwise - */ - static boolean isEnumType(TypeMirror type) { - DeclaredType declaredType = ofDeclaredType(type); - return declaredType != null && ENUM == declaredType.asElement().getKind(); - } - - /** - * Checks whether the given Element represents an enum type. - * - *

- * This method determines if the provided Element corresponds to an enum type - * by checking its kind via the underlying element's {@link Element#getKind()}. - * If the provided Element is null or cannot be resolved to a declared type, - * the method returns false. - *

- * - *

Example Usage

- * 
{@code
-     * Element enumElement = ...; // represents an enum type like MyEnum
-     * boolean isEnum = TypeUtils.isEnumType(enumElement); // returns true
-     *
-     * Element stringElement = ...; // represents 'java.lang.String'
-     * boolean isEnum = TypeUtils.isEnumType(stringElement); // returns false
-     * }
- * - * @param element the Element to check, may be null - * @return true if the element represents an enum type; false otherwise - */ - static boolean isEnumType(Element element) { - return element != null && isEnumType(element.asType()); - } - - /** - * Checks whether the given {@link TypeMirror} represents a class type. - * A class type is determined by checking if its corresponding element has the kind of a class. - * - *

Example Usage

- * 
{@code
-     * TypeMirror classTypeMirror = element.asType(); // represents a class like MyClass
-     * boolean isClass = TypeUtils.isClassType(classTypeMirror); // returns true
-     *
-     * TypeMirror interfaceTypeMirror = element.asType(); // represents an interface like MyInterface
-     * boolean isClass = TypeUtils.isClassType(interfaceTypeMirror); // returns false
-     * }
- * - * @param type the TypeMirror to check, may be null - * @return true if the type is a class type; false otherwise - */ - static boolean isClassType(TypeMirror type) { - DeclaredType declaredType = ofDeclaredType(type); - return declaredType != null && isClassType(declaredType.asElement()); - } - - /** - * Checks whether the given Element represents a class type. - * A class type is determined by checking if its corresponding element has the kind of a class. - * - *

Example Usage

- * 
{@code
-     * Element classElement = ...; // represents a class like MyClass
-     * boolean isClass = TypeUtils.isClassType(classElement); // returns true
-     *
-     * Element interfaceElement = ...; // represents an interface like MyInterface
-     * boolean isClass = TypeUtils.isClassType(interfaceElement); // returns false
-     * }
- * - * @param element the Element to check, may be null - * @return true if the element represents a class type; false otherwise - */ - static boolean isClassType(Element element) { - return element != null && CLASS == element.getKind(); - } - - /** - * Checks whether the given {@link TypeMirror} represents a primitive type. - * A primitive type is one of the predefined types in Java such as int, boolean, etc. - * - *

Example Usage

- * 
{@code
-     * TypeMirror intTypeMirror = processingEnv.getTypeUtils().getPrimitiveType(TypeKind.INT);
-     * boolean isPrimitive = TypeUtils.isPrimitiveType(intTypeMirror); // returns true
-     *
-     * TypeMirror stringTypeMirror = elementUtils.getTypeElement("java.lang.String").asType();
-     * boolean isPrimitiveString = TypeUtils.isPrimitiveType(stringTypeMirror); // returns false
-     * }
- * - * @param type the TypeMirror to check, may be null - * @return true if the type is a primitive type; false otherwise - */ - static boolean isPrimitiveType(TypeMirror type) { - return type != null && type.getKind().isPrimitive(); - } - - /** - * Checks whether the given Element represents a primitive type. - * A primitive type is one of the predefined types in Java such as int, boolean, etc. - * - *

Example Usage

- * 
{@code
-     * Element intElement = ...; // represents 'int'
-     * boolean isPrimitive = TypeUtils.isPrimitiveType(intElement); // returns true
-     *
-     * Element stringElement = ...; // represents 'java.lang.String'
-     * boolean isPrimitiveString = TypeUtils.isPrimitiveType(stringElement); // returns false
-     * }
- * - * @param element the Element to check, may be null - * @return true if the element represents a primitive type; false otherwise - */ - static boolean isPrimitiveType(Element element) { - return element != null && isPrimitiveType(element.asType()); - } - - /** - * Checks whether the given {@link TypeMirror} represents an interface type. - * An interface type is determined by checking if its corresponding element has the kind of an interface. - * - *

Example Usage

- * 
{@code
-     * TypeMirror interfaceTypeMirror = element.asType(); // represents an interface like MyInterface
-     * boolean isInterface = TypeUtils.isInterfaceType(interfaceTypeMirror); // returns true
-     *
-     * TypeMirror classTypeMirror = element.asType(); // represents a class like MyClass
-     * boolean isInterface = TypeUtils.isInterfaceType(classTypeMirror); // returns false
-     * }
- * - * @param type the TypeMirror to check, may be null - * @return true if the type is an interface type; false otherwise - */ - static boolean isInterfaceType(TypeMirror type) { - DeclaredType declaredType = ofDeclaredType(type); - return declaredType != null && isInterfaceType(declaredType.asElement()); - } - - /** - * Checks whether the given Element represents an interface type. - * An interface type is determined by checking if its corresponding element has the kind of an interface. - * - *

Example Usage

- * 
{@code
-     * Element interfaceElement = ...; // represents an interface like MyInterface
-     * boolean isInterface = TypeUtils.isInterfaceType(interfaceElement); // returns true
-     *
-     * Element classElement = ...; // represents a class like MyClass
-     * boolean isInterface = TypeUtils.isInterfaceType(classElement); // returns false
-     * }
- * - * @param element the Element to check, may be null - * @return true if the element represents an interface type; false otherwise - */ - static boolean isInterfaceType(Element element) { - return element != null && INTERFACE == element.getKind(); - } - - /** - * Checks whether the given {@link TypeMirror} represents an annotation type. - * An annotation type is determined by checking if its corresponding element has the kind of an annotation. - * - *

Example Usage

- * 
{@code
-     * TypeMirror annotationTypeMirror = element.asType(); // represents an annotation like MyAnnotation
-     * boolean isAnnotation = TypeUtils.isAnnotationType(annotationTypeMirror); // returns true
-     *
-     * TypeMirror classTypeMirror = element.asType(); // represents a class like MyClass
-     * boolean isAnnotation = TypeUtils.isAnnotationType(classTypeMirror); // returns false
-     * }
- * - * @param type the TypeMirror to check, may be null - * @return true if the type is an annotation type; false otherwise - */ - static boolean isAnnotationType(TypeMirror type) { - DeclaredType declaredType = ofDeclaredType(type); - return declaredType != null && isAnnotationType(declaredType.asElement()); - } - - /** - * Checks whether the given Element represents an annotation type. - * An annotation type is determined by checking if its corresponding element has the kind of an annotation. - * - *

Example Usage

- * 
{@code
-     * Element annotationElement = ...; // represents an annotation like MyAnnotation
-     * boolean isAnnotation = TypeUtils.isAnnotationType(annotationElement); // returns true
-     *
-     * Element classElement = ...; // represents a class like MyClass
-     * boolean isAnnotation = TypeUtils.isAnnotationType(classElement); // returns false
-     * }
- * - * @param element the Element to check, may be null - * @return true if the element represents an annotation type; false otherwise - */ - static boolean isAnnotationType(Element element) { - return element != null && ANNOTATION_TYPE == element.getKind(); - } - - /** - * Checks if the given Element is a TypeElement. - * - *

- * This method verifies whether the provided Element represents a type element, - * such as a class, interface, enum, or annotation type. If the element is null, - * it returns false. - *

- * - *

Example Usage

- * 
{@code
-     * Element classElement = ...; // represents a class like MyClass
-     * boolean isType = TypeUtils.isTypeElement(classElement); // returns true
-     *
-     * Element packageElement = ...; // represents a package
-     * boolean isType = TypeUtils.isTypeElement(packageElement); // returns false
-     * }
- * - * @param element The Element to check, may be null. - * @return true if the element is a TypeElement; false otherwise. - */ - static boolean isTypeElement(Element element) { - return element instanceof TypeElement; - } - - /** - * Checks if the given TypeMirror represents a TypeElement. - * A TypeElement is a type that corresponds to a class, interface, enum, or annotation type - * that has been explicitly defined in the source code. - * - *

Example Usage

- * 
{@code
-     * TypeMirror classTypeMirror = element.asType(); // represents a class like MyClass
-     * boolean isType = TypeUtils.isTypeElement(classTypeMirror); // returns true
-     *
-     * TypeMirror intTypeMirror = processingEnv.getTypeUtils().getPrimitiveType(TypeKind.INT);
-     * boolean isTypePrimitive = TypeUtils.isTypeElement(intTypeMirror); // returns false
-     *
-     * TypeMirror stringArrayTypeMirror = processingEnv.getTypeUtils().getArrayType(...); // represents String[]
-     * boolean isTypeArray = TypeUtils.isTypeElement(stringArrayTypeMirror); // returns false
-     * }
- * - * @param type the TypeMirror to check, may be null - * @return true if the TypeMirror represents a TypeElement; false otherwise - */ - static boolean isTypeElement(TypeMirror type) { - DeclaredType declaredType = ofDeclaredType(type); - return declaredType != null && isTypeElement(declaredType.asElement()); - } - - /** - * Checks whether the given Element represents a declared type. - * A declared type is a type that corresponds to a class, interface, enum, or annotation type - * that has been explicitly defined in the source code. - * - *

Example Usage

- * 
{@code
-     * Element classElement = ...; // represents a class like MyClass
-     * boolean isDeclared = TypeUtils.isDeclaredType(classElement); // returns true
-     *
-     * Element packageElement = ...; // represents a package
-     * boolean isDeclaredPackage = TypeUtils.isDeclaredType(packageElement); // returns false
-     * }
- * - * @param element the Element to check, may be null - * @return true if the element represents a DeclaredType; false otherwise - */ - static boolean isDeclaredType(Element element) { - return element != null && isDeclaredType(element.asType()); - } - - /** - * Checks whether the given {@link TypeMirror} represents a declared type. - * A declared type is a type that corresponds to a class, interface, enum, or annotation type - * that has been explicitly defined in the source code. - * - *

Example Usage

- * 
{@code
-     * TypeMirror classTypeMirror = element.asType(); // represents a class like MyClass
-     * boolean isDeclared = TypeUtils.isDeclaredType(classTypeMirror); // returns true
-     *
-     * TypeMirror intTypeMirror = processingEnv.getTypeUtils().getPrimitiveType(TypeKind.INT);
-     * boolean isDeclaredPrimitive = TypeUtils.isDeclaredType(intTypeMirror); // returns false
-     *
-     * TypeMirror stringArrayTypeMirror = processingEnv.getTypeUtils().getArrayType(...); // represents String[]
-     * boolean isDeclaredArray = TypeUtils.isDeclaredType(stringArrayTypeMirror); // returns false
-     * }
- * - * @param type the TypeMirror to check, may be null - * @return true if the type is a declared type; false otherwise - */ - static boolean isDeclaredType(TypeMirror type) { - return type instanceof DeclaredType; - } - - /** - * Converts the given Element to a TypeElement if it is an instance of TypeElement. - * - *

- * This method checks if the provided Element represents a type element such as a class, interface, - * enum, or annotation type. If the element is null or not a TypeElement, this method returns null. - *

- * - *

Example Usage

- * 
{@code
-     * Element classElement = ...; // represents a class like MyClass
-     * TypeElement typeElement = TypeUtils.ofTypeElement(classElement); // returns a valid TypeElement
-     *
-     * Element packageElement = ...; // represents a package
-     * TypeElement typeElementForPackage = TypeUtils.ofTypeElement(packageElement); // returns null
-     * }
- * - * @param element The Element to convert, may be null. - * @return The converted TypeElement if the element is a TypeElement; otherwise, null. - */ - static TypeElement ofTypeElement(Element element) { - return isTypeElement(element) ? (TypeElement) element : null; - } - - /** - * Converts the given TypeMirror to a TypeElement if it represents a declared type. - * - *

- * This method checks if the provided TypeMirror corresponds to a declared type - * (such as a class, interface, enum, or annotation type). If it does, the corresponding - * TypeElement is returned. If the TypeMirror is null or not a declared type, - * this method returns null. - *

- * - *

Example Usage

- * 
{@code
-     * TypeMirror classTypeMirror = element.asType(); // represents a class like MyClass
-     * TypeElement typeElement = TypeUtils.ofTypeElement(classTypeMirror); // returns a valid TypeElement
-     *
-     * TypeMirror intTypeMirror = processingEnv.getTypeUtils().getPrimitiveType(TypeKind.INT);
-     * TypeElement primitiveTypeElement = TypeUtils.ofTypeElement(intTypeMirror); // returns null
-     * }
- * - * @param type The TypeMirror to convert, may be null. - * @return The corresponding TypeElement if the TypeMirror represents a declared type; - * otherwise, null if the type is null or not a DeclaredType. - */ - @Nullable - static TypeElement ofTypeElement(TypeMirror type) { - DeclaredType declaredType = ofDeclaredType(type); - return ofTypeElement(declaredType); - } - - /** - * Converts the given DeclaredType to a TypeElement if it is not null. - * - *

This method attempts to convert the provided {@link DeclaredType} to a corresponding - * {@link TypeElement}. If the declared type is null, or if it cannot be resolved to a type element, - * this method returns null. - * - *

Example Usage

- * 
{@code
-     * DeclaredType declaredType = ...; // represents a declared type like MyClass
-     * TypeElement typeElement = TypeUtils.ofTypeElement(declaredType); // returns a valid TypeElement if available
-     *
-     * DeclaredType nullDeclaredType = null;
-     * TypeElement nullTypeElement = TypeUtils.ofTypeElement(nullDeclaredType); // returns null
-     * }
- * - * @param declaredType the DeclaredType to convert, may be null - * @return the corresponding TypeElement if the DeclaredType is not null; - * otherwise, null - */ - @Nullable - static TypeElement ofTypeElement(DeclaredType declaredType) { - if (declaredType != null) { - return ofTypeElement(declaredType.asElement()); - } - return null; - } - - /** - * Converts the given Element to a DeclaredType by first converting it to a TypeElement. - * If the element is null or cannot be converted to a DeclaredType, returns null. - * - *

- * This method checks if the provided Element represents a type element (class, interface, enum, or annotation). - * If it does, the corresponding TypeElement is obtained, and its asType() method is called to retrieve the TypeMirror. - * Then, the TypeMirror is converted to a DeclaredType if it represents a declared type. - *

- * - *

Example Usage

- * 
{@code
-     * Element classElement = ...; // represents a class like MyClass
-     * DeclaredType declaredType = TypeUtils.ofDeclaredType(classElement); // returns a valid DeclaredType
-     *
-     * Element packageElement = ...; // represents a package
-     * DeclaredType packageDeclaredType = TypeUtils.ofDeclaredType(packageElement); // returns null
-     * }
- * - * @param element The Element to convert, may be null. - * @return The corresponding DeclaredType if the element is valid and represents a declared type; - * otherwise, null if the element is null or conversion fails. - */ - @Nullable - static DeclaredType ofDeclaredType(Element element) { - return element == null ? null : ofDeclaredType(element.asType()); - } - - /** - * Converts the given TypeMirror to a DeclaredType if it represents a declared type. - * A declared type is a type that corresponds to a class, interface, enum, or annotation type - * that has been explicitly defined in the source code. - * - *

Example Usage

- * 
{@code
-     * TypeMirror classTypeMirror = element.asType(); // represents a class like MyClass
-     * DeclaredType declaredType = TypeUtils.ofDeclaredType(classTypeMirror); // returns a valid DeclaredType
-     *
-     * TypeMirror intTypeMirror = processingEnv.getTypeUtils().getPrimitiveType(TypeKind.INT);
-     * DeclaredType primitiveDeclaredType = TypeUtils.ofDeclaredType(intTypeMirror); // returns null
-     *
-     * TypeMirror stringArrayTypeMirror = processingEnv.getTypeUtils().getArrayType(...); // represents String[]
-     * DeclaredType arrayDeclaredType = TypeUtils.ofDeclaredType(stringArrayTypeMirror); // returns null
-     * }
- * - * @param type The TypeMirror to convert, may be null. - * @return The corresponding DeclaredType if the TypeMirror represents a declared type; - * otherwise, null if the type is null or not a DeclaredType. - */ - @Nullable - static DeclaredType ofDeclaredType(TypeMirror type) { - return isDeclaredType(type) ? (DeclaredType) type : null; - } - - /** - * Converts an array of Elements to a List of TypeMirrors. - * If the input array is null or empty, returns an empty list. - * - *

Example Usage

- * 
{@code
-     * Element classElement = ...; // represents a class like MyClass
-     * Element interfaceElement = ...; // represents an interface like MyInterface
-     *
-     * List typeMirrors = TypeUtils.ofTypeMirrors(classElement, interfaceElement);
-     * // typeMirrors now contains the TypeMirror of MyClass and MyInterface
-     *
-     * List emptyList = TypeUtils.ofTypeMirrors(); // returns an empty list
-     * }
- * - * @param elements the array of Elements to convert - * @return a List of TypeMirrors derived from the given Elements - */ - @Nonnull - @Immutable - static List ofTypeMirrors(Element... elements) { - return ofTypeMirrors(ofList(elements)); - } - - /** - * Converts a collection of Elements to a list of TypeMirrors. - * Optionally applies an array of predicates to filter the resulting TypeMirrors. - * - *

Example Usage

- * 
{@code
-     * Element classElement = ...; // represents a class like MyClass
-     * Element interfaceElement = ...; // represents an interface like MyInterface
-     *
-     * List typeMirrors = TypeUtils.ofTypeMirrors(Arrays.asList(classElement, interfaceElement));
-     * // typeMirrors now contains the TypeMirror of MyClass and MyInterface
-     *
-     * List emptyList = TypeUtils.ofTypeMirrors(Collections.emptyList()); // returns an empty list
-     * }
- * - * @param elements The collection of Elements to convert. Must not be null. - * @return A list of TypeMirrors derived from the given Elements. - */ - @Nonnull - @Immutable - static List ofTypeMirrors(Collection elements) { - return ofTypeMirrors(elements, EMPTY_PREDICATE_ARRAY); - } - - @Nonnull - @Immutable - static List ofTypeMirrors(Collection elements, Predicate... typeFilters) { - return isEmpty(elements) ? emptyList() : - unmodifiableList(elements.stream().map(Element::asType).filter(and(typeFilters)).collect(toList())); - } - - /** - * Converts an array of TypeMirrors to a List of TypeElements. - * If the input array is null or empty, returns an empty list. - * - *

Example Usage

- * 
{@code
-     * TypeMirror classTypeMirror = element.asType(); // represents a class like MyClass
-     * TypeMirror interfaceTypeMirror = element.asType(); // represents an interface like MyInterface
-     *
-     * List typeElements = TypeUtils.ofTypeElements(classTypeMirror, interfaceTypeMirror);
-     * // typeElements now contains the TypeElement of MyClass and MyInterface
-     *
-     * List emptyList = TypeUtils.ofTypeElements(); // returns an empty list
-     * }
- * - * @param types The array of TypeMirrors to convert. May be null or contain null elements. - * @return A List of TypeElements derived from the given TypeMirrors. - */ - @Nonnull - @Immutable - static List ofTypeElements(TypeMirror... types) { - return ofTypeElements(ofList(types)); - } - - /** - * Converts a collection of TypeMirrors to a list of TypeElements. - * Optionally applies an array of predicates to filter the resulting TypeElements. - * - *

Example Usage

- * 
{@code
-     * TypeMirror classTypeMirror = element.asType(); // represents a class like MyClass
-     * TypeMirror interfaceTypeMirror = element.asType(); // represents an interface like MyInterface
-     *
-     * List typeElements = TypeUtils.ofTypeElements(Arrays.asList(classTypeMirror, interfaceTypeMirror));
-     * // typeElements now contains the TypeElement of MyClass and MyInterface
-     *
-     * List emptyList = TypeUtils.ofTypeElements(Collections.emptyList()); // returns an empty list
-     * }
- * - * @param types The collection of TypeMirrors to convert. Must not be null. - * @return A list of TypeElements derived from the given TypeMirrors. - */ - @Nonnull - @Immutable - static List ofTypeElements(Collection types) { - return ofTypeElements(types, EMPTY_PREDICATE_ARRAY); - } - - /** - * Converts a collection of TypeMirrors to a list of TypeElements. - * Optionally applies an array of predicates to filter the resulting TypeElements. - * - *

Example Usage

- * 
{@code
-     * TypeMirror classTypeMirror = element.asType(); // represents a class like MyClass
-     * TypeMirror interfaceTypeMirror = element.asType(); // represents an interface like MyInterface
-     *
-     * List typeElements = TypeUtils.ofTypeElements(Arrays.asList(classTypeMirror, interfaceTypeMirror));
-     * // typeElements now contains the TypeElement of MyClass and MyInterface
-     *
-     * List emptyList = TypeUtils.ofTypeElements(Collections.emptyList()); // returns an empty list
-     * }
- * - * @param types The collection of TypeMirrors to convert. Must not be null. - * @param typeFilters Optional predicates to filter the TypeElements. May be null or empty. - * @return A list of TypeElements derived from the given TypeMirrors, filtered by the provided predicates. - */ - @Nonnull - @Immutable - static List ofTypeElements(Collection types, Predicate... typeFilters) { - return isEmpty(types) ? emptyList() : unmodifiableList( - types.stream() - .map(TypeUtils::ofTypeElement) - .filter(Objects::nonNull) - .filter(and(typeFilters)).collect(toList()) - ); - } - - /** - * Converts an array of Elements to a List of DeclaredTypes. - * If the input array is null or empty, returns an empty list. - * - *

Example Usage

- * 
{@code
-     * Element classElement = ...; // represents a class like MyClass
-     * Element interfaceElement = ...; // represents an interface like MyInterface
-     *
-     * List declaredTypes = TypeUtils.ofDeclaredTypes(classElement, interfaceElement);
-     * // declaredTypes now contains the DeclaredType of MyClass and MyInterface
-     *
-     * List emptyList = TypeUtils.ofDeclaredTypes(); // returns an empty list
-     * }
- * - * @param elements the array of Elements to convert - * @return a List of DeclaredTypes derived from the given Elements - */ - @Nonnull - @Immutable - static List ofDeclaredTypes(Element... elements) { - return ofDeclaredTypes(ofList(elements)); - } - - /** - * Converts a collection of Elements to a list of DeclaredTypes. - * Optionally applies an array of predicates to filter the resulting DeclaredTypes. - * - *

Example Usage

- * 
{@code
-     * Element classElement = ...; // represents a class like MyClass
-     * Element interfaceElement = ...; // represents an interface like MyInterface
-     *
-     * List declaredTypes = TypeUtils.ofDeclaredTypes(Arrays.asList(classElement, interfaceElement));
-     * // declaredTypes now contains the DeclaredType of MyClass and MyInterface
-     *
-     * List emptyList = TypeUtils.ofDeclaredTypes(Collections.emptyList()); // returns an empty list
-     * }
- * - * @param elements The collection of Elements to convert. Must not be null. - * @return A list of DeclaredTypes derived from the given Elements. - */ - @Nonnull - @Immutable - static List ofDeclaredTypes(Collection elements) { - return ofDeclaredTypes(elements, EMPTY_PREDICATE_ARRAY); - } - - /** - * Converts a collection of Elements to a list of DeclaredTypes. - * Optionally applies an array of predicates to filter the resulting DeclaredTypes. - * - *

Example Usage

- * 
{@code
-     * Element classElement = ...; // represents a class like MyClass
-     * Element interfaceElement = ...; // represents an interface like MyInterface
-     *
-     * List declaredTypes = TypeUtils.ofDeclaredTypes(Arrays.asList(classElement, interfaceElement));
-     * // declaredTypes now contains the DeclaredType of MyClass and MyInterface
-     *
-     * List emptyList = TypeUtils.ofDeclaredTypes(Collections.emptyList()); // returns an empty list
-     * }
- * - * @param elements The collection of Elements to convert. Must not be null. - * @param typeFilters Optional predicates to filter the DeclaredTypes. May be null or empty. - * @return A list of DeclaredTypes derived from the given Elements, filtered by the provided predicates. - */ - @Nonnull - @Immutable - static List ofDeclaredTypes(Collection elements, - Predicate... typeFilters) { - - if (isEmpty(elements)) { - return emptyList(); - } - - List declaredTypes = elements.stream() - .map(TypeUtils::ofTypeElement) - .filter(Objects::nonNull) - .map(Element::asType) - .map(TypeUtils::ofDeclaredType) - .filter(Objects::nonNull) - .filter(and(typeFilters)) - .collect(toList()); - - return declaredTypes.isEmpty() ? emptyList() : unmodifiableList(declaredTypes); - } - - /** - * Retrieves the TypeElement representing the superclass of the given TypeElement. - * - *

If the provided TypeElement is null or represents a class without a superclass - * (e.g., {@link Object}, an interface, or an enum), this method returns null. - * - *

Example Usage

- * 
{@code
-     * TypeElement type = ...; // represents a class like MyClass which extends SomeBaseClass
-     * TypeElement superClass = TypeUtils.getTypeElementOfSuperclass(type);
-     * // superClass now represents SomeBaseClass if available
-     *
-     * TypeElement interfaceType = ...; // represents an interface
-     * TypeElement superClassForInterface = TypeUtils.getTypeElementOfSuperclass(interfaceType);
-     * // superClassForInterface will be null since interfaces do not have a superclass
-     *
-     * TypeElement objectType = processingEnv.getElementUtils().getTypeElement("java.lang.Object");
-     * TypeElement superClassForObject = TypeUtils.getTypeElementOfSuperclass(objectType);
-     * // superClassForObject will be null since Object has no superclass
-     * }
- * - * @param type the TypeElement whose superclass is to be retrieved, may be null - * @return the TypeElement of the superclass if available; otherwise, null - */ - @Nullable - static TypeElement getTypeElementOfSuperclass(TypeElement type) { - return type == null ? null : ofTypeElement(type.getSuperclass()); - } - - /** - * Retrieves all TypeElements representing the superclasses and interfaces in the hierarchy of the given TypeElement. - * This includes both direct and indirect superclasses as well as implemented interfaces from the entire hierarchy. - * - *

Example Usage

- * 
{@code
-     * TypeElement type = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
-     * List superTypes = TypeUtils.getAllTypeElementsOfSuperTypes(type);
-     * // superTypes now contains all superclasses and interfaces in the hierarchy of MyClass
-     *
-     * TypeElement interfaceType = processingEnv.getElementUtils().getTypeElement("com.example.MyInterface");
-     * List interfaceSuperTypes = TypeUtils.getAllTypeElementsOfSuperTypes(interfaceType);
-     * // interfaceSuperTypes now contains all superinterfaces of MyInterface
-     *
-     * List emptyList = TypeUtils.getAllTypeElementsOfSuperTypes(null); // returns an empty list
-     * }
- * - * @param type The TypeElement whose hierarchy is to be explored, may be null. - * @return A list of TypeElements representing all superclasses and interfaces in the hierarchy of the provided TypeElement. - * Returns an empty list if the input is null or no super types exist. - */ - @Nonnull - @Immutable - static List getAllTypeElementsOfSuperTypes(TypeElement type) { - return findAllTypeElementsOfSuperTypes(type, EMPTY_PREDICATE_ARRAY); - } - - /** - * Retrieves all TypeElements representing the superclasses in the hierarchy of the given TypeElement. - * This includes direct and indirect superclasses, but excludes interfaces. - * - *

Example Usage

- * 
{@code
-     * TypeElement type = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
-     * List superclasses = TypeUtils.getAllTypeElementsOfSuperclasses(type);
-     * // superclasses now contains all superclass TypeElements in the hierarchy of MyClass
-     *
-     * List emptyList = TypeUtils.getAllTypeElementsOfSuperclasses(null); // returns an empty list
-     * }
- * - * @param type The TypeElement whose superclass hierarchy is to be explored, may be null. - * @return A list of TypeElements representing all superclasses in the hierarchy of the provided TypeElement. - * Returns an empty list if the input is null or no superclasses exist in the hierarchy. - */ - @Nonnull - @Immutable - static List getAllTypeElementsOfSuperclasses(TypeElement type) { - return findAllTypeElementsOfSuperclasses(type, EMPTY_PREDICATE_ARRAY); - } - - /** - * Retrieves the direct interface types implemented by the given TypeElement. - * This method only returns interfaces directly declared on the specified type, - * and does not include superinterfaces from the entire hierarchy. - * - *

Example Usage

- * 
{@code
-     * TypeElement type = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
-     * List interfaces = TypeUtils.getTypeElementsOfInterfaces(type);
-     * // interfaces now contains the directly implemented interfaces of MyClass
-     *
-     * List emptyList = TypeUtils.getTypeElementsOfInterfaces(null); // returns an empty list
-     * }
- * - * @param type The TypeElement whose directly implemented interfaces are to be retrieved, may be null. - * @return A list of TypeElements representing the directly implemented interfaces. - * Returns an empty list if the input is null or no interfaces are directly implemented. - */ - @Nonnull - @Immutable - static List getTypeElementsOfInterfaces(TypeElement type) { - return findTypeElementsOfInterfaces(type, EMPTY_PREDICATE_ARRAY); - } - - /** - * Retrieves all TypeElements representing the interfaces implemented in the entire hierarchy of the given TypeElement. - * This includes both directly and indirectly implemented interfaces from superclasses and superinterfaces. - * - *

Example Usage

- * 
{@code
-     * TypeElement type = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
-     * List interfaces = TypeUtils.getAllTypeElementsOfInterfaces(type);
-     * // interfaces now contains all interfaces implemented by MyClass, including those from superclasses
-     *
-     * List emptyList = TypeUtils.getAllTypeElementsOfInterfaces(null); // returns an empty list
-     * }
- * - * @param type The TypeElement whose interface hierarchy is to be explored, may be null. - * @return A list of TypeElements representing all implemented interfaces in the hierarchy of the provided TypeElement. - * Returns an empty list if the input is null or no interfaces are found in the hierarchy. - */ - @Nonnull - @Immutable - static List getAllTypeElementsOfInterfaces(TypeElement type) { - return findAllTypeElementsOfInterfaces(type, EMPTY_PREDICATE_ARRAY); - } - - /** - * Retrieves the directly associated TypeElements of the given TypeElement. - * This includes: - * - The type itself - * - Direct superclass (if any) - * - Directly implemented interfaces (if any) - * - *

This method does not traverse the entire hierarchy. It only includes direct relationships. - * - *

Example Usage

- * 
{@code
-     * TypeElement type = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
-     * List directTypes = TypeUtils.getTypeElements(type);
-     * // directTypes contains:
-     * // - MyClass itself
-     * // - Its direct superclass (if any)
-     * // - Interfaces directly implemented by MyClass (if any)
-     *
-     * List emptyList = TypeUtils.getTypeElements(null); // returns an empty list
-     * }
- * - * @param type The TypeElement to retrieve directly associated types from, may be null. - * @return A list of TypeElements representing the directly associated types. - * Returns an empty list if the input is null or no direct associations exist. - */ - @Nonnull - @Immutable - static List getTypeElements(TypeElement type) { - return getTypeElements(type, true, false, true, true); - } - - /** - * Retrieves all TypeElements associated with the given TypeElement, including: - * - The type itself - * - Direct and hierarchical superclasses - * - Direct and hierarchical interfaces - * - *

Example Usage

- * 
{@code
-     * TypeElement type = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
-     * List allTypes = TypeUtils.getAllTypeElements(type);
-     * // allTypes contains:
-     * // - MyClass itself
-     * // - All superclasses in the hierarchy (e.g., Object, SomeBaseClass)
-     * // - All implemented interfaces, including those from superclasses and superinterfaces
-     *
-     * List emptyList = TypeUtils.getAllTypeElements(null); // returns an empty list
-     * }
- * - * @param type The TypeElement to retrieve all associated types from, may be null. - * @return A list of TypeElements representing all associated types in the hierarchy. - * Returns an empty list if the input is null or no types are found. - */ - @Nonnull - @Immutable - static List getAllTypeElements(TypeElement type) { - return getTypeElements(type, true, true, true, true); - } - - /** - * Retrieves a list of TypeElements associated with the given TypeElement based on the specified inclusion criteria. - * - *

- * This method allows fine-grained control over which types are included in the result: - *

- * - *
    - *
  • {@code includeSelf} - Whether to include the given TypeElement itself in the result.
    • - *
  • {@code includeHierarchicalTypes} - Whether to include types from the entire hierarchy (e.g., superclasses and interfaces).
    • - *
  • {@code includeSuperclass} - Whether to include direct or hierarchical superclasses based on the value of includeHierarchicalTypes.
    • - *
  • {@code includeSuperInterfaces} - Whether to include direct or hierarchical interfaces based on the value of includeHierarchicalTypes.
    • - *
- * - *

Example Usage

- * 
{@code
-     * TypeElement type = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
-     *
-     * // Get the type itself and all direct superclasses and interfaces
-     * List directTypes = TypeUtils.getTypeElements(type, false, false, true, true);
-     *
-     * // Get the type itself and all hierarchical superclasses and interfaces
-     * List hierarchicalTypes = TypeUtils.getTypeElements(type, true, true, true, true);
-     *
-     * // Get only the direct superclasses without including interfaces
-     * List superclassesOnly = TypeUtils.getTypeElements(type, false, false, true, false);
-     *
-     * // Get only the hierarchical interfaces
-     * List interfacesOnly = TypeUtils.getTypeElements(type, false, true, false, true);
-     * }
- * - * @param type The TypeElement to find associated types for, may be null. - * @param includeSelf Whether to include the type itself in the result. - * @param includeHierarchicalTypes Whether to include types from the entire hierarchy (e.g., superclasses and interfaces). - * @param includeSuperClasses Whether to include direct or hierarchical superclasses based on includeHierarchicalTypes. - * @param includeSuperInterfaces Whether to include direct or hierarchical interfaces based on includeHierarchicalTypes. - * @return A list of TypeElements representing the associated types according to the inclusion criteria. - * Returns an empty list if the input type is null or no matching types are found. - */ - @Nonnull - @Immutable - static List getTypeElements(TypeElement type, - boolean includeSelf, - boolean includeHierarchicalTypes, - boolean includeSuperClasses, - boolean includeSuperInterfaces) { - return findTypeElements(type, includeSelf, includeHierarchicalTypes, includeSuperClasses, includeSuperInterfaces, EMPTY_PREDICATE_ARRAY); - } - - /** - * Retrieves the TypeElements representing the interfaces directly implemented by the given TypeElement. - * This method only returns interfaces that are directly declared on the specified type, - * and does not include superinterfaces from the entire hierarchy. - * - *

Example Usage

- * 
{@code
-     * TypeElement type = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
-     * List interfaces = TypeUtils.findTypeElementsOfInterfaces(type);
-     * // interfaces now contains the directly implemented interfaces of MyClass
-     *
-     * List emptyList = TypeUtils.findTypeElementsOfInterfaces(null); // returns an empty list
-     * }
- * - * @param type The TypeElement whose directly implemented interfaces are to be retrieved, may be null. - * @param interfaceFilters Optional predicates to filter the resulting TypeElements. May be null or empty. - * @return A list of TypeElements representing the directly implemented interfaces. - * Returns an empty list if the input is null or no interfaces are directly implemented. - */ - @Nonnull - @Immutable - static List findTypeElementsOfInterfaces(TypeElement type, Predicate... interfaceFilters) { - return findTypeElements(type, false, false, false, true, interfaceFilters); - } - - /** - * Retrieves all TypeElements representing the superclasses in the hierarchy of the given TypeElement. - * This includes direct and indirect superclasses, but excludes interfaces. - * - *

Example Usage

- * 
{@code
-     * TypeElement type = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
-     * List superclasses = TypeUtils.findAllTypeElementsOfSuperclasses(type);
-     * // superclasses now contains all superclass TypeElements in the hierarchy of MyClass
-     *
-     * List emptyList = TypeUtils.findAllTypeElementsOfSuperclasses(null); // returns an empty list
-     * }
- * - * @param type The TypeElement whose superclass hierarchy is to be explored, may be null. - * @param typeFilters Optional predicates to filter the resulting TypeElements. May be null or empty. - * @return A list of TypeElements representing all superclasses in the hierarchy of the provided TypeElement. - * Returns an empty list if the input is null or no superclasses exist in the hierarchy. - */ - @Nonnull - @Immutable - static List findAllTypeElementsOfSuperclasses(TypeElement type, Predicate... typeFilters) { - return findTypeElements(type, false, true, true, false, typeFilters); - } - - /** - * Retrieves all TypeElements representing the interfaces implemented in the entire hierarchy of the given TypeElement. - * This includes both directly and indirectly implemented interfaces from superclasses and superinterfaces. - * - *

Example Usage

- * 
{@code
-     * TypeElement type = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
-     * List interfaces = TypeUtils.findAllTypeElementsOfInterfaces(type);
-     * // interfaces now contains all interfaces implemented by MyClass, including those from superclasses
-     *
-     * List emptyList = TypeUtils.findAllTypeElementsOfInterfaces(null); // returns an empty list
-     * }
- * - * @param type The TypeElement whose interface hierarchy is to be explored, may be null. - * @return A list of TypeElements representing all implemented interfaces in the hierarchy of the provided TypeElement. - * Returns an empty list if the input is null or no interfaces are found in the hierarchy. - */ - @Nonnull - @Immutable - static List findAllTypeElementsOfInterfaces(TypeElement type, Predicate... interfaceFilters) { - return findTypeElements(type, false, true, false, true, interfaceFilters); - } - - /** - * Retrieves all TypeElements representing the superclasses and interfaces in the hierarchy of the given TypeElement. - * This includes both direct and indirect superclasses as well as implemented interfaces from the entire hierarchy. - * Optionally applies an array of predicates to filter the resulting TypeElements. - * - *

Example Usage

- * 
{@code
-     * TypeElement type = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
-     * List superTypes = TypeUtils.findAllTypeElementsOfSuperTypes(type);
-     * // superTypes now contains all superclasses and interfaces in the hierarchy of MyClass
-     *
-     * List filteredSuperTypes = TypeUtils.findAllTypeElementsOfSuperTypes(type,
-     *     t -> t.getQualifiedName().toString().startsWith("com.example"));
-     * // filteredSuperTypes contains only those superTypes whose qualified names start with "com.example"
-     *
-     * List emptyList = TypeUtils.findAllTypeElementsOfSuperTypes(null); // returns an empty list
-     * }
- * - * @param type The TypeElement whose hierarchy is to be explored, may be null. - * @param typeFilters Optional predicates to filter the resulting TypeElements. May be null or empty. - * @return A list of TypeElements representing all superclasses and interfaces in the hierarchy of the provided TypeElement, - * filtered by the provided predicates. Returns an empty list if the input is null or no types are found in the hierarchy. - */ - @Nonnull - @Immutable - static List findAllTypeElementsOfSuperTypes(TypeElement type, Predicate... typeFilters) { - return findTypeElements(type, false, true, true, true, typeFilters); - } - - /** - * Finds and returns a list of TypeElements based on the specified criteria. - * - *

This method allows detailed control over which types are included in the result: - * - Whether to include the type itself - * - Whether to include hierarchical types (e.g., superclasses and interfaces) - * - Whether to include superclasses and/or interfaces based on the inclusion criteria

- * - *

Example Usage

- * 
{@code
-     * TypeElement type = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
-     *
-     * // Get the type itself and all direct superclasses and interfaces
-     * List directTypes = TypeUtils.findTypeElements(type, true, false, true, true);
-     *
-     * // Get all types in the hierarchy including superclasses and interfaces
-     * List hierarchicalTypes = TypeUtils.findTypeElements(type, true, true, true, true);
-     *
-     * // Get only direct superclasses without including interfaces
-     * List superclassesOnly = TypeUtils.findTypeElements(type, false, false, true, false);
-     *
-     * // Get only interfaces from the entire hierarchy
-     * List interfacesOnly = TypeUtils.findTypeElements(type, false, true, false, true);
-     * }
- * - * @param type The TypeElement to start the search from, may be null. - * @param includeSelf Whether to include the type itself in the result. - * @param includeHierarchicalTypes Whether to include types from the entire hierarchy (e.g., superclasses and interfaces). - * @param includeSuperclass Whether to include direct or hierarchical superclasses based on includeHierarchicalTypes. - * @param includeSuperInterfaces Whether to include direct or hierarchical interfaces based on includeHierarchicalTypes. - * @param typeFilters Optional predicates to filter the resulting TypeElements. May be null or empty. - * @return A list of TypeElements matching the specified criteria. - * Returns an empty list if the input type is null or no matching types are found. - * @throws IllegalArgumentException if any element of 'typeFilters' array is null. - */ - @Nonnull - @Immutable - static List findTypeElements(TypeElement type, - boolean includeSelf, - boolean includeHierarchicalTypes, - boolean includeSuperclass, - boolean includeSuperInterfaces, - Predicate... typeFilters) throws IllegalArgumentException { - if (type == null) { - return emptyList(); - } - assertNoNullElements(typeFilters, () -> "Any element of 'typeFilters' array must not be null"); - return typeElementFinder(type, includeSelf, includeHierarchicalTypes, includeSuperclass, includeSuperInterfaces).findTypes(typeFilters); - } - - /** - * Retrieves the declared type of the superclass for the given Element. - * If the provided Element is null or does not represent a type with a superclass, - * this method will return null. - * - *

Example Usage

- * 
{@code
-     * Element typeElement = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
-     * DeclaredType superClassType = TypeUtils.getDeclaredTypeOfSuperclass(typeElement);
-     * // superClassType now contains the DeclaredType of the superclass of MyClass, if available
-     *
-     * Element interfaceElement = processingEnv.getElementUtils().getTypeElement("com.example.MyInterface");
-     * DeclaredType superClassTypeForInterface = TypeUtils.getDeclaredTypeOfSuperclass(interfaceElement);
-     * // superClassTypeForInterface will be null since interfaces do not have a superclass
-     *
-     * DeclaredType nullCase = TypeUtils.getDeclaredTypeOfSuperclass(null);
-     * // nullCase will be null since the input is null
-     * }
- * - * @param typeElement the Element to retrieve the superclass declared type from, may be null - * @return the DeclaredType representing the superclass of the given Element, or null if none exists - */ - @Nullable - static DeclaredType getDeclaredTypeOfSuperclass(Element typeElement) { - return typeElement == null ? null : getDeclaredTypeOfSuperclass(typeElement.asType()); - } - - /** - * Retrieves the declared type of the superclass for the given TypeMirror. - * If the provided TypeMirror is null or does not represent a type with a superclass, - * this method will return null. - * - *

Example Usage

- * 
{@code
-     * TypeMirror type = processingEnv.getTypeUtils().getDeclaredType(typeElement);
-     * DeclaredType superClassType = TypeUtils.getDeclaredTypeOfSuperclass(type);
-     * // superClassType contains the DeclaredType of the superclass if available
-     *
-     * DeclaredType nullCase = TypeUtils.getDeclaredTypeOfSuperclass(null);
-     * // nullCase will be null since the input is null
-     * }
- * - * @param type the TypeMirror to retrieve the superclass declared type from, may be null - * @return the DeclaredType representing the superclass of the given TypeMirror, or null if none exists - */ - @Nullable - static DeclaredType getDeclaredTypeOfSuperclass(TypeMirror type) { - TypeElement superType = getTypeElementOfSuperclass(ofTypeElement(type)); - return superType == null ? null : ofDeclaredType(superType.asType()); - } - - /** - * Retrieves a list of declared types representing the interfaces directly implemented by the given Element. - * This method only returns interfaces that are directly declared on the specified type, - * and does not include interfaces from superclasses or superinterfaces. - * - *

Example Usage

- * 
{@code
-     * Element typeElement = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
-     * List interfaces = TypeUtils.getDeclaredTypesOfInterfaces(typeElement);
-     * // interfaces now contains the directly implemented interfaces of MyClass
-     *
-     * List emptyList = TypeUtils.getDeclaredTypesOfInterfaces(null); // returns an empty list
-     * }
- * - * @param element The Element whose directly implemented interfaces are to be retrieved, may be null. - * @return A list of DeclaredTypes representing the interfaces directly implemented by the given Element. - * Returns an empty list if the input is null or no interfaces are directly implemented. - */ - @Nonnull - @Immutable - static List getDeclaredTypesOfInterfaces(Element element) { - return element == null ? emptyList() : findDeclaredTypesOfInterfaces(element.asType(), EMPTY_PREDICATE_ARRAY); - } - - /** - * Retrieves a list of declared types representing the interfaces directly implemented by the given TypeMirror. - * This method only returns interfaces that are directly declared on the specified type, - * and does not include interfaces from superclasses or superinterfaces. - * - *

Example Usage

- * 
{@code
-     * TypeMirror type = processingEnv.getTypeUtils().getDeclaredType(typeElement);
-     * List interfaces = TypeUtils.getDeclaredTypesOfInterfaces(type);
-     * // interfaces now contains the directly implemented interfaces of the given type
-     *
-     * List emptyList = TypeUtils.getDeclaredTypesOfInterfaces(null); // returns an empty list
-     * }
- * - * @param type The TypeMirror whose directly implemented interfaces are to be retrieved, may be null. - * @return A list of DeclaredTypes representing the interfaces directly implemented by the given TypeMirror. - * Returns an empty list if the input is null or no interfaces are directly implemented. - */ - @Nonnull - @Immutable - static List getDeclaredTypesOfInterfaces(TypeMirror type) { - return findDeclaredTypesOfInterfaces(type, EMPTY_PREDICATE_ARRAY); - } - - /** - * Retrieves a list of DeclaredTypes representing all superclasses in the hierarchy of the given Element. - * This includes both direct and indirect superclasses, traversing up through the entire type hierarchy. - * If the provided Element is null or does not have any superclasses, an empty list is returned. - * - *

Example Usage

- * 
{@code
-     * Element typeElement = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
-     * List superclasses = TypeUtils.getAllDeclaredTypesOfSuperclasses(typeElement);
-     * // superclasses now contains all superclass DeclaredTypes in the hierarchy of MyClass
-     *
-     * List emptyList = TypeUtils.getAllDeclaredTypesOfSuperclasses(null); // returns an empty list
-     * }
- * - * @param type The Element to retrieve superclass declared types from, may be null. - * @return A list of DeclaredTypes representing all superclasses in the hierarchy of the provided Element. - * Returns an empty list if the input is null or no superclasses exist in the hierarchy. - */ - @Nonnull - @Immutable - static List getAllDeclaredTypesOfSuperclasses(Element type) { - return type == null ? emptyList() : findAllDeclaredTypesOfSuperclasses(type.asType(), EMPTY_PREDICATE_ARRAY); - } - - /** - * Retrieves a list of DeclaredTypes representing all superclasses in the hierarchy of the given TypeMirror. - * This includes both direct and indirect superclasses, traversing up through the entire type hierarchy. - * - *

Example Usage

- * 
{@code
-     * TypeMirror type = processingEnv.getTypeUtils().getDeclaredType(typeElement);
-     * List superclasses = TypeUtils.getAllDeclaredTypesOfSuperclasses(type);
-     * // superclasses now contains all superclass DeclaredTypes in the hierarchy of the given type
-     *
-     * List emptyList = TypeUtils.getAllDeclaredTypesOfSuperclasses(null); // returns an empty list
-     * }
- * - * @param type The TypeMirror whose superclass hierarchy is to be explored, may be null. - * @return A list of DeclaredTypes representing all superclasses in the hierarchy of the provided TypeMirror. - * Returns an empty list if the input is null or no superclasses exist in the hierarchy. - */ - @Nonnull - @Immutable - static List getAllDeclaredTypesOfSuperclasses(TypeMirror type) { - return findAllDeclaredTypesOfSuperclasses(type, EMPTY_PREDICATE_ARRAY); - } - - /** - * Retrieves a list of DeclaredTypes representing all interfaces implemented in the entire hierarchy - * of the given Element. This includes both directly and indirectly implemented interfaces from - * superclasses and superinterfaces. - * - *

Example Usage

- * 
{@code
-     * Element typeElement = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
-     * List interfaces = TypeUtils.getAllDeclaredTypesOfInterfaces(typeElement);
-     * // interfaces now contains all interfaces implemented by MyClass, including those from superclasses
-     *
-     * List emptyList = TypeUtils.getAllDeclaredTypesOfInterfaces(null); // returns an empty list
-     * }
- * - * @param type The Element whose interface hierarchy is to be explored, may be null. - * @return A list of DeclaredTypes representing all implemented interfaces in the hierarchy of - * the provided Element. Returns an empty list if the input is null or no interfaces - * are found in the hierarchy. - */ - @Nonnull - @Immutable - static List getAllDeclaredTypesOfInterfaces(Element type) { - return type == null ? emptyList() : findAllDeclaredTypesOfInterfaces(type.asType(), EMPTY_PREDICATE_ARRAY); - } - - /** - * Retrieves a list of DeclaredTypes representing all interfaces implemented in the entire hierarchy - * of the given TypeMirror. This includes both directly and indirectly implemented interfaces from - * superclasses and superinterfaces. - * - *

Example Usage

- * 
{@code
-     * TypeMirror type = processingEnv.getTypeUtils().getDeclaredType(typeElement);
-     * List interfaces = TypeUtils.getAllDeclaredTypesOfInterfaces(type);
-     * // interfaces now contains all interfaces implemented by the given type, including those from superclasses
-     *
-     * List emptyList = TypeUtils.getAllDeclaredTypesOfInterfaces(null); // returns an empty list
-     * }
- * - * @param type The TypeMirror whose interface hierarchy is to be explored, may be null. - * @return A list of DeclaredTypes representing all implemented interfaces in the hierarchy of - * the provided TypeMirror. Returns an empty list if the input is null or no interfaces - * are found in the hierarchy. - */ - @Nonnull - @Immutable - static List getAllDeclaredTypesOfInterfaces(TypeMirror type) { - return findAllDeclaredTypesOfInterfaces(type, EMPTY_PREDICATE_ARRAY); - } - - /** - * Retrieves a list of DeclaredTypes representing all superclasses and interfaces in the hierarchy - * of the given Element. This includes both direct and indirect superclasses as well as implemented - * interfaces from the entire hierarchy. - * - *

Example Usage

- * 
{@code
-     * Element typeElement = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
-     * List superTypes = TypeUtils.getAllDeclaredTypesOfSuperTypes(typeElement);
-     * // superTypes now contains all superclasses and interfaces in the hierarchy of MyClass
-     *
-     * List emptyList = TypeUtils.getAllDeclaredTypesOfSuperTypes(null); // returns an empty list
-     * }
- * - * @param type The Element to retrieve super types from, may be null. - * @return A list of DeclaredTypes representing all superclasses and interfaces in the hierarchy - * of the provided Element. Returns an empty list if the input is null or no types are found. - */ - @Nonnull - @Immutable - static List getAllDeclaredTypesOfSuperTypes(Element type) { - return type == null ? emptyList() : findAllDeclaredTypesOfSuperTypes(type.asType(), EMPTY_PREDICATE_ARRAY); - } - - /** - * Retrieves a list of DeclaredTypes representing all superclasses and interfaces in the hierarchy - * of the given TypeMirror. This includes both direct and indirect superclasses as well as implemented - * interfaces from the entire hierarchy. - * - *

Example Usage

- * 
{@code
-     * TypeMirror type = processingEnv.getTypeUtils().getDeclaredType(typeElement);
-     * List superTypes = TypeUtils.getAllDeclaredTypesOfSuperTypes(type);
-     * // superTypes now contains all superclasses and interfaces in the hierarchy of the given type
-     *
-     * List emptyList = TypeUtils.getAllDeclaredTypesOfSuperTypes(null); // returns an empty list
-     * }
- * - * @param type The TypeMirror whose hierarchy is to be explored, may be null. - * @return A list of DeclaredTypes representing all superclasses and interfaces in the hierarchy of - * the provided TypeMirror. Returns an empty list if the input is null or no types are found. - */ - @Nonnull - @Immutable - static List getAllDeclaredTypesOfSuperTypes(TypeMirror type) { - return findAllDeclaredTypesOfSuperTypes(type, EMPTY_PREDICATE_ARRAY); - } - - /** - * Retrieves a list of DeclaredTypes representing all associated types of the given Element. - * This includes: - * - The type itself (if it is a declared type) - * - Direct and hierarchical superclasses - * - Direct and hierarchical interfaces implemented by the type - * - *

Example Usage

- * 
{@code
-     * Element typeElement = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
-     * List allTypes = TypeUtils.getAllDeclaredTypes(typeElement);
-     * // allTypes now contains MyClass itself, its superclasses, and all implemented interfaces
-     *
-     * List emptyList = TypeUtils.getAllDeclaredTypes(null); // returns an empty list
-     * }
- * - * @param type The Element to retrieve associated DeclaredTypes from, may be null. - * @return A list of DeclaredTypes derived from the given Element. Returns an empty list if - * the input is null or no DeclaredTypes are found. - */ - @Nonnull - @Immutable - static List getAllDeclaredTypes(Element type) { - return type == null ? emptyList() : findAllDeclaredTypes(type.asType(), EMPTY_PREDICATE_ARRAY); - } - - /** - * Retrieves a list of DeclaredTypes representing all associated types in the hierarchy of the given TypeMirror. - * This includes: - * - The type itself (if it is a declared type) - * - Direct and hierarchical superclasses - * - Direct and hierarchical interfaces implemented by the type - * - * @param type The TypeMirror to retrieve associated DeclaredTypes from, may be null. - * @return A list of DeclaredTypes representing all associated types in the hierarchy of the provided TypeMirror. - * Returns an empty list if the input is null or no DeclaredTypes are found. - */ - @Nonnull - @Immutable - static List getAllDeclaredTypes(TypeMirror type) { - return findAllDeclaredTypes(type, EMPTY_PREDICATE_ARRAY); - } - - /** - * Retrieves a list of DeclaredTypes associated with the given Element based on the specified inclusion criteria. - * A DeclaredType typically refers to a type that is explicitly declared in the code, such as classes, - * interfaces, enums, or annotation types. - * - * @param type The Element to retrieve DeclaredTypes from, may be null. - * @param includeSelf Whether to include the type itself in the result. - * @param includeHierarchicalTypes Whether to include types from the entire hierarchy (e.g., superclasses and interfaces). - * @param includeSuperClasses Whether to include direct or hierarchical superclasses based on includeHierarchicalTypes. - * @param includeSuperInterfaces Whether to include direct or hierarchical interfaces based on includeHierarchicalTypes. - * @return A list of DeclaredTypes derived from the given Element according to the inclusion criteria. - * Returns an empty list if the input is null or no DeclaredTypes are found. - */ - @Nonnull - @Immutable - static List getDeclaredTypes(Element type, - boolean includeSelf, - boolean includeHierarchicalTypes, - boolean includeSuperClasses, - boolean includeSuperInterfaces) { - return getDeclaredTypes(type.asType(), includeSelf, includeHierarchicalTypes, includeSuperClasses, includeSuperInterfaces); - } - - /** - * Retrieves a list of DeclaredTypes associated with the given TypeMirror based on the specified inclusion criteria. - * A DeclaredType typically refers to a type that is explicitly declared in the code, such as classes, - * interfaces, enums, or annotation types. - * - * @param type The TypeMirror to retrieve DeclaredTypes from, may be null. - * @param includeSelf Whether to include the type itself in the result. - * @param includeHierarchicalTypes Whether to include types from the entire hierarchy (e.g., superclasses and interfaces). - * @param includeSuperClasses Whether to include direct or hierarchical superclasses based on includeHierarchicalTypes. - * @param includeSuperInterfaces Whether to include direct or hierarchical interfaces based on includeHierarchicalTypes. - * @return A list of DeclaredTypes derived from the given TypeMirror according to the inclusion criteria. - * Returns an empty list if the input is null or no DeclaredTypes are found. - */ - @Nonnull - @Immutable - static List getDeclaredTypes(TypeMirror type, - boolean includeSelf, - boolean includeHierarchicalTypes, - boolean includeSuperClasses, - boolean includeSuperInterfaces) { - return findDeclaredTypes(type, includeSelf, includeHierarchicalTypes, includeSuperClasses, includeSuperInterfaces, EMPTY_PREDICATE_ARRAY); - } - - - /** - * Finds and returns a list of DeclaredTypes associated with the given TypeMirror, - * excluding any types that match the specified excludedTypes. - * - * @param type The TypeMirror to find associated DeclaredTypes from, may be null. - * @param excludedTypes The array of Types to exclude from the result. May be null or empty. - * @return A list of DeclaredTypes derived from the given TypeMirror, excluding the specified types. - * Returns an empty list if the input type is null or no matching DeclaredTypes are found. - */ - @Nonnull - @Immutable - static List findDeclaredTypes(TypeMirror type, Type... excludedTypes) { - return type == null ? emptyList() : findDeclaredTypes(ofTypeElement(type), excludedTypes); - } - - /** - * Finds and returns a list of DeclaredTypes associated with the given Element, - * excluding any types that match the specified excludedTypes. - * - * @param type The Element to find associated DeclaredTypes from, may be null. - * @param excludedTypes The array of Types to exclude from the result. May be null or empty. - * @return A list of DeclaredTypes derived from the given Element, excluding the specified types. - * Returns an empty list if the input type is null or no matching DeclaredTypes are found. - */ - @Nonnull - @Immutable - static List findDeclaredTypes(Element type, Type... excludedTypes) { - return type == null ? emptyList() : findDeclaredTypes(type, getTypeNames(excludedTypes)); - } - - /** - * Finds and returns a list of DeclaredTypes associated with the given TypeMirror, - * excluding any types whose names match the specified excludedTypeNames. - * - * @param type The TypeMirror to find associated DeclaredTypes from, may be null. - * @param excludedTypeNames An array of fully qualified type names to exclude from the result. - * May be null or empty. - * @return A list of DeclaredTypes derived from the given TypeMirror, excluding the specified types. - * Returns an empty list if the input type is null or no matching DeclaredTypes are found. - */ - @Nonnull - @Immutable - static List findDeclaredTypes(TypeMirror type, CharSequence... excludedTypeNames) { - return type == null ? emptyList() : findDeclaredTypes(ofTypeElement(type), excludedTypeNames); - } - - /** - * Finds and returns a list of DeclaredTypes associated with the given Element, - * excluding any types whose names match the specified excludedTypeNames. - * - * @param type The Element to find associated DeclaredTypes from, may be null. - * @param excludedTypeNames An array of fully qualified type names to exclude from the result. - * May be null or empty. - * @return A list of DeclaredTypes derived from the given Element, excluding the specified types. - * Returns an empty list if the input is null or no matching DeclaredTypes are found. - */ - @Nonnull - @Immutable - static List findDeclaredTypes(Element type, CharSequence... excludedTypeNames) { - return type == null ? emptyList() : findDeclaredTypes(type, false, false, true, true, t -> !contains(excludedTypeNames, t.toString())); - } - - /** - * Retrieves a list of DeclaredTypes representing the interfaces directly implemented by the given Element. - * This method only returns interfaces that are directly declared on the specified type, - * and does not include interfaces from superclasses or superinterfaces. - * - * @param type The Element whose directly implemented interfaces are to be retrieved, may be null. - * @param typeFilters Optional predicates to filter the resulting DeclaredTypes. May be null or empty. - * @return A list of DeclaredTypes representing the interfaces directly implemented by the given Element. - * Returns an empty list if the input is null or no interfaces are directly implemented. - */ - @Nonnull - @Immutable - static List findDeclaredTypesOfInterfaces(Element type, Predicate... typeFilters) { - return type == null ? emptyList() : findDeclaredTypesOfInterfaces(type.asType(), typeFilters); - } - - /** - * Retrieves a list of DeclaredTypes representing the interfaces directly implemented by the given TypeMirror. - * This method only returns interfaces that are directly declared on the specified type, - * and does not include interfaces from superclasses or superinterfaces. - * - * @param type The TypeMirror whose directly implemented interfaces are to be retrieved, may be null. - * @param typeFilters Optional predicates to filter the resulting DeclaredTypes. May be null or empty. - * @return A list of DeclaredTypes representing the interfaces directly implemented by the given TypeMirror. - * Returns an empty list if the input is null or no interfaces are directly implemented. - */ - @Nonnull - @Immutable - static List findDeclaredTypesOfInterfaces(TypeMirror type, Predicate... typeFilters) { - return type == null ? emptyList() : ofDeclaredTypes(getTypeElementsOfInterfaces(ofTypeElement(type)), typeFilters); - } - - /** - * Retrieves a list of DeclaredTypes representing all superclasses in the hierarchy of the given Element. - * This includes both direct and indirect superclasses, traversing up through the entire type hierarchy. - * Optionally applies an array of predicates to filter the resulting DeclaredTypes. - * - * @param type The Element to retrieve superclass declared types from, may be null. - * @param typeFilters Optional predicates to filter the resulting DeclaredTypes. May be null or empty. - * @return A list of DeclaredTypes representing all superclasses in the hierarchy of the provided Element. - * Returns an empty list if the input is null or no superclasses exist in the hierarchy. - */ - @Nonnull - @Immutable - static List findAllDeclaredTypesOfSuperclasses(Element type, Predicate... typeFilters) { - return type == null ? emptyList() : findAllDeclaredTypesOfSuperclasses(type.asType(), typeFilters); - } - - /** - * Retrieves a list of DeclaredTypes representing all superclasses in the hierarchy of the given TypeMirror. - * This includes both direct and indirect superclasses, traversing up through the entire type hierarchy. - * Optionally applies an array of predicates to filter the resulting DeclaredTypes. - * - * @param type The TypeMirror whose superclass hierarchy is to be explored, may be null. - * @param typeFilters Optional predicates to filter the resulting DeclaredTypes. May be null or empty. - * @return A list of DeclaredTypes representing all superclasses in the hierarchy of the provided TypeMirror, - * filtered by the provided predicates. Returns an empty list if the input is null or no superclasses - * exist in the hierarchy. - */ - @Nonnull - @Immutable - static List findAllDeclaredTypesOfSuperclasses(TypeMirror type, Predicate... typeFilters) { - return type == null ? emptyList() : ofDeclaredTypes(getAllTypeElementsOfSuperclasses(ofTypeElement(type)), typeFilters); - } - - /** - * Retrieves a list of DeclaredTypes representing all interfaces implemented in the entire hierarchy - * of the given Element. This includes both directly and indirectly implemented interfaces from - * superclasses and superinterfaces. Optionally applies an array of predicates to filter the resulting DeclaredTypes. - * - * @param type The Element whose interface hierarchy is to be explored, may be null. - * @param typeFilters Optional predicates to filter the resulting DeclaredTypes. May be null or empty. - * @return A list of DeclaredTypes representing all implemented interfaces in the hierarchy of - * the provided Element, filtered by the provided predicates. Returns an empty list if - * the input is null or no interfaces are found in the hierarchy. - */ - @Nonnull - @Immutable - static List findAllDeclaredTypesOfInterfaces(Element type, Predicate... typeFilters) { - return type == null ? emptyList() : findAllDeclaredTypesOfInterfaces(type.asType(), typeFilters); - } - - /** - * Retrieves a list of DeclaredTypes representing all interfaces implemented in the entire hierarchy - * of the given TypeMirror. This includes both directly and indirectly implemented interfaces from - * superclasses and superinterfaces. Optionally applies an array of predicates to filter the resulting DeclaredTypes. - * - * @param type The TypeMirror whose interface hierarchy is to be explored, may be null. - * @param typeFilters Optional predicates to filter the resulting DeclaredTypes. May be null or empty. - * @return A list of DeclaredTypes representing all implemented interfaces in the hierarchy of - * the provided TypeMirror, filtered by the provided predicates. Returns an empty list if - * the input is null or no interfaces are found in the hierarchy. - */ - @Nonnull - @Immutable - static List findAllDeclaredTypesOfInterfaces(TypeMirror type, Predicate... typeFilters) { - return type == null ? emptyList() : ofDeclaredTypes(getAllTypeElementsOfInterfaces(ofTypeElement(type)), typeFilters); - } - - /** - * Retrieves a list of DeclaredTypes representing all superclasses and interfaces in the hierarchy - * of the given Element. This includes both direct and indirect superclasses as well as implemented - * interfaces from the entire hierarchy. Optionally applies an array of predicates to filter the resulting DeclaredTypes. - * - * @param type The Element to retrieve superclass and interface declared types from, may be null. - * @param typeFilters Optional predicates to filter the resulting DeclaredTypes. May be null or empty. - * @return A list of DeclaredTypes representing all superclasses and interfaces in the hierarchy of - * the provided Element, filtered by the provided predicates. Returns an empty list if the - * input is null or no matching DeclaredTypes are found. - */ - @Nonnull - @Immutable - static List findAllDeclaredTypesOfSuperTypes(Element type, Predicate... typeFilters) { - return type == null ? emptyList() : findAllDeclaredTypesOfSuperTypes(type.asType(), typeFilters); - } - - /** - * Retrieves a list of DeclaredTypes representing all superclasses and interfaces in the hierarchy - * of the given TypeMirror. This includes both direct and indirect superclasses as well as implemented - * interfaces from the entire hierarchy. Optionally applies an array of predicates to filter the resulting DeclaredTypes. - * - * @param type The TypeMirror whose superclass and interface hierarchy is to be explored, may be null. - * @param typeFilters Optional predicates to filter the resulting DeclaredTypes. May be null or empty. - * @return A list of DeclaredTypes representing all superclasses and interfaces in the hierarchy of - * the provided TypeMirror, filtered by the provided predicates. Returns an empty list if the - * input is null or no matching DeclaredTypes are found. - */ - @Nonnull - @Immutable - static List findAllDeclaredTypesOfSuperTypes(TypeMirror type, Predicate... typeFilters) { - return type == null ? emptyList() : ofDeclaredTypes(getAllTypeElementsOfSuperTypes(ofTypeElement(type)), typeFilters); - } - - /** - * Retrieves a list of DeclaredTypes representing all associated types in the hierarchy - * of the given TypeMirror, excluding any types that match the specified excludedTypes. - * This includes: - * - The type itself (if it is a declared type) - * - Direct and hierarchical superclasses - * - Direct and hierarchical interfaces implemented by the type - * - * @param type The TypeMirror to retrieve associated DeclaredTypes from, may be null. - * @param excludedTypes The array of Types to exclude from the result. May be null or empty. - * @return A list of DeclaredTypes derived from the given TypeMirror, excluding the specified types. - * Returns an empty list if the input is null or no matching DeclaredTypes are found. - */ - @Nonnull - @Immutable - static List findAllDeclaredTypes(TypeMirror type, Type... excludedTypes) { - return type == null ? emptyList() : findAllDeclaredTypes(ofTypeElement(type), excludedTypes); - } - - /** - * Retrieves a list of DeclaredTypes representing all associated types in the hierarchy - * of the given Element, excluding any types that match the specified excludedTypes. - * This includes: - * - The type itself (if it is a declared type) - * - Direct and hierarchical superclasses - * - Direct and hierarchical interfaces implemented by the type - * - * @param type The Element to retrieve associated DeclaredTypes from, may be null. - * @param excludedTypes The array of Types to exclude from the result. May be null or empty. - * @return A list of DeclaredTypes derived from the given Element, excluding the specified types. - * Returns an empty list if the input is null or no matching DeclaredTypes are found. - */ - @Nonnull - @Immutable - static List findAllDeclaredTypes(Element type, Type... excludedTypes) { - return type == null ? emptyList() : findAllDeclaredTypes(type, getTypeNames(excludedTypes)); - } - - /** - * Retrieves a list of DeclaredTypes representing all associated types in the hierarchy - * of the given TypeMirror, excluding any types whose names match the specified excludedTypeNames. - * This includes: - * - The type itself (if it is a declared type) - * - Direct and hierarchical superclasses - * - Direct and hierarchical interfaces implemented by the type - * - * @param type The TypeMirror to retrieve associated DeclaredTypes from, may be null. - * @param excludedTypeNames An array of fully qualified type names to exclude from the result. - * May be null or empty. - * @return A list of DeclaredTypes derived from the given TypeMirror, excluding the specified types. - * Returns an empty list if the input type is null or no matching DeclaredTypes are found. - */ - @Nonnull - @Immutable - static List findAllDeclaredTypes(TypeMirror type, CharSequence... excludedTypeNames) { - return type == null ? emptyList() : findAllDeclaredTypes(ofTypeElement(type), excludedTypeNames); - } - - /** - * Retrieves a list of DeclaredTypes representing all associated types in the hierarchy - * of the given Element, excluding any types whose names match the specified excludedTypeNames. - * This includes: - * - The type itself (if it is a declared type) - * - Direct and hierarchical superclasses - * - Direct and hierarchical interfaces implemented by the type - * - * @param type The Element to retrieve associated DeclaredTypes from, may be null. - * @param excludedTypeNames An array of fully qualified type names to exclude from the result. - * May be null or empty. - * @return A list of DeclaredTypes derived from the given Element, excluding the specified types. - * Returns an empty list if the input is null or no matching DeclaredTypes are found. - */ - @Nonnull - @Immutable - static List findAllDeclaredTypes(Element type, CharSequence... excludedTypeNames) { - return type == null ? emptyList() : findAllDeclaredTypes(type, t -> !contains(excludedTypeNames, t.toString())); - } - - /** - * Retrieves a list of DeclaredTypes representing all associated types in the hierarchy - * of the given Element, filtered by the provided predicates. - * This includes: - * - The type itself (if it is a declared type) - * - Direct and hierarchical superclasses - * - Direct and hierarchical interfaces implemented by the type - * - * @param type The Element to retrieve associated DeclaredTypes from, may be null. - * @param typeFilters Optional predicates to filter the resulting DeclaredTypes. May be null or empty. - * @return A list of DeclaredTypes derived from the given Element, filtered by the provided predicates. - * Returns an empty list if the input is null or no matching DeclaredTypes are found. - */ - @Nonnull - @Immutable - static List findAllDeclaredTypes(Element type, Predicate... typeFilters) { - return type == null ? emptyList() : findAllDeclaredTypes(type.asType(), typeFilters); - } - - /** - * Retrieves a list of DeclaredTypes representing all associated types in the hierarchy - * of the given TypeMirror, filtered by the provided predicates. - * This includes: - * - The type itself (if it is a declared type) - * - Direct and hierarchical superclasses - * - Direct and hierarchical interfaces implemented by the type - * - * @param type The TypeMirror to retrieve associated DeclaredTypes from, may be null. - * @param typeFilters Optional predicates to filter the resulting DeclaredTypes. May be null or empty. - * @return A list of DeclaredTypes derived from the given TypeMirror, filtered by the provided predicates. - * Returns an empty list if the input is null or no matching DeclaredTypes are found. - */ - @Nonnull - @Immutable - static List findAllDeclaredTypes(TypeMirror type, Predicate... typeFilters) { - return type == null ? emptyList() : ofDeclaredTypes(getAllTypeElements(ofTypeElement(type)), typeFilters); - } - - /** - * Finds and returns a list of DeclaredTypes associated with the given Element based on the specified criteria. - * - *

A DeclaredType typically refers to a type that is explicitly declared in the code, such as classes, - * interfaces, enums, or annotation types. This method allows filtering based on whether to include: - * - The type itself - * - Direct or hierarchical superclasses (based on the includeHierarchicalTypes flag) - * - Direct or hierarchical interfaces (based on the includeHierarchicalTypes flag) - * - * @param type The Element to find associated DeclaredTypes from. May be null. - * @param includeSelf Whether to include the type itself in the result. - * @param includeHierarchicalTypes Whether to include types from the entire hierarchy (e.g., superclasses and interfaces). - * @param includeSuperClasses Whether to include direct or hierarchical superclasses based on includeHierarchicalTypes. - * @param includeSuperInterfaces Whether to include direct or hierarchical interfaces based on includeHierarchicalTypes. - * @param typeFilters Optional predicates to filter the resulting DeclaredTypes. May be null or empty. - * @return A list of DeclaredTypes matching the specified criteria. - * Returns an empty list if the input type is null or no matching types are found. - * @throws IllegalArgumentException if any element of 'typeFilters' array is null. - */ - @Nonnull - @Immutable - static List findDeclaredTypes(Element type, - boolean includeSelf, - boolean includeHierarchicalTypes, - boolean includeSuperClasses, - boolean includeSuperInterfaces, - Predicate... typeFilters) { - return type == null ? emptyList() : findDeclaredTypes(type.asType(), includeSelf, includeHierarchicalTypes, includeSuperClasses, includeSuperInterfaces, typeFilters); - } - - /** - * Finds and returns a list of DeclaredTypes associated with the given TypeMirror based on the specified criteria. - * - *

A DeclaredType typically refers to a type that is explicitly declared in the code, such as classes, - * interfaces, enums, or annotation types. This method allows filtering based on whether to include: - * - The type itself - * - Direct or hierarchical superclasses (based on the includeHierarchicalTypes flag) - * - Direct or hierarchical interfaces (based on the includeHierarchicalTypes flag) - * - * @param type The TypeMirror to find associated DeclaredTypes from. May be null. - * @param includeSelf Whether to include the type itself in the result. - * @param includeHierarchicalTypes Whether to include types from the entire hierarchy (e.g., superclasses and interfaces). - * @param includeSuperClasses Whether to include direct or hierarchical superclasses based on includeHierarchicalTypes. - * @param includeSuperInterfaces Whether to include direct or hierarchical interfaces based on includeHierarchicalTypes. - * @param typeFilters Optional predicates to filter the resulting DeclaredTypes. May be null or empty. - * @return A list of DeclaredTypes matching the specified criteria. - * Returns an empty list if the input type is null or no matching types are found. - * @throws IllegalArgumentException if any element of 'typeFilters' array is null. - */ - @Nonnull - @Immutable - static List findDeclaredTypes(TypeMirror type, - boolean includeSelf, - boolean includeHierarchicalTypes, - boolean includeSuperClasses, - boolean includeSuperInterfaces, - Predicate... typeFilters) { - return type == null ? emptyList() : ofDeclaredTypes(getTypeElements(ofTypeElement(type), includeSelf, includeHierarchicalTypes, includeSuperClasses, includeSuperInterfaces), typeFilters); - } - - /** - * Retrieves a list of TypeMirrors representing the interfaces directly implemented by the given TypeMirror. - * This method only returns interfaces that are directly declared on the specified type, - * and does not include interfaces from superclasses or superinterfaces. - * - * @param type The TypeMirror whose directly implemented interfaces are to be retrieved, may be null. - * @return A list of TypeMirrors representing the interfaces directly implemented by the given TypeMirror. - * Returns an empty list if the input is null or no interfaces are directly implemented. - */ - @Nonnull - @Immutable - static List getTypeMirrorsOfInterfaces(TypeMirror type) { - return type == null ? emptyList() : findTypeMirrorsOfInterfaces(type, EMPTY_PREDICATE_ARRAY); - } - - /** - * Retrieves a list of TypeMirrors representing the interfaces directly implemented by the given TypeElement. - * This method only returns interfaces that are directly declared on the specified type, - * and does not include interfaces from superclasses or superinterfaces. - * - * @param type The TypeElement whose directly implemented interfaces are to be retrieved, may be null. - * @return A list of TypeMirrors representing the interfaces directly implemented by the given TypeElement. - * Returns an empty list if the input is null or no interfaces are directly implemented. - */ - @Nonnull - @Immutable - static List getTypeMirrorsOfInterfaces(TypeElement type) { - return type == null ? emptyList() : findTypeMirrorsOfInterfaces(type, EMPTY_PREDICATE_ARRAY); - } - - /** - * Retrieves a list of TypeMirrors representing the interfaces directly implemented by the given TypeMirror. - * This method only returns interfaces that are directly declared on the specified type, - * and does not include interfaces from superclasses or superinterfaces. - * - * @param type The TypeMirror whose directly implemented interfaces are to be retrieved, may be null. - * @param interfaceFilters Optional predicates to filter the resulting TypeMirrors. May be null or empty. - * @return A list of TypeMirrors representing the interfaces directly implemented by the given TypeMirror, - * filtered by the provided predicates. Returns an empty list if the input is null or no interfaces - * are directly implemented. - */ - @Nonnull - @Immutable - static List findTypeMirrorsOfInterfaces(TypeMirror type, Predicate... interfaceFilters) { - return type == null ? emptyList() : findTypeMirrorsOfInterfaces(ofTypeElement(type), interfaceFilters); - } - - /** - * Retrieves a list of TypeMirrors representing the interfaces directly implemented by the given TypeElement. - * This method only returns interfaces that are directly declared on the specified type, - * and does not include interfaces from superclasses or superinterfaces. - * - * @param type The TypeElement whose directly implemented interfaces are to be retrieved, may be null. - * @param interfaceFilters Optional predicates to filter the resulting TypeMirrors. May be null or empty. - * @return A list of TypeMirrors representing the interfaces directly implemented by the given TypeElement, - * filtered by the provided predicates. Returns an empty list if the input is null or no interfaces - * are directly implemented. - */ - @Nonnull - @Immutable - static List findTypeMirrorsOfInterfaces(TypeElement type, Predicate... interfaceFilters) { - if (type == null) { - return emptyList(); - } - List typeMirrors = getTypeElementsOfInterfaces(type).stream() - .map(TypeElement::asType) - .filter(and(interfaceFilters)) - .collect(toList()); - return typeMirrors.isEmpty() ? emptyList() : typeMirrors; - } - - /** - * Retrieves a list of TypeMirrors representing all interfaces implemented in the entire hierarchy - * of the given TypeMirror. This includes both directly and indirectly implemented interfaces from - * superclasses and superinterfaces. - * - * @param type The TypeMirror whose interface hierarchy is to be explored, may be null. - * @return A list of TypeMirrors representing all implemented interfaces in the hierarchy of - * the provided TypeMirror. Returns an empty list if the input is null or no interfaces - * are found in the hierarchy. - */ - @Nonnull - @Immutable - static List getAllTypeMirrorsOfInterfaces(TypeMirror type) { - return findAllTypeMirrorsOfInterfaces(type, EMPTY_PREDICATE_ARRAY); - } - - /** - * Retrieves a list of TypeMirrors representing all interfaces implemented in the entire hierarchy - * of the given TypeElement. This includes both directly and indirectly implemented interfaces from - * superclasses and superinterfaces. - * - * @param type The TypeElement whose interface hierarchy is to be explored, may be null. - * @return A list of TypeMirrors representing all implemented interfaces in the hierarchy of - * the provided TypeElement. Returns an empty list if the input is null or no interfaces - * are found in the hierarchy. - */ - @Nonnull - @Immutable - static List getAllTypeMirrorsOfInterfaces(TypeElement type) { - return findAllTypeMirrorsOfInterfaces(type, EMPTY_PREDICATE_ARRAY); - } - - /** - * Retrieves a list of TypeMirrors representing all interfaces implemented in the entire hierarchy - * of the given TypeMirror. This includes both directly and indirectly implemented interfaces from - * superclasses and superinterfaces. Optionally applies an array of predicates to filter the resulting TypeMirrors. - * - * @param type The TypeMirror whose interface hierarchy is to be explored, may be null. - * @param interfaceFilters Optional predicates to filter the resulting TypeMirrors. May be null or empty. - * @return A list of TypeMirrors representing all implemented interfaces in the hierarchy of - * the provided TypeMirror, filtered by the provided predicates. Returns an empty list if - * the input is null or no interfaces are found in the hierarchy. - */ - @Nonnull - @Immutable - static List findAllTypeMirrorsOfInterfaces(TypeMirror type, Predicate... interfaceFilters) { - return type == null ? emptyList() : findAllTypeMirrorsOfInterfaces(ofTypeElement(type), interfaceFilters); - } - - /** - * Retrieves a list of TypeMirrors representing all interfaces implemented in the entire hierarchy - * of the given TypeElement. This includes both directly and indirectly implemented interfaces from - * superclasses and superinterfaces. Optionally applies an array of predicates to filter the resulting TypeMirrors. - * - * @param type The TypeElement whose interface hierarchy is to be explored, may be null. - * @param interfaceFilters Optional predicates to filter the resulting TypeMirrors. May be null or empty. - * @return A list of TypeMirrors representing all implemented interfaces in the hierarchy of - * the provided TypeElement, filtered by the provided predicates. Returns an empty list if - * the input is null or no interfaces are found in the hierarchy. - */ - @Nonnull - @Immutable - static List findAllTypeMirrorsOfInterfaces(TypeElement type, Predicate... interfaceFilters) { - if (type == null) { - return emptyList(); - } - List typeMirrors = getAllTypeElementsOfInterfaces(type).stream() - .map(TypeElement::asType) - .filter(and(interfaceFilters)) - .collect(toList()); - return typeMirrors.isEmpty() ? emptyList() : typeMirrors; - } - - /** - * Finds and returns the TypeMirror representing the specified interface type from the given Element. - * If the provided Element or interfaceType is null, returns null. - * - * @param type The Element to find the interface TypeMirror from. May be null. - * @param interfaceType The Type representing the interface to search for. May be null. - * @return The TypeMirror of the specified interface if found; otherwise, null. - */ - @Nullable - static TypeMirror findInterfaceTypeMirror(Element type, Type interfaceType) { - return findInterfaceTypeMirror(type, interfaceType.getTypeName()); - } - - /** - * Finds and returns the TypeMirror representing the specified interface type from the given TypeMirror. - * If the provided TypeMirror or interfaceType is null, returns null. - * - * @param type The TypeMirror to find the interface TypeMirror from. May be null. - * @param interfaceType The Type representing the interface to search for. May be null. - * @return The TypeMirror of the specified interface if found; otherwise, null. - */ - @Nullable - static TypeMirror findInterfaceTypeMirror(TypeMirror type, Type interfaceType) { - return findInterfaceTypeMirror(type, interfaceType.getTypeName()); - } - - /** - * Finds and returns the TypeMirror representing the specified interface type from the given Element. - * If the provided Element or interfaceClassName is null, returns null. - * - * @param type The Element to find the interface TypeMirror from. May be null. - * @param interfaceClassName The fully qualified class name of the interface to search for. May be null. - * @return The TypeMirror of the specified interface if found; otherwise, null. - */ - @Nullable - static TypeMirror findInterfaceTypeMirror(Element type, CharSequence interfaceClassName) { - return type == null ? null : findInterfaceTypeMirror(type.asType(), interfaceClassName); - } - - /** - * Finds and returns the TypeMirror representing the specified interface type from the given TypeMirror. - * If the provided TypeMirror or interfaceClassName is null, returns null. - * - *

This method searches through all interfaces implemented in the entire hierarchy of the given TypeMirror, - * including both directly and indirectly implemented interfaces from superclasses and superinterfaces. - * - * @param type The TypeMirror to find the interface TypeMirror from. May be null. - * @param interfaceClassName The fully qualified class name of the interface to search for. May be null. - * @return The TypeMirror of the specified interface if found; otherwise, null. - */ - @Nullable - static TypeMirror findInterfaceTypeMirror(TypeMirror type, CharSequence interfaceClassName) { - return filterFirst(getAllTypeMirrorsOfInterfaces(type), t -> isSameType(t, interfaceClassName)); - } - - /** - * Converts an array of Type objects to a list of TypeMirror instances using the provided ProcessingEnvironment. - * If the input array is null or empty, returns an empty list. - * - * @param processingEnv The ProcessingEnvironment used to resolve TypeMirrors. Must not be null. - * @param types The array of Type objects to convert. May contain null elements which will be ignored. - * @return A list of TypeMirror instances derived from the given Types. Returns an empty list if the input array is null or empty, - * or if no valid TypeMirror instances could be resolved. - */ - @Nonnull - @Immutable - static List getTypeMirrors(ProcessingEnvironment processingEnv, Type... types) { - if (isEmpty(types)) { - return emptyList(); - } - List typeMirrors = of(types) - .filter(Objects::nonNull) - .map(t -> getTypeMirror(processingEnv, t)) - .filter(Objects::nonNull) - .collect(toList()); - return typeMirrors.isEmpty() ? emptyList() : unmodifiableList(typeMirrors); - } - - /** - * Converts the given Type to a TypeMirror using the provided ProcessingEnvironment. - * - *

If the provided Type is null, this method returns null. Otherwise, it attempts - * to resolve the Type into a TypeElement and then retrieves its corresponding TypeMirror. - * - * @param processingEnv The ProcessingEnvironment used to resolve TypeMirrors. Must not be null. - * @param type The Type to convert to a TypeMirror. May be null. - * @return The resolved TypeMirror if available; otherwise, null. - */ - @Nullable - static TypeMirror getTypeMirror(ProcessingEnvironment processingEnv, Type type) { - TypeElement typeElement = getTypeElement(processingEnv, type); - return typeElement == null ? null : typeElement.asType(); - } - - /** - * Converts an array of Type objects to a list of TypeElement instances using the provided ProcessingEnvironment. - * If the input array is null or empty, returns an empty list. - * - * @param processingEnv The ProcessingEnvironment used to resolve TypeElements. Must not be null. - * @param types The array of Type objects to convert. May contain null elements which will be ignored. - * @return A list of TypeElement instances derived from the given Types. Returns an empty list if the input array is null or empty, - * or if no valid TypeElement instances could be resolved. - */ - @Nonnull - @Immutable - static List getTypeElements(ProcessingEnvironment processingEnv, Type... types) { - if (isEmpty(types)) { - return emptyList(); - } - List typeElements = of(types) - .filter(Objects::nonNull) - .map(t -> getTypeElement(processingEnv, t)) - .filter(Objects::nonNull) - .collect(toList()); - return typeElements.isEmpty() ? emptyList() : unmodifiableList(typeElements); - } - - /** - * Retrieves the TypeElement corresponding to the given Type using the provided ProcessingEnvironment. - * - *

If the provided {@link Type} is null, this method returns null. Otherwise, it attempts - * to resolve the Type into a TypeElement by first obtaining its fully qualified type name - * and then using the ElementUtils from the ProcessingEnvironment. - * - * @param processingEnv The ProcessingEnvironment used to resolve TypeElements. Must not be null. - * @param type The Type to convert to a TypeElement. May be null. - * @return The resolved TypeElement if available; otherwise, null. - */ - @Nullable - static TypeElement getTypeElement(ProcessingEnvironment processingEnv, Type type) { - return type == null ? null : getTypeElement(processingEnv, type.getTypeName()); - } - - /** - * Retrieves the TypeElement corresponding to the given TypeMirror using the provided ProcessingEnvironment. - * - *

If the provided {@link TypeMirror} is null, this method returns null. Otherwise, it attempts - * to resolve the TypeMirror into a TypeElement by first obtaining its fully qualified type name - * and then using the ElementUtils from the ProcessingEnvironment. - * - * @param processingEnv The ProcessingEnvironment used to resolve TypeElements. Must not be null. - * @param type The TypeMirror to convert to a TypeElement. May be null. - * @return The resolved TypeElement if available; otherwise, null. - */ - @Nullable - static TypeElement getTypeElement(ProcessingEnvironment processingEnv, TypeMirror type) { - return type == null ? null : getTypeElement(processingEnv, type.toString()); - } - - /** - * Retrieves the TypeElement corresponding to the given type name using the provided ProcessingEnvironment. - * - *

If the provided {@link ProcessingEnvironment} or typeName is null, this method returns null. - * Otherwise, it uses the ElementUtils from the ProcessingEnvironment to find and return the TypeElement. - * - * @param processingEnv The ProcessingEnvironment used to resolve TypeElements. Must not be null. - * @param typeName The fully qualified class name of the type to search for. May be null. - * @return The resolved TypeElement if available; otherwise, null. - */ - @Nullable - static TypeElement getTypeElement(ProcessingEnvironment processingEnv, CharSequence typeName) { - if (processingEnv == null || typeName == null) { - return null; - } - Elements elements = processingEnv.getElementUtils(); - return elements.getTypeElement(typeName); - } - - /** - * Retrieves the DeclaredType corresponding to the given Type using the provided ProcessingEnvironment. - * - *

If the provided {@link Type} is null, this method returns null. Otherwise, it attempts - * to resolve the Type into a DeclaredType by first obtaining its fully qualified type name - * and then using the ElementUtils from the ProcessingEnvironment to find the corresponding TypeElement. - * - * @param processingEnv The ProcessingEnvironment used to resolve DeclaredTypes. Must not be null. - * @param type The Type to convert to a DeclaredType. May be null. - * @return The resolved DeclaredType if available; otherwise, null. - */ - @Nullable - static DeclaredType getDeclaredType(ProcessingEnvironment processingEnv, Type type) { - return type == null ? null : getDeclaredType(processingEnv, type.getTypeName()); - } - - /** - * Retrieves the DeclaredType corresponding to the given TypeMirror using the provided ProcessingEnvironment. - * - *

If the provided {@link TypeMirror} is null, this method returns null. Otherwise, it attempts - * to resolve the TypeMirror into a DeclaredType by first obtaining its fully qualified type name - * and then using the ElementUtils from the ProcessingEnvironment to find the corresponding TypeElement. - * - * @param processingEnv The ProcessingEnvironment used to resolve DeclaredTypes. Must not be null. - * @param type The TypeMirror to convert to a DeclaredType. May be null. - * @return The resolved DeclaredType if available; otherwise, null. - */ - @Nullable - static DeclaredType getDeclaredType(ProcessingEnvironment processingEnv, TypeMirror type) { - return type == null ? null : getDeclaredType(processingEnv, type.toString()); - } - - /** - * Retrieves the DeclaredType corresponding to the given type name using the provided ProcessingEnvironment. - * - *

If the provided {@link ProcessingEnvironment} or typeName is null, this method returns null. - * Otherwise, it uses the ElementUtils from the ProcessingEnvironment to find and return the TypeElement, - * then converts it to a DeclaredType. - * - * @param processingEnv The ProcessingEnvironment used to resolve DeclaredTypes. Must not be null. - * @param typeName The fully qualified class name of the type to search for. May be null. - * @return The resolved DeclaredType if available; otherwise, null. - */ - @Nullable - static DeclaredType getDeclaredType(ProcessingEnvironment processingEnv, CharSequence typeName) { - return ofDeclaredType(getTypeElement(processingEnv, typeName)); - } - - /** - * Converts the given TypeMirror to its string representation. - * This method is typically used to obtain a readable and fully qualified name of the type, - * including any type parameters if present. - * - * @param type The TypeMirror to convert to a string, may be null. - * @return The string representation of the TypeMirror, or null if the input is null. - */ - @Nullable - static String toString(TypeMirror type) { - return getTypeName(type); - } - - /** - * Gets the fully qualified name of the given TypeMirror, including type parameters if present. - * - * @param type The TypeMirror to get the name from, may be null. - * @return The fully qualified name of the type including type parameters, or null if the input is null. - */ - @Nullable - static String getTypeName(TypeMirror type) { - if (type == null) { - return null; - } - TypeElement element = ofTypeElement(type); - if (element != null) { - List typeParameterElements = element.getTypeParameters(); - int typeParameterElementsSize = typeParameterElements.size(); - if (typeParameterElementsSize > 0) { - List typeMirrors = invokeMethod(type, "getTypeArguments"); - int size = typeMirrors.size(); - if (size > 0) { - StringBuilder typeBuilder = new StringBuilder(element.toString()); - typeBuilder.append(LESS_THAN_CHAR) - .append(typeMirrors) - .append(GREATER_THAN_CHAR); - return typeBuilder.toString(); - } - } - } - return type.toString(); - } - - /** - * Creates a TypeFinder instance for the specified TypeElement with configurable inclusion options. - * - *

This method allows searching for associated types based on the provided criteria: - * - *

    - *
  • {@code includeSelf} - Whether to include the type itself in the result.
    • - *
  • {@code includeHierarchicalTypes} - Whether to include types from the entire hierarchy (e.g., superclasses and interfaces).
    • - *
  • {@code includeSuperclass} - Whether to include direct or hierarchical superclasses based on includeHierarchicalTypes.
    • - *
  • {@code includeInterfaces} - Whether to include direct or hierarchical interfaces based on includeHierarchicalTypes.
    • - *
- * - * @param typeElement The TypeElement to start the search from. Must not be null. - * @param includeSelf Whether to include the type itself in the result. - * @param includeHierarchicalTypes Whether to include types from the entire hierarchy. - * @param includeSuperclass Whether to include direct or hierarchical superclasses. - * @param includeInterfaces Whether to include direct or hierarchical interfaces. - * @return A TypeFinder instance configured with the given parameters. - * @throws IllegalArgumentException if any parameter is invalid or if assertions fail. - */ - @Nonnull - static TypeFinder typeElementFinder(TypeElement typeElement, boolean includeSelf, - boolean includeHierarchicalTypes, boolean includeSuperclass, boolean includeInterfaces) { - return new TypeFinder(typeElement, TYPE_ELEMENT_GET_SUPERCLASS, TYPE_ELEMENT_GET_INTERFACES, includeSelf, - includeHierarchicalTypes, includeSuperclass, includeInterfaces); - } -} \ No newline at end of file diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/AbstractAnnotationProcessingTest.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/AbstractAnnotationProcessingTest.java deleted file mode 100644 index ce674e512..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/AbstractAnnotationProcessingTest.java +++ /dev/null @@ -1,202 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor; - -import io.microsphere.annotation.processor.util.TypeUtils; -import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.extension.ExtendWith; - -import javax.annotation.processing.ProcessingEnvironment; -import javax.annotation.processing.RoundEnvironment; -import javax.lang.model.AnnotatedConstruct; -import javax.lang.model.element.AnnotationMirror; -import javax.lang.model.element.Element; -import javax.lang.model.element.ElementKind; -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.Modifier; -import javax.lang.model.element.TypeElement; -import javax.lang.model.element.VariableElement; -import javax.lang.model.type.DeclaredType; -import javax.lang.model.type.TypeMirror; -import javax.lang.model.util.Elements; -import javax.lang.model.util.Types; -import java.lang.annotation.Annotation; -import java.lang.reflect.Type; -import java.util.Collection; -import java.util.List; -import java.util.Set; -import java.util.function.Predicate; - -import static io.microsphere.annotation.processor.util.ConstructorUtils.findConstructor; -import static io.microsphere.annotation.processor.util.FieldUtils.findField; -import static io.microsphere.annotation.processor.util.MethodUtils.findMethod; -import static io.microsphere.annotation.processor.util.TypeUtils.ofDeclaredType; -import static java.util.Collections.emptyList; -import static org.junit.jupiter.api.Assertions.assertSame; - -/** - * Abstract {@link Annotation} Processing Test case - * - * @author Mercy - * @since 1.0.0 - */ -@ExtendWith(CompilerInvocationInterceptor.class) -public abstract class AbstractAnnotationProcessingTest { - - protected static final TypeMirror NULL_TYPE_MIRROR = null; - - protected static final TypeMirror[] EMPTY_TYPE_MIRROR_ARRAY = new TypeMirror[0]; - - protected static final TypeMirror[] NULL_TYPE_MIRROR_ARRAY = null; - - protected static final Collection[] EMPTY_COLLECTION_ARRAY = new Collection[0]; - - protected static final Collection NULL_COLLECTION = null; - - protected static final List NULL_LIST = null; - - protected static final Element NULL_ELEMENT = null; - - protected static final ElementKind NULL_ELEMENT_KIND = null; - - protected static final Element[] EMPTY_ELEMENT_ARRAY = new Element[0]; - - protected static final Element[] NULL_ELEMENT_ARRAY = null; - - protected static final TypeElement NULL_TYPE_ELEMENT = null; - - protected static final Type[] NULL_TYPE_ARRAY = null; - - protected static final Type[] EMPTY_TYPE_ARRAY = new Type[0]; - - protected static final Type NULL_TYPE = null; - - protected static final ProcessingEnvironment NULL_PROCESSING_ENVIRONMENT = null; - - protected static final String NULL_STRING = null; - - protected static final String[] NULL_STRING_ARRAY = null; - - protected static final Class NULL_CLASS = null; - - protected static final Class[] NULL_CLASS_ARRAY = null; - - protected static final AnnotatedConstruct NULL_ANNOTATED_CONSTRUCT = null; - - protected static final Predicate[] NULL_PREDICATE_ARRAY = null; - - protected static final VariableElement NULL_FIELD = null; - - protected static final Modifier NULL_MODIFIER = null; - - protected static final Modifier[] NULL_MODIFIER_ARRAY = null; - - protected static final ExecutableElement NULL_METHOD = null; - - protected static final ExecutableElement[] NULL_METHOD_ARRAY = null; - - protected static final AnnotationMirror NULL_ANNOTATION_MIRROR = null; - - static ThreadLocal testInstanceHolder = new ThreadLocal<>(); - - protected RoundEnvironment roundEnv; - - protected ProcessingEnvironment processingEnv; - - protected Elements elements; - - protected Types types; - - protected Class testClass; - - protected String testClassName; - - protected TypeElement testTypeElement; - - protected TypeMirror testTypeMirror; - - protected DeclaredType testDeclaredType; - - @BeforeEach - final void setUp() { - testInstanceHolder.set(this); - } - - @AfterEach - final void tearDown() { - testInstanceHolder.remove(); - } - - protected void addCompiledClasses(Set> compiledClasses) { - } - - protected void beforeTest() { - this.testClass = TestServiceImpl.class; - this.testClassName = TestServiceImpl.class.getName(); - this.testTypeElement = getTypeElement(testClass); - this.testTypeMirror = this.testTypeElement.asType(); - this.testDeclaredType = ofDeclaredType(this.testTypeElement); - } - - protected void afterTest() { - } - - protected List getTypeMirrors(Type... types) { - return TypeUtils.getTypeMirrors(processingEnv, types); - } - - protected TypeMirror getTypeMirror(Type type) { - return TypeUtils.getTypeMirror(processingEnv, type); - } - - protected List getTypeElements(Type... types) { - return TypeUtils.getTypeElements(processingEnv, types); - } - - protected TypeElement getTypeElement(Type type) { - return TypeUtils.getTypeElement(processingEnv, type); - } - - protected VariableElement getField(Type type, String fieldName) { - TypeElement typeElement = getTypeElement(type); - return findField(typeElement, fieldName); - } - - protected ExecutableElement getMethod(Type type, String methodName, Type... parameterTypes) { - TypeElement typeElement = getTypeElement(type); - return findMethod(typeElement, methodName, parameterTypes); - } - - protected ExecutableElement getConstructor(Type type, Type... parameterTypes) { - TypeElement typeElement = getTypeElement(type); - return findConstructor(typeElement, parameterTypes); - } - - protected Element[] getElements(Type... types) { - return getTypeMirrors(types).stream().map(TypeUtils::ofTypeElement).toArray(Element[]::new); - } - - protected DeclaredType getDeclaredType(Type type) { - return TypeUtils.getDeclaredType(processingEnv, type); - } - - protected void assertEmptyList(List list) { - assertSame(emptyList(), list); - } - -} diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/AnnotationProcessingTestProcessor.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/AnnotationProcessingTestProcessor.java deleted file mode 100644 index 68e28ccd0..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/AnnotationProcessingTestProcessor.java +++ /dev/null @@ -1,86 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor; - -import org.junit.jupiter.api.extension.ExtensionContext; -import org.junit.jupiter.api.extension.InvocationInterceptor; -import org.junit.jupiter.api.extension.ReflectiveInvocationContext; - -import javax.annotation.processing.AbstractProcessor; -import javax.annotation.processing.RoundEnvironment; -import javax.annotation.processing.SupportedAnnotationTypes; -import javax.lang.model.SourceVersion; -import javax.lang.model.element.TypeElement; -import java.lang.reflect.Method; -import java.util.Set; - -import static io.microsphere.constants.SymbolConstants.WILDCARD; -import static javax.lang.model.SourceVersion.latestSupported; - -/** - * {@link AnnotationProcessingTestProcessor} - * - * @author Mercy - * @since 1.0.0 - */ -@SupportedAnnotationTypes(WILDCARD) -public class AnnotationProcessingTestProcessor extends AbstractProcessor { - - private final AbstractAnnotationProcessingTest abstractAnnotationProcessingTest; - private final InvocationInterceptor.Invocation invocation; - - private final ReflectiveInvocationContext invocationContext; - - private final ExtensionContext extensionContext; - - public AnnotationProcessingTestProcessor(AbstractAnnotationProcessingTest abstractAnnotationProcessingTest, InvocationInterceptor.Invocation invocation, - ReflectiveInvocationContext invocationContext, - ExtensionContext extensionContext) { - this.abstractAnnotationProcessingTest = abstractAnnotationProcessingTest; - this.invocation = invocation; - this.invocationContext = invocationContext; - this.extensionContext = extensionContext; - } - - @Override - public boolean process(Set annotations, RoundEnvironment roundEnv) { - if (!roundEnv.processingOver()) { - prepare(roundEnv); - abstractAnnotationProcessingTest.beforeTest(); - try { - invocation.proceed(); - } catch (Throwable throwable) { - throw new RuntimeException(throwable); - } finally { - abstractAnnotationProcessingTest.afterTest(); - } - } - return false; - } - - protected void prepare(RoundEnvironment roundEnv) { - abstractAnnotationProcessingTest.roundEnv = roundEnv; - abstractAnnotationProcessingTest.processingEnv = super.processingEnv; - abstractAnnotationProcessingTest.elements = super.processingEnv.getElementUtils(); - abstractAnnotationProcessingTest.types = super.processingEnv.getTypeUtils(); - } - - @Override - public SourceVersion getSupportedSourceVersion() { - return latestSupported(); - } -} \ No newline at end of file diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/Compiler.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/Compiler.java deleted file mode 100644 index b8545abbc..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/Compiler.java +++ /dev/null @@ -1,214 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor; - -import io.microsphere.logging.Logger; - -import javax.annotation.processing.Processor; -import javax.tools.JavaCompiler; -import javax.tools.JavaCompiler.CompilationTask; -import javax.tools.JavaFileObject; -import javax.tools.StandardJavaFileManager; -import java.io.File; -import java.io.IOException; -import java.net.URL; -import java.util.LinkedHashSet; -import java.util.List; -import java.util.Set; - -import static io.microsphere.collection.CollectionUtils.addAll; -import static io.microsphere.collection.CollectionUtils.first; -import static io.microsphere.collection.ListUtils.newArrayList; -import static io.microsphere.collection.Lists.ofList; -import static io.microsphere.collection.SetUtils.newLinkedHashSet; -import static io.microsphere.constants.FileConstants.JAVA_EXTENSION; -import static io.microsphere.constants.ProtocolConstants.FILE_PROTOCOL; -import static io.microsphere.constants.SymbolConstants.DOT_CHAR; -import static io.microsphere.io.scanner.SimpleFileScanner.INSTANCE; -import static io.microsphere.logging.LoggerFactory.getLogger; -import static io.microsphere.util.ClassUtils.getTypeName; -import static io.microsphere.util.StringUtils.substringBefore; -import static java.io.File.separatorChar; -import static java.util.Collections.singleton; -import static javax.tools.StandardLocation.CLASS_OUTPUT; -import static javax.tools.StandardLocation.SOURCE_OUTPUT; -import static javax.tools.StandardLocation.SOURCE_PATH; -import static javax.tools.ToolProvider.getSystemJavaCompiler; - -/** - * The Java Compiler - * - * @author Mercy - * @since 1.0.0 - */ -public class Compiler { - - private static final Logger logger = getLogger(Compiler.class); - - private final Set sourcePaths; - - private final JavaCompiler javaCompiler; - - private final StandardJavaFileManager javaFileManager; - - private final Set processors = new LinkedHashSet<>(); - - public Compiler() throws IOException { - this(defaultTargetDirectory()); - } - - public Compiler(File targetDirectory) throws IOException { - this(defaultSourceDirectory(), targetDirectory); - } - - public Compiler(File defaultSourceDirectory, File targetDirectory) throws IOException { - this.sourcePaths = newLinkedHashSet(defaultSourceDirectory); - this.javaCompiler = getSystemJavaCompiler(); - this.javaFileManager = javaCompiler.getStandardFileManager(null, null, null); - this.javaFileManager.setLocation(SOURCE_PATH, sourcePaths); - this.javaFileManager.setLocation(CLASS_OUTPUT, singleton(targetDirectory)); - this.javaFileManager.setLocation(SOURCE_OUTPUT, singleton(targetDirectory)); - } - - static File defaultSourceDirectory() { - return detectSourcePath(Compiler.class); - } - - static File defaultRootDirectory() { - return detectRootDirectory(Compiler.class); - } - - static File defaultTargetDirectory() { - File dir = new File(defaultRootDirectory(), "target/generated-classes"); - dir.mkdirs(); - return dir; - } - - static File detectSourcePath(Class sourceClass) { - File rootDirectory = detectRootDirectory(sourceClass); - String javaSourceFileRelativePath = resolveJavaSourceFileRelativePath(sourceClass); - - Set sourceFiles = INSTANCE.scan(rootDirectory, true, - file -> file.getAbsolutePath().endsWith(javaSourceFileRelativePath)); - if (sourceFiles.isEmpty()) { - if (logger.isTraceEnabled()) { - logger.trace("The source files of class[name : '{}'] can't be found in the root directory[path :'{}']", - getTypeName(sourceClass), rootDirectory.getAbsolutePath()); - } - return null; - } - - File sourceFile = first(sourceFiles); - String javaSourceFilePath = sourceFile.getAbsolutePath(); - String javaSourcePath = substringBefore(javaSourceFilePath, javaSourceFileRelativePath); - File sourcePath = new File(javaSourcePath); - - if (logger.isTraceEnabled()) { - logger.trace("The source file[path : '{}] of class[name : '{}'] was found in the source directory[path :'{}']", - sourceFile.getAbsolutePath(), getTypeName(sourceClass), sourcePath.getAbsolutePath()); - } - - return sourcePath.exists() ? sourcePath : null; - } - - static File detectRootDirectory(Class sourceClass) { - File classPath = detectClassPath(sourceClass); - // classPath : "${rootDirectory}/target/classes" - File rootDirectory = classPath.getParentFile().getParentFile(); - if (logger.isTraceEnabled()) { - logger.trace("The root directory[path : '{}'] was found by the source class[name : '{}']", - rootDirectory.getAbsolutePath(), getTypeName(sourceClass)); - } - return rootDirectory; - } - - static File detectClassPath(Class sourceClass) { - URL classFileURL = sourceClass.getProtectionDomain().getCodeSource().getLocation(); - if (FILE_PROTOCOL.equals(classFileURL.getProtocol())) { - return new File(classFileURL.getPath()); - } else { - throw new RuntimeException("No support"); - } - } - - static String resolveJavaSourceFileRelativePath(Class sourceClass) { - return sourceClass.getName().replace(DOT_CHAR, separatorChar).concat(JAVA_EXTENSION); - } - - public Compiler sourcePaths(File... sourcePaths) { - addAll(this.sourcePaths, sourcePaths); - return this; - } - - public Compiler sourcePaths(Iterable> sourceClasses) { - for (Class sourceClass : sourceClasses) { - sourcePath(sourceClass); - } - return this; - } - - public Compiler sourcePath(Class sourceClass) { - File sourcePath = detectSourcePath(sourceClass); - if (sourcePath != null) { - return sourcePaths(sourcePath); - } - return this; - } - - public Compiler processors(Processor... processors) { - addAll(this.processors, processors); - return this; - } - - private Iterable getJavaFileObjects(Class... sourceClasses) { - int size = sourceClasses == null ? 0 : sourceClasses.length; - List javaSourceFiles = newArrayList(size); - for (int i = 0; i < size; i++) { - File javaSourceFile = searchJavaSourceFile(sourceClasses[i]); - if (javaSourceFile != null) { - javaSourceFiles.add(javaSourceFile); - } - } - return javaFileManager.getJavaFileObjects(javaSourceFiles.toArray(new File[0])); - } - - private File searchJavaSourceFile(Class sourceClass) { - String javaSourceFilePath = resolveJavaSourceFileRelativePath(sourceClass); - for (File sourceDirectory : sourcePaths) { - File javaSourceFile = new File(sourceDirectory, javaSourceFilePath); - if (javaSourceFile.exists()) { - return javaSourceFile; - } - } - return null; - } - - public boolean compile(Class... sourceClasses) { - CompilationTask task = javaCompiler.getTask(null, this.javaFileManager, null, - ofList("-parameters", "-Xlint:unchecked", "-nowarn", "-Xlint:deprecation"), -// null, - null, getJavaFileObjects(sourceClasses)); - if (!processors.isEmpty()) { - task.setProcessors(processors); - } - return task.call(); - } - - public JavaCompiler getJavaCompiler() { - return javaCompiler; - } -} diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/CompilerInvocationInterceptor.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/CompilerInvocationInterceptor.java deleted file mode 100644 index 966e6defa..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/CompilerInvocationInterceptor.java +++ /dev/null @@ -1,57 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor; - -import org.junit.jupiter.api.extension.ExtensionContext; -import org.junit.jupiter.api.extension.InvocationInterceptor; -import org.junit.jupiter.api.extension.ReflectiveInvocationContext; - -import javax.annotation.processing.Processor; -import java.lang.reflect.Method; -import java.util.LinkedHashSet; -import java.util.LinkedList; -import java.util.List; -import java.util.Set; - -import static io.microsphere.annotation.processor.AbstractAnnotationProcessingTest.testInstanceHolder; -import static io.microsphere.util.ServiceLoaderUtils.loadServicesList; - - -/** - * {@link InvocationInterceptor} based on Java {@link Compiler} - * - * @author Mercy - * @since 1.0.0 - */ -public class CompilerInvocationInterceptor implements InvocationInterceptor { - - @Override - public void interceptTestMethod(Invocation invocation, - ReflectiveInvocationContext invocationContext, - ExtensionContext extensionContext) throws Throwable { - Set> compiledClasses = new LinkedHashSet<>(); - AbstractAnnotationProcessingTest abstractAnnotationProcessingTest = testInstanceHolder.get(); - compiledClasses.add(getClass()); - abstractAnnotationProcessingTest.addCompiledClasses(compiledClasses); - Compiler compiler = new Compiler(); - compiler.sourcePaths(compiledClasses); - List processors = new LinkedList<>(loadServicesList(Processor.class, this.getClass().getClassLoader())); - processors.add(new AnnotationProcessingTestProcessor(abstractAnnotationProcessingTest, invocation, invocationContext, extensionContext)); - compiler.processors(processors.toArray(new Processor[0])); - compiler.compile(compiledClasses.toArray(new Class[0])); - } -} diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/DefaultTestService.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/DefaultTestService.java deleted file mode 100644 index 7e643daab..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/DefaultTestService.java +++ /dev/null @@ -1,58 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor; - - -import io.microsphere.annotation.processor.model.Model; - -import java.util.concurrent.TimeUnit; - -/** - * {@link TestService} Implementation - * - * @author Mercy - * @since 1.0.0 - */ -public class DefaultTestService implements TestService { - - private String name; - - @Override - public String echo(String message) { - return "[ECHO] " + message; - } - - @Override - public Model model(Model model) { - return model; - } - - @Override - public String testPrimitive(boolean z, int i) { - return null; - } - - @Override - public Model testEnum(TimeUnit timeUnit) { - return null; - } - - @Override - public String testArray(String[] strArray, int[] intArray, Model[] modelArray) { - return null; - } -} diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/GenericTestService.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/GenericTestService.java deleted file mode 100644 index 449b73611..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/GenericTestService.java +++ /dev/null @@ -1,33 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor; - - -import java.util.EventListener; - -/** - * {@link TestService} Implementation - * - * @author Mercy - * @since 1.0.0 - */ -public class GenericTestService extends DefaultTestService implements TestService, EventListener { - @Override - public String echo(String message) { - return "[ECHO] " + message; - } -} diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/TestAnnotation.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/TestAnnotation.java deleted file mode 100644 index 4d35d6f82..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/TestAnnotation.java +++ /dev/null @@ -1,73 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package io.microsphere.annotation.processor; - -import io.microsphere.annotation.ConfigurationProperty; -import io.microsphere.annotation.Since; - -import java.lang.annotation.Annotation; -import java.lang.annotation.Documented; -import java.lang.annotation.Retention; -import java.lang.annotation.Target; -import java.util.concurrent.TimeUnit; - -import static java.lang.annotation.ElementType.TYPE; -import static java.lang.annotation.RetentionPolicy.RUNTIME; -import static java.util.concurrent.TimeUnit.DAYS; - -/** - * The {@link Annotation} for testing - * - * @author Mercy - * @see Annotation - * @since 1.0.0 - */ -@Retention(RUNTIME) -@Target(TYPE) -@Documented -public @interface TestAnnotation { - - boolean z() default false; - - char c() default 'a'; - - byte b() default 1; - - short s() default 2; - - int i() default 3; - - long l() default 4L; - - float f() default 5.0f; - - double d() default 6.0d; - - String string() default "string"; - - Class type() default String.class; - - Class[] types() default {String.class, Integer.class}; - - TimeUnit timeUnit() default DAYS; - - Since since(); - - ConfigurationProperty[] properties() default {}; - -} diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/TestService.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/TestService.java deleted file mode 100644 index 860748c13..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/TestService.java +++ /dev/null @@ -1,55 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor; - -import io.microsphere.annotation.processor.model.Model; - -import javax.ws.rs.DefaultValue; -import javax.ws.rs.GET; -import javax.ws.rs.POST; -import javax.ws.rs.PUT; -import javax.ws.rs.Path; -import javax.ws.rs.PathParam; -import java.util.concurrent.TimeUnit; - -/** - * Test Service - * - * @author Mercy - * @since 1.0.0 - */ -@Path("/echo") -public interface TestService { - - @GET - String echo(@PathParam("message") @DefaultValue("mercyblitz") String message); - - @POST - Model model(@PathParam("model") Model model); - - // Test primitive - @PUT - String testPrimitive(boolean z, int i); - - // Test enumeration - @PUT - Model testEnum(TimeUnit timeUnit); - - // Test Array - @GET - String testArray(String[] strArray, int[] intArray, Model[] modelArray); -} diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/TestServiceImpl.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/TestServiceImpl.java deleted file mode 100644 index e587e888e..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/TestServiceImpl.java +++ /dev/null @@ -1,100 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor; - -import io.microsphere.annotation.ConfigurationProperty; -import io.microsphere.annotation.Since; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.cache.annotation.Cacheable; -import org.springframework.context.ApplicationContext; -import org.springframework.context.annotation.ComponentScan; -import org.springframework.context.annotation.ComponentScans; -import org.springframework.core.env.Environment; -import org.springframework.stereotype.Service; - -import javax.xml.ws.ServiceMode; -import java.io.Serializable; - -import static java.util.concurrent.TimeUnit.HOURS; -import static org.springframework.context.annotation.FilterType.ASPECTJ; -import static org.springframework.context.annotation.ScopedProxyMode.INTERFACES; - -/** - * @author Mercy - * @since 1.0.0 - */ -@Service("testService") -@ServiceMode -@ComponentScans(value = { - @ComponentScan( - basePackages = "io.microsphere.annotation.processor.model", - scopedProxy = INTERFACES - ), - @ComponentScan( - basePackages = "io.microsphere.annotation.processor.util", - includeFilters = { - @ComponentScan.Filter( - type = ASPECTJ, - classes = {Object.class, CharSequence.class} - ) - }) -}) -@TestAnnotation( - z = true, - c = 'b', - b = 1, - s = 1, - i = 1, - l = 1, - f = 1, - d = 1, - string = "testService", - type = GenericTestService.class, - types = {TestService.class, AutoCloseable.class, Serializable.class}, - timeUnit = HOURS, - since = @Since("1.0.0"), - properties = { - @ConfigurationProperty(name = "key", type = String.class, defaultValue = "default-value", required = true, description = "description"), - @ConfigurationProperty(name = "key2", type = Integer.class, defaultValue = "default-value2", required = true, description = "description2"), - @ConfigurationProperty(name = "key3", type = Class.class, defaultValue = "default-value3", required = true, description = "description3") - } -) -public class TestServiceImpl extends GenericTestService implements TestService, AutoCloseable, Serializable { - - @Autowired - private ApplicationContext context; - - private Environment environment; - - public TestServiceImpl() { - this(null); - } - - public TestServiceImpl(@Autowired Environment environment) { - this.environment = environment; - } - - @Override - @Cacheable(cacheNames = {"cache-1", "cache-2"}) - public String echo(String message) { - return "[ECHO] " + message; - } - - @Override - public void close() throws Exception { - } -} diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/Ancestor.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/Ancestor.java deleted file mode 100644 index 9a749d056..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/Ancestor.java +++ /dev/null @@ -1,35 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor.model; - -import java.io.Serializable; - -/** - * Ancestor - */ -public class Ancestor implements Serializable { - - private boolean z; - - public boolean isZ() { - return z; - } - - public void setZ(boolean z) { - this.z = z; - } -} diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/ArrayTypeModel.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/ArrayTypeModel.java deleted file mode 100644 index fc6c057f3..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/ArrayTypeModel.java +++ /dev/null @@ -1,36 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor.model; - -/** - * Array Type Model - * - * @since 1.0.0 - */ -public class ArrayTypeModel { - - private int[] integers; // Primitive type array - - private String[] strings; // Simple type array - - private PrimitiveTypeModel[] primitiveTypeModels; // Complex type array - - private Model[] models; // Hierarchical Complex type array - - private Color[] colors; // Enum type array - -} diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/CollectionTypeModel.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/CollectionTypeModel.java deleted file mode 100644 index 3f5426361..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/CollectionTypeModel.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor.model; - -import java.util.Collection; -import java.util.Deque; -import java.util.List; -import java.util.Queue; -import java.util.Set; - -/** - * {@link Collection} Type Model - * - * @since 1.0.0 - */ -public class CollectionTypeModel { - - private Collection strings; // The composite element is simple type - - private List colors; // The composite element is Enum type - - private Queue primitiveTypeModels; // The composite element is POJO type - - private Deque models; // The composite element is hierarchical POJO type - - private Set modelArrays; // The composite element is hierarchical POJO type - -} diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/Color.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/Color.java deleted file mode 100644 index 177dfaffc..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/Color.java +++ /dev/null @@ -1,46 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor.model; - -/** - * Color enumeration - * - * @since 1.0.0 - */ -public enum Color { - - RED(1), - YELLOW(2), - BLUE(3); - - private final int value; - - Color(int value) { - this.value = value; - } - - @Override - public String toString() { - return "Color{" + - "value=" + value + - "} " + super.toString(); - } - - public int getValue() { - return value; - } -} diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/ConfigurationPropertyModel.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/ConfigurationPropertyModel.java deleted file mode 100644 index 9a6505460..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/ConfigurationPropertyModel.java +++ /dev/null @@ -1,47 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package io.microsphere.annotation.processor.model; - -import io.microsphere.annotation.ConfigurationProperty; - -/** - * {@link ConfigurationProperty} Model - * - * @author Mercy - * @see ConfigurationProperty - * @since 1.0.0 - */ -public class ConfigurationPropertyModel { - - @ConfigurationProperty(name = "microsphere.annotation.processor.model.name") - private String name; - - @ConfigurationProperty(name = "microsphere.annotation.processor.model.type") - private Class type; - - @ConfigurationProperty(name = "microsphere.annotation.processor.model.default-value") - private String defaultValue; - - @ConfigurationProperty(name = "microsphere.annotation.processor.model.required") - private boolean required; - - @ConfigurationProperty(name = "microsphere.annotation.processor.model.description") - private String description; - - -} diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/MapTypeModel.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/MapTypeModel.java deleted file mode 100644 index 3c9fc58c4..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/MapTypeModel.java +++ /dev/null @@ -1,41 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor.model; - -import java.util.HashMap; -import java.util.Map; -import java.util.NavigableMap; -import java.util.SortedMap; -import java.util.TreeMap; - -/** - * {@link Map} Type model - * - * @since 1.0.0 - */ -public class MapTypeModel { - - private Map strings; // The composite element is simple type - - private SortedMap colors; // The composite element is Enum type - - private NavigableMap primitiveTypeModels; // The composite element is POJO type - - private HashMap models; // The composite element is hierarchical POJO type - - private TreeMap modelArrays; // The composite element is hierarchical POJO type -} diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/Model.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/Model.java deleted file mode 100644 index 08348e513..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/Model.java +++ /dev/null @@ -1,87 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor.model; - -import java.math.BigDecimal; -import java.math.BigInteger; -import java.util.concurrent.TimeUnit; - -/** - * Model Object - */ -public class Model extends Parent { - - private float f; - - private double d; - - private TimeUnit tu; - - private String str; - - private BigInteger bi; - - private BigDecimal bd; - - public float getF() { - return f; - } - - public void setF(float f) { - this.f = f; - } - - public double getD() { - return d; - } - - public void setD(double d) { - this.d = d; - } - - public TimeUnit getTu() { - return tu; - } - - public void setTu(TimeUnit tu) { - this.tu = tu; - } - - public String getStr() { - return str; - } - - public void setStr(String str) { - this.str = str; - } - - public BigInteger getBi() { - return bi; - } - - public void setBi(BigInteger bi) { - this.bi = bi; - } - - public BigDecimal getBd() { - return bd; - } - - public void setBd(BigDecimal bd) { - this.bd = bd; - } -} diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/Parent.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/Parent.java deleted file mode 100644 index b124fb814..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/Parent.java +++ /dev/null @@ -1,63 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor.model; - -/** - * Parent - */ -public class Parent extends Ancestor { - - private byte b; - - private short s; - - private int i; - - private long l; - - public byte getB() { - return b; - } - - public void setB(byte b) { - this.b = b; - } - - public short getS() { - return s; - } - - public void setS(short s) { - this.s = s; - } - - public int getI() { - return i; - } - - public void setI(int i) { - this.i = i; - } - - public long getL() { - return l; - } - - public void setL(long l) { - this.l = l; - } -} diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/PrimitiveTypeModel.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/PrimitiveTypeModel.java deleted file mode 100644 index 2bbe5372b..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/PrimitiveTypeModel.java +++ /dev/null @@ -1,73 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor.model; - -/** - * Primitive Type model - * - * @since 1.0.0 - */ -public class PrimitiveTypeModel { - - private boolean z; - - private byte b; - - private char c; - - private short s; - - private int i; - - private long l; - - private float f; - - private double d; - - public boolean isZ() { - return z; - } - - public byte getB() { - return b; - } - - public char getC() { - return c; - } - - public short getS() { - return s; - } - - public int getI() { - return i; - } - - public long getL() { - return l; - } - - public float getF() { - return f; - } - - public double getD() { - return d; - } -} diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/SimpleTypeModel.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/SimpleTypeModel.java deleted file mode 100644 index 4522d5554..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/SimpleTypeModel.java +++ /dev/null @@ -1,161 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License; Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing; software - * distributed under the License is distributed on an "AS IS" BASIS; - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND; either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor.model; - -import java.math.BigDecimal; -import java.math.BigInteger; -import java.util.Date; - -/** - * Simple Type model - * - * @since 1.0.0 - */ -public class SimpleTypeModel { - - private Void v; - - private Boolean z; - - private Character c; - - private Byte b; - - private Short s; - - private Integer i; - - private Long l; - - private Float f; - - private Double d; - - private String str; - - private BigDecimal bd; - - private BigInteger bi; - - private Date dt; - - private int invalid; - - public Void getV() { - return v; - } - - public void setV(Void v) { - this.v = v; - } - - public Boolean getZ() { - return z; - } - - public void setZ(Boolean z) { - this.z = z; - } - - public Character getC() { - return c; - } - - public void setC(Character c) { - this.c = c; - } - - public Byte getB() { - return b; - } - - public void setB(Byte b) { - this.b = b; - } - - public Short getS() { - return s; - } - - public void setS(Short s) { - this.s = s; - } - - public Integer getI() { - return i; - } - - public void setI(Integer i) { - this.i = i; - } - - public Long getL() { - return l; - } - - public void setL(Long l) { - this.l = l; - } - - public Float getF() { - return f; - } - - public void setF(Float f) { - this.f = f; - } - - public Double getD() { - return d; - } - - public void setD(Double d) { - this.d = d; - } - - public String getStr() { - return str; - } - - public void setStr(String str) { - this.str = str; - } - - public BigDecimal getBd() { - return bd; - } - - public void setBd(BigDecimal bd) { - this.bd = bd; - } - - public BigInteger getBi() { - return bi; - } - - public void setBi(BigInteger bi) { - this.bi = bi; - } - - public Date getDt() { - return dt; - } - - public void setDt(Date dt) { - this.dt = dt; - } -} diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/StringArrayList.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/StringArrayList.java deleted file mode 100644 index f59710d58..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/StringArrayList.java +++ /dev/null @@ -1,30 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package io.microsphere.annotation.processor.model; - -import java.util.ArrayList; - -/** - * String type {@link ArrayList} - * - * @author Mercy - * @see ArrayList - * @since 1.0.0 - */ -public class StringArrayList extends ArrayList { -} diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/element/StringAnnotationValueTest.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/element/StringAnnotationValueTest.java deleted file mode 100644 index 6e96fb50a..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/element/StringAnnotationValueTest.java +++ /dev/null @@ -1,53 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package io.microsphere.annotation.processor.model.element; - - -import io.microsphere.annotation.processor.model.util.ResolvableAnnotationValueVisitor; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * {@link StringAnnotationValue} Test - * - * @author Mercy - * @see StringAnnotationValue - * @since 1.0.0 - */ -class StringAnnotationValueTest { - - private StringAnnotationValue value; - - @BeforeEach - void setUp() { - this.value = new StringAnnotationValue("testing"); - } - - @Test - void testGetValue() { - assertEquals("testing", value.getValue()); - } - - @Test - void testAccept() { - ResolvableAnnotationValueVisitor visitor = new ResolvableAnnotationValueVisitor(); - assertEquals("testing", value.accept(visitor, null)); - } -} \ No newline at end of file diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/util/JSONAnnotationValueVisitorTest.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/util/JSONAnnotationValueVisitorTest.java deleted file mode 100644 index 094b1460c..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/util/JSONAnnotationValueVisitorTest.java +++ /dev/null @@ -1,133 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package io.microsphere.annotation.processor.model.util; - - -import io.microsphere.annotation.processor.AbstractAnnotationProcessingTest; -import io.microsphere.annotation.processor.TestAnnotation; -import org.junit.jupiter.api.Test; - -import javax.lang.model.element.AnnotationValue; -import javax.lang.model.element.ExecutableElement; -import java.util.Map; - -import static io.microsphere.annotation.processor.util.AnnotationUtils.getElementValue; -import static io.microsphere.annotation.processor.util.AnnotationUtils.getElementValues; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertSame; - -/** - * {@link JSONAnnotationValueVisitor} Test - * - * @author Mercy - * @see JSONAnnotationValueVisitor - * @since 1.0.0 - */ -class JSONAnnotationValueVisitorTest extends AbstractAnnotationProcessingTest { - - private StringBuilder jsonBuilder; - - private JSONAnnotationValueVisitor visitor; - - private Map testAnnotationAttributes; - - protected void beforeTest() { - super.beforeTest(); - this.jsonBuilder = new StringBuilder(); - this.visitor = new JSONAnnotationValueVisitor(jsonBuilder); - this.testAnnotationAttributes = getElementValues(testTypeElement, TestAnnotation.class); - } - - @Test - void testVisitBoolean() { - testVisit("z", "\"z\":true"); - } - - @Test - void testVisitByte() { - testVisit("b", "\"b\":1"); - } - - @Test - void testVisitChar() { - testVisit("c", "\"c\":\"b\""); - } - - @Test - void testVisitDouble() { - testVisit("d", "\"d\":1.0"); - } - - @Test - void testVisitFloat() { - testVisit("f", "\"f\":1.0"); - } - - @Test - void testVisitInt() { - testVisit("i", "\"i\":1"); - } - - @Test - void testVisitLong() { - testVisit("l", "\"l\":1"); - } - - @Test - void testVisitShort() { - testVisit("s", "\"s\":1"); - } - - @Test - void testVisitString() { - testVisit("string", "\"string\":\"testService\""); - } - - @Test - void testVisitType() { - testVisit("type", "\"type\":\"io.microsphere.annotation.processor.GenericTestService\""); - } - - @Test - void testVisitEnumConstant() { - testVisit("timeUnit", "\"timeUnit\":\"HOURS\""); - } - - @Test - void testVisitAnnotation() { - testVisit("since", "\"since\":{\"module\":\"\",\"value\":\"1.0.0\"}"); - } - - @Test - void testVisitArray() { - testVisit("properties", "\"properties\":[{\"name\":\"key\",\"type\":\"java.lang.String\",\"defaultValue\":\"default-value\",\"required\":true,\"description\":\"description\",\"source\":[]},{\"name\":\"key2\",\"type\":\"java.lang.Integer\",\"defaultValue\":\"default-value2\",\"required\":true,\"description\":\"description2\",\"source\":[]},{\"name\":\"key3\",\"type\":\"java.lang.Class\",\"defaultValue\":\"default-value3\",\"required\":true,\"description\":\"description3\",\"source\":[]}]"); - } - - @Test - void testVisitUnknown() { - assertSame(this.jsonBuilder, visitor.visitUnknown(null, null)); - } - - void testVisit(String attributeName, String expectedJson) { - Map.Entry elementValue = getElementValue(this.testAnnotationAttributes, attributeName); - ExecutableElement attributeMethod = elementValue.getKey(); - AnnotationValue annotationValue = elementValue.getValue(); - StringBuilder jsonBuilder = visitor.visit(annotationValue, attributeMethod); - assertEquals(expectedJson, jsonBuilder.toString()); - } -} \ No newline at end of file diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/util/JSONElementVisitorTest.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/util/JSONElementVisitorTest.java deleted file mode 100644 index 81a9a5adf..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/util/JSONElementVisitorTest.java +++ /dev/null @@ -1,254 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package io.microsphere.annotation.processor.model.util; - - -import io.microsphere.annotation.processor.AbstractAnnotationProcessingTest; -import io.microsphere.annotation.processor.TestAnnotation; -import io.microsphere.annotation.processor.model.Color; -import io.microsphere.annotation.processor.model.StringArrayList; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.PackageElement; -import javax.lang.model.element.TypeElement; -import javax.lang.model.element.TypeParameterElement; -import javax.lang.model.element.VariableElement; -import javax.lang.model.type.TypeMirror; -import java.io.Serializable; -import java.util.List; - -import static io.microsphere.annotation.processor.util.TypeUtils.ofTypeElement; -import static java.lang.Boolean.TRUE; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertTrue; - -/** - * {@link JSONElementVisitor} Test - * - * @author Mercy - * @see JSONElementVisitor - * @since 1.0.0 - */ -class JSONElementVisitorTest extends AbstractAnnotationProcessingTest { - - private boolean supported; - - private StringBuilder jsonBuilder; - - private JSONElementVisitor visitor; - - - @BeforeEach - void setUp() { - this.supported = true; - this.jsonBuilder = new StringBuilder(); - this.visitor = new JSONElementVisitor() { - - @Override - protected boolean supports(Element e) { - super.supports(e); - return supported; - } - - @Override - protected boolean doVisitPackage(PackageElement e, StringBuilder jsonBuilder) { - super.doVisitPackage(e, jsonBuilder); - jsonBuilder.append("visitPackage"); - return TRUE; - } - - @Override - protected boolean doVisitTypeParameter(TypeParameterElement e, StringBuilder jsonBuilder) { - super.doVisitTypeParameter(e, jsonBuilder); - jsonBuilder.append("visitTypeParameter"); - return TRUE; - } - - @Override - public Boolean visitVariableAsEnumConstant(VariableElement e, StringBuilder stringBuilder) { - jsonBuilder.append("visitVariableAsEnumConstant"); - return TRUE; - } - - @Override - public Boolean visitVariableAsField(VariableElement e, StringBuilder stringBuilder) { - jsonBuilder.append("visitVariableAsField"); - return TRUE; - } - - @Override - public Boolean visitVariableAsParameter(VariableElement e, StringBuilder stringBuilder) { - jsonBuilder.append("visitVariableAsParameter"); - return TRUE; - } - - @Override - public Boolean visitExecutableAsConstructor(ExecutableElement e, StringBuilder stringBuilder) { - jsonBuilder.append("visitExecutableAsConstructor"); - return TRUE; - } - - @Override - public Boolean visitExecutableAsMethod(ExecutableElement e, StringBuilder stringBuilder) { - jsonBuilder.append("visitExecutableAsMethod"); - return TRUE; - } - - @Override - public Boolean visitTypeAsInterface(TypeElement e, StringBuilder stringBuilder) { - jsonBuilder.append("visitTypeAsInterface"); - return TRUE; - } - - @Override - public Boolean visitTypeAsEnum(TypeElement e, StringBuilder stringBuilder) { - jsonBuilder.append("visitTypeAsEnum"); - return TRUE; - } - - @Override - public Boolean visitTypeAsClass(TypeElement e, StringBuilder stringBuilder) { - jsonBuilder.append("visitTypeAsClass"); - return TRUE; - } - - @Override - public Boolean visitTypeAsAnnotationType(TypeElement e, StringBuilder stringBuilder) { - jsonBuilder.append("visitTypeAsAnnotationType"); - return TRUE; - } - }; - } - - @Test - void testVisitPackage() { - assertTrue(visitor.visitPackage(this.elements.getPackageElement("io.microsphere.annotation.processor.model.util"), jsonBuilder)); - assertJson("visitPackage"); - } - - @Test - void testVisitVariableOnUnsupported() { - supported = false; - assertFalse(visitor.visitVariable(null, jsonBuilder)); - } - - @Test - void testVisitVariableAsEnumConstant() { - VariableElement element = getField(Color.class, "RED"); - assertTrue(visitor.visitVariable(element, jsonBuilder)); - assertJson("visitVariableAsEnumConstant"); - - } - - @Test - void testVisitExecutableAsField() { - VariableElement element = getField(testClass, "context"); - assertTrue(visitor.visitVariable(element, jsonBuilder)); - assertJson("visitVariableAsField"); - } - - @Test - void testVisitVariableAsParameter() { - ExecutableElement method = getMethod(testClass, "echo", String.class); - for (VariableElement parameter : method.getParameters()) { - assertTrue(visitor.visitVariable(parameter, jsonBuilder)); - assertJson("visitVariableAsParameter"); - } - } - - @Test - void testVisitExecutableOnUnsupported() { - supported = false; - assertFalse(visitor.visitExecutable(null, jsonBuilder)); - } - - @Test - void testVisitExecutableAsConstructor() { - ExecutableElement constructor = getConstructor(testClass); - assertTrue(visitor.visitExecutable(constructor, jsonBuilder)); - assertJson("visitExecutableAsConstructor"); - } - - @Test - void testVisitExecutableAsMethod() { - ExecutableElement method = getMethod(testClass, "echo", String.class); - assertTrue(visitor.visitExecutable(method, jsonBuilder)); - assertJson("visitExecutableAsMethod"); - } - - @Test - void testVisitTypeOnUnsupported() { - supported = false; - TypeElement typeElement = getTypeElement(Serializable.class); - assertFalse(visitor.visitType(typeElement, jsonBuilder)); - } - - @Test - void testVisitTypeAsInterface() { - TypeElement typeElement = getTypeElement(Serializable.class); - assertTrue(visitor.visitType(typeElement, jsonBuilder)); - assertJson("visitTypeAsInterface"); - } - - @Test - void testVisitTypeAsEnum() { - TypeElement typeElement = getTypeElement(Color.class); - assertTrue(visitor.visitType(typeElement, jsonBuilder)); - assertTrue(jsonBuilder.toString().startsWith("visitTypeAsEnum")); - } - - @Test - void testVisitTypeAsClass() { - TypeElement typeElement = getTypeElement(testClass); - assertTrue(visitor.visitType(typeElement, jsonBuilder)); - assertTrue(jsonBuilder.toString().startsWith("visitTypeAsClass")); - } - - @Test - void testVisitTypeAsAnnotationType() { - TypeElement typeElement = getTypeElement(TestAnnotation.class); - assertTrue(visitor.visitType(typeElement, jsonBuilder)); - assertTrue(jsonBuilder.toString().startsWith("visitTypeAsAnnotationType")); - } - - @Test - void testVisitTypeParameterOnUnsupported() { - supported = false; - assertFalse(visitor.visitTypeParameter(null, jsonBuilder)); - } - - @Test - void testVisitTypeParameter() { - TypeElement typeElement = getTypeElement(StringArrayList.class); - TypeMirror superclass = typeElement.getSuperclass(); - TypeElement superTypeElement = ofTypeElement(superclass); - List typeParameters = superTypeElement.getTypeParameters(); - for (TypeParameterElement typeParameter : typeParameters) { - assertTrue(visitor.visitTypeParameter(typeParameter, jsonBuilder)); - assertJson("visitTypeParameter"); - } - } - - void assertJson(String expected) { - assertEquals(expected, jsonBuilder.toString()); - } -} \ No newline at end of file diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/util/ResolvableAnnotationValueVisitorTest.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/util/ResolvableAnnotationValueVisitorTest.java deleted file mode 100644 index 0f0ef36d7..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/model/util/ResolvableAnnotationValueVisitorTest.java +++ /dev/null @@ -1,214 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package io.microsphere.annotation.processor.model.util; - -import io.microsphere.annotation.processor.AbstractAnnotationProcessingTest; -import io.microsphere.annotation.processor.GenericTestService; -import io.microsphere.annotation.processor.TestAnnotation; -import io.microsphere.annotation.processor.TestService; -import org.junit.jupiter.api.Test; - -import javax.lang.model.element.AnnotationValue; -import javax.lang.model.element.AnnotationValueVisitor; -import javax.lang.model.element.ExecutableElement; -import java.io.Serializable; -import java.util.LinkedHashMap; -import java.util.Map; -import java.util.Map.Entry; - -import static io.microsphere.annotation.processor.util.AnnotationUtils.getElementValue; -import static io.microsphere.annotation.processor.util.AnnotationUtils.getElementValues; -import static java.util.Objects.deepEquals; -import static java.util.concurrent.TimeUnit.HOURS; -import static java.util.stream.Stream.of; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.junit.jupiter.api.Assertions.assertTrue; - -/** - * {@link ResolvableAnnotationValueVisitor} Test - * - * @author Mercy - * @see ResolvableAnnotationValueVisitor - * @since 1.0.0 - */ -class ResolvableAnnotationValueVisitorTest extends AbstractAnnotationProcessingTest { - - private ResolvableAnnotationValueVisitor visitor; - - private ResolvableAnnotationValueVisitor visitor1; - - private ResolvableAnnotationValueVisitor visitor2; - - static final boolean BOOLEAN_VALUE = true; - - static final byte BYTE_VALUE = 1; - - static final char CHAR_VALUE = 'b'; - - static final double DOUBLE_VALUE = 1.0D; - - static final float FLOAT_VALUE = 1.0F; - - static final int INT_VALUE = 1; - - static final long LONG_VALUE = 1L; - - static final short SHORT_VALUE = 1; - - static final String STRING_VALUE = "testService"; - - static final Class TYPE_VALUE = GenericTestService.class; - - static final Class[] TYPES_VALUE = {TestService.class, AutoCloseable.class, Serializable.class}; - - private Map testAnnotationAttributes; - - protected void beforeTest() { - super.beforeTest(); - this.visitor = new ResolvableAnnotationValueVisitor(); - this.visitor1 = new ResolvableAnnotationValueVisitor(true); - this.visitor2 = new ResolvableAnnotationValueVisitor(true, true); - this.testAnnotationAttributes = getElementValues(testTypeElement, TestAnnotation.class); - } - - @Test - void testVisitBoolean() { - assertEquals(BOOLEAN_VALUE, visitor.visitBoolean(BOOLEAN_VALUE, null)); - assertVisit(this.visitor, "z", BOOLEAN_VALUE); - assertVisit(this.visitor1, "z", BOOLEAN_VALUE); - assertVisit(this.visitor2, "z", BOOLEAN_VALUE); - } - - @Test - void testVisitByte() { - assertEquals(BYTE_VALUE, visitor.visitByte(BYTE_VALUE, null)); - assertVisit(this.visitor, "b", BYTE_VALUE); - assertVisit(this.visitor1, "b", BYTE_VALUE); - assertVisit(this.visitor2, "b", BYTE_VALUE); - } - - @Test - void testVisitChar() { - assertEquals(CHAR_VALUE, visitor.visitChar(CHAR_VALUE, null)); - assertVisit(this.visitor, "c", CHAR_VALUE); - assertVisit(this.visitor1, "c", CHAR_VALUE); - assertVisit(this.visitor2, "c", CHAR_VALUE); - } - - @Test - void testVisitDouble() { - assertEquals(DOUBLE_VALUE, visitor.visitDouble(DOUBLE_VALUE, null)); - assertVisit(this.visitor, "d", DOUBLE_VALUE); - assertVisit(this.visitor1, "d", DOUBLE_VALUE); - assertVisit(this.visitor2, "d", DOUBLE_VALUE); - } - - @Test - void testVisitFloat() { - assertEquals(FLOAT_VALUE, visitor.visitFloat(FLOAT_VALUE, null)); - assertVisit(this.visitor, "f", FLOAT_VALUE); - assertVisit(this.visitor1, "f", FLOAT_VALUE); - assertVisit(this.visitor2, "f", FLOAT_VALUE); - } - - @Test - void testVisitInt() { - assertEquals(INT_VALUE, visitor.visitInt(INT_VALUE, null)); - assertVisit(this.visitor, "i", INT_VALUE); - assertVisit(this.visitor1, "i", INT_VALUE); - assertVisit(this.visitor2, "i", INT_VALUE); - } - - @Test - void testVisitLong() { - assertEquals(LONG_VALUE, visitor.visitLong(LONG_VALUE, null)); - assertVisit(this.visitor, "l", LONG_VALUE); - assertVisit(this.visitor1, "l", LONG_VALUE); - assertVisit(this.visitor2, "l", LONG_VALUE); - } - - @Test - void testVisitShort() { - assertEquals(SHORT_VALUE, visitor.visitShort(SHORT_VALUE, null)); - assertVisit(this.visitor, "s", SHORT_VALUE); - assertVisit(this.visitor1, "s", SHORT_VALUE); - assertVisit(this.visitor2, "s", SHORT_VALUE); - } - - @Test - void testVisitString() { - assertEquals(STRING_VALUE, visitor.visitString(STRING_VALUE, null)); - assertVisit(this.visitor, "string", STRING_VALUE); - assertVisit(this.visitor1, "string", STRING_VALUE); - assertVisit(this.visitor1, "string", STRING_VALUE); - } - - @Test - void testVisitType() { - assertEquals(TYPE_VALUE, visitor.visitType(getTypeMirror(TYPE_VALUE), null)); - assertVisit(this.visitor, "type", TYPE_VALUE); - assertVisit(this.visitor1, "type", TYPE_VALUE.getName()); - assertVisit(this.visitor2, "type", TYPE_VALUE.getName()); - } - - @Test - void testVisitEnumConstant() { - assertVisit(this.visitor, "timeUnit", HOURS); - assertVisit(this.visitor1, "timeUnit", HOURS); - assertVisit(this.visitor2, "timeUnit", HOURS); - } - - @Test - void testVisitAnnotation() { - String attributeName = "since"; - - Map attributesMap = new LinkedHashMap<>(); - attributesMap.put("module", ""); - attributesMap.put("value", "1.0.0"); - - TestAnnotation testAnnotation = testClass.getAnnotation(TestAnnotation.class); - - assertVisit(this.visitor, attributeName, testAnnotation.since()); - assertVisit(this.visitor1, attributeName, testAnnotation.since()); - assertVisit(this.visitor2, attributeName, attributesMap); - } - - @Test - void testVisitArray() { - assertVisit(this.visitor, "types", TYPES_VALUE); - assertVisit(this.visitor1, "types", of(TYPES_VALUE).map(Class::getName).toArray(String[]::new)); - assertVisit(this.visitor2, "types", of(TYPES_VALUE).map(Class::getName).toArray(String[]::new)); - } - - @Test - void testVisitUnknown() { - for (Entry elementValue : this.testAnnotationAttributes.entrySet()) { - ExecutableElement attributeMethod = elementValue.getKey(); - AnnotationValue annotationValue = elementValue.getValue(); - assertSame(annotationValue, visitor.visitUnknown(annotationValue, attributeMethod)); - } - } - - void assertVisit(AnnotationValueVisitor visitor, String attributeName, Object expectedValue) { - Entry elementValue = getElementValue(this.testAnnotationAttributes, attributeName); - ExecutableElement attributeMethod = elementValue.getKey(); - AnnotationValue annotationValue = elementValue.getValue(); - assertTrue(deepEquals(expectedValue, annotationValue.accept(visitor, attributeMethod))); - } -} diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/AnnotationUtilsTest.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/AnnotationUtilsTest.java deleted file mode 100644 index 7aae66dc0..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/AnnotationUtilsTest.java +++ /dev/null @@ -1,776 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor.util; - -import io.microsphere.annotation.processor.AbstractAnnotationProcessingTest; -import io.microsphere.annotation.processor.TestAnnotation; -import io.microsphere.annotation.processor.TestService; -import io.microsphere.annotation.processor.TestServiceImpl; -import io.microsphere.annotation.processor.model.Model; -import io.microsphere.annotation.processor.model.element.StringAnnotationValue; -import org.junit.jupiter.api.Test; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.cache.annotation.Cacheable; -import org.springframework.context.annotation.ComponentScan; -import org.springframework.context.annotation.ComponentScans; -import org.springframework.stereotype.Component; -import org.springframework.stereotype.Service; - -import javax.lang.model.element.AnnotationMirror; -import javax.lang.model.element.AnnotationValue; -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.VariableElement; -import javax.lang.model.type.DeclaredType; -import javax.ws.rs.DefaultValue; -import javax.ws.rs.GET; -import javax.ws.rs.HttpMethod; -import javax.ws.rs.Path; -import javax.ws.rs.PathParam; -import javax.xml.ws.ServiceMode; -import java.io.Serializable; -import java.lang.annotation.Annotation; -import java.lang.annotation.Documented; -import java.lang.annotation.ElementType; -import java.lang.annotation.Inherited; -import java.lang.annotation.Target; -import java.util.List; -import java.util.Map; -import java.util.Map.Entry; - -import static io.microsphere.annotation.processor.util.AnnotationUtils.EMPTY_ELEMENT_TYPE_ARRAY; -import static io.microsphere.annotation.processor.util.AnnotationUtils.findAllAnnotations; -import static io.microsphere.annotation.processor.util.AnnotationUtils.findAnnotation; -import static io.microsphere.annotation.processor.util.AnnotationUtils.findAnnotations; -import static io.microsphere.annotation.processor.util.AnnotationUtils.findMetaAnnotation; -import static io.microsphere.annotation.processor.util.AnnotationUtils.getAllAnnotations; -import static io.microsphere.annotation.processor.util.AnnotationUtils.getAnnotation; -import static io.microsphere.annotation.processor.util.AnnotationUtils.getAnnotations; -import static io.microsphere.annotation.processor.util.AnnotationUtils.getAttribute; -import static io.microsphere.annotation.processor.util.AnnotationUtils.getAttributeName; -import static io.microsphere.annotation.processor.util.AnnotationUtils.getAttributesMap; -import static io.microsphere.annotation.processor.util.AnnotationUtils.getElementTypes; -import static io.microsphere.annotation.processor.util.AnnotationUtils.getElementValue; -import static io.microsphere.annotation.processor.util.AnnotationUtils.getElementValues; -import static io.microsphere.annotation.processor.util.AnnotationUtils.getValue; -import static io.microsphere.annotation.processor.util.AnnotationUtils.isAnnotationPresent; -import static io.microsphere.annotation.processor.util.AnnotationUtils.matchesAnnotationTypeName; -import static io.microsphere.annotation.processor.util.AnnotationUtils.matchesAttributeMethod; -import static io.microsphere.annotation.processor.util.AnnotationUtils.matchesAttributeValue; -import static io.microsphere.annotation.processor.util.AnnotationUtils.matchesDefaultAttributeValue; -import static io.microsphere.annotation.processor.util.FieldUtils.findField; -import static io.microsphere.annotation.processor.util.MethodUtils.findMethod; -import static io.microsphere.annotation.processor.util.MethodUtils.getAllDeclaredMethods; -import static io.microsphere.lang.function.Predicates.alwaysFalse; -import static io.microsphere.lang.function.Predicates.alwaysTrue; -import static io.microsphere.util.ArrayUtils.EMPTY_STRING_ARRAY; -import static io.microsphere.util.ArrayUtils.ofArray; -import static io.microsphere.util.StringUtils.EMPTY_STRING; -import static java.lang.annotation.ElementType.METHOD; -import static java.lang.annotation.ElementType.TYPE; -import static java.util.Collections.emptyMap; -import static org.junit.jupiter.api.Assertions.assertArrayEquals; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.junit.jupiter.api.Assertions.assertTrue; - -/** - * The {@link AnnotationUtils} Test - * - * @author Mercy - * @since 1.0.0 - */ -class AnnotationUtilsTest extends AbstractAnnotationProcessingTest { - - @Test - void testGetAnnotation() { - asserGetAnnotation(Service.class); - } - - @Test - void testGetAnnotationWithClassName() { - asserGetAnnotation("org.springframework.stereotype.Service"); - } - - @Test - void testGetAnnotationOnNull() { - assertNull(getAnnotation(testTypeElement, NULL_CLASS)); - assertNull(getAnnotation(testTypeElement.asType(), NULL_CLASS)); - assertNull(getAnnotation(NULL_ANNOTATED_CONSTRUCT, NULL_CLASS)); - } - - @Test - void testGetAnnotationWithClassNameOnNull() { - assertNull(getAnnotation(testTypeElement, NULL_STRING)); - assertNull(getAnnotation(testTypeElement.asType(), NULL_STRING)); - assertNull(getAnnotation(NULL_ANNOTATED_CONSTRUCT, NULL_STRING)); - } - - @Test - void testGetAnnotations() { - List annotations = getAnnotations(testTypeElement); - assertEquals(4, annotations.size()); - assertAnnotation(annotations.get(0), Service.class); - assertAnnotation(annotations.get(1), ServiceMode.class); - assertAnnotation(annotations.get(2), ComponentScans.class); - assertAnnotation(annotations.get(3), TestAnnotation.class); - } - - @Test - void testGetAnnotationsOnNull() { - List annotations = getAnnotations(NULL_ANNOTATED_CONSTRUCT); - assertEmptyList(annotations); - } - - @Test - void testGetAnnotationsWithAnnotationClass() { - assertGetAnnotations(Service.class); - assertGetAnnotations(ServiceMode.class); - } - - @Test - void testGetAnnotationsWithAnnotationClassOnNull() { - assertTrue(getAnnotations(NULL_ANNOTATED_CONSTRUCT, NULL_CLASS).isEmpty()); - assertTrue(getAnnotations(testTypeElement, NULL_CLASS).isEmpty()); - assertTrue(getAnnotations(NULL_ANNOTATED_CONSTRUCT, Service.class).isEmpty()); - } - - @Test - void testGetAnnotationsWithAnnotationClassOnNotFound() { - List annotations = getAnnotations(testTypeElement, Override.class); - assertEquals(0, annotations.size()); - } - - @Test - void testGetAnnotationsWithAnnotationClassName() { - assertGetAnnotations("org.springframework.stereotype.Service"); - assertGetAnnotations("javax.xml.ws.ServiceMode"); - } - - @Test - void testGetAnnotationsWithAnnotationClassNameOnNull() { - assertTrue(getAnnotations(NULL_ANNOTATED_CONSTRUCT, NULL_STRING).isEmpty()); - assertTrue(getAnnotations(testTypeElement, NULL_STRING).isEmpty()); - assertTrue(getAnnotations(NULL_ANNOTATED_CONSTRUCT, "org.springframework.stereotype.Service").isEmpty()); - } - - @Test - void testGetAllAnnotations() { - List annotations = getAllAnnotations(testTypeElement); - assertEquals(5, annotations.size()); - - annotations = getAllAnnotations(testTypeMirror); - assertEquals(5, annotations.size()); - } - - @Test - void testGetAllAnnotationsOnNull() { - assertEmptyList(getAllAnnotations(NULL_ELEMENT)); - assertEmptyList(getAllAnnotations(NULL_TYPE_MIRROR)); - } - - @Test - void testGetAllAnnotationsWithAnnotationClass() { - List annotations = getAllAnnotations(testTypeElement, Override.class); - assertEquals(0, annotations.size()); - - annotations = getAllAnnotations(testTypeMirror, Override.class); - assertEquals(0, annotations.size()); - - annotations = getAllAnnotations(testTypeElement, Service.class); - assertEquals(1, annotations.size()); - - annotations = getAllAnnotations(testTypeMirror, Service.class); - assertEquals(1, annotations.size()); - - annotations = getAllAnnotations(processingEnv, TestServiceImpl.class); - assertEquals(5, annotations.size()); - } - - @Test - void testGetAllAnnotationsWithAnnotationClassOnNull() { - assertEmptyList(getAllAnnotations(NULL_ELEMENT, NULL_CLASS)); - assertEmptyList(getAllAnnotations(NULL_TYPE_MIRROR, NULL_CLASS)); - assertEmptyList(getAllAnnotations(NULL_PROCESSING_ENVIRONMENT, NULL_CLASS)); - - assertEmptyList(getAllAnnotations(NULL_ELEMENT, Service.class)); - assertEmptyList(getAllAnnotations(NULL_TYPE_MIRROR, Service.class)); - assertEmptyList(getAllAnnotations(NULL_PROCESSING_ENVIRONMENT, Service.class)); - - assertEmptyList(getAllAnnotations(testTypeElement, NULL_CLASS)); - assertEmptyList(getAllAnnotations(testTypeMirror, NULL_CLASS)); - assertEmptyList(getAllAnnotations(processingEnv, NULL_CLASS)); - } - - @Test - void testGetAllAnnotationsWithAnnotationClassName() { - List annotations = getAllAnnotations(testTypeElement, "java.lang.Override"); - assertEquals(0, annotations.size()); - - annotations = getAllAnnotations(testTypeMirror, "org.springframework.stereotype.Service"); - assertEquals(1, annotations.size()); - } - - @Test - void testGetAllAnnotationsWithAnnotationClassNameOnNull() { - assertEmptyList(getAllAnnotations(NULL_ELEMENT, NULL_STRING)); - assertEmptyList(getAllAnnotations(NULL_TYPE_MIRROR, NULL_STRING)); - - assertTrue(getAllAnnotations(NULL_ELEMENT, "org.springframework.stereotype.Service").isEmpty()); - assertTrue(getAllAnnotations(NULL_TYPE_MIRROR, "org.springframework.stereotype.Service").isEmpty()); - - assertEmptyList(getAllAnnotations(testTypeElement, NULL_STRING)); - assertEmptyList(getAllAnnotations(testTypeMirror, NULL_STRING)); - } - - @Test - void testFindAnnotation() { - assertFindAnnotation(Service.class); - assertFindAnnotation(Path.class); - } - - @Test - void testFindAnnotationOnNotFound() { - assertNull(findAnnotation(testTypeMirror, Target.class)); - assertNull(findAnnotation(testTypeElement, Target.class)); - assertNull(findAnnotation(testTypeMirror, Override.class)); - assertNull(findAnnotation(testTypeElement, Override.class)); - } - - @Test - void testFindAnnotationOnNull() { - assertNull(findAnnotation(NULL_ELEMENT, NULL_CLASS)); - assertNull(findAnnotation(NULL_TYPE_MIRROR, NULL_CLASS)); - assertNull(findAnnotation(testTypeMirror, NULL_CLASS)); - assertNull(findAnnotation(testTypeElement, NULL_CLASS)); - - assertNull(findAnnotation(NULL_ELEMENT, NULL_STRING)); - assertNull(findAnnotation(NULL_TYPE_MIRROR, NULL_STRING)); - assertNull(findAnnotation(testTypeMirror, NULL_STRING)); - assertNull(findAnnotation(testTypeElement, NULL_STRING)); - } - - @Test - void testFindMetaAnnotationWithAnnotationClass() { - getAllDeclaredMethods(getTypeElement(TestService.class)).forEach(method -> { - assertFindMetaAnnotation(method, HttpMethod.class); - }); - } - - @Test - void testFindMetaAnnotationWithAnnotationClassOnNotFound() { - assertNull(findMetaAnnotation(testTypeElement, Service.class)); - } - - @Test - void testFindMetaAnnotationWithAnnotationClassNameOnNotFound() { - assertNull(findMetaAnnotation(testTypeElement, "org.springframework.stereotype.Service")); - } - - @Test - void testFindMetaAnnotationWithAnnotationClassOnNull() { - assertNull(findMetaAnnotation(NULL_ELEMENT, NULL_CLASS)); - assertNull(findMetaAnnotation(NULL_ELEMENT, Service.class)); - assertNull(findMetaAnnotation(testTypeElement, NULL_CLASS)); - } - - @Test - void testFindMetaAnnotationWithAnnotationClassName() { - getAllDeclaredMethods(getTypeElement(TestService.class)).forEach(method -> { - assertFindMetaAnnotation(method, "javax.ws.rs.HttpMethod"); - }); - } - - @Test - void testFindMetaAnnotationWithAnnotationClassNameOnNull() { - assertNull(findMetaAnnotation(NULL_ELEMENT, NULL_STRING)); - assertNull(findMetaAnnotation(NULL_ELEMENT, "test")); - assertNull(findMetaAnnotation(testTypeElement, NULL_STRING)); - } - - @Test - void testFindAllAnnotationsWithTypeMirror() { - List annotations = findAllAnnotations(testTypeMirror, alwaysTrue()); - assertEquals(5, annotations.size()); - - annotations = findAllAnnotations(testTypeMirror, alwaysFalse()); - assertEmptyList(annotations); - } - - @Test - void testFindAllAnnotationsWithTypeElement() { - List annotations = findAllAnnotations(testTypeElement, alwaysTrue()); - assertEquals(5, annotations.size()); - - annotations = findAllAnnotations(testTypeElement, alwaysFalse()); - assertEmptyList(annotations); - } - - @Test - void testFindAllAnnotationsWithMethod() { - ExecutableElement method = findMethod(testTypeElement, "echo", String.class); - - List annotations = findAllAnnotations(method, alwaysTrue()); - assertEquals(1, annotations.size()); - assertAnnotation(annotations.get(0), Cacheable.class); - - method = findMethod(getTypeElement(TestService.class), "echo", String.class); - - annotations = findAllAnnotations(method); - assertEquals(1, annotations.size()); - assertAnnotation(annotations.get(0), GET.class); - } - - @Test - void testFindAllAnnotationsWithMethodParameters() { - ExecutableElement method = findMethod(getTypeElement(TestService.class), "echo", String.class); - List parameters = method.getParameters(); - assertEquals(1, parameters.size()); - - List annotations = findAllAnnotations(parameters.get(0), alwaysTrue()); - assertEquals(2, annotations.size()); - assertAnnotation(annotations.get(0), PathParam.class); - assertAnnotation(annotations.get(1), DefaultValue.class); - - method = findMethod(getTypeElement(TestService.class), "model", Model.class); - parameters = method.getParameters(); - assertEquals(1, parameters.size()); - - annotations = findAllAnnotations(parameters.get(0)); - assertEquals(1, annotations.size()); - assertAnnotation(annotations.get(0), PathParam.class); - } - - @Test - void testFindAllAnnotationsWithField() { - VariableElement field = findField(testTypeElement, "context"); - - List annotations = findAllAnnotations(field, alwaysTrue()); - assertEquals(1, annotations.size()); - assertAnnotation(annotations.get(0), Autowired.class); - - field = findField(testTypeElement, "environment"); - annotations = findAllAnnotations(field, alwaysTrue()); - assertEmptyList(annotations); - } - - @Test - void testFindAllAnnotationsWithTypeMirrorOnNull() { - assertEmptyList(findAllAnnotations(NULL_TYPE_MIRROR, alwaysTrue())); - assertEmptyList(findAllAnnotations(NULL_TYPE_MIRROR, alwaysFalse())); - } - - @Test - void testFindAllAnnotationsWithTypeElementOnNull() { - assertEmptyList(findAllAnnotations(NULL_TYPE_ELEMENT, alwaysTrue())); - assertEmptyList(findAllAnnotations(NULL_TYPE_ELEMENT, alwaysFalse())); - } - - @Test - void testFindAllAnnotationsWithElementOnNull() { - assertEmptyList(findAllAnnotations(NULL_ELEMENT, alwaysTrue())); - assertEmptyList(findAllAnnotations(NULL_ELEMENT, alwaysFalse())); - } - - @Test - void testFindAllAnnotationsOnNull() { - assertEmptyList(findAllAnnotations(NULL_PROCESSING_ENVIRONMENT, Service.class, alwaysTrue())); - assertEmptyList(findAllAnnotations(NULL_PROCESSING_ENVIRONMENT, Service.class, alwaysTrue())); - assertEmptyList(findAllAnnotations(NULL_PROCESSING_ENVIRONMENT, "org.springframework.stereotype.Service", alwaysFalse())); - assertEmptyList(findAllAnnotations(NULL_PROCESSING_ENVIRONMENT, "org.springframework.stereotype.Service", alwaysFalse())); - assertEmptyList(findAllAnnotations(processingEnv, NULL_TYPE, alwaysTrue())); - assertEmptyList(findAllAnnotations(processingEnv, NULL_TYPE, alwaysFalse())); - assertEmptyList(findAllAnnotations(processingEnv, NULL_STRING, alwaysTrue())); - assertEmptyList(findAllAnnotations(processingEnv, NULL_STRING, alwaysFalse())); - } - - @Test - void testMatchesAnnotationClass() { - AnnotationMirror annotation = findAnnotation(testTypeElement, Service.class); - assertTrue(AnnotationUtils.matchesAnnotationType(annotation, Service.class)); - } - - @Test - void testMatchesAnnotationClassOnNull() { - assertFalse(AnnotationUtils.matchesAnnotationType(NULL_ANNOTATION_MIRROR, Service.class)); - assertFalse(AnnotationUtils.matchesAnnotationType(findAnnotation(testTypeElement, Service.class), NULL_CLASS)); - } - - @Test - void testMatchesAnnotationTypeName() { - AnnotationMirror annotation = findAnnotation(testTypeElement, "org.springframework.stereotype.Service"); - assertTrue(matchesAnnotationTypeName(annotation, "org.springframework.stereotype.Service")); - } - - @Test - void testMatchesAnnotationTypeNameOnNull() { - assertFalse(matchesAnnotationTypeName(NULL_ANNOTATION_MIRROR, "org.springframework.stereotype.Service")); - assertFalse(matchesAnnotationTypeName(findAnnotation(testTypeElement, "org.springframework.stereotype.Service"), NULL_STRING)); - } - - @Test - void testGetAttribute() { - assertEquals("testService", getAttribute(findAnnotation(testTypeElement, Service.class), "value")); - assertEquals("testService", getAttribute(findAnnotation(testTypeElement, Service.class), "value", false)); - assertEquals("/echo", getAttribute(findAnnotation(testTypeElement, Path.class), "value")); - - assertNull(getAttribute(findAnnotation(testTypeElement, Path.class), NULL_STRING)); - assertNull(getAttribute(findAnnotation(testTypeElement, NULL_CLASS), NULL_STRING)); - - ExecutableElement echoMethod = findMethod(testTypeElement, "echo", String.class); - AnnotationMirror cacheableAnnotation = findAnnotation(echoMethod, Cacheable.class); - String[] cacheNames = getAttribute(cacheableAnnotation, "cacheNames"); - assertArrayEquals(ofArray("cache-1", "cache-2"), cacheNames); - - String key = getAttribute(cacheableAnnotation, "key"); - assertEquals(EMPTY_STRING, key); - - DeclaredType cacheableAnnotationType = cacheableAnnotation.getAnnotationType(); - AnnotationMirror targetAnnotation = findAnnotation(cacheableAnnotationType, Target.class); - ElementType[] elementTypes = getAttribute(targetAnnotation, "value"); - assertArrayEquals(ofArray(TYPE, METHOD), elementTypes); - - } - - @Test - void testGetValue() { - AnnotationMirror pathAnnotation = getAnnotation(getTypeElement(TestService.class), Path.class); - assertEquals("/echo", getValue(pathAnnotation)); - } - - @Test - void testIsAnnotationPresentOnAnnotationClass() { - assertTrue(isAnnotationPresent(testTypeElement, Service.class)); - assertTrue(isAnnotationPresent(testTypeElement, Component.class)); - assertTrue(isAnnotationPresent(testTypeElement, ServiceMode.class)); - assertTrue(isAnnotationPresent(testTypeElement, Inherited.class)); - assertTrue(isAnnotationPresent(testTypeElement, Documented.class)); - } - - @Test - void testIsAnnotationPresentOnAnnotationClassOnNull() { - assertFalse(isAnnotationPresent(NULL_ELEMENT, Service.class)); - assertFalse(isAnnotationPresent(testTypeElement, NULL_CLASS)); - assertFalse(isAnnotationPresent(testTypeElement, Override.class)); - } - - @Test - void testIsAnnotationPresentOnAnnotationClassName() { - assertTrue(isAnnotationPresent(testTypeElement, "org.springframework.stereotype.Service")); - assertTrue(isAnnotationPresent(testTypeElement, "org.springframework.stereotype.Component")); - assertTrue(isAnnotationPresent(testTypeElement, "javax.xml.ws.ServiceMode")); - assertTrue(isAnnotationPresent(testTypeElement, "java.lang.annotation.Inherited")); - assertTrue(isAnnotationPresent(testTypeElement, "java.lang.annotation.Documented")); - } - - @Test - void testIsAnnotationPresentOnAnnotationClassNameOnNull() { - assertFalse(isAnnotationPresent(NULL_ELEMENT, "org.springframework.stereotype.Service")); - assertFalse(isAnnotationPresent(testTypeElement, NULL_STRING)); - assertFalse(isAnnotationPresent(testTypeElement, "java.lang.Override")); - - } - - @Test - void testFindAnnotations() { - List annotations = findAnnotations(testTypeElement); - assertEquals(4, annotations.size()); - assertAnnotation(annotations.get(0), Service.class); - assertAnnotation(annotations.get(1), ServiceMode.class); - assertAnnotation(annotations.get(2), ComponentScans.class); - assertAnnotation(annotations.get(3), TestAnnotation.class); - - annotations = findAnnotations(testTypeElement, alwaysTrue()); - assertEquals(4, annotations.size()); - assertAnnotation(annotations.get(0), Service.class); - assertAnnotation(annotations.get(1), ServiceMode.class); - assertAnnotation(annotations.get(2), ComponentScans.class); - assertAnnotation(annotations.get(3), TestAnnotation.class); - - annotations = findAnnotations(testTypeElement, alwaysFalse()); - assertEmptyList(annotations); - } - - @Test - void testFindAnnotationsOnNotFound() { - assertEmptyList(findAnnotations(getTypeElement(Serializable.class))); - } - - @Test - void testFindAnnotationsOnNull() { - assertEmptyList(findAnnotations(NULL_ELEMENT)); - } - - @Test - void testGetAttributeName() { - Map elementValues = getElementValues(testTypeElement, TestAnnotation.class); - for (Entry entry : elementValues.entrySet()) { - ExecutableElement attributeMethod = entry.getKey(); - assertEquals(attributeMethod.getSimpleName().toString(), getAttributeName(attributeMethod)); - } - } - - @Test - void testMatchesAttributeMethod() { - Map elementValues = getElementValues(testTypeElement, TestAnnotation.class); - for (Entry entry : elementValues.entrySet()) { - ExecutableElement attributeMethod = entry.getKey(); - assertTrue(matchesAttributeMethod(attributeMethod, getAttributeName(attributeMethod))); - } - } - - @Test - void testMatchesAttributeMethodOnNull() { - assertFalse(matchesAttributeMethod(null, null)); - - Map elementValues = getElementValues(testTypeElement, TestAnnotation.class); - for (Entry entry : elementValues.entrySet()) { - ExecutableElement attributeMethod = entry.getKey(); - assertFalse(matchesAttributeMethod(attributeMethod, null)); - } - } - - @Test - void testMatchesAttributeValue() { - Map elementValues = getElementValues(testTypeElement, TestAnnotation.class); - for (Entry entry : elementValues.entrySet()) { - AnnotationValue annotationValue = entry.getValue(); - assertTrue(matchesAttributeValue(annotationValue, annotationValue)); - assertTrue(matchesAttributeValue(annotationValue, annotationValue.getValue())); - } - - assertTrue(matchesAttributeValue(new StringAnnotationValue(""), new StringAnnotationValue(""))); - } - - @Test - void testMatchesAttributeValueOnNull() { - assertTrue(matchesAttributeValue(null, null)); - assertFalse(matchesAttributeValue(null, (Object) null)); - - Map elementValues = getElementValues(testTypeElement, TestAnnotation.class); - for (Entry entry : elementValues.entrySet()) { - AnnotationValue annotationValue = entry.getValue(); - assertFalse(matchesAttributeValue(annotationValue, null)); - assertFalse(matchesAttributeValue(annotationValue, (Object) null)); - } - } - - @Test - void testMatchesDefaultAttributeValue() { - Map elementValues = getElementValues(testTypeElement, ServiceMode.class); - for (Entry entry : elementValues.entrySet()) { - ExecutableElement attributeMethod = entry.getKey(); - assertTrue(matchesDefaultAttributeValue(attributeMethod, attributeMethod.getDefaultValue())); - } - } - - @Test - void testGetElementValue() { - Map elementValues = getElementValues(testTypeElement, TestAnnotation.class); - for (Entry entry : elementValues.entrySet()) { - ExecutableElement attributeMethod = entry.getKey(); - String attributeName = getAttributeName(attributeMethod); - assertEquals(entry, getElementValue(elementValues, attributeName)); - } - - assertNull(getElementValue(elementValues, "unknown")); - } - - @Test - void testGetElementValueOnEmptyElementValues() { - AnnotationMirror annotation = findAnnotation(testTypeElement, ServiceMode.class); - Map elementValues = annotation.getElementValues(); - assertNull(getElementValue(elementValues, "value")); - } - - @Test - void testGetElementValueOnNull() { - assertNull(getElementValue(null, "value")); - } - - @Test - void testGetElementValuesMapOnAnnotatedClass() { - Map attributesMap = getAttributesMap(testTypeElement, Service.class); - assertEquals(1, attributesMap.size()); - assertEquals("testService", attributesMap.get("value")); - } - - @Test - void testGetElementValuesMapOnAnnotatedMethod() { - ExecutableElement method = findMethod(testTypeElement, "echo", String.class); - Map attributesMap = getAttributesMap(method, Cacheable.class); - assertEquals(9, attributesMap.size()); - assertArrayEquals(ofArray("cache-1", "cache-2"), (String[]) attributesMap.get("cacheNames")); - } - - @Test - void testGetElementValuesMapOnRepeatableAnnotation() { - Map attributesMap = getAttributesMap(testTypeElement, ComponentScans.class); - assertEquals(1, attributesMap.size()); - - ComponentScans componentScans = testClass.getAnnotation(ComponentScans.class); - ComponentScan[] componentScanArray = (ComponentScan[]) attributesMap.get("value"); - assertEquals(2, componentScanArray.length); - assertArrayEquals(componentScanArray, componentScans.value()); - } - - @Test - void testGetElementValuesMapOnNull() { - Map attributesMap = getAttributesMap(null, null); - assertSame(emptyMap(), attributesMap); - - attributesMap = getAttributesMap(testTypeElement, null); - assertSame(emptyMap(), attributesMap); - - attributesMap = getAttributesMap(null); - assertSame(emptyMap(), attributesMap); - } - - @Test - void testGetElementValuesOnAnnotatedClass() { - Map elementValues = getElementValues(testTypeElement, Service.class); - assertServiceAttributes(elementValues); - - elementValues = getElementValues(testTypeElement, Service.class, false); - assertServiceAttributes(elementValues); - } - - @Test - void testGetElementValuesOnAnnotatedMethod() { - ExecutableElement method = findMethod(testTypeElement, "echo", String.class); - Map elementValues = getElementValues(method, Cacheable.class, false); - assertEquals(1, elementValues.size()); - assertAttributeEntry(elementValues, "cacheNames", ofArray("cache-1", "cache-2")); - - - elementValues = getElementValues(method, Cacheable.class, true); - assertEquals(9, elementValues.size()); - assertAttributeEntry(elementValues, "value", EMPTY_STRING_ARRAY); - assertAttributeEntry(elementValues, "cacheNames", ofArray("cache-1", "cache-2")); - assertAttributeEntry(elementValues, "key", EMPTY_STRING); - assertAttributeEntry(elementValues, "keyGenerator", EMPTY_STRING); - assertAttributeEntry(elementValues, "cacheManager", EMPTY_STRING); - assertAttributeEntry(elementValues, "cacheResolver", EMPTY_STRING); - assertAttributeEntry(elementValues, "condition", EMPTY_STRING); - assertAttributeEntry(elementValues, "unless", EMPTY_STRING); - assertAttributeEntry(elementValues, "sync", false); - } - - @Test - void testGetElementValuesOnNull() { - Map elementValues = getElementValues(null); - assertSame(emptyMap(), elementValues); - } - - @Test - void testGetElementTypes() { - assertElementTypes(Service.class, TYPE); - assertElementTypes(ServiceMode.class, TYPE); - assertElementTypes(ComponentScans.class, TYPE); - assertElementTypes(TestAnnotation.class, TYPE); - } - - void assertElementTypes(Class annotationClass, ElementType... expectedElementTypes) { - AnnotationMirror annotationMirror = findAnnotation(this.testTypeElement, annotationClass); - assertArrayEquals(expectedElementTypes, getElementTypes(annotationMirror)); - } - - @Test - void testGetElementTypesOnNull() { - assertSame(EMPTY_ELEMENT_TYPE_ARRAY, getElementTypes((AnnotationMirror) null)); - assertSame(EMPTY_ELEMENT_TYPE_ARRAY, getElementTypes((DeclaredType) null)); - } - - void assertServiceAttributes(Map attributes) { - assertEquals(1, attributes.size()); - assertAttributeEntry(attributes, "value", "testService"); - } - - void assertAttributeEntry(Map attributes, String attributeName, Object attributeValue) { - for (Entry entry : attributes.entrySet()) { - ExecutableElement attributeMethod = entry.getKey(); - if (matchesAttributeMethod(attributeMethod, attributeName)) { - assertAttributeEntry(entry, attributeName, attributeValue); - break; - } - } - } - - void assertAttributeEntry(Entry attributeEntry, String attributeName, Object attributeValue) { - ExecutableElement attributeMethod = attributeEntry.getKey(); - AnnotationValue annotationValue = attributeEntry.getValue(); - assertEquals(attributeName, getAttributeName(attributeMethod)); - Object value = getAttribute(attributeEntry); - Class attributeValueClass = value.getClass(); - if (attributeValueClass.isArray()) { - Class componentType = attributeValueClass.getComponentType(); - if (String.class.equals(componentType)) { - assertArrayEquals((String[]) attributeValue, (String[]) value); - } - } else { - assertEquals(attributeValue, value); - } - } - - private void assertFindMetaAnnotation(Element element, Class annotationClass) { - assertAnnotation(findMetaAnnotation(element, annotationClass), annotationClass); - } - - private void assertFindMetaAnnotation(Element element, String annotationClassName) { - assertAnnotation(findMetaAnnotation(element, annotationClassName), annotationClassName); - } - - private void assertFindAnnotation(Class annotationClass) { - assertAnnotation(findAnnotation(testTypeMirror, annotationClass), annotationClass); - assertAnnotation(findAnnotation(testTypeElement, annotationClass), annotationClass); - assertAnnotation(findAnnotation(testTypeMirror, annotationClass.getName()), annotationClass); - assertAnnotation(findAnnotation(testTypeElement, annotationClass.getName()), annotationClass); - } - - private void asserGetAnnotation(Class annotationClass) { - AnnotationMirror annotation = getAnnotation(testTypeElement, annotationClass); - assertAnnotation(annotation, annotationClass); - } - - private void asserGetAnnotation(String annotationClassName) { - AnnotationMirror annotation = getAnnotation(testTypeElement, annotationClassName); - assertAnnotation(annotation, annotationClassName); - } - - private void assertGetAnnotations(Class annotationClass) { - List annotations = getAnnotations(testTypeElement, annotationClass); - assertEquals(1, annotations.size()); - assertAnnotation(annotations.get(0), annotationClass); - } - - private void assertGetAnnotations(String annotationClassName) { - List annotations = getAnnotations(testTypeElement, annotationClassName); - assertEquals(1, annotations.size()); - assertAnnotation(annotations.get(0), annotationClassName); - } - - private void assertAnnotation(AnnotationMirror annotation, Class annotationClass) { - assertTrue(AnnotationUtils.matchesAnnotationType(annotation, annotationClass)); - assertAnnotation(annotation, annotationClass.getName()); - } - - private void assertAnnotation(AnnotationMirror annotation, String annotationClassName) { - assertEquals(annotation.getAnnotationType().toString(), annotationClassName); - } -} diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/ClassUtilsTest.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/ClassUtilsTest.java deleted file mode 100644 index 3785041ad..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/ClassUtilsTest.java +++ /dev/null @@ -1,52 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package io.microsphere.annotation.processor.util; - -import io.microsphere.annotation.processor.AbstractAnnotationProcessingTest; -import org.junit.jupiter.api.Test; -import org.springframework.context.annotation.ComponentScan; - -import static io.microsphere.annotation.processor.util.ClassUtils.getClassName; -import static io.microsphere.annotation.processor.util.ClassUtils.loadClass; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertSame; - -/** - * {@link ClassUtils} Test - * - * @author Mercy - * @see ClassUtils - * @since 1.0.0 - */ -class ClassUtilsTest extends AbstractAnnotationProcessingTest { - - @Test - void testGetClassName() { - assertEquals(this.testClassName, getClassName(this.testTypeMirror)); - } - - @Test - void testLoadClassOnTypeMirror() { - assertSame(this.testClass, loadClass(this.testTypeMirror)); - } - - @Test - void testLoadClass() { - assertSame(ComponentScan.Filter.class, loadClass("org.springframework.context.annotation.ComponentScan.Filter")); - } -} diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/ConstructorUtilsTest.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/ConstructorUtilsTest.java deleted file mode 100644 index 09aac37d9..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/ConstructorUtilsTest.java +++ /dev/null @@ -1,150 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package io.microsphere.annotation.processor.util; - - -import io.microsphere.annotation.processor.AbstractAnnotationProcessingTest; -import org.junit.jupiter.api.Test; -import org.springframework.core.env.Environment; - -import javax.lang.model.element.ExecutableElement; -import java.io.Serializable; -import java.util.List; - -import static io.microsphere.annotation.processor.util.ConstructorUtils.findConstructor; -import static io.microsphere.annotation.processor.util.ConstructorUtils.findDeclaredConstructors; -import static io.microsphere.annotation.processor.util.ConstructorUtils.getDeclaredConstructors; -import static io.microsphere.annotation.processor.util.ElementUtils.matchParameterTypes; -import static io.microsphere.lang.function.Predicates.alwaysFalse; -import static io.microsphere.lang.function.Predicates.alwaysTrue; -import static java.util.Collections.emptyList; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.junit.jupiter.api.Assertions.assertTrue; - -/** - * {@link ConstructorUtils} Test - * - * @author Mercy - * @see ConstructorUtils - * @since 1.0.0 - */ -class ConstructorUtilsTest extends AbstractAnnotationProcessingTest { - - @Test - void testGetDeclaredConstructors() { - List constructors = getDeclaredConstructors(this.testTypeElement); - assertTestServiceImplConstructors(constructors); - - constructors = getDeclaredConstructors(this.testDeclaredType); - assertTestServiceImplConstructors(constructors); - } - - @Test - void testGetDeclaredConstructorsOnNull() { - assertSame(emptyList(), getDeclaredConstructors(NULL_TYPE_ELEMENT)); - assertSame(emptyList(), getDeclaredConstructors(NULL_TYPE_MIRROR)); - } - - @Test - void testFindConstructor() { - assertTestServiceImpl1stConstructor(ConstructorUtils.findConstructor(this.testTypeElement)); - assertTestServiceImpl1stConstructor(findConstructor(this.testDeclaredType)); - - assertTestServiceImpl2ndConstructor(ConstructorUtils.findConstructor(this.testTypeElement, Environment.class)); - assertTestServiceImpl2ndConstructor(findConstructor(this.testDeclaredType, Environment.class)); - } - - @Test - void testFindConstructorOnNull() { - assertNull(ConstructorUtils.findConstructor(NULL_TYPE_ELEMENT)); - assertNull(findConstructor(NULL_TYPE_MIRROR)); - - assertNull(ConstructorUtils.findConstructor(this.testTypeElement, null)); - assertNull(findConstructor(this.testDeclaredType, null)); - } - - @Test - void testFindConstructorOnMismatch() { - assertNull(ConstructorUtils.findConstructor(NULL_TYPE_ELEMENT, Object.class)); - assertNull(findConstructor(NULL_TYPE_MIRROR, Object.class)); - - assertNull(ConstructorUtils.findConstructor(NULL_TYPE_ELEMENT, Object.class, String.class)); - assertNull(findConstructor(NULL_TYPE_MIRROR, Object.class, String.class)); - - assertNull(ConstructorUtils.findConstructor(NULL_TYPE_ELEMENT, Object.class, String.class, Integer.class)); - assertNull(findConstructor(NULL_TYPE_MIRROR, Object.class, String.class, Integer.class)); - } - - @Test - void testFindConstructors() { - List constructors = findDeclaredConstructors(this.testTypeElement); - assertTestServiceImplConstructors(constructors); - - constructors = findDeclaredConstructors(this.testDeclaredType); - assertTestServiceImplConstructors(constructors); - - constructors = findDeclaredConstructors(this.testTypeElement, alwaysTrue()); - assertTestServiceImplConstructors(constructors); - - constructors = findDeclaredConstructors(this.testDeclaredType, alwaysTrue()); - assertTestServiceImplConstructors(constructors); - } - - @Test - void testFindConstructorsOnNull() { - assertSame(emptyList(), findDeclaredConstructors(NULL_TYPE_ELEMENT)); - assertSame(emptyList(), findDeclaredConstructors(NULL_TYPE_MIRROR)); - - assertSame(emptyList(), findDeclaredConstructors(this.testTypeElement, null)); - assertSame(emptyList(), findDeclaredConstructors(this.testDeclaredType, null)); - } - - @Test - void testFindConstructorsOnMismatch() { - assertSame(emptyList(), findDeclaredConstructors(this.testTypeElement, alwaysFalse())); - assertSame(emptyList(), findDeclaredConstructors(this.testDeclaredType, alwaysFalse())); - } - - @Test - void testFindConstructorsOnNotFound() { - assertSame(emptyList(), findDeclaredConstructors(getTypeElement(Serializable.class))); - assertSame(emptyList(), findDeclaredConstructors(getDeclaredType(Serializable.class))); - - assertSame(emptyList(), findDeclaredConstructors(getTypeElement(List.class))); - assertSame(emptyList(), findDeclaredConstructors(getDeclaredType(List.class))); - } - - void assertTestServiceImplConstructors(List constructors) { - assertEquals(2, constructors.size()); - assertTestServiceImpl1stConstructor(constructors.get(0)); - assertTestServiceImpl2ndConstructor(constructors.get(1)); - } - - void assertTestServiceImpl1stConstructor(ExecutableElement constructor) { - assertEquals(this.testTypeElement, constructor.getEnclosingElement()); - assertEquals(emptyList(), constructor.getParameters()); - } - - void assertTestServiceImpl2ndConstructor(ExecutableElement constructor) { - assertEquals(this.testTypeElement, constructor.getEnclosingElement()); - assertEquals(1, constructor.getParameters().size()); - assertTrue(matchParameterTypes(constructor, Environment.class)); - } -} \ No newline at end of file diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/ElementUtilsTest.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/ElementUtilsTest.java deleted file mode 100644 index 91cb83a6f..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/ElementUtilsTest.java +++ /dev/null @@ -1,350 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package io.microsphere.annotation.processor.util; - - -import io.microsphere.annotation.processor.AbstractAnnotationProcessingTest; -import org.junit.jupiter.api.Test; - -import javax.lang.model.element.Element; -import javax.lang.model.element.ElementKind; -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.VariableElement; -import java.lang.annotation.ElementType; -import java.util.List; - -import static io.microsphere.annotation.processor.util.ElementUtils.filterElements; -import static io.microsphere.annotation.processor.util.ElementUtils.hasModifiers; -import static io.microsphere.annotation.processor.util.ElementUtils.isClass; -import static io.microsphere.annotation.processor.util.ElementUtils.isDeclaredType; -import static io.microsphere.annotation.processor.util.ElementUtils.isExecutable; -import static io.microsphere.annotation.processor.util.ElementUtils.isField; -import static io.microsphere.annotation.processor.util.ElementUtils.isInitializer; -import static io.microsphere.annotation.processor.util.ElementUtils.isInterface; -import static io.microsphere.annotation.processor.util.ElementUtils.isMember; -import static io.microsphere.annotation.processor.util.ElementUtils.isPublicNonStatic; -import static io.microsphere.annotation.processor.util.ElementUtils.isVariable; -import static io.microsphere.annotation.processor.util.ElementUtils.matchParameterTypeNames; -import static io.microsphere.annotation.processor.util.ElementUtils.matchParameterTypes; -import static io.microsphere.annotation.processor.util.ElementUtils.matchesElementKind; -import static io.microsphere.annotation.processor.util.ElementUtils.matchesElementType; -import static io.microsphere.annotation.processor.util.ElementUtils.toElementKind; -import static io.microsphere.annotation.processor.util.MemberUtils.getAllDeclaredMembers; -import static io.microsphere.annotation.processor.util.MemberUtils.getDeclaredMembers; -import static io.microsphere.annotation.processor.util.MethodUtils.findMethod; -import static io.microsphere.collection.ListUtils.ofList; -import static io.microsphere.lang.function.Predicates.alwaysFalse; -import static io.microsphere.lang.function.Predicates.alwaysTrue; -import static java.lang.annotation.ElementType.PACKAGE; -import static java.lang.annotation.ElementType.TYPE; -import static java.lang.annotation.ElementType.TYPE_USE; -import static java.lang.annotation.ElementType.values; -import static java.util.Collections.emptyList; -import static javax.lang.model.element.ElementKind.ANNOTATION_TYPE; -import static javax.lang.model.element.ElementKind.CLASS; -import static javax.lang.model.element.ElementKind.CONSTRUCTOR; -import static javax.lang.model.element.ElementKind.ENUM; -import static javax.lang.model.element.ElementKind.ENUM_CONSTANT; -import static javax.lang.model.element.ElementKind.EXCEPTION_PARAMETER; -import static javax.lang.model.element.ElementKind.FIELD; -import static javax.lang.model.element.ElementKind.INSTANCE_INIT; -import static javax.lang.model.element.ElementKind.INTERFACE; -import static javax.lang.model.element.ElementKind.LOCAL_VARIABLE; -import static javax.lang.model.element.ElementKind.METHOD; -import static javax.lang.model.element.ElementKind.OTHER; -import static javax.lang.model.element.ElementKind.PARAMETER; -import static javax.lang.model.element.ElementKind.RESOURCE_VARIABLE; -import static javax.lang.model.element.ElementKind.STATIC_INIT; -import static javax.lang.model.element.Modifier.PRIVATE; -import static javax.lang.model.util.ElementFilter.fieldsIn; -import static javax.lang.model.util.ElementFilter.methodsIn; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.junit.jupiter.api.Assertions.assertTrue; - -/** - * {@link ElementUtils} Test - * - * @author Mercy - * @see ElementUtils - * @since 1.0.0 - */ -class ElementUtilsTest extends AbstractAnnotationProcessingTest { - - private ExecutableElement echoMethod; - - @Override - protected void beforeTest() { - super.beforeTest(); - this.echoMethod = findMethod(testTypeElement, "echo", "java.lang.String"); - } - - @Test - void testMatchesElementTypeElementKind() { - assertTrue(matchesElementKind(echoMethod, METHOD)); - assertFalse(matchesElementKind(echoMethod, FIELD)); - } - - @Test - void testMatchesElementTypeElementKindOnNull() { - assertFalse(matchesElementKind(NULL_ELEMENT, FIELD)); - assertFalse(matchesElementKind(echoMethod, NULL_ELEMENT_KIND)); - } - - @Test - void testIsPublicNonStatic() { - methodsIn(getDeclaredMembers(testTypeElement)).forEach(method -> assertTrue(isPublicNonStatic(method))); - - // Integer#valueOf(String) is a public static method - assertFalse(isPublicNonStatic(findMethod(getTypeElement(Integer.class), "valueOf", String.class))); - } - - @Test - void testIsPublicNonStaticOnNull() { - assertFalse(isPublicNonStatic(NULL_ELEMENT)); - } - - @Test - void testHasModifiers() { - List members = getAllDeclaredMembers(testTypeElement.asType()); - List fields = fieldsIn(members); - assertTrue(hasModifiers(fields.get(0), PRIVATE)); - } - - @Test - void testHasModifiersOnNull() { - assertFalse(hasModifiers(NULL_ELEMENT)); - assertFalse(hasModifiers(testTypeElement, null)); - } - - @Test - void testIsClass() { - assertTrue(isClass(CLASS)); - assertTrue(isClass(ENUM)); - assertFalse(isClass(INTERFACE)); - } - - @Test - void testIsClassOnNull() { - assertFalse(isClass(null)); - } - - @Test - void testIsInterface() { - assertTrue(isInterface(INTERFACE)); - assertTrue(isInterface(ANNOTATION_TYPE)); - assertFalse(isInterface(CLASS)); - } - - @Test - void testIsInterfaceOnNull() { - assertFalse(isInterface(null)); - } - - @Test - void testIsDeclaredType() { - assertTrue(isDeclaredType(CLASS)); - assertTrue(isDeclaredType(ENUM)); - assertTrue(isDeclaredType(INTERFACE)); - assertTrue(isDeclaredType(ANNOTATION_TYPE)); - assertFalse(isDeclaredType(LOCAL_VARIABLE)); - } - - @Test - void testIsDeclaredTypeOnNull() { - assertFalse(isDeclaredType(null)); - } - - @Test - void testIsField() { - assertTrue(isField(FIELD)); - assertTrue(isField(ENUM_CONSTANT)); - assertFalse(isField(LOCAL_VARIABLE)); - } - - @Test - void testIsFieldOnNull() { - assertFalse(isField(null)); - } - - @Test - void testIsExecutable() { - assertTrue(isExecutable(METHOD)); - assertTrue(isExecutable(CONSTRUCTOR)); - assertTrue(isExecutable(STATIC_INIT)); - assertTrue(isExecutable(INSTANCE_INIT)); - assertFalse(isExecutable(CLASS)); - } - - @Test - void testIsExecutableOnNull() { - assertFalse(isExecutable(null)); - } - - @Test - void testIsMember() { - assertTrue(isMember(METHOD)); - assertTrue(isMember(CONSTRUCTOR)); - assertTrue(isMember(STATIC_INIT)); - assertTrue(isMember(INSTANCE_INIT)); - assertTrue(isMember(FIELD)); - assertTrue(isMember(ENUM_CONSTANT)); - assertFalse(isMember(CLASS)); - } - - @Test - void testIsMemberOnNull() { - assertFalse(isMember(null)); - } - - @Test - void testIsInitializer() { - assertTrue(isInitializer(STATIC_INIT)); - assertTrue(isInitializer(INSTANCE_INIT)); - assertFalse(isInitializer(METHOD)); - assertFalse(isInitializer(CONSTRUCTOR)); - assertFalse(isInitializer(CLASS)); - } - - @Test - void testIsInitializerOnNull() { - assertFalse(isInitializer(null)); - } - - @Test - void testIsVariable() { - assertTrue(isVariable(ENUM_CONSTANT)); - assertTrue(isVariable(FIELD)); - assertTrue(isVariable(PARAMETER)); - assertTrue(isVariable(LOCAL_VARIABLE)); - assertTrue(isVariable(EXCEPTION_PARAMETER)); - assertTrue(isVariable(RESOURCE_VARIABLE)); - assertFalse(isVariable(CLASS)); - } - - @Test - void testIsVariableOnNull() { - assertFalse(isVariable(null)); - } - - @Test - void testToElementKind() { - for (ElementType elementType : values()) { - assertElementKind(elementType); - } - } - - @Test - void testToElementKindOnNull() { - assertSame(OTHER, toElementKind(null)); - } - - @Test - void testMatchesElementType() { - for (ElementType elementType : values()) { - assertMatchesElementType(elementType); - } - } - - @Test - void testMatchesElementTypeOnNull() { - assertFalse(matchesElementType(null, (ElementType) null)); - assertFalse(matchesElementType(null, TYPE_USE)); - assertFalse(matchesElementType(toElementKind(TYPE_USE), (ElementType) null)); - } - - @Test - void testMatchesElementTypeWithArray() { - for (ElementType elementType : values()) { - assertTrue(matchesElementType(toElementKind(elementType), values())); - } - } - - @Test - void testMatchesElementTypeWithElement() { - matchesElementType(this.testTypeElement, TYPE); - } - - @Test - void testMatchesElementTypeWithArrayOnNull() { - assertFalse(matchesElementType(NULL_ELEMENT_KIND)); - assertFalse(matchesElementType(NULL_ELEMENT)); - - assertFalse(matchesElementType(NULL_ELEMENT_KIND, (ElementType[]) null)); - assertFalse(matchesElementType(NULL_ELEMENT, (ElementType[]) null)); - - assertFalse(matchesElementType(NULL_ELEMENT_KIND, TYPE_USE, PACKAGE)); - assertFalse(matchesElementType(NULL_ELEMENT, TYPE_USE, PACKAGE)); - - assertFalse(matchesElementType(toElementKind(TYPE_USE), (ElementType[]) null)); - } - - @Test - void testFilterElements() { - assertEmptyList(filterElements(ofList(testTypeElement), alwaysFalse())); - } - - @Test - void testFilterElementsOnNull() { - assertEmptyList(filterElements(NULL_LIST, alwaysTrue())); - List methods = ofList(echoMethod); - assertSame(emptyList(), filterElements(methods, NULL_PREDICATE_ARRAY)); - } - - @Test - void testFilterElementsOnEmpty() { - assertEmptyList(filterElements(emptyList(), alwaysTrue())); - List methods = ofList(echoMethod); - assertEquals(methods, filterElements(methods)); - } - - @Test - void testMatchParameterTypes() { - assertTrue(matchParameterTypes(echoMethod.getParameters(), String.class)); - assertFalse(matchParameterTypes(echoMethod.getParameters(), Object.class)); - } - - @Test - void testMatchParameterTypesOnNull() { - assertFalse(matchParameterTypes(NULL_LIST, String.class)); - assertFalse(matchParameterTypes(emptyList(), NULL_CLASS_ARRAY)); - } - - @Test - void testMatchParameterTypeNames() { - assertTrue(matchParameterTypeNames(echoMethod.getParameters(), "java.lang.String")); - assertFalse(matchParameterTypeNames(echoMethod.getParameters(), "java.lang.Object")); - } - - @Test - void testMatchParameterTypeNamesOnNull() { - assertFalse(matchParameterTypeNames(NULL_LIST, "java.lang.String")); - assertFalse(matchParameterTypeNames(emptyList(), NULL_STRING_ARRAY)); - } - - void assertElementKind(ElementType elementType) { - ElementKind elementKind = toElementKind(elementType); - assertNotNull(elementKind); - } - - void assertMatchesElementType(ElementType elementType) { - assertTrue(matchesElementType(toElementKind(elementType), elementType)); - } -} \ No newline at end of file diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/ExecutableElementComparatorTest.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/ExecutableElementComparatorTest.java deleted file mode 100644 index dfd4eaa25..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/ExecutableElementComparatorTest.java +++ /dev/null @@ -1,76 +0,0 @@ -package io.microsphere.annotation.processor.util; - -import io.microsphere.annotation.processor.AbstractAnnotationProcessingTest; -import io.microsphere.annotation.processor.TestService; -import org.junit.jupiter.api.Test; - -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.TypeElement; -import java.lang.reflect.Type; - -import static io.microsphere.annotation.processor.util.ExecutableElementComparator.INSTANCE; -import static io.microsphere.annotation.processor.util.MethodUtils.findMethod; -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * {@link ExecutableElementComparator} Test - * - * @author Mercy - * @see ExecutableElementComparator - * @since 1.0.0 - */ -class ExecutableElementComparatorTest extends AbstractAnnotationProcessingTest { - - private final ExecutableElementComparator comparator = INSTANCE; - - @Test - void testCompareOnSameMethods() { - // Object#toString() - String methodName = "toString"; - ExecutableElement method = getMethod(methodName); - assertEquals(0, comparator.compare(method, method)); - } - - @Test - void testCompareOnDifferentMethods() { - assertEquals("toString".compareTo("hashCode"), comparator.compare(getMethod("toString"), getMethod("hashCode"))); - } - - @Test - void testCompareOnOverloadMethodsWithSameParameterCount() { - // Integer#valueOf(int) | Integer#valueOf(String) - TypeElement typeElement = getTypeElement(Integer.class); - String methodName = "valueOf"; - assertEquals(int.class.getName().compareTo(String.class.getName()), comparator.compare(findMethod(typeElement, methodName, int.class), findMethod(typeElement, methodName, String.class))); - } - - @Test - void testCompareOnOverloadMethodsWithDifferentParameterCount() { - // StringBuilder#append(char[]) | StringBuilder#append(char[],int,int) - TypeElement typeElement = getTypeElement(StringBuilder.class); - String methodName = "append"; - assertEquals(-2, comparator.compare( - findMethod(typeElement, methodName, char[].class), - findMethod(typeElement, methodName, char[].class, int.class, int.class))); - } - - @Test - void testCompare() { - // AutoCloseable#close() - assertEquals(0, comparator.compare(getMethod("close"), - findMethod(getTypeElement(AutoCloseable.class), "close"))); - - // TestService#echo(String) - assertEquals(0, comparator.compare(getMethod("echo", String.class), - findMethod(getTypeElement(TestService.class), "echo", String.class))); - } - - @Override - public boolean equals(Object object) { - return super.equals(object); - } - - private ExecutableElement getMethod(String methodName, Type... parameterTypes) { - return findMethod(testTypeElement, methodName, parameterTypes); - } -} \ No newline at end of file diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/FieldUtilsTest.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/FieldUtilsTest.java deleted file mode 100644 index 7477f52ee..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/FieldUtilsTest.java +++ /dev/null @@ -1,413 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor.util; - -import io.microsphere.annotation.processor.AbstractAnnotationProcessingTest; -import io.microsphere.annotation.processor.model.Color; -import io.microsphere.annotation.processor.model.Model; -import org.junit.jupiter.api.Test; - -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.TypeElement; -import javax.lang.model.element.VariableElement; -import javax.lang.model.type.TypeMirror; -import java.io.Serializable; -import java.lang.annotation.ElementType; -import java.lang.reflect.Type; -import java.math.BigDecimal; -import java.math.BigInteger; -import java.util.List; -import java.util.concurrent.TimeUnit; - -import static io.microsphere.annotation.processor.util.FieldUtils.equalsFieldName; -import static io.microsphere.annotation.processor.util.FieldUtils.filterDeclaredFields; -import static io.microsphere.annotation.processor.util.FieldUtils.findAllDeclaredFields; -import static io.microsphere.annotation.processor.util.FieldUtils.findDeclaredFields; -import static io.microsphere.annotation.processor.util.FieldUtils.findField; -import static io.microsphere.annotation.processor.util.FieldUtils.getAllDeclaredFields; -import static io.microsphere.annotation.processor.util.FieldUtils.getAllNonStaticFields; -import static io.microsphere.annotation.processor.util.FieldUtils.getDeclaredField; -import static io.microsphere.annotation.processor.util.FieldUtils.getDeclaredFields; -import static io.microsphere.annotation.processor.util.FieldUtils.getNonStaticFields; -import static io.microsphere.annotation.processor.util.FieldUtils.isEnumMemberField; -import static io.microsphere.annotation.processor.util.FieldUtils.isField; -import static io.microsphere.annotation.processor.util.FieldUtils.isNonStaticField; -import static io.microsphere.annotation.processor.util.MethodUtils.findMethod; -import static io.microsphere.lang.function.Predicates.alwaysFalse; -import static io.microsphere.lang.function.Predicates.alwaysTrue; -import static io.microsphere.util.StringUtils.EMPTY_STRING; -import static javax.lang.model.element.Modifier.FINAL; -import static javax.lang.model.element.Modifier.PRIVATE; -import static javax.lang.model.element.Modifier.PUBLIC; -import static javax.lang.model.element.Modifier.STATIC; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertTrue; - -/** - * {@link FieldUtils} Test - * - * @author Mercy - * @since 1.0.0 - */ -class FieldUtilsTest extends AbstractAnnotationProcessingTest { - - @Test - void testGetDeclaredField() { - TypeElement type = getTypeElement(Model.class); - testGetDeclaredField(type, "f", float.class); - testGetDeclaredField(type, "d", double.class); - testGetDeclaredField(type, "tu", TimeUnit.class); - testGetDeclaredField(type, "str", String.class); - testGetDeclaredField(type, "bi", BigInteger.class); - testGetDeclaredField(type, "bd", BigDecimal.class); - } - - @Test - void testGetDeclaredFieldOnNotFound() { - TypeElement type = getTypeElement(Model.class); - assertNull(getDeclaredField(type, "b")); - assertNull(getDeclaredField(type, "s")); - assertNull(getDeclaredField(type, "i")); - assertNull(getDeclaredField(type, "l")); - assertNull(getDeclaredField(type, "z")); - } - - @Test - void testGetDeclaredFieldOnNull() { - assertNull(getDeclaredField(NULL_ELEMENT, "z")); - assertNull(getDeclaredField(NULL_TYPE_MIRROR, "z")); - } - - @Test - void testGetDeclaredFields() { - TypeElement type = getTypeElement(Model.class); - List fields = getDeclaredFields(type); - assertModelFields(fields); - - fields = getDeclaredFields(type.asType()); - assertModelFields(fields); - } - - @Test - void testGetDeclaredFieldsOnNull() { - assertTrue(getDeclaredFields(NULL_ELEMENT).isEmpty()); - assertTrue(getDeclaredFields(NULL_TYPE_MIRROR).isEmpty()); - } - - @Test - void testGetAllDeclaredFields() { - TypeElement type = getTypeElement(Model.class); - List fields = getAllDeclaredFields(type); - assertModelAllFields(fields); - } - - @Test - void testGetAllDeclaredFieldsOnNull() { - assertTrue(getAllDeclaredFields(NULL_ELEMENT).isEmpty()); - assertTrue(getAllDeclaredFields(NULL_TYPE_MIRROR).isEmpty()); - } - - @Test - void testFindField() { - TypeElement type = getTypeElement(Model.class); - testFindField(type, "f", float.class); - testFindField(type, "d", double.class); - testFindField(type, "tu", TimeUnit.class); - testFindField(type, "str", String.class); - testFindField(type, "bi", BigInteger.class); - testFindField(type, "bd", BigDecimal.class); - testFindField(type, "b", byte.class); - testFindField(type, "s", short.class); - testFindField(type, "i", int.class); - testFindField(type, "l", long.class); - testFindField(type, "z", boolean.class); - } - - @Test - void testFindFieldOnNull() { - TypeElement type = getTypeElement(Model.class); - assertNull(findField(NULL_ELEMENT, "f")); - assertNull(findField(NULL_ELEMENT, NULL_STRING)); - - assertNull(findField(NULL_TYPE_MIRROR, "f")); - assertNull(findField(NULL_TYPE_MIRROR, NULL_STRING)); - - assertNull(findField(type, NULL_STRING)); - assertNull(findField(type.asType(), NULL_STRING)); - } - - @Test - void testFindDeclaredFields() { - TypeElement type = getTypeElement(Model.class); - - List fields = findAllDeclaredFields(type, alwaysTrue()); - assertModelAllFields(fields); - - fields = findAllDeclaredFields(type, alwaysFalse()); - assertEmptyList(fields); - - fields = findDeclaredFields(type, f -> "f".equals(f.getSimpleName().toString())); - assertEquals(1, fields.size()); - assertEquals("f", fields.get(0).getSimpleName().toString()); - } - - @Test - void testFindDeclaredFieldsOnNull() { - assertEmptyList(findDeclaredFields(NULL_ELEMENT, alwaysTrue())); - assertEmptyList(findDeclaredFields(NULL_TYPE_MIRROR, alwaysTrue())); - } - - @Test - void testFindAllDeclaredFields() { - TypeElement type = getTypeElement(Model.class); - - List fields = findAllDeclaredFields(type, alwaysTrue()); - assertModelAllFields(fields); - - fields = findAllDeclaredFields(type, alwaysFalse()); - assertEmptyList(fields); - - fields = findAllDeclaredFields(type, f -> "f".equals(f.getSimpleName().toString())); - assertEquals(1, fields.size()); - assertEquals("f", fields.get(0).getSimpleName().toString()); - } - - @Test - void testFindAllDeclaredFieldsOnNull() { - assertEmptyList(findAllDeclaredFields(NULL_ELEMENT, alwaysTrue())); - assertEmptyList(findAllDeclaredFields(NULL_TYPE_MIRROR, alwaysTrue())); - } - - @Test - void testFilterDeclaredFieldsOnNull() { - assertFilterDeclaredFieldsReturningEmptyList(NULL_TYPE_MIRROR); - } - - @Test - void testFilterDeclaredFields() { - TypeMirror type = getTypeMirror(Model.class); - List fields = filterDeclaredFields(type, true, alwaysTrue()); - assertModelAllFields(fields); - - fields = filterDeclaredFields(type, true, alwaysFalse()); - assertEmptyList(fields); - - fields = filterDeclaredFields(type, false, alwaysTrue()); - assertModelFields(fields); - - fields = filterDeclaredFields(type, false, alwaysFalse()); - assertEmptyList(fields); - } - - @Test - void testFilterDeclaredFieldsOnNoDeclaredMembers() { - TypeMirror type = getTypeMirror(Serializable.class); - assertFilterDeclaredFieldsReturningEmptyList(type); - } - - @Test - void testFilterDeclaredFieldsOnNoDeclaredFields() { - TypeMirror type = getTypeMirror(Object.class); - assertFilterDeclaredFieldsReturningEmptyList(type); - } - - private void assertFilterDeclaredFieldsReturningEmptyList(TypeMirror type) { - assertEmptyList(filterDeclaredFields(type, true, alwaysTrue())); - assertEmptyList(filterDeclaredFields(type, false, alwaysTrue())); - assertEmptyList(filterDeclaredFields(type, true, alwaysFalse())); - assertEmptyList(filterDeclaredFields(type, false, alwaysFalse())); - assertEmptyList(filterDeclaredFields(type, true, NULL_PREDICATE_ARRAY)); - assertEmptyList(filterDeclaredFields(type, false, NULL_PREDICATE_ARRAY)); - assertEmptyList(filterDeclaredFields(type, true)); - assertEmptyList(filterDeclaredFields(type, false)); - } - - @Test - void testIsEnumField() { - TypeElement type = getTypeElement(Color.class); - - VariableElement field = findField(type, "RED"); - assertTrue(isEnumMemberField(field)); - - field = findField(type, "YELLOW"); - assertTrue(isEnumMemberField(field)); - - field = findField(type, "BLUE"); - assertTrue(isEnumMemberField(field)); - - type = getTypeElement(Model.class); - field = findField(type, "f"); - assertFalse(isEnumMemberField(field)); - - assertFalse(isEnumMemberField(NULL_FIELD)); - } - - @Test - void testIsNonStaticField() { - TypeElement type = getTypeElement(Model.class); - assertTrue(isNonStaticField(findField(type, "f"))); - } - - @Test - void testIsNonStaticFieldOnStaticField() { - TypeElement type = getTypeElement(Color.class); - for (Color color : Color.values()) { - assertFalse(isNonStaticField(findField(type, color.name()))); - } - } - - @Test - void testIsNonStaticFieldOnMethod() { - TypeElement type = getTypeElement(Model.class); - ExecutableElement method = findMethod(type, "setF", float.class); - for (VariableElement parameter : method.getParameters()) { - assertFalse(isNonStaticField(parameter)); - } - } - - @Test - void testIsField() { - TypeElement type = getTypeElement(Model.class); - assertTrue(isField(findField(type, "f"))); - assertTrue(isField(findField(type, "f"), PRIVATE)); - - type = getTypeElement(Color.class); - assertTrue(isField(findField(type, "BLUE"), PUBLIC, STATIC, FINAL)); - } - - @Test - void testIsFieldOnMethod() { - TypeElement type = getTypeElement(Model.class); - ExecutableElement method = findMethod(type, "getF"); - for (VariableElement parameter : method.getParameters()) { - assertFalse(isField(parameter)); - } - } - - @Test - void testIsFieldOnNull() { - assertFalse(isField(NULL_FIELD)); - assertFalse(isField(NULL_FIELD, PUBLIC, STATIC, FINAL)); - - TypeElement type = getTypeElement(Model.class); - assertFalse(isField(findField(type, "f"), NULL_MODIFIER_ARRAY)); - } - - @Test - void testGetNonStaticFields() { - TypeElement type = getTypeElement(Model.class); - - List fields = getNonStaticFields(type); - assertModelFields(fields); - - fields = getNonStaticFields(type.asType()); - assertModelFields(fields); - - assertTrue(getAllNonStaticFields(NULL_ELEMENT).isEmpty()); - assertTrue(getAllNonStaticFields(NULL_TYPE_MIRROR).isEmpty()); - } - - @Test - void testGetNonStaticFieldsOnNull() { - assertTrue(getNonStaticFields(NULL_TYPE_MIRROR).isEmpty()); - assertTrue(getNonStaticFields(NULL_ELEMENT).isEmpty()); - } - - @Test - void testGetNonStaticFieldsOnEnum() { - TypeElement type = getTypeElement(ElementType.class); - List fields = getNonStaticFields(type); - assertEmptyList(fields); - } - - @Test - void testGetAllNonStaticFields() { - TypeElement type = getTypeElement(Model.class); - - List fields = getAllNonStaticFields(type); - assertModelAllFields(fields); - - fields = getAllNonStaticFields(type.asType()); - assertModelAllFields(fields); - - assertTrue(getAllNonStaticFields(NULL_ELEMENT).isEmpty()); - assertTrue(getAllNonStaticFields(NULL_TYPE_MIRROR).isEmpty()); - } - - @Test - void testEqualsFieldName() { - TypeElement type = getTypeElement(Model.class); - String fieldName = "f"; - VariableElement field = findField(type, fieldName); - assertTrue(equalsFieldName(field, fieldName)); - assertFalse(equalsFieldName(field, "d")); - } - - @Test - void testEqualsFieldNameOnNull() { - TypeElement type = getTypeElement(Model.class); - String fieldName = "f"; - VariableElement field = findField(type, fieldName); - - assertFalse(equalsFieldName(NULL_FIELD, EMPTY_STRING)); - assertFalse(equalsFieldName(field, NULL_STRING)); - } - - private void assertModelFields(List fields) { - assertEquals(6, fields.size()); - assertEquals("d", fields.get(1).getSimpleName().toString()); - assertEquals("tu", fields.get(2).getSimpleName().toString()); - assertEquals("str", fields.get(3).getSimpleName().toString()); - assertEquals("bi", fields.get(4).getSimpleName().toString()); - assertEquals("bd", fields.get(5).getSimpleName().toString()); - } - - private void assertModelAllFields(List fields) { - assertEquals(11, fields.size()); - assertEquals("f", fields.get(0).getSimpleName().toString()); - assertEquals("d", fields.get(1).getSimpleName().toString()); - assertEquals("tu", fields.get(2).getSimpleName().toString()); - assertEquals("str", fields.get(3).getSimpleName().toString()); - assertEquals("bi", fields.get(4).getSimpleName().toString()); - assertEquals("bd", fields.get(5).getSimpleName().toString()); - assertEquals("b", fields.get(6).getSimpleName().toString()); - assertEquals("s", fields.get(7).getSimpleName().toString()); - assertEquals("i", fields.get(8).getSimpleName().toString()); - assertEquals("l", fields.get(9).getSimpleName().toString()); - assertEquals("z", fields.get(10).getSimpleName().toString()); - } - - private void testGetDeclaredField(TypeElement type, String fieldName, Type fieldType) { - VariableElement field = getDeclaredField(type, fieldName); - assertField(field, fieldName, fieldType); - - field = getDeclaredField(type.asType(), fieldName); - assertField(field, fieldName, fieldType); - } - - private void testFindField(TypeElement type, String fieldName, Type fieldType) { - VariableElement field = findField(type, fieldName); - assertField(field, fieldName, fieldType); - } - - private void assertField(VariableElement field, String fieldName, Type fieldType) { - assertEquals(fieldName, field.getSimpleName().toString()); - assertEquals(fieldType.getTypeName(), field.asType().toString()); - } -} diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/LoggerUtilsTest.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/LoggerUtilsTest.java deleted file mode 100644 index dd436fae9..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/LoggerUtilsTest.java +++ /dev/null @@ -1,76 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor.util; - -import org.junit.jupiter.api.Test; - -import static io.microsphere.annotation.processor.util.LoggerUtils.LOGGER; -import static io.microsphere.annotation.processor.util.LoggerUtils.debug; -import static io.microsphere.annotation.processor.util.LoggerUtils.error; -import static io.microsphere.annotation.processor.util.LoggerUtils.info; -import static io.microsphere.annotation.processor.util.LoggerUtils.trace; -import static io.microsphere.annotation.processor.util.LoggerUtils.warn; -import static org.junit.jupiter.api.Assertions.assertNotNull; - -/** - * {@link LoggerUtils} Test - * - * @author Mercy - * @since 1.0.0 - */ -class LoggerUtilsTest { - - @Test - void testLogger() { - assertNotNull(LOGGER); - } - - @Test - void testTrace() { - trace("Hello,World"); - trace("Hello,{}", "World"); - trace("{},{}", "Hello", "World"); - } - - @Test - void testDebug() { - debug("Hello,World"); - debug("Hello,{}", "World"); - debug("{},{}", "Hello", "World"); - } - - @Test - void testInfo() { - info("Hello,World"); - info("Hello,{}", "World"); - info("{},{}", "Hello", "World"); - } - - @Test - void testWarn() { - warn("Hello,World"); - warn("Hello,{}", "World"); - warn("{},{}", "Hello", "World"); - } - - @Test - void testError() { - error("Hello,World"); - error("Hello,{}", "World"); - error("{},{}", "Hello", "World"); - } -} diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/MemberUtilsTest.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/MemberUtilsTest.java deleted file mode 100644 index aa455d3a5..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/MemberUtilsTest.java +++ /dev/null @@ -1,174 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor.util; - -import io.microsphere.annotation.processor.AbstractAnnotationProcessingTest; -import io.microsphere.annotation.processor.model.Model; -import org.junit.jupiter.api.Test; - -import javax.lang.model.element.Element; -import javax.lang.model.element.TypeElement; -import javax.lang.model.element.VariableElement; -import java.util.List; - -import static io.microsphere.annotation.processor.util.MemberUtils.findAllDeclaredMembers; -import static io.microsphere.annotation.processor.util.MemberUtils.findDeclaredMembers; -import static io.microsphere.annotation.processor.util.MemberUtils.getAllDeclaredMembers; -import static io.microsphere.annotation.processor.util.MemberUtils.getDeclaredMembers; -import static io.microsphere.lang.function.Predicates.alwaysFalse; -import static io.microsphere.lang.function.Predicates.alwaysTrue; -import static javax.lang.model.util.ElementFilter.fieldsIn; -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * {@link MemberUtils} Test - * - * @author Mercy - * @since 1.0.0 - */ -class MemberUtilsTest extends AbstractAnnotationProcessingTest { - - @Test - void testGetDeclaredMembers() { - assertGetDeclaredMembersOfModel(); - } - - @Test - void testGetDeclaredMembersOnNull() { - assertEmptyList(getDeclaredMembers(NULL_TYPE_ELEMENT)); - assertEmptyList(getDeclaredMembers(NULL_TYPE_MIRROR)); - } - - @Test - void testGetAllDeclaredMembers() { - assertGetAllDeclaredMembersOfModel(); - } - - @Test - void testGetAllDeclaredMembersOnNull() { - assertEmptyList(getAllDeclaredMembers(NULL_TYPE_ELEMENT)); - assertEmptyList(getAllDeclaredMembers(NULL_TYPE_MIRROR)); - } - - @Test - void testGetDeclaredMembersOnAll() { - assertGetAllDeclaredMembersOfModel(getDeclaredMembers(getDeclaredType(Model.class), true)); - assertGetAllDeclaredMembersOfModel(getDeclaredMembers(getTypeElement(Model.class), true)); - } - - @Test - void testGetDeclaredMembersOnNotAll() { - assertGetDeclaredMembersOfModel(getDeclaredMembers(getDeclaredType(Model.class), false)); - assertGetDeclaredMembersOfModel(getDeclaredMembers(getTypeElement(Model.class), false)); - } - - @Test - void testFindDeclaredMembers() { - assertFindDeclaredMembersOfModel(); - } - - @Test - void testFindDeclaredMembersOnNull() { - assertEmptyList(findDeclaredMembers(NULL_TYPE_ELEMENT, alwaysTrue())); - assertEmptyList(findDeclaredMembers(NULL_TYPE_ELEMENT, alwaysFalse())); - assertEmptyList(findDeclaredMembers(NULL_TYPE_MIRROR, alwaysTrue())); - assertEmptyList(findDeclaredMembers(NULL_TYPE_MIRROR, alwaysFalse())); - } - - @Test - void testFindAllDeclaredMembers() { - assertFindAllDeclaredMembersOfModel(); - } - - @Test - void testFindAllDeclaredMembersOnNull() { - assertEmptyList(findAllDeclaredMembers(NULL_TYPE_ELEMENT, alwaysTrue())); - assertEmptyList(findAllDeclaredMembers(NULL_TYPE_ELEMENT, alwaysFalse())); - assertEmptyList(findAllDeclaredMembers(NULL_TYPE_MIRROR, alwaysTrue())); - assertEmptyList(findAllDeclaredMembers(NULL_TYPE_MIRROR, alwaysFalse())); - } - - @Test - void testFindDeclaredMembersOnAll() { - assertGetAllDeclaredMembersOfModel(findDeclaredMembers(getDeclaredType(Model.class), true, alwaysTrue())); - assertGetAllDeclaredMembersOfModel(findDeclaredMembers(getTypeElement(Model.class), true, alwaysTrue())); - } - - @Test - void testFindDeclaredMembersOnNotAll() { - assertGetDeclaredMembersOfModel(findDeclaredMembers(getDeclaredType(Model.class), false, alwaysTrue())); - assertGetDeclaredMembersOfModel(findDeclaredMembers(getTypeElement(Model.class), false, alwaysTrue())); - } - - private void assertFindDeclaredMembersOfModel() { - TypeElement type = getTypeElement(Model.class); - assertGetDeclaredMembersOfModel(findDeclaredMembers(type, alwaysTrue(), alwaysTrue())); - assertGetDeclaredMembersOfModel(findDeclaredMembers(type.asType(), alwaysTrue())); - - assertEmptyList(findDeclaredMembers(type, alwaysFalse())); - assertEmptyList(findDeclaredMembers(type.asType(), alwaysFalse())); - } - - private void assertFindAllDeclaredMembersOfModel() { - TypeElement type = getTypeElement(Model.class); - assertGetAllDeclaredMembersOfModel(findAllDeclaredMembers(type, alwaysTrue(), alwaysTrue())); - assertGetAllDeclaredMembersOfModel(findAllDeclaredMembers(type.asType(), alwaysTrue())); - - assertEmptyList(findAllDeclaredMembers(type, alwaysFalse())); - assertEmptyList(findAllDeclaredMembers(type.asType(), alwaysFalse())); - } - - private void assertGetDeclaredMembersOfModel() { - TypeElement type = getTypeElement(Model.class); - assertGetDeclaredMembersOfModel(getDeclaredMembers(type)); - assertGetDeclaredMembersOfModel(getDeclaredMembers(type.asType())); - } - - private void assertGetDeclaredMembersOfModel(List members) { - List fields = fieldsIn(members); - assertEquals(19, members.size()); - assertEquals(6, fields.size()); - assertEquals("f", fields.get(0).getSimpleName().toString()); - assertEquals("d", fields.get(1).getSimpleName().toString()); - assertEquals("tu", fields.get(2).getSimpleName().toString()); - assertEquals("str", fields.get(3).getSimpleName().toString()); - assertEquals("bi", fields.get(4).getSimpleName().toString()); - assertEquals("bd", fields.get(5).getSimpleName().toString()); - } - - private void assertGetAllDeclaredMembersOfModel() { - TypeElement type = getTypeElement(Model.class); - assertGetAllDeclaredMembersOfModel(getAllDeclaredMembers(type)); - assertGetAllDeclaredMembersOfModel(getAllDeclaredMembers(type.asType())); - } - - private void assertGetAllDeclaredMembersOfModel(List members) { - List fields = fieldsIn(members); - assertEquals(11, fields.size()); - assertEquals("f", fields.get(0).getSimpleName().toString()); - assertEquals("d", fields.get(1).getSimpleName().toString()); - assertEquals("tu", fields.get(2).getSimpleName().toString()); - assertEquals("str", fields.get(3).getSimpleName().toString()); - assertEquals("bi", fields.get(4).getSimpleName().toString()); - assertEquals("bd", fields.get(5).getSimpleName().toString()); - assertEquals("b", fields.get(6).getSimpleName().toString()); - assertEquals("s", fields.get(7).getSimpleName().toString()); - assertEquals("i", fields.get(8).getSimpleName().toString()); - assertEquals("l", fields.get(9).getSimpleName().toString()); - assertEquals("z", fields.get(10).getSimpleName().toString()); - } -} diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/MessagerUtilsTest.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/MessagerUtilsTest.java deleted file mode 100644 index 9e7d629ae..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/MessagerUtilsTest.java +++ /dev/null @@ -1,79 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package io.microsphere.annotation.processor.util; - - -import io.microsphere.annotation.processor.AbstractAnnotationProcessingTest; -import org.junit.jupiter.api.Test; - -import javax.annotation.processing.Messager; - -import static io.microsphere.annotation.processor.util.MessagerUtils.printError; -import static io.microsphere.annotation.processor.util.MessagerUtils.printMandatoryWarning; -import static io.microsphere.annotation.processor.util.MessagerUtils.printMessage; -import static io.microsphere.annotation.processor.util.MessagerUtils.printNote; -import static io.microsphere.annotation.processor.util.MessagerUtils.printWarning; -import static javax.tools.Diagnostic.Kind.OTHER; - -/** - * {@link MessagerUtils} Test - * - * @author Mercy - * @see MessagerUtils - * @see Messager - * @since 1.0.0 - */ -class MessagerUtilsTest extends AbstractAnnotationProcessingTest { - - private Messager messager; - - @Override - protected void beforeTest() { - this.messager = this.processingEnv.getMessager(); - } - - @Test - void testPrintNote() { - printNote(this.processingEnv, "Hello, {}!", "printNote"); - printNote(this.messager, "Hello, {}!", "printNote"); - } - - @Test - void testPrintWarning() { - printWarning(this.processingEnv, "Hello, {}!", "printWarning"); - printWarning(this.messager, "Hello, {}!", "printWarning"); - } - - @Test - void testPrintMandatoryWarning() { - printMandatoryWarning(this.processingEnv, "Hello, {}!", "printMandatoryWarning"); - printMandatoryWarning(this.messager, "Hello, {}!", "printMandatoryWarning"); - } - - @Test - void testPrintError() { - printError(this.processingEnv, "Hello, {}!", "printError"); - printError(this.messager, "Hello, {}!", "printError"); - } - - @Test - void testPrintMessage() { - printMessage(this.processingEnv, OTHER, "Hello, {}!", "printMessage"); - printMessage(this.messager, OTHER, "Hello, {}!", "printMessage"); - } -} \ No newline at end of file diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/MethodUtilsTest.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/MethodUtilsTest.java deleted file mode 100644 index f5e728b85..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/MethodUtilsTest.java +++ /dev/null @@ -1,506 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor.util; - -import io.microsphere.annotation.processor.AbstractAnnotationProcessingTest; -import io.microsphere.annotation.processor.TestService; -import io.microsphere.annotation.processor.model.Model; -import io.microsphere.constants.Constants; -import io.microsphere.constants.PropertyConstants; -import org.junit.jupiter.api.Test; - -import javax.lang.model.element.Element; -import javax.lang.model.element.ExecutableElement; -import javax.lang.model.element.TypeElement; -import javax.lang.model.type.TypeMirror; -import java.io.Serializable; -import java.lang.reflect.Type; -import java.util.List; -import java.util.Set; - -import static io.microsphere.annotation.processor.util.ElementUtils.isPublicNonStatic; -import static io.microsphere.annotation.processor.util.MemberUtils.getDeclaredMembers; -import static io.microsphere.annotation.processor.util.MethodUtils.filterMethods; -import static io.microsphere.annotation.processor.util.MethodUtils.findAllDeclaredMethods; -import static io.microsphere.annotation.processor.util.MethodUtils.findDeclaredMethods; -import static io.microsphere.annotation.processor.util.MethodUtils.findMethod; -import static io.microsphere.annotation.processor.util.MethodUtils.findPublicNonStaticMethods; -import static io.microsphere.annotation.processor.util.MethodUtils.getAllDeclaredMethods; -import static io.microsphere.annotation.processor.util.MethodUtils.getDeclaredMethods; -import static io.microsphere.annotation.processor.util.MethodUtils.getEnclosingElement; -import static io.microsphere.annotation.processor.util.MethodUtils.getMethodName; -import static io.microsphere.annotation.processor.util.MethodUtils.getMethodParameterTypeMirrors; -import static io.microsphere.annotation.processor.util.MethodUtils.getMethodParameterTypeNames; -import static io.microsphere.annotation.processor.util.MethodUtils.getOverrideMethod; -import static io.microsphere.annotation.processor.util.MethodUtils.getReturnTypeName; -import static io.microsphere.annotation.processor.util.MethodUtils.isMethod; -import static io.microsphere.annotation.processor.util.MethodUtils.isPublicNonStaticMethod; -import static io.microsphere.annotation.processor.util.MethodUtils.matches; -import static io.microsphere.collection.Lists.ofList; -import static io.microsphere.lang.function.Predicates.alwaysFalse; -import static io.microsphere.lang.function.Predicates.alwaysTrue; -import static io.microsphere.reflect.TypeUtils.getTypeNames; -import static io.microsphere.util.ArrayUtils.EMPTY_STRING_ARRAY; -import static io.microsphere.util.ArrayUtils.ofArray; -import static java.util.Collections.emptyList; -import static javax.lang.model.element.ElementKind.METHOD; -import static org.junit.jupiter.api.Assertions.assertArrayEquals; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.junit.jupiter.api.Assertions.assertTrue; - -/** - * {@link MethodUtils} Test - * - * @author Mercy - * @since 1.0.0 - */ -class MethodUtilsTest extends AbstractAnnotationProcessingTest { - - private List objectMethods; - - private int objectMethodsSize; - - @Override - protected void addCompiledClasses(Set> compiledClasses) { - compiledClasses.add(PropertyConstants.class); - } - - @Override - protected void beforeTest() { - super.beforeTest(); - TypeElement type = getTypeElement(Object.class); - List methods = getDeclaredMethods(type); - this.objectMethods = methods; - this.objectMethodsSize = methods.size(); - } - - @Test - void testDeclaredMethods() { - TypeElement type = getTypeElement(Model.class); - List methods = getDeclaredMethods(type); - assertEquals(12, methods.size()); - - methods = getDeclaredMethods(type.asType()); - assertEquals(12, methods.size()); - } - - @Test - void testDeclaredMethodsOnNull() { - assertTrue(getDeclaredMethods(NULL_TYPE_ELEMENT).isEmpty()); - assertTrue(getDeclaredMethods(NULL_TYPE_MIRROR).isEmpty()); - } - - @Test - void testGetAllDeclaredMethods() { - TypeElement type = getTypeElement(Model.class); - List methods = getAllDeclaredMethods(type); - assertEquals(objectMethodsSize + 22, methods.size()); - - methods = getAllDeclaredMethods(type.asType()); - assertEquals(objectMethodsSize + 22, methods.size()); - } - - @Test - void testGetAllDeclaredMethodsOnNull() { - assertTrue(getAllDeclaredMethods(NULL_TYPE_ELEMENT).isEmpty()); - assertTrue(getAllDeclaredMethods(NULL_TYPE_MIRROR).isEmpty()); - } - - @Test - void testFindDeclaredMethods() { - List methods = findDeclaredMethods(testTypeElement, alwaysTrue()); - assertEquals(2, methods.size()); - - methods = findDeclaredMethods(testTypeMirror, alwaysTrue()); - assertEquals(2, methods.size()); - - methods = findDeclaredMethods(testTypeElement, alwaysFalse()); - assertEmptyList(methods); - - methods = findDeclaredMethods(testTypeMirror, alwaysFalse()); - assertEmptyList(methods); - } - - @Test - void testFindDeclaredMethodsOnNoMemberType() { - TypeElement typeElement = getTypeElement(Serializable.class); - List methods = findDeclaredMethods(typeElement, alwaysTrue()); - assertEmptyList(methods); - } - - @Test - void testFindDeclaredMethodsOnNoMethodType() { - TypeElement typeElement = getTypeElement(PropertyConstants.class); - List methods = findDeclaredMethods(typeElement, alwaysTrue()); - assertEmptyList(methods); - } - - @Test - void testFindAllDeclaredMethods() { - List methods = findAllDeclaredMethods(testTypeElement, alwaysTrue()); - assertEquals(objectMethodsSize + 14, methods.size()); - - methods = findAllDeclaredMethods(testTypeMirror, alwaysTrue()); - assertEquals(objectMethodsSize + 14, methods.size()); - - methods = findAllDeclaredMethods(testTypeElement, alwaysFalse()); - assertEmptyList(methods); - - methods = findAllDeclaredMethods(testTypeMirror, alwaysFalse()); - assertEmptyList(methods); - } - - @Test - void testFindAllDeclaredMethodsOnNoMemberType() { - TypeElement typeElement = getTypeElement(Serializable.class); - List methods = findAllDeclaredMethods(typeElement, alwaysTrue()); - assertEmptyList(methods); - } - - @Test - void testFindAllDeclaredMethodsOnNoMethodType() { - TypeElement typeElement = getTypeElement(Constants.class); - List methods = findAllDeclaredMethods(typeElement, alwaysTrue()); - assertEmptyList(methods); - } - - @Test - void testFindAllDeclaredMethodsOnNull() { - assertEmptyList(findAllDeclaredMethods(NULL_TYPE_ELEMENT, alwaysTrue())); - assertEmptyList(findAllDeclaredMethods(NULL_TYPE_ELEMENT, alwaysFalse())); - assertEmptyList(findAllDeclaredMethods(NULL_TYPE_MIRROR, alwaysTrue())); - assertEmptyList(findAllDeclaredMethods(NULL_TYPE_MIRROR, alwaysFalse())); - } - - @Test - void testFindAllDeclaredMethodsWithExcludedTypes() { - List methods = findAllDeclaredMethodsWithoutObjectType(); - assertEquals(14, methods.size()); - } - - @Test - void testFindAllDeclaredMethodsWithExcludedTypesOnNull() { - assertEmptyList(findAllDeclaredMethods(NULL_TYPE_ELEMENT, Object.class)); - assertEmptyList(findAllDeclaredMethods(NULL_TYPE_MIRROR, Object.class)); - } - - @Test - void testFindPublicNonStaticMethods() { - List methods = findPublicNonStaticMethods(testTypeElement, Object.class); - assertEquals(14, methods.size()); - - methods = findPublicNonStaticMethods(testTypeElement.asType(), Object.class); - assertEquals(14, methods.size()); - } - - @Test - void testFindPublicNonStaticMethodsOnNull() { - assertEmptyList(findPublicNonStaticMethods(NULL_TYPE_ELEMENT, Object.class)); - assertEmptyList(findPublicNonStaticMethods(NULL_TYPE_MIRROR, Object.class)); - } - - @Test - void testIsMethod() { - List members = getDeclaredMembers(testTypeElement); - for (Element member : members) { - if (member instanceof ExecutableElement) { - ExecutableElement element = (ExecutableElement) member; - assertEquals(METHOD == member.getKind(), isMethod(element)); - } - } - } - - @Test - void testIsMethodOnNull() { - assertFalse(isMethod(NULL_METHOD)); - } - - @Test - void testIsPublicNonStaticMethod() { - List members = getDeclaredMembers(testTypeElement); - for (Element member : members) { - if (member instanceof ExecutableElement) { - ExecutableElement element = (ExecutableElement) member; - switch (member.getKind()) { - case METHOD: - assertEquals(isPublicNonStaticMethod(element), isPublicNonStatic(element)); - break; - case CONSTRUCTOR: - assertFalse(isPublicNonStaticMethod(element)); - break; - } - } - } - - // Integer#valueOf(String) is a public static method - assertFalse(isPublicNonStaticMethod(findMethod(getTypeElement(Integer.class), "valueOf", String.class))); - - } - - @Test - void testIsPublicNonStaticMethodOnNull() { - assertFalse(isPublicNonStaticMethod(NULL_METHOD)); - } - - @Test - void testFindMethod() { - // Test methods from java.lang.Object - // Object#toString() - Type type = Model.class; - assertFindMethod(type, "toString"); - - // Object#hashCode() - assertFindMethod(type, "hashCode"); - - // Object#getClass() - assertFindMethod(type, "getClass"); - - // Object#finalize() - assertFindMethod(type, "finalize"); - - // Object#clone() - assertFindMethod(type, "clone"); - - // Object#notify() - assertFindMethod(type, "notify"); - - // Object#notifyAll() - assertFindMethod(type, "notifyAll"); - - // Object#wait(long) - assertFindMethod(type, "wait", long.class); - - // Object#wait(long,int) - assertFindMethod(type, "wait", long.class, int.class); - - // Object#equals(Object) - assertFindMethod(type, "equals", Object.class); - } - - @Test - void testFindMethodOnNotFound() { - assertNull(findMethod(testTypeElement, "notFound")); - assertNull(findMethod(testTypeElement, "notFound", String.class)); - assertNull(findMethod(testTypeElement, "notFound", "java.lang.String")); - - assertNull(findMethod(testTypeMirror, "notFound")); - assertNull(findMethod(testTypeMirror, "notFound", String.class)); - assertNull(findMethod(testTypeMirror, "notFound", "java.lang.String")); - } - - @Test - void testFindMethodOnNull() { - assertNull(findMethod(NULL_TYPE_ELEMENT, "toString")); - assertNull(findMethod(NULL_TYPE_ELEMENT, "toString", String.class)); - assertNull(findMethod(NULL_TYPE_ELEMENT, "toString", "java.lang.String")); - assertNull(findMethod(NULL_TYPE_ELEMENT, "toString", NULL_TYPE_ARRAY)); - assertNull(findMethod(NULL_TYPE_ELEMENT, "toString", NULL_STRING_ARRAY)); - - assertNull(findMethod(NULL_TYPE_MIRROR, "toString")); - assertNull(findMethod(NULL_TYPE_MIRROR, "toString", String.class)); - assertNull(findMethod(NULL_TYPE_MIRROR, "toString", "java.lang.String")); - assertNull(findMethod(NULL_TYPE_MIRROR, "toString", NULL_TYPE_ARRAY)); - assertNull(findMethod(NULL_TYPE_MIRROR, "toString", NULL_STRING_ARRAY)); - - assertNull(findMethod(testTypeElement, NULL_STRING)); - assertNull(findMethod(testTypeElement, NULL_STRING, String.class)); - assertNull(findMethod(testTypeElement, NULL_STRING, "java.lang.String")); - assertNull(findMethod(testTypeElement, NULL_STRING, NULL_TYPE_ARRAY)); - assertNull(findMethod(testTypeElement, NULL_STRING, NULL_STRING_ARRAY)); - - assertNull(findMethod(testTypeMirror, NULL_STRING)); - assertNull(findMethod(testTypeMirror, NULL_STRING, String.class)); - assertNull(findMethod(testTypeMirror, NULL_STRING, "java.lang.String")); - assertNull(findMethod(testTypeMirror, NULL_STRING, NULL_TYPE_ARRAY)); - assertNull(findMethod(testTypeMirror, NULL_STRING, NULL_STRING_ARRAY)); - - - assertNull(findMethod(testTypeElement, "toString", NULL_TYPE_ARRAY)); - assertNull(findMethod(testTypeElement, "toString", NULL_STRING_ARRAY)); - - assertNull(findMethod(testTypeMirror, "toString", NULL_TYPE_ARRAY)); - assertNull(findMethod(testTypeMirror, "toString", NULL_STRING_ARRAY)); - } - - @Test - void testGetOverrideMethod() { - List methods = findAllDeclaredMethodsWithoutObjectType(); - - ExecutableElement overrideMethod = getOverrideMethod(processingEnv, testTypeElement, methods.get(0)); - assertNull(overrideMethod); - - ExecutableElement declaringMethod = findMethod(getTypeElement(TestService.class), "echo", "java.lang.String"); - - overrideMethod = getOverrideMethod(processingEnv, testTypeElement, declaringMethod); - assertEquals(methods.get(0), overrideMethod); - } - - @Test - void testFilterMethods() { - - } - - @Test - void testFilterMethodsOnNull() { - assertEmptyList(filterMethods(NULL_LIST, alwaysTrue())); - assertEmptyList(filterMethods(NULL_LIST, NULL_PREDICATE_ARRAY)); - } - - @Test - void testFilterMethodsOnEmpty() { - assertEmptyList(filterMethods(emptyList(), alwaysTrue())); - assertEmptyList(filterMethods(emptyList(), NULL_PREDICATE_ARRAY)); - } - - @Test - void testFilterMethodsOnReturningEmptyList() { - List methods = getDeclaredMethods(testTypeElement); - assertEmptyList(filterMethods(methods, alwaysFalse())); - assertEquals(methods, filterMethods(methods)); - } - - @Test - void testGetMethodName() { - ExecutableElement method = findMethod(testTypeElement, "echo", "java.lang.String"); - assertEquals("echo", getMethodName(method)); - assertNull(getMethodName(NULL_METHOD)); - } - - @Test - void testGetMethodNameOnNull() { - assertNull(getMethodName(NULL_METHOD)); - } - - @Test - void testReturnTypeName() { - ExecutableElement method = findMethod(testTypeElement, "echo", "java.lang.String"); - assertEquals("java.lang.String", getReturnTypeName(method)); - } - - @Test - void testReturnTypeNameOnNull() { - assertNull(getReturnTypeName(NULL_METHOD)); - } - - @Test - void testMatchParameterTypeNames() { - String[] parameterTypeNames = ofArray("java.lang.String"); - ExecutableElement method = findMethod(testTypeElement, "echo", parameterTypeNames); - assertArrayEquals(parameterTypeNames, getMethodParameterTypeNames(method)); - } - - @Test - void testMatchParameterTypeNamesOnNull() { - assertSame(EMPTY_STRING_ARRAY, getMethodParameterTypeNames(NULL_METHOD)); - } - - @Test - void testMatchParameterTypes() { - ExecutableElement method = findMethod(testTypeElement, "toString"); - assertEmptyList(getMethodParameterTypeMirrors(method)); - - method = findMethod(testTypeElement, "equals", Object.class); - List parameterTypes = getMethodParameterTypeMirrors(method); - assertEquals(ofList(parameterTypes.toArray(EMPTY_TYPE_MIRROR_ARRAY)), parameterTypes); - } - - @Test - void testMatchParameterTypesOnNull() { - assertEmptyList(getMethodParameterTypeMirrors(NULL_METHOD)); - } - - @Test - void testMatches() { - assertFindMethod(testClass, "echo", String.class); - } - - @Test - void tstMatchesOnFalse() { - ExecutableElement method = findMethod(testTypeElement, "echo", String.class); - - Type[] parameterTypes = ofArray(String.class, String.class); - String[] parameterTypeNames = getTypeNames(parameterTypes); - assertFalse(matches(method, "echo", parameterTypes)); - assertFalse(matches(method, "echo", parameterTypeNames)); - - parameterTypes = ofArray(Object.class); - parameterTypeNames = getTypeNames(parameterTypes); - assertFalse(matches(method, "echo", parameterTypes)); - assertFalse(matches(method, "echo", parameterTypeNames)); - } - - @Test - void testMatchesOnNull() { - String methodName = "echo"; - Type[] parameterTypes = ofArray(String.class); - String[] parameterTypeNames = getTypeNames(parameterTypes); - ExecutableElement method = findMethod(testTypeElement, methodName, parameterTypes); - - assertFalse(matches(NULL_METHOD, NULL_STRING, parameterTypes)); - assertFalse(matches(method, NULL_STRING, parameterTypes)); - assertFalse(matches(method, methodName, NULL_TYPE_ARRAY)); - - assertFalse(matches(NULL_METHOD, NULL_STRING, parameterTypeNames)); - assertFalse(matches(method, NULL_STRING, parameterTypeNames)); - assertFalse(matches(method, methodName, NULL_STRING_ARRAY)); - } - - @Test - void testGetEnclosingElement() { - String methodName = "echo"; - Type[] parameterTypes = ofArray(String.class); - ExecutableElement method = findMethod(testTypeElement, methodName, parameterTypes); - assertSame(testTypeElement, getEnclosingElement(method)); - } - - @Test - void testGetEnclosingElementOnNull() { - assertNull(getEnclosingElement(NULL_METHOD)); - } - - private void assertFindMethod(Type type, String methodName, Type... parameterTypes) { - TypeElement typeElement = getTypeElement(type); - String[] parameterTypeNames = getTypeNames(parameterTypes); - - ExecutableElement method = findMethod(typeElement, methodName, parameterTypes); - assertMatchesMethod(method, methodName, parameterTypes); - - method = findMethod(typeElement, methodName, parameterTypeNames); - assertMatchesMethod(method, methodName, parameterTypes); - - method = findMethod(typeElement.asType(), methodName, parameterTypes); - assertMatchesMethod(method, methodName, parameterTypes); - - method = findMethod(typeElement.asType(), methodName, parameterTypeNames); - assertMatchesMethod(method, methodName, parameterTypeNames); - } - - private void assertMatchesMethod(ExecutableElement method, String methodName, Type... parameterTypes) { - assertTrue(matches(method, methodName, parameterTypes)); - } - - private void assertMatchesMethod(ExecutableElement method, String methodName, String... parameterTypeNames) { - assertTrue(matches(method, methodName, parameterTypeNames)); - } - - private List findAllDeclaredMethodsWithoutObjectType() { - return findAllDeclaredMethods(testTypeElement, Object.class); - } -} diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/TypeUtilsTest.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/TypeUtilsTest.java deleted file mode 100644 index 3908724fc..000000000 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/TypeUtilsTest.java +++ /dev/null @@ -1,1877 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.microsphere.annotation.processor.util; - -import io.microsphere.annotation.processor.AbstractAnnotationProcessingTest; -import io.microsphere.annotation.processor.DefaultTestService; -import io.microsphere.annotation.processor.GenericTestService; -import io.microsphere.annotation.processor.TestService; -import io.microsphere.annotation.processor.TestServiceImpl; -import io.microsphere.annotation.processor.model.ArrayTypeModel; -import io.microsphere.annotation.processor.model.CollectionTypeModel; -import io.microsphere.annotation.processor.model.Color; -import io.microsphere.annotation.processor.model.MapTypeModel; -import io.microsphere.annotation.processor.model.Model; -import io.microsphere.annotation.processor.model.PrimitiveTypeModel; -import org.junit.jupiter.api.Test; - -import javax.lang.model.element.Element; -import javax.lang.model.element.TypeElement; -import javax.lang.model.type.DeclaredType; -import javax.lang.model.type.TypeKind; -import javax.lang.model.type.TypeMirror; -import java.io.Serializable; -import java.lang.reflect.Type; -import java.math.BigDecimal; -import java.math.BigInteger; -import java.util.Date; -import java.util.EventListener; -import java.util.List; -import java.util.Set; -import java.util.concurrent.TimeUnit; -import java.util.function.Predicate; - -import static io.microsphere.annotation.processor.util.FieldUtils.findField; -import static io.microsphere.annotation.processor.util.FieldUtils.getDeclaredFields; -import static io.microsphere.annotation.processor.util.MethodUtils.findMethod; -import static io.microsphere.annotation.processor.util.TypeUtils.findAllDeclaredTypes; -import static io.microsphere.annotation.processor.util.TypeUtils.findAllDeclaredTypesOfInterfaces; -import static io.microsphere.annotation.processor.util.TypeUtils.findAllDeclaredTypesOfSuperTypes; -import static io.microsphere.annotation.processor.util.TypeUtils.findAllDeclaredTypesOfSuperclasses; -import static io.microsphere.annotation.processor.util.TypeUtils.findAllTypeElementsOfInterfaces; -import static io.microsphere.annotation.processor.util.TypeUtils.findAllTypeElementsOfSuperclasses; -import static io.microsphere.annotation.processor.util.TypeUtils.findAllTypeMirrorsOfInterfaces; -import static io.microsphere.annotation.processor.util.TypeUtils.findDeclaredTypes; -import static io.microsphere.annotation.processor.util.TypeUtils.findDeclaredTypesOfInterfaces; -import static io.microsphere.annotation.processor.util.TypeUtils.findInterfaceTypeMirror; -import static io.microsphere.annotation.processor.util.TypeUtils.findTypeElements; -import static io.microsphere.annotation.processor.util.TypeUtils.findTypeElementsOfInterfaces; -import static io.microsphere.annotation.processor.util.TypeUtils.findTypeMirrorsOfInterfaces; -import static io.microsphere.annotation.processor.util.TypeUtils.getAllDeclaredTypes; -import static io.microsphere.annotation.processor.util.TypeUtils.getAllDeclaredTypesOfInterfaces; -import static io.microsphere.annotation.processor.util.TypeUtils.getAllDeclaredTypesOfSuperTypes; -import static io.microsphere.annotation.processor.util.TypeUtils.getAllDeclaredTypesOfSuperclasses; -import static io.microsphere.annotation.processor.util.TypeUtils.getAllTypeElements; -import static io.microsphere.annotation.processor.util.TypeUtils.getAllTypeElementsOfInterfaces; -import static io.microsphere.annotation.processor.util.TypeUtils.getAllTypeElementsOfSuperTypes; -import static io.microsphere.annotation.processor.util.TypeUtils.getAllTypeElementsOfSuperclasses; -import static io.microsphere.annotation.processor.util.TypeUtils.getAllTypeMirrorsOfInterfaces; -import static io.microsphere.annotation.processor.util.TypeUtils.getDeclaredTypeOfSuperclass; -import static io.microsphere.annotation.processor.util.TypeUtils.getDeclaredTypes; -import static io.microsphere.annotation.processor.util.TypeUtils.getDeclaredTypesOfInterfaces; -import static io.microsphere.annotation.processor.util.TypeUtils.getTypeElementOfSuperclass; -import static io.microsphere.annotation.processor.util.TypeUtils.getTypeElementsOfInterfaces; -import static io.microsphere.annotation.processor.util.TypeUtils.getTypeMirrorsOfInterfaces; -import static io.microsphere.annotation.processor.util.TypeUtils.isAnnotationType; -import static io.microsphere.annotation.processor.util.TypeUtils.isArrayType; -import static io.microsphere.annotation.processor.util.TypeUtils.isClassType; -import static io.microsphere.annotation.processor.util.TypeUtils.isDeclaredType; -import static io.microsphere.annotation.processor.util.TypeUtils.isEnumType; -import static io.microsphere.annotation.processor.util.TypeUtils.isInterfaceType; -import static io.microsphere.annotation.processor.util.TypeUtils.isPrimitiveType; -import static io.microsphere.annotation.processor.util.TypeUtils.isSameType; -import static io.microsphere.annotation.processor.util.TypeUtils.isSimpleType; -import static io.microsphere.annotation.processor.util.TypeUtils.isTypeElement; -import static io.microsphere.annotation.processor.util.TypeUtils.ofDeclaredType; -import static io.microsphere.annotation.processor.util.TypeUtils.ofDeclaredTypes; -import static io.microsphere.annotation.processor.util.TypeUtils.ofTypeElement; -import static io.microsphere.annotation.processor.util.TypeUtils.ofTypeElements; -import static io.microsphere.annotation.processor.util.TypeUtils.ofTypeMirrors; -import static io.microsphere.annotation.processor.util.TypeUtils.typeElementFinder; -import static io.microsphere.collection.ListUtils.ofList; -import static io.microsphere.lang.function.Predicates.alwaysFalse; -import static io.microsphere.lang.function.Predicates.alwaysTrue; -import static io.microsphere.reflect.TypeUtils.getTypeNames; -import static io.microsphere.util.ArrayUtils.EMPTY_STRING_ARRAY; -import static io.microsphere.util.ArrayUtils.combine; -import static io.microsphere.util.ArrayUtils.length; -import static io.microsphere.util.ArrayUtils.ofArray; -import static java.util.Collections.emptyList; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.junit.jupiter.api.Assertions.assertTrue; - -/** - * The {@link TypeUtils} Test - * - * @author Mercy - * @since 1.0.0 - */ -class TypeUtilsTest extends AbstractAnnotationProcessingTest { - - /** - * self type - */ - private static final Class SELF_TYPE = TestServiceImpl.class; - - /** - * super class - */ - private static final Class SUPER_CLASS = GenericTestService.class; - - /** - * all types - */ - private static final Type[] ALL_TYPES = ofArray(SELF_TYPE, SUPER_CLASS, DefaultTestService.class, Object.class, TestService.class, EventListener.class, AutoCloseable.class, Serializable.class); - - /** - * all super types - */ - private static final Type[] ALL_SUPER_TYPES = ofArray(SUPER_CLASS, DefaultTestService.class, Object.class, TestService.class, EventListener.class, AutoCloseable.class, Serializable.class); - - /** - * all super classes - */ - private static final Type[] ALL_SUPER_CLASSES = ofArray(SUPER_CLASS, DefaultTestService.class, Object.class); - - /** - * all super interfaces - */ - private static final Type[] ALL_SUPER_INTERFACES = ofArray(TestService.class, EventListener.class, AutoCloseable.class, Serializable.class); - - /** - * super interfaces - */ - private static final Type[] SUPER_INTERFACES = ofArray(TestService.class, AutoCloseable.class, Serializable.class); - - /** - * super class + super interfaces - */ - private static final Type[] SUPER_TYPES = combine(SUPER_CLASS, SUPER_INTERFACES); - - /** - * self type + all super types = all types - */ - private static final Type[] SELF_TYPE_PLUS_ALL_SUPER_TYPES = combine(SELF_TYPE, ALL_SUPER_TYPES); - - /** - * self type + all super classes - */ - private static final Type[] SELF_TYPE_PLUS_ALL_SUPER_CLASSES = combine(SELF_TYPE, ALL_SUPER_CLASSES); - - /** - * self type + all super interfaces - */ - private static final Type[] SELF_TYPE_PLUS_ALL_SUPER_INTERFACES = combine(SELF_TYPE, ALL_SUPER_INTERFACES); - - /** - * self type + super class - */ - private static final Type[] SELF_TYPE_PLUS_SUPER_CLASS = ofArray(SELF_TYPE, SUPER_CLASS); - - /** - * self type + super interfaces - */ - private static final Type[] SELF_TYPE_PLUS_SUPER_INTERFACES = combine(SELF_TYPE, SUPER_INTERFACES); - - /** - * self type + super class + super interfaces - */ - private static final Type[] SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES = combine(SELF_TYPE, SUPER_TYPES); - - @Override - protected void addCompiledClasses(Set> compiledClasses) { - compiledClasses.add(ArrayTypeModel.class); - compiledClasses.add(CollectionTypeModel.class); - compiledClasses.add(Color.class); - compiledClasses.add(MapTypeModel.class); - } - - @Test - void testIsSimpleType() { - assertTrue(isSimpleType(getTypeElement(Void.class))); - assertTrue(isSimpleType(getTypeElement(Boolean.class))); - assertTrue(isSimpleType(getTypeElement(Character.class))); - assertTrue(isSimpleType(getTypeElement(Byte.class))); - assertTrue(isSimpleType(getTypeElement(Short.class))); - assertTrue(isSimpleType(getTypeElement(Integer.class))); - assertTrue(isSimpleType(getTypeElement(Long.class))); - assertTrue(isSimpleType(getTypeElement(Float.class))); - assertTrue(isSimpleType(getTypeElement(Double.class))); - assertTrue(isSimpleType(getTypeElement(String.class))); - assertTrue(isSimpleType(getTypeElement(BigDecimal.class))); - assertTrue(isSimpleType(getTypeElement(BigInteger.class))); - assertTrue(isSimpleType(getTypeElement(Date.class))); - assertTrue(isSimpleType(getTypeElement(Object.class))); - - assertFalse(isSimpleType(getTypeElement(getClass()))); - } - - @Test - void testIsSimpleTypeOnNull() { - assertFalse(isSimpleType(NULL_TYPE_ELEMENT)); - assertFalse(isSimpleType(NULL_TYPE_MIRROR)); - } - - @Test - void testIsSameType() { - assertIsSameType(testTypeElement, testClass); - - assertFalse(isSameType(getDeclaredType(String.class), "java.lang.Void")); - } - - @Test - void testIsSameTypeOnNull() { - assertFalse(isSameType(NULL_TYPE_MIRROR, testClass)); - assertFalse(isSameType(NULL_TYPE_MIRROR, testClassName)); - assertFalse(isSameType(NULL_ELEMENT, testClass)); - assertFalse(isSameType(NULL_ELEMENT, testClassName)); - - assertFalse(isSameType(testTypeElement, NULL_TYPE)); - assertFalse(isSameType(testTypeElement, NULL_STRING)); - - assertFalse(isSameType(testTypeMirror, NULL_TYPE)); - assertFalse(isSameType(testTypeMirror, NULL_STRING)); - - assertTrue(isSameType(NULL_TYPE_MIRROR, NULL_TYPE)); - assertTrue(isSameType(NULL_TYPE_MIRROR, NULL_STRING)); - assertTrue(isSameType(NULL_ELEMENT, NULL_TYPE)); - assertTrue(isSameType(NULL_ELEMENT, NULL_STRING)); - } - - @Test - void testIsArrayTypeOnTypeMirror() { - assertIsArrayType(ArrayTypeModel.class); - - assertFalse(isArrayType(getTypeMirror(Color.class))); - assertFalse(isArrayType(getTypeMirror(ArrayTypeModel.class))); - } - - @Test - void testIsArrayTypeOnElement() { - assertIsArrayType(getTypeElement(ArrayTypeModel.class)); - - assertFalse(isArrayType(getTypeElement(Color.class))); - assertFalse(isArrayType(getTypeElement(ArrayTypeModel.class))); - } - - @Test - void testIsArrayTypeOnNull() { - assertFalse(isArrayType(NULL_ELEMENT)); - assertFalse(isArrayType(NULL_TYPE_MIRROR)); - } - - @Test - void testIsEnumType() { - assertTrue(isEnumType(getDeclaredType(Color.class))); - assertFalse(isEnumType(getTypeElement(ArrayTypeModel.class))); - } - - @Test - void testIsEnumTypeOnNull() { - assertFalse(isEnumType(NULL_ELEMENT)); - assertFalse(isEnumType(NULL_TYPE_MIRROR)); - } - - @Test - void testIsClassType() { - // class - assertTrue(isClassType(getTypeElement(ArrayTypeModel.class))); - assertTrue(isClassType(getDeclaredType(ArrayTypeModel.class))); - - assertTrue(isClassType(getTypeElement(Model.class))); - assertTrue(isClassType(getDeclaredType(Model.class))); - - // enum - assertFalse(isClassType(getTypeElement(TimeUnit.class))); - assertFalse(isClassType(getDeclaredType(TimeUnit.class))); - - // interface - assertFalse(isClassType(getTypeElement(Serializable.class))); - assertFalse(isClassType(getDeclaredType(Serializable.class))); - } - - @Test - void testIsClassTypeOnNull() { - assertFalse(isClassType(NULL_ELEMENT)); - assertFalse(isClassType(NULL_TYPE_MIRROR)); - } - - @Test - void testIsPrimitiveType() { - TypeElement type = getTypeElement(PrimitiveTypeModel.class); - - getDeclaredFields(type).forEach(t -> { - assertTrue(isPrimitiveType(t)); - assertTrue(isPrimitiveType(t.asType())); - }); - - assertFalse(isPrimitiveType(getTypeElement(ArrayTypeModel.class))); - } - - @Test - void testIsPrimitiveTypeOnNull() { - assertFalse(isPrimitiveType(NULL_ELEMENT)); - assertFalse(isPrimitiveType(NULL_TYPE_MIRROR)); - } - - @Test - void testIsInterfaceType() { - assertTrue(isInterfaceType(getTypeElement(CharSequence.class))); - assertTrue(isInterfaceType(getDeclaredType(CharSequence.class))); - - assertFalse(isInterfaceType(getTypeElement(Model.class))); - assertFalse(isInterfaceType(getDeclaredType(Model.class))); - } - - @Test - void testIsInterfaceTypeOnNull() { - assertFalse(isInterfaceType(NULL_ELEMENT)); - assertFalse(isInterfaceType(NULL_TYPE_MIRROR)); - } - - @Test - void testIsAnnotationType() { - assertTrue(isAnnotationType(getTypeElement(Override.class))); - assertTrue(isAnnotationType(getDeclaredType(Override.class))); - - assertFalse(isAnnotationType(getTypeElement(Model.class))); - assertFalse(isAnnotationType(getDeclaredType(Model.class))); - } - - @Test - void testIsAnnotationTypeOnNull() { - assertFalse(isAnnotationType(NULL_ELEMENT)); - assertFalse(isAnnotationType(NULL_TYPE_MIRROR)); - } - - @Test - void testIsTypeElement() { - assertTrue(isTypeElement(testTypeElement)); - assertTrue(isTypeElement(testTypeMirror)); - assertTrue(isTypeElement(getFieldType(testTypeElement, "context"))); - - // primitive type - assertFalse(isTypeElement(getTypeMirror(int.class))); - } - - @Test - void testIsTypeElementOnNull() { - assertFalse(isTypeElement(NULL_ELEMENT)); - assertFalse(isTypeElement(NULL_TYPE_MIRROR)); - } - - @Test - void testIsDeclaredType() { - assertTrue(isDeclaredType(testTypeElement)); - assertTrue(isDeclaredType(testTypeMirror)); - assertFalse(isDeclaredType(types.getNullType())); - assertFalse(isDeclaredType(types.getPrimitiveType(TypeKind.BYTE))); - assertFalse(isDeclaredType(types.getArrayType(types.getPrimitiveType(TypeKind.BYTE)))); - - // field - assertFalse(isDeclaredType(findField(getTypeMirror(PrimitiveTypeModel.class), "z"))); - - // method - assertFalse(isDeclaredType(findMethod(testTypeElement, "close"))); - } - - @Test - void testIsDeclaredTypeOnNull() { - assertFalse(isDeclaredType(NULL_ELEMENT)); - assertFalse(isDeclaredType(NULL_TYPE_MIRROR)); - } - - @Test - void testOfTypeElement() { - assertEquals(testTypeElement, ofTypeElement(testTypeElement)); - assertEquals(testTypeElement, ofTypeElement(testTypeMirror)); - } - - @Test - void testOfTypeElementOnNull() { - assertNull(ofTypeElement(NULL_ELEMENT)); - assertNull(ofTypeElement(NULL_TYPE_MIRROR)); - } - - @Test - void testOfDeclaredType() { - assertEquals(testTypeMirror, testDeclaredType); - assertEquals(testTypeMirror, ofDeclaredType(testTypeMirror)); - assertEquals(testDeclaredType, ofDeclaredType(testTypeMirror)); - } - - @Test - void testOfDeclaredTypeOnNull() { - assertNull(ofDeclaredType(NULL_ELEMENT)); - assertNull(ofDeclaredType(NULL_TYPE_MIRROR)); - } - - @Test - void testOfTypeMirrors() { - assertOfTypeMirrors(String.class, SELF_TYPE, Color.class); - } - - @Test - void testOfTypeMirrorsOnNull() { - assertEmptyList(ofTypeMirrors(EMPTY_ELEMENT_ARRAY)); - assertEmptyList(ofTypeMirrors(NULL_COLLECTION)); - } - - @Test - void testOfTypeMirrorsOnEmpty() { - assertEmptyList(ofTypeMirrors(EMPTY_ELEMENT_ARRAY)); - assertEmptyList(ofTypeMirrors(emptyList())); - } - - @Test - void testOfTypeElements() { - assertOfTypeElements(String.class, SELF_TYPE, Color.class); - } - - @Test - void testOfTypeElementsOnNull() { - assertEmptyList(ofTypeElements(NULL_TYPE_MIRROR_ARRAY)); - assertEmptyList(ofTypeElements(NULL_COLLECTION)); - } - - @Test - void testOfTypeElementsOnEmpty() { - assertEmptyList(ofTypeElements(EMPTY_TYPE_MIRROR_ARRAY)); - assertEmptyList(ofTypeElements(emptyList())); - } - - @Test - void testOfDeclaredTypes() { - assertOfDeclaredTypes(String.class, SELF_TYPE, Color.class); - } - - @Test - void testOfDeclaredTypesWithFilter() { - List declaredTypes = ofDeclaredTypes(ofList(getTypeElement(String.class), getTypeElement(TestServiceImpl.class), getTypeElement(Color.class)), t -> true); - assertDeclaredTypes(declaredTypes, String.class, SELF_TYPE, Color.class); - } - - @Test - void testOfDeclaredTypesOnNull() { - assertEmptyList(ofDeclaredTypes(NULL_ELEMENT_ARRAY)); - assertEmptyList(ofDeclaredTypes(NULL_COLLECTION)); - } - - @Test - void testOfDeclaredTypesOnEmpty() { - assertEmptyList(ofDeclaredTypes(emptyList())); - } - - @Test - void testGetTypeElementOfSuperclass() { - TypeElement superTypeElement = getTypeElementOfSuperclass(testTypeElement); - assertEquals(getTypeElement(GenericTestService.class), superTypeElement); - - superTypeElement = getTypeElementOfSuperclass(superTypeElement); - assertEquals(getTypeElement(DefaultTestService.class), superTypeElement); - - superTypeElement = getTypeElementOfSuperclass(superTypeElement); - assertEquals(getTypeElement(Object.class), superTypeElement); - - assertNull(getTypeElementOfSuperclass(superTypeElement)); - } - - @Test - void testGetTypeElementOfSuperclassOnNull() { - assertNull(getTypeElementOfSuperclass(NULL_TYPE_ELEMENT)); - } - - @Test - void testGetAllTypeElementsOfSuperclasses() { - List allSuperTypes = getAllTypeElementsOfSuperclasses(testTypeElement); - assertTypeElements(allSuperTypes, ALL_SUPER_CLASSES); - } - - @Test - void testGetAllTypeElementsOfSuperclassesOnNull() { - assertEmptyList(getAllTypeElementsOfSuperclasses(NULL_TYPE_ELEMENT)); - } - - @Test - void testGetTypeElementsOfInterfaces() { - List typeElements = getTypeElementsOfInterfaces(testTypeElement); - assertTypeElements(typeElements, SUPER_INTERFACES); - } - - @Test - void testGetTypeElementsOfInterfacesOnNull() { - assertEmptyList(getTypeElementsOfInterfaces(NULL_TYPE_ELEMENT)); - } - - @Test - void testGetAllTypeElementsOfInterfaces() { - List typeElements = getAllTypeElementsOfInterfaces(testTypeElement); - assertTypeElements(typeElements, ALL_SUPER_INTERFACES); - } - - @Test - void testGetAllTypeElementsOfInterfacesOnNull() { - assertEmptyList(getAllTypeElementsOfInterfaces(NULL_TYPE_ELEMENT)); - } - - @Test - void testGetAllTypeElements() { - List allTypeElements = getAllTypeElements(testTypeElement); - assertTypeElements(allTypeElements, ALL_TYPES); - } - - @Test - void testGetAllTypeElementsOnNull() { - assertEmptyList(getAllTypeElements(NULL_TYPE_ELEMENT)); - } - - @Test - void testGetTypeElementsWithNoArgument() { - List typeElements = TypeUtils.getTypeElements(testTypeElement); - assertTypeElements(typeElements, SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES); - } - - @Test - void testGetTypeElements() { - // true true true true : all types - List typeElements = TypeUtils.getTypeElements(testTypeElement, true, true, true, true); - assertTypeElements(typeElements, ALL_TYPES); - assertEquals(getAllTypeElements(testTypeElement), typeElements); - - // true true true false : self type + all super classes - typeElements = TypeUtils.getTypeElements(testTypeElement, true, true, true, false); - assertTypeElements(typeElements, SELF_TYPE_PLUS_ALL_SUPER_CLASSES); - - // true true false true : self type + all super interfaces - typeElements = TypeUtils.getTypeElements(testTypeElement, true, true, false, true); - assertTypeElements(typeElements, SELF_TYPE_PLUS_ALL_SUPER_INTERFACES); - - // true true false false : self type - typeElements = TypeUtils.getTypeElements(testTypeElement, true, true, false, false); - assertTypeElements(typeElements, SELF_TYPE); - - // true false true true : self type + super class + super interfaces - typeElements = TypeUtils.getTypeElements(testTypeElement, true, false, true, true); - assertTypeElements(typeElements, SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES); - - // true false true false : self type + super class - typeElements = TypeUtils.getTypeElements(testTypeElement, true, false, true, false); - assertTypeElements(typeElements, SELF_TYPE_PLUS_SUPER_CLASS); - - // true false false true : self type + super interfaces - typeElements = TypeUtils.getTypeElements(testTypeElement, true, false, false, true); - assertTypeElements(typeElements, SELF_TYPE_PLUS_SUPER_INTERFACES); - - // true false false false : self type - typeElements = TypeUtils.getTypeElements(testTypeElement, true, false, false, false); - assertTypeElements(typeElements, SELF_TYPE); - - // false true true true : all super types - typeElements = TypeUtils.getTypeElements(testTypeElement, false, true, true, true); - assertTypeElements(typeElements, ALL_SUPER_TYPES); - assertEquals(getAllTypeElementsOfSuperTypes(testTypeElement), typeElements); - - // false true true false : all super classes - typeElements = TypeUtils.getTypeElements(testTypeElement, false, true, true, false); - assertTypeElements(typeElements, ALL_SUPER_CLASSES); - assertEquals(getAllTypeElementsOfSuperclasses(testTypeElement), typeElements); - - // false true false true : all super interfaces - typeElements = TypeUtils.getTypeElements(testTypeElement, false, true, false, true); - assertTypeElements(typeElements, ALL_SUPER_INTERFACES); - assertEquals(getAllTypeElementsOfInterfaces(testTypeElement), typeElements); - - // false true false false : nothing - typeElements = TypeUtils.getTypeElements(testTypeElement, false, true, false, false); - assertTypeElements(typeElements); - assertEmptyList(typeElements); - - // false false true true : super class + super interfaces - typeElements = TypeUtils.getTypeElements(testTypeElement, false, false, true, true); - assertTypeElements(typeElements, SUPER_TYPES); - - // false false true false : super class - typeElements = TypeUtils.getTypeElements(testTypeElement, false, false, true, false); - assertTypeElements(typeElements, SUPER_CLASS); - assertEquals(ofList(getTypeElementOfSuperclass(testTypeElement)), typeElements); - - // false false false true : super interfaces - typeElements = TypeUtils.getTypeElements(testTypeElement, false, false, false, true); - assertTypeElements(typeElements, SUPER_INTERFACES); - assertEquals(ofList(getTypeElementsOfInterfaces(testTypeElement)), typeElements); - - // false false false false : nothing - typeElements = TypeUtils.getTypeElements(testTypeElement, false, false, false, false); - assertTypeElements(typeElements); - assertEmptyList(typeElements); - } - - @Test - void testGetTypeElementsOnNull() { - assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, true, true, true, true)); - assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, true, true, true, false)); - assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, true, true, false, true)); - assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, true, true, false, false)); - - assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, true, false, true, true)); - assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, false, false, true, false)); - assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, false, false, false, true)); - assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, false, false, false, false)); - - assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, false, true, true, true)); - assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, false, true, true, false)); - assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, false, true, false, true)); - assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, false, true, false, false)); - - assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, false, false, true, true)); - assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, false, false, true, false)); - assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, false, false, false, true)); - assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, false, false, false, false)); - } - - @Test - void testFindAllTypeElementsOfSuperclasses() { - List typeElements = findAllTypeElementsOfSuperclasses(testTypeElement, alwaysTrue()); - assertTypeElements(typeElements, ALL_SUPER_CLASSES); - assertEquals(getAllTypeElementsOfSuperclasses(testTypeElement), typeElements); - - assertEmptyList(findAllTypeElementsOfSuperclasses(testTypeElement, alwaysFalse())); - } - - @Test - void testFindAllTypeElementsOfSuperclassesOnNull() { - assertEmptyList(findAllTypeElementsOfSuperclasses(NULL_TYPE_ELEMENT, alwaysTrue())); - assertEmptyList(findAllTypeElementsOfSuperclasses(NULL_TYPE_ELEMENT, alwaysFalse())); - } - - @Test - void testFindAllTypeElementsOfInterfaces() { - List typeElements = findAllTypeElementsOfInterfaces(testTypeElement, alwaysTrue()); - assertTypeElements(typeElements, ALL_SUPER_INTERFACES); - assertEquals(getAllTypeElementsOfInterfaces(testTypeElement), typeElements); - - assertEmptyList(findAllTypeElementsOfInterfaces(testTypeElement, alwaysFalse())); - } - - @Test - void testFindAllTypeElementsOfInterfacesOnNull() { - assertEmptyList(findAllTypeElementsOfInterfaces(NULL_TYPE_ELEMENT, alwaysTrue())); - assertEmptyList(findAllTypeElementsOfInterfaces(NULL_TYPE_ELEMENT, alwaysFalse())); - } - - @Test - void testFindTypeElementsOfInterfaces() { - List typeElements = findTypeElementsOfInterfaces(testTypeElement, alwaysTrue()); - assertTypeElements(typeElements, SUPER_INTERFACES); - assertEquals(getTypeElementsOfInterfaces(testTypeElement), typeElements); - - assertEmptyList(findTypeElementsOfInterfaces(testTypeElement, alwaysFalse())); - } - - @Test - void testFindTypeElementsOfInterfacesOnNull() { - assertEmptyList(findTypeElementsOfInterfaces(NULL_TYPE_ELEMENT, alwaysTrue())); - assertEmptyList(findTypeElementsOfInterfaces(NULL_TYPE_ELEMENT, alwaysFalse())); - } - - @Test - void testFindTypeElements() { - // true true true true : all types - List typeElements = findTypeElements(testTypeElement, true, true, true, true, alwaysTrue()); - assertTypeElements(typeElements, ALL_TYPES); - assertEquals(getAllTypeElements(testTypeElement), typeElements); - - // true true true false : self type + all super classes - typeElements = findTypeElements(testTypeElement, true, true, true, false, alwaysTrue()); - assertTypeElements(typeElements, SELF_TYPE_PLUS_ALL_SUPER_CLASSES); - - // true true false true : self type + all super interfaces - typeElements = findTypeElements(testTypeElement, true, true, false, true, alwaysTrue()); - assertTypeElements(typeElements, SELF_TYPE_PLUS_ALL_SUPER_INTERFACES); - - // true true false false : self type - typeElements = findTypeElements(testTypeElement, true, true, false, false, alwaysTrue()); - assertTypeElements(typeElements, SELF_TYPE); - - // true false true true : self type + super class + super interfaces - typeElements = findTypeElements(testTypeElement, true, false, true, true, alwaysTrue()); - assertTypeElements(typeElements, SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES); - - // true false true false : self type + super class - typeElements = findTypeElements(testTypeElement, true, false, true, false, alwaysTrue()); - assertTypeElements(typeElements, SELF_TYPE_PLUS_SUPER_CLASS); - - // true false false true : self type + super interfaces - typeElements = findTypeElements(testTypeElement, true, false, false, true, alwaysTrue()); - assertTypeElements(typeElements, SELF_TYPE_PLUS_SUPER_INTERFACES); - - // true false false false : self type - typeElements = findTypeElements(testTypeElement, true, false, false, false, alwaysTrue()); - assertTypeElements(typeElements, SELF_TYPE); - - // false true true true : all super types - typeElements = findTypeElements(testTypeElement, false, true, true, true, alwaysTrue()); - assertTypeElements(typeElements, ALL_SUPER_TYPES); - assertEquals(getAllTypeElementsOfSuperTypes(testTypeElement), typeElements); - - // false true true false : all super classes - typeElements = findTypeElements(testTypeElement, false, true, true, false, alwaysTrue()); - assertTypeElements(typeElements, ALL_SUPER_CLASSES); - assertEquals(getAllTypeElementsOfSuperclasses(testTypeElement), typeElements); - - // false true false true : all super interfaces - typeElements = findTypeElements(testTypeElement, false, true, false, true, alwaysTrue()); - assertTypeElements(typeElements, ALL_SUPER_INTERFACES); - assertEquals(getAllTypeElementsOfInterfaces(testTypeElement), typeElements); - - // false true false false : nothing - typeElements = findTypeElements(testTypeElement, false, true, false, false, alwaysTrue()); - assertTypeElements(typeElements); - assertEmptyList(typeElements); - - // false false true true : super types - typeElements = findTypeElements(testTypeElement, false, false, true, true, alwaysTrue()); - assertTypeElements(typeElements, SUPER_TYPES); - - // false false true false : super class - typeElements = findTypeElements(testTypeElement, false, false, true, false, alwaysTrue()); - assertTypeElements(typeElements, SUPER_CLASS); - assertEquals(ofList(getTypeElementOfSuperclass(testTypeElement)), typeElements); - - // false false false true : super interfaces - typeElements = findTypeElements(testTypeElement, false, false, false, true, alwaysTrue()); - assertTypeElements(typeElements, SUPER_INTERFACES); - assertEquals(ofList(getTypeElementsOfInterfaces(testTypeElement)), typeElements); - - // false false false false : nothing - typeElements = findTypeElements(testTypeElement, false, false, false, false, alwaysTrue()); - assertTypeElements(typeElements); - assertEmptyList(typeElements); - } - - @Test - void testFindTypeElementsOnNullFilterElement() { - assertThrows(IllegalArgumentException.class, - () -> findTypeElements(testTypeElement, true, true, true, true, new Predicate[]{null})); - } - - - @Test - void testGetDeclaredTypeOfSuperclass() { - DeclaredType superDeclaredType = getDeclaredTypeOfSuperclass(testTypeMirror); - assertEquals(superDeclaredType, getTypeElement(GenericTestService.class).asType()); - - superDeclaredType = getDeclaredTypeOfSuperclass(superDeclaredType); - assertEquals(superDeclaredType, getTypeElement(DefaultTestService.class).asType()); - - superDeclaredType = getDeclaredTypeOfSuperclass(superDeclaredType); - assertEquals(superDeclaredType, getTypeElement(Object.class).asType()); - - assertNull(getDeclaredTypeOfSuperclass(superDeclaredType)); - } - - @Test - void testGetDeclaredTypeOfSuperclassOnNull() { - assertNull(getDeclaredTypeOfSuperclass(NULL_ELEMENT)); - assertNull(getDeclaredTypeOfSuperclass(NULL_TYPE_MIRROR)); - } - - @Test - void testGetDeclaredTypesOfInterfaces() { - List declaredTypes = getDeclaredTypesOfInterfaces(testTypeMirror); - assertDeclaredTypes(declaredTypes, SUPER_INTERFACES); - } - - @Test - void testGetDeclaredTypesOfInterfacesOnNull() { - assertEmptyList(getDeclaredTypesOfInterfaces(NULL_ELEMENT)); - assertEmptyList(getDeclaredTypesOfInterfaces(NULL_TYPE_MIRROR)); - } - - @Test - void testGetAllDeclaredTypesOfSuperclasses() { - List declaredTypes = getAllDeclaredTypesOfSuperclasses(testTypeMirror); - assertDeclaredTypes(declaredTypes, ALL_SUPER_CLASSES); - } - - @Test - void testGetAllDeclaredTypesOfSuperclassesOnNull() { - assertEmptyList(getAllDeclaredTypesOfSuperclasses(NULL_ELEMENT)); - assertEmptyList(getAllDeclaredTypesOfSuperclasses(NULL_TYPE_MIRROR)); - } - - @Test - void testGetAllDeclaredTypesOfInterfaces() { - List declaredTypes = getAllDeclaredTypesOfInterfaces(testTypeMirror); - assertDeclaredTypes(declaredTypes, ALL_SUPER_INTERFACES); - } - - @Test - void testGetAllDeclaredTypesOfInterfacesOnNull() { - assertEmptyList(getAllDeclaredTypesOfInterfaces(NULL_ELEMENT)); - assertEmptyList(getAllDeclaredTypesOfInterfaces(NULL_TYPE_MIRROR)); - } - - @Test - void testGetAllDeclaredTypesOfSuperTypes() { - List declaredTypes = getAllDeclaredTypesOfSuperTypes(testTypeMirror); - assertDeclaredTypes(declaredTypes, ALL_SUPER_TYPES); - } - - @Test - void testGetAllDeclaredTypesOfSuperTypesOnNull() { - assertEmptyList(getAllDeclaredTypesOfSuperTypes(NULL_ELEMENT)); - assertEmptyList(getAllDeclaredTypesOfSuperTypes(NULL_TYPE_MIRROR)); - } - - @Test - void testGetAllDeclaredTypes() { - List declaredTypes = getAllDeclaredTypes(testTypeMirror); - assertDeclaredTypes(declaredTypes, ALL_TYPES); - } - - @Test - void testGetAllDeclaredTypesOnNull() { - assertEmptyList(getAllDeclaredTypes(NULL_ELEMENT)); - assertEmptyList(getAllDeclaredTypes(NULL_TYPE_MIRROR)); - } - - @Test - void testGetDeclaredTypes() { - // true true true true : all types - List declaredTypes = getDeclaredTypes(testTypeElement, true, true, true, true); - assertDeclaredTypes(declaredTypes, ALL_TYPES); - assertEquals(getAllDeclaredTypes(testTypeElement), declaredTypes); - - // true true true false : self type + all super classes - declaredTypes = getDeclaredTypes(testTypeElement, true, true, true, false); - assertDeclaredTypes(declaredTypes, SELF_TYPE_PLUS_ALL_SUPER_CLASSES); - - // true true false true : self type + all super interfaces - declaredTypes = getDeclaredTypes(testTypeElement, true, true, false, true); - assertDeclaredTypes(declaredTypes, SELF_TYPE_PLUS_ALL_SUPER_INTERFACES); - - // true true false false : self type - declaredTypes = getDeclaredTypes(testTypeElement, true, true, false, false); - assertDeclaredTypes(declaredTypes, SELF_TYPE); - - // true false true true : self type + super class + super interfaces - declaredTypes = getDeclaredTypes(testTypeElement, true, false, true, true); - assertDeclaredTypes(declaredTypes, SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES); - - // true false true false : self type + super class - declaredTypes = getDeclaredTypes(testTypeElement, true, false, true, false); - assertDeclaredTypes(declaredTypes, SELF_TYPE_PLUS_SUPER_CLASS); - - // true false false true : self type + super interfaces - declaredTypes = getDeclaredTypes(testTypeElement, true, false, false, true); - assertDeclaredTypes(declaredTypes, SELF_TYPE_PLUS_SUPER_INTERFACES); - - // true false false false : self type - declaredTypes = getDeclaredTypes(testTypeElement, true, false, false, false); - assertDeclaredTypes(declaredTypes, SELF_TYPE); - - // false true true true : all super types - declaredTypes = getDeclaredTypes(testTypeElement, false, true, true, true); - assertDeclaredTypes(declaredTypes, ALL_SUPER_TYPES); - assertEquals(getAllDeclaredTypesOfSuperTypes(testTypeElement), declaredTypes); - - // false true true false : all super classes - declaredTypes = getDeclaredTypes(testTypeElement, false, true, true, false); - assertDeclaredTypes(declaredTypes, ALL_SUPER_CLASSES); - assertEquals(getAllDeclaredTypesOfSuperclasses(testTypeElement), declaredTypes); - - // false true false true : all super interfaces - declaredTypes = getDeclaredTypes(testTypeElement, false, true, false, true); - assertDeclaredTypes(declaredTypes, ALL_SUPER_INTERFACES); - assertEquals(getAllDeclaredTypesOfInterfaces(testTypeElement), declaredTypes); - - // false true false false : nothing - declaredTypes = getDeclaredTypes(testTypeElement, false, true, false, false); - assertDeclaredTypes(declaredTypes); - assertEmptyList(declaredTypes); - - // false false true true : super class + super interfaces - declaredTypes = getDeclaredTypes(testTypeElement, false, false, true, true); - assertDeclaredTypes(declaredTypes, SUPER_TYPES); - - // false false true false : super class - declaredTypes = getDeclaredTypes(testTypeElement, false, false, true, false); - assertDeclaredTypes(declaredTypes, SUPER_CLASS); - assertEquals(ofList(getDeclaredTypeOfSuperclass(testTypeElement)), declaredTypes); - - // false false false true : super interfaces - declaredTypes = getDeclaredTypes(testTypeElement, false, false, false, true); - assertDeclaredTypes(declaredTypes, SUPER_INTERFACES); - assertEquals(ofList(getDeclaredTypesOfInterfaces(testTypeElement)), declaredTypes); - - // false false false false : nothing - declaredTypes = getDeclaredTypes(testTypeElement, false, false, false, false); - assertDeclaredTypes(declaredTypes); - assertEmptyList(declaredTypes); - } - - @Test - void testFindDeclaredTypesWithExcludedTypes() { - List declaredTypes = findDeclaredTypes(testTypeElement, SUPER_CLASS); - assertDeclaredTypes(declaredTypes, SUPER_INTERFACES); - - declaredTypes = findDeclaredTypes(testTypeElement, getTypeNames(SUPER_CLASS)); - assertDeclaredTypes(declaredTypes, SUPER_INTERFACES); - - declaredTypes = findDeclaredTypes(testTypeElement, SUPER_INTERFACES); - assertDeclaredTypes(declaredTypes, SUPER_CLASS); - - declaredTypes = findDeclaredTypes(testTypeElement, getTypeNames(SUPER_INTERFACES)); - assertDeclaredTypes(declaredTypes, SUPER_CLASS); - - declaredTypes = findDeclaredTypes(testTypeMirror, SUPER_CLASS); - assertDeclaredTypes(declaredTypes, SUPER_INTERFACES); - - declaredTypes = findDeclaredTypes(testTypeMirror, getTypeNames(SUPER_CLASS)); - assertDeclaredTypes(declaredTypes, SUPER_INTERFACES); - - declaredTypes = findDeclaredTypes(testTypeMirror, SUPER_INTERFACES); - assertDeclaredTypes(declaredTypes, SUPER_CLASS); - - declaredTypes = findDeclaredTypes(testTypeMirror, getTypeNames(SUPER_INTERFACES)); - assertDeclaredTypes(declaredTypes, SUPER_CLASS); - } - - @Test - void testFindDeclaredTypesWithExcludedTypesOnNull() { - assertEmptyList(findDeclaredTypes(NULL_ELEMENT, NULL_TYPE_ARRAY)); - assertEmptyList(findDeclaredTypes(NULL_ELEMENT, EMPTY_TYPE_ARRAY)); - assertEmptyList(findDeclaredTypes(NULL_ELEMENT, ALL_TYPES)); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, NULL_TYPE_ARRAY)); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, EMPTY_TYPE_ARRAY)); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, ALL_TYPES)); - } - - @Test - void testFindDeclaredTypesWithExcludedTypeNamesOnNull() { - assertEmptyList(findDeclaredTypes(NULL_ELEMENT, NULL_STRING_ARRAY)); - assertEmptyList(findDeclaredTypes(NULL_ELEMENT, EMPTY_STRING_ARRAY)); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, NULL_STRING_ARRAY)); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, EMPTY_STRING_ARRAY)); - } - - @Test - void testFindDeclaredTypesOfInterfaces() { - List declaredTypes = findDeclaredTypesOfInterfaces(testTypeMirror, alwaysTrue()); - assertDeclaredTypes(declaredTypes, SUPER_INTERFACES); - - findDeclaredTypesOfInterfaces(testTypeElement, alwaysTrue()); - assertDeclaredTypes(declaredTypes, SUPER_INTERFACES); - - declaredTypes = findDeclaredTypesOfInterfaces(testTypeMirror, alwaysFalse()); - assertEmptyList(declaredTypes); - - declaredTypes = findDeclaredTypesOfInterfaces(testTypeElement, alwaysFalse()); - assertEmptyList(declaredTypes); - } - - @Test - void testFindDeclaredTypesOfInterfacesOnNull() { - assertEmptyList(findDeclaredTypesOfInterfaces(NULL_ELEMENT, alwaysTrue())); - assertEmptyList(findDeclaredTypesOfInterfaces(NULL_ELEMENT, alwaysFalse())); - assertEmptyList(findDeclaredTypesOfInterfaces(NULL_TYPE_MIRROR, alwaysTrue())); - assertEmptyList(findDeclaredTypesOfInterfaces(NULL_TYPE_MIRROR, alwaysTrue())); - } - - @Test - void testFindAllDeclaredTypesOfSuperclasses() { - List declaredTypes = findAllDeclaredTypesOfSuperclasses(testTypeElement, alwaysTrue()); - assertDeclaredTypes(declaredTypes, ALL_SUPER_CLASSES); - - declaredTypes = findAllDeclaredTypesOfSuperclasses(testTypeMirror, alwaysFalse()); - assertEmptyList(declaredTypes); - } - - @Test - void testFindAllDeclaredTypesOfSuperclassesOnNull() { - assertEmptyList(findAllDeclaredTypesOfSuperclasses(NULL_ELEMENT, alwaysTrue())); - assertEmptyList(findAllDeclaredTypesOfSuperclasses(NULL_ELEMENT, alwaysFalse())); - assertEmptyList(findAllDeclaredTypesOfSuperclasses(NULL_TYPE_MIRROR, alwaysTrue())); - assertEmptyList(findAllDeclaredTypesOfSuperclasses(NULL_TYPE_MIRROR, alwaysFalse())); - } - - @Test - void testFindAllDeclaredTypesOfInterfaces() { - List declaredTypes = findAllDeclaredTypesOfInterfaces(testTypeElement, alwaysTrue()); - assertDeclaredTypes(declaredTypes, ALL_SUPER_INTERFACES); - - declaredTypes = findAllDeclaredTypesOfInterfaces(testTypeMirror, alwaysFalse()); - assertEmptyList(declaredTypes); - } - - @Test - void testFindAllDeclaredTypesOfInterfacesOnNull() { - assertEmptyList(findAllDeclaredTypesOfInterfaces(NULL_ELEMENT, alwaysTrue())); - assertEmptyList(findAllDeclaredTypesOfInterfaces(NULL_ELEMENT, alwaysFalse())); - assertEmptyList(findAllDeclaredTypesOfInterfaces(NULL_TYPE_MIRROR, alwaysTrue())); - assertEmptyList(findAllDeclaredTypesOfInterfaces(NULL_TYPE_MIRROR, alwaysFalse())); - } - - @Test - void testFindAllDeclaredTypesOfSuperTypes() { - List declaredTypes = findAllDeclaredTypesOfSuperTypes(testTypeMirror, alwaysTrue()); - assertDeclaredTypes(declaredTypes, ALL_SUPER_TYPES); - - findAllDeclaredTypesOfSuperTypes(testTypeElement, alwaysTrue()); - assertDeclaredTypes(declaredTypes, ALL_SUPER_TYPES); - - declaredTypes = findAllDeclaredTypesOfSuperTypes(testTypeMirror, alwaysFalse()); - assertEmptyList(declaredTypes); - - declaredTypes = findAllDeclaredTypesOfSuperTypes(testTypeElement, alwaysFalse()); - assertEmptyList(declaredTypes); - } - - @Test - void testFindAllDeclaredTypesOfSuperTypesOnNull() { - assertEmptyList(findAllDeclaredTypesOfSuperTypes(NULL_ELEMENT)); - assertEmptyList(findAllDeclaredTypesOfSuperTypes(NULL_TYPE_MIRROR)); - } - - @Test - void testFindAllDeclaredTypes() { - List declaredTypes = findAllDeclaredTypes(testTypeElement, alwaysTrue()); - assertDeclaredTypes(declaredTypes, ALL_TYPES); - - declaredTypes = findAllDeclaredTypes(testTypeMirror, alwaysFalse()); - assertEmptyList(declaredTypes); - } - - @Test - void testFindAllDeclaredTypesOnNull() { - assertEmptyList(findAllDeclaredTypes(NULL_ELEMENT, alwaysTrue())); - assertEmptyList(findAllDeclaredTypes(NULL_ELEMENT, alwaysFalse())); - assertEmptyList(findAllDeclaredTypes(NULL_TYPE_MIRROR, alwaysTrue())); - assertEmptyList(findAllDeclaredTypes(NULL_TYPE_MIRROR, alwaysFalse())); - } - - @Test - void testFindAllDeclaredTypesWithExcludedTypes() { - List declaredTypes = findAllDeclaredTypes(testTypeElement, testClass); - assertDeclaredTypes(declaredTypes, ALL_SUPER_TYPES); - - - declaredTypes = findAllDeclaredTypes(testTypeMirror, testClass); - assertDeclaredTypes(declaredTypes, ALL_SUPER_TYPES); - } - - @Test - void testFindAllDeclaredTypesWithExcludedTypeNames() { - List declaredTypes = findAllDeclaredTypes(testTypeElement, testClassName); - assertDeclaredTypes(declaredTypes, ALL_SUPER_TYPES); - - declaredTypes = findAllDeclaredTypes(testTypeMirror, testClassName); - assertDeclaredTypes(declaredTypes, ALL_SUPER_TYPES); - } - - @Test - void testFindAllDeclaredTypesWithExcludedTypesOnNull() { - assertEmptyList(findAllDeclaredTypes(NULL_ELEMENT, NULL_TYPE_ARRAY)); - assertEmptyList(findAllDeclaredTypes(NULL_ELEMENT, EMPTY_TYPE_ARRAY)); - assertEmptyList(findAllDeclaredTypes(NULL_ELEMENT, ALL_TYPES)); - assertEmptyList(findAllDeclaredTypes(NULL_TYPE_MIRROR, NULL_TYPE_ARRAY)); - assertEmptyList(findAllDeclaredTypes(NULL_TYPE_MIRROR, EMPTY_TYPE_ARRAY)); - assertEmptyList(findAllDeclaredTypes(NULL_TYPE_MIRROR, ALL_TYPES)); - } - - @Test - void testFindAllDeclaredTypesWithExcludedTypeNamesOnNull() { - assertEmptyList(findAllDeclaredTypes(NULL_ELEMENT, NULL_STRING_ARRAY)); - assertEmptyList(findAllDeclaredTypes(NULL_ELEMENT, EMPTY_STRING_ARRAY)); - assertEmptyList(findAllDeclaredTypes(NULL_TYPE_MIRROR, NULL_STRING_ARRAY)); - assertEmptyList(findAllDeclaredTypes(NULL_TYPE_MIRROR, EMPTY_STRING_ARRAY)); - } - - @Test - void testFindDeclaredTypes() { - // true true true true : all types - List declaredTypes = findDeclaredTypes(testTypeElement, true, true, true, true, alwaysTrue()); - assertDeclaredTypes(declaredTypes, ALL_TYPES); - assertEquals(getAllDeclaredTypes(testTypeElement), declaredTypes); - - // true true true false : self type + all super classes - declaredTypes = findDeclaredTypes(testTypeElement, true, true, true, false, alwaysTrue()); - assertDeclaredTypes(declaredTypes, SELF_TYPE_PLUS_ALL_SUPER_CLASSES); - - // true true false true : self type + all super interfaces - declaredTypes = findDeclaredTypes(testTypeElement, true, true, false, true, alwaysTrue()); - assertDeclaredTypes(declaredTypes, SELF_TYPE_PLUS_ALL_SUPER_INTERFACES); - - // true true false false : self type - declaredTypes = findDeclaredTypes(testTypeElement, true, true, false, false, alwaysTrue()); - assertDeclaredTypes(declaredTypes, SELF_TYPE); - - // true false true true : self type + super class + super interfaces - declaredTypes = findDeclaredTypes(testTypeElement, true, false, true, true, alwaysTrue()); - assertDeclaredTypes(declaredTypes, SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES); - - // true false true false : self type + super class - declaredTypes = findDeclaredTypes(testTypeElement, true, false, true, false, alwaysTrue()); - assertDeclaredTypes(declaredTypes, SELF_TYPE_PLUS_SUPER_CLASS); - - // true false false true : self type + super interfaces - declaredTypes = findDeclaredTypes(testTypeElement, true, false, false, true, alwaysTrue()); - assertDeclaredTypes(declaredTypes, SELF_TYPE_PLUS_SUPER_INTERFACES); - - // true false false false : self type - declaredTypes = findDeclaredTypes(testTypeElement, true, false, false, false, alwaysTrue()); - assertDeclaredTypes(declaredTypes, SELF_TYPE); - - // false true true true : all super types - declaredTypes = findDeclaredTypes(testTypeElement, false, true, true, true, alwaysTrue()); - assertDeclaredTypes(declaredTypes, ALL_SUPER_TYPES); - assertEquals(getAllDeclaredTypesOfSuperTypes(testTypeElement), declaredTypes); - - // false true true false : all super classes - declaredTypes = findDeclaredTypes(testTypeElement, false, true, true, false, alwaysTrue()); - assertDeclaredTypes(declaredTypes, ALL_SUPER_CLASSES); - assertEquals(getAllDeclaredTypesOfSuperclasses(testTypeElement), declaredTypes); - - // false true false true : all super interfaces - declaredTypes = findDeclaredTypes(testTypeElement, false, true, false, true, alwaysTrue()); - assertDeclaredTypes(declaredTypes, ALL_SUPER_INTERFACES); - assertEquals(getAllDeclaredTypesOfInterfaces(testTypeElement), declaredTypes); - - // false true false false : nothing - declaredTypes = findDeclaredTypes(testTypeElement, false, true, false, false, alwaysTrue()); - assertDeclaredTypes(declaredTypes); - assertEmptyList(declaredTypes); - - // false false true true : super class + super interfaces - declaredTypes = findDeclaredTypes(testTypeElement, false, false, true, true, alwaysTrue()); - assertDeclaredTypes(declaredTypes, SUPER_TYPES); - - // false false true false : super class - declaredTypes = findDeclaredTypes(testTypeElement, false, false, true, false, alwaysTrue()); - assertDeclaredTypes(declaredTypes, SUPER_CLASS); - assertEquals(ofList(getDeclaredTypeOfSuperclass(testTypeElement)), declaredTypes); - - // false false false true : super interfaces - declaredTypes = findDeclaredTypes(testTypeElement, false, false, false, true, alwaysTrue()); - assertDeclaredTypes(declaredTypes, SUPER_INTERFACES); - assertEquals(ofList(getDeclaredTypesOfInterfaces(testTypeElement)), declaredTypes); - - // false false false false : nothing - declaredTypes = findDeclaredTypes(testTypeElement, false, false, false, false, alwaysTrue()); - assertDeclaredTypes(declaredTypes); - assertEmptyList(declaredTypes); - } - - @Test - void testFindDeclaredTypesOnNull() { - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, true, true, true, true, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, true, true, true, true, alwaysFalse())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, true, true, true, true, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, true, true, true, true, alwaysFalse())); - - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, true, true, true, false, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, true, true, true, false, alwaysFalse())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, true, true, true, false, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, true, true, true, false, alwaysFalse())); - - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, true, true, false, true, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, true, true, false, true, alwaysFalse())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, true, true, false, true, alwaysFalse())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, true, true, false, true, alwaysFalse())); - - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, true, true, false, false, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, true, true, false, false, alwaysFalse())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, true, true, false, false, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, true, true, false, false, alwaysFalse())); - - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, true, false, true, true, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, true, false, true, true, alwaysFalse())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, true, false, true, true, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, true, false, true, true, alwaysFalse())); - - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, false, true, false, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, false, true, false, alwaysFalse())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, false, true, false, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, false, true, false, alwaysFalse())); - - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, false, false, true, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, false, false, true, alwaysFalse())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, false, false, true, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, false, false, true, alwaysFalse())); - - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, false, false, false, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, false, false, false, alwaysFalse())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, false, false, false, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, false, false, false, alwaysFalse())); - - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, true, true, true, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, true, true, true, alwaysFalse())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, true, true, true, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, true, true, true, alwaysFalse())); - - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, true, true, false, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, true, true, false, alwaysFalse())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, true, true, false, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, true, true, false, alwaysFalse())); - - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, true, false, true, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, true, false, true, alwaysFalse())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, true, false, true, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, true, false, true, alwaysFalse())); - - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, true, false, false, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, true, false, false, alwaysFalse())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, true, false, false, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, true, false, false, alwaysFalse())); - - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, false, true, true, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, false, true, true, alwaysFalse())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, false, true, true, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, false, true, true, alwaysFalse())); - - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, false, true, false, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, false, true, false, alwaysFalse())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, false, true, false, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, false, true, false, alwaysFalse())); - - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, false, false, true, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, false, false, true, alwaysFalse())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, false, false, true, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, false, false, true, alwaysFalse())); - - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, false, false, false, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, false, false, false, alwaysFalse())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, false, false, false, alwaysTrue())); - assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, false, false, false, alwaysFalse())); - } - - @Test - void testGetTypeMirrorsOfInterfaces() { - List typeMirrors = getTypeMirrorsOfInterfaces(testTypeMirror); - assertTypeMirrors(typeMirrors, SUPER_INTERFACES); - - typeMirrors = getTypeMirrorsOfInterfaces(testTypeElement); - assertTypeMirrors(typeMirrors, SUPER_INTERFACES); - - typeMirrors = getTypeMirrorsOfInterfaces(getTypeElement(Object.class)); - assertEmptyList(typeMirrors); - - typeMirrors = getTypeMirrorsOfInterfaces(getTypeMirror(Object.class)); - assertSame(typeMirrors, typeMirrors); - } - - @Test - void testGetTypeMirrorsOfInterfacesOnNull() { - List typeMirrors = getTypeMirrorsOfInterfaces(NULL_TYPE_MIRROR); - assertEmptyList(typeMirrors); - - typeMirrors = getTypeMirrorsOfInterfaces(NULL_TYPE_ELEMENT); - assertEmptyList(typeMirrors); - } - - @Test - void testFindTypeMirrorsOfInterfaces() { - List typeMirrors = findTypeMirrorsOfInterfaces(testTypeMirror, alwaysTrue()); - assertTypeMirrors(typeMirrors, SUPER_INTERFACES); - - typeMirrors = findTypeMirrorsOfInterfaces(testTypeElement, alwaysTrue()); - assertTypeMirrors(typeMirrors, SUPER_INTERFACES); - - typeMirrors = findTypeMirrorsOfInterfaces(testTypeMirror, alwaysFalse()); - assertEmptyList(typeMirrors); - - typeMirrors = findTypeMirrorsOfInterfaces(testTypeElement, alwaysFalse()); - assertEmptyList(typeMirrors); - - typeMirrors = findTypeMirrorsOfInterfaces(getTypeElement(Object.class), alwaysTrue()); - assertEmptyList(typeMirrors); - - typeMirrors = findTypeMirrorsOfInterfaces(getTypeElement(Object.class), alwaysFalse()); - assertEmptyList(typeMirrors); - - typeMirrors = findTypeMirrorsOfInterfaces(getTypeMirror(Object.class), alwaysTrue()); - assertSame(typeMirrors, typeMirrors); - - typeMirrors = findTypeMirrorsOfInterfaces(getTypeMirror(Object.class), alwaysFalse()); - assertSame(typeMirrors, typeMirrors); - } - - @Test - void testFindTypeMirrorsOfInterfacesOnNull() { - List typeMirrors = findTypeMirrorsOfInterfaces(NULL_TYPE_MIRROR, alwaysTrue()); - assertEmptyList(typeMirrors); - - typeMirrors = findTypeMirrorsOfInterfaces(NULL_TYPE_ELEMENT, alwaysTrue()); - assertEmptyList(typeMirrors); - - typeMirrors = findTypeMirrorsOfInterfaces(NULL_TYPE_MIRROR, alwaysFalse()); - assertEmptyList(typeMirrors); - - typeMirrors = findTypeMirrorsOfInterfaces(NULL_TYPE_ELEMENT, alwaysFalse()); - assertEmptyList(typeMirrors); - } - - @Test - void testGetAllTypeMirrorsOfInterfaces() { - List typeMirrors = getAllTypeMirrorsOfInterfaces(testTypeMirror); - assertTypeMirrors(typeMirrors, ALL_SUPER_INTERFACES); - - typeMirrors = getAllTypeMirrorsOfInterfaces(testTypeElement); - assertTypeMirrors(typeMirrors, ALL_SUPER_INTERFACES); - - typeMirrors = getAllTypeMirrorsOfInterfaces(getTypeElement(Object.class)); - assertEmptyList(typeMirrors); - - typeMirrors = getAllTypeMirrorsOfInterfaces(getTypeMirror(Object.class)); - assertSame(typeMirrors, typeMirrors); - } - - @Test - void testGetAllTypeMirrorsOfInterfacesOnNull() { - List typeMirrors = getAllTypeMirrorsOfInterfaces(NULL_TYPE_MIRROR); - assertEmptyList(typeMirrors); - - typeMirrors = getAllTypeMirrorsOfInterfaces(NULL_TYPE_ELEMENT); - assertEmptyList(typeMirrors); - } - - @Test - void testFindAllTypeMirrorsOfInterfaces() { - List typeMirrors = findAllTypeMirrorsOfInterfaces(testTypeMirror, alwaysTrue()); - assertTypeMirrors(typeMirrors, ALL_SUPER_INTERFACES); - - typeMirrors = findAllTypeMirrorsOfInterfaces(testTypeElement, alwaysTrue()); - assertTypeMirrors(typeMirrors, ALL_SUPER_INTERFACES); - - typeMirrors = findAllTypeMirrorsOfInterfaces(testTypeMirror, alwaysFalse()); - assertEmptyList(typeMirrors); - - typeMirrors = findAllTypeMirrorsOfInterfaces(testTypeElement, alwaysFalse()); - assertEmptyList(typeMirrors); - - typeMirrors = findAllTypeMirrorsOfInterfaces(getTypeElement(Object.class), alwaysTrue()); - assertEmptyList(typeMirrors); - - typeMirrors = findAllTypeMirrorsOfInterfaces(getTypeElement(Object.class), alwaysFalse()); - assertEmptyList(typeMirrors); - - typeMirrors = findAllTypeMirrorsOfInterfaces(getTypeMirror(Object.class), alwaysTrue()); - assertSame(typeMirrors, typeMirrors); - - typeMirrors = findAllTypeMirrorsOfInterfaces(getTypeMirror(Object.class), alwaysFalse()); - assertSame(typeMirrors, typeMirrors); - } - - @Test - void testFindAllTypeMirrorsOfInterfacesOnNull() { - List typeMirrors = findAllTypeMirrorsOfInterfaces(NULL_TYPE_MIRROR, alwaysTrue()); - assertEmptyList(typeMirrors); - - typeMirrors = findAllTypeMirrorsOfInterfaces(NULL_TYPE_MIRROR, alwaysFalse()); - assertEmptyList(typeMirrors); - - typeMirrors = findAllTypeMirrorsOfInterfaces(NULL_TYPE_ELEMENT, alwaysTrue()); - assertEmptyList(typeMirrors); - - typeMirrors = findAllTypeMirrorsOfInterfaces(NULL_TYPE_MIRROR, alwaysFalse()); - assertEmptyList(typeMirrors); - } - - @Test - void testFindInterfaceTypeMirror() { - for (Type interfaceType : ALL_SUPER_INTERFACES) { - assertInterfaceTypeMirror(testTypeElement, interfaceType); - } - - for (Type superClass : ALL_SUPER_CLASSES) { - assertNull(findInterfaceTypeMirror(testTypeElement, superClass)); - assertNull(findInterfaceTypeMirror(testTypeMirror, superClass)); - } - } - - @Test - void testFindInterfaceTypeMirrorOnNull() { - for (Type type : ALL_TYPES) { - assertNull(findInterfaceTypeMirror(NULL_ELEMENT, type)); - assertNull(findInterfaceTypeMirror(NULL_TYPE_MIRROR, type)); - } - } - - @Test - void testGetTypeMirrors() { - assertGetTypeMirrors(NULL_TYPE); - assertGetTypeMirrors(SELF_TYPE); - assertGetTypeMirrors(SUPER_CLASS); - assertGetTypeMirrors(ALL_TYPES); - assertGetTypeMirrors(ALL_SUPER_TYPES); - assertGetTypeMirrors(ALL_SUPER_CLASSES); - assertGetTypeMirrors(ALL_SUPER_INTERFACES); - assertGetTypeMirrors(SUPER_INTERFACES); - assertGetTypeMirrors(SUPER_TYPES); - - assertGetTypeMirrors(SELF_TYPE_PLUS_ALL_SUPER_TYPES); - assertGetTypeMirrors(SELF_TYPE_PLUS_ALL_SUPER_CLASSES); - assertGetTypeMirrors(SELF_TYPE_PLUS_ALL_SUPER_INTERFACES); - assertGetTypeMirrors(SELF_TYPE_PLUS_SUPER_CLASS); - assertGetTypeMirrors(SELF_TYPE_PLUS_SUPER_INTERFACES); - assertGetTypeMirrors(SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES); - } - - @Test - void testGetTypeMirrorsOnNull() { - assertGetTypeMirrors(NULL_TYPE); - assertGetTypeMirrors(NULL_TYPE_ARRAY); - assertGetTypeMirrors(EMPTY_TYPE_ARRAY); - - TypeUtils.getTypeMirrors(NULL_PROCESSING_ENVIRONMENT, SELF_TYPE); - TypeUtils.getTypeMirrors(NULL_PROCESSING_ENVIRONMENT, SUPER_CLASS); - TypeUtils.getTypeMirrors(NULL_PROCESSING_ENVIRONMENT, ALL_TYPES); - TypeUtils.getTypeMirrors(NULL_PROCESSING_ENVIRONMENT, ALL_SUPER_TYPES); - TypeUtils.getTypeMirrors(NULL_PROCESSING_ENVIRONMENT, ALL_SUPER_CLASSES); - TypeUtils.getTypeMirrors(NULL_PROCESSING_ENVIRONMENT, ALL_SUPER_INTERFACES); - TypeUtils.getTypeMirrors(NULL_PROCESSING_ENVIRONMENT, SUPER_INTERFACES); - TypeUtils.getTypeMirrors(NULL_PROCESSING_ENVIRONMENT, SUPER_TYPES); - - TypeUtils.getTypeMirrors(NULL_PROCESSING_ENVIRONMENT, SELF_TYPE_PLUS_ALL_SUPER_TYPES); - TypeUtils.getTypeMirrors(NULL_PROCESSING_ENVIRONMENT, SELF_TYPE_PLUS_ALL_SUPER_CLASSES); - TypeUtils.getTypeMirrors(NULL_PROCESSING_ENVIRONMENT, SELF_TYPE_PLUS_ALL_SUPER_INTERFACES); - TypeUtils.getTypeMirrors(NULL_PROCESSING_ENVIRONMENT, SELF_TYPE_PLUS_SUPER_CLASS); - TypeUtils.getTypeMirrors(NULL_PROCESSING_ENVIRONMENT, SELF_TYPE_PLUS_SUPER_INTERFACES); - TypeUtils.getTypeMirrors(NULL_PROCESSING_ENVIRONMENT, SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES); - } - - @Test - void testGetTypeMirror() { - assertGetTypeMirror(NULL_TYPE); - assertGetTypeMirror(SELF_TYPE); - assertGetTypeMirror(SUPER_CLASS); - assertGetTypeMirror(ALL_TYPES); - assertGetTypeMirror(ALL_SUPER_TYPES); - assertGetTypeMirror(ALL_SUPER_CLASSES); - assertGetTypeMirror(ALL_SUPER_INTERFACES); - assertGetTypeMirror(SUPER_INTERFACES); - assertGetTypeMirror(SUPER_TYPES); - - assertGetTypeMirror(SELF_TYPE_PLUS_ALL_SUPER_TYPES); - assertGetTypeMirror(SELF_TYPE_PLUS_ALL_SUPER_CLASSES); - assertGetTypeMirror(SELF_TYPE_PLUS_ALL_SUPER_INTERFACES); - assertGetTypeMirror(SELF_TYPE_PLUS_SUPER_CLASS); - assertGetTypeMirror(SELF_TYPE_PLUS_SUPER_INTERFACES); - assertGetTypeMirror(SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES); - } - - @Test - void testGetTypeMirrorOnNull() { - assertNull(TypeUtils.getTypeMirror(this.processingEnv, NULL_TYPE)); - assertNull(getTypeMirror(NULL_TYPE)); - - assertGetTypeMirrorOnNullProcessingEnvironment(SELF_TYPE); - assertGetTypeMirrorOnNullProcessingEnvironment(SUPER_CLASS); - assertGetTypeMirrorOnNullProcessingEnvironment(ALL_TYPES); - assertGetTypeMirrorOnNullProcessingEnvironment(ALL_SUPER_TYPES); - assertGetTypeMirrorOnNullProcessingEnvironment(ALL_SUPER_CLASSES); - assertGetTypeMirrorOnNullProcessingEnvironment(ALL_SUPER_INTERFACES); - assertGetTypeMirrorOnNullProcessingEnvironment(SUPER_INTERFACES); - assertGetTypeMirrorOnNullProcessingEnvironment(SUPER_TYPES); - - assertGetTypeMirrorOnNullProcessingEnvironment(SELF_TYPE_PLUS_ALL_SUPER_TYPES); - assertGetTypeMirrorOnNullProcessingEnvironment(SELF_TYPE_PLUS_ALL_SUPER_CLASSES); - assertGetTypeMirrorOnNullProcessingEnvironment(SELF_TYPE_PLUS_ALL_SUPER_INTERFACES); - assertGetTypeMirrorOnNullProcessingEnvironment(SELF_TYPE_PLUS_SUPER_CLASS); - assertGetTypeMirrorOnNullProcessingEnvironment(SELF_TYPE_PLUS_SUPER_INTERFACES); - assertGetTypeMirrorOnNullProcessingEnvironment(SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES); - } - - @Test - void testGetTypeElementsWithProcessingEnvironment() { - assertGetTypeElementsWithProcessingEnvironment(SELF_TYPE); - assertGetTypeElementsWithProcessingEnvironment(SUPER_CLASS); - assertGetTypeElementsWithProcessingEnvironment(ALL_TYPES); - assertGetTypeElementsWithProcessingEnvironment(ALL_SUPER_TYPES); - assertGetTypeElementsWithProcessingEnvironment(ALL_SUPER_CLASSES); - assertGetTypeElementsWithProcessingEnvironment(ALL_SUPER_INTERFACES); - assertGetTypeElementsWithProcessingEnvironment(SUPER_INTERFACES); - assertGetTypeElementsWithProcessingEnvironment(SUPER_TYPES); - - assertGetTypeElementsWithProcessingEnvironment(SELF_TYPE_PLUS_ALL_SUPER_TYPES); - assertGetTypeElementsWithProcessingEnvironment(SELF_TYPE_PLUS_ALL_SUPER_CLASSES); - assertGetTypeElementsWithProcessingEnvironment(SELF_TYPE_PLUS_ALL_SUPER_INTERFACES); - assertGetTypeElementsWithProcessingEnvironment(SELF_TYPE_PLUS_SUPER_CLASS); - assertGetTypeElementsWithProcessingEnvironment(SELF_TYPE_PLUS_SUPER_INTERFACES); - assertGetTypeElementsWithProcessingEnvironment(SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES); - } - - @Test - void testGetTypeElementsWithProcessingEnvironmentOnNull() { - assertEmptyList(TypeUtils.getTypeElements(this.processingEnv, NULL_TYPE)); - assertEmptyList(TypeUtils.getTypeElements(this.processingEnv, NULL_TYPE_ARRAY)); - assertEmptyList(TypeUtils.getTypeElements(this.processingEnv, EMPTY_TYPE_ARRAY)); - - assertGetTypeElementsOnNullProcessingEnvironment(SELF_TYPE); - assertGetTypeElementsOnNullProcessingEnvironment(SUPER_CLASS); - assertGetTypeElementsOnNullProcessingEnvironment(ALL_TYPES); - assertGetTypeElementsOnNullProcessingEnvironment(ALL_SUPER_TYPES); - assertGetTypeElementsOnNullProcessingEnvironment(ALL_SUPER_CLASSES); - assertGetTypeElementsOnNullProcessingEnvironment(ALL_SUPER_INTERFACES); - assertGetTypeElementsOnNullProcessingEnvironment(SUPER_INTERFACES); - assertGetTypeElementsOnNullProcessingEnvironment(SUPER_TYPES); - - assertGetTypeElementsOnNullProcessingEnvironment(SELF_TYPE_PLUS_ALL_SUPER_TYPES); - assertGetTypeElementsOnNullProcessingEnvironment(SELF_TYPE_PLUS_ALL_SUPER_CLASSES); - assertGetTypeElementsOnNullProcessingEnvironment(SELF_TYPE_PLUS_ALL_SUPER_INTERFACES); - assertGetTypeElementsOnNullProcessingEnvironment(SELF_TYPE_PLUS_SUPER_CLASS); - assertGetTypeElementsOnNullProcessingEnvironment(SELF_TYPE_PLUS_SUPER_INTERFACES); - assertGetTypeElementsOnNullProcessingEnvironment(SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES); - } - - @Test - void testGetTypeElement() { - assertEquals(testTypeElement, TypeUtils.getTypeElement(processingEnv, testClassName)); - } - - @Test - void testGetTypeElementOnTypeMirror() { - assertEquals(testTypeElement, TypeUtils.getTypeElement(processingEnv, testTypeMirror)); - } - - @Test - void testGetTypeElementOnType() { - assertEquals(testTypeElement, TypeUtils.getTypeElement(processingEnv, SELF_TYPE)); - } - - @Test - void testGetTypeElementOnNull() { - assertNull(TypeUtils.getTypeElement(processingEnv, NULL_TYPE)); - assertNull(TypeUtils.getTypeElement(processingEnv, NULL_TYPE_MIRROR)); - assertNull(TypeUtils.getTypeElement(processingEnv, NULL_STRING)); - assertNull(TypeUtils.getTypeElement(NULL_PROCESSING_ENVIRONMENT, NULL_STRING)); - } - - @Test - void testGetDeclaredType() { - assertGetDeclaredType(NULL_TYPE); - assertGetDeclaredType(SELF_TYPE); - assertGetDeclaredType(SUPER_CLASS); - assertGetDeclaredType(ALL_TYPES); - assertGetDeclaredType(ALL_SUPER_TYPES); - assertGetDeclaredType(ALL_SUPER_CLASSES); - assertGetDeclaredType(ALL_SUPER_INTERFACES); - assertGetDeclaredType(SUPER_INTERFACES); - assertGetDeclaredType(SUPER_TYPES); - - assertGetDeclaredType(SELF_TYPE_PLUS_ALL_SUPER_TYPES); - assertGetDeclaredType(SELF_TYPE_PLUS_ALL_SUPER_CLASSES); - assertGetDeclaredType(SELF_TYPE_PLUS_ALL_SUPER_INTERFACES); - assertGetDeclaredType(SELF_TYPE_PLUS_SUPER_CLASS); - assertGetDeclaredType(SELF_TYPE_PLUS_SUPER_INTERFACES); - assertGetDeclaredType(SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES); - } - - @Test - void testGetDeclaredTypeOnNull() { - assertNull(TypeUtils.getDeclaredType(this.processingEnv, NULL_TYPE)); - assertNull(TypeUtils.getDeclaredType(this.processingEnv, NULL_TYPE_MIRROR)); - assertNull(TypeUtils.getDeclaredType(this.processingEnv, NULL_STRING)); - - assertNull(getDeclaredType(NULL_TYPE)); - - assertGetDeclaredTypeOnNullProcessingEnvironment(SELF_TYPE); - assertGetDeclaredTypeOnNullProcessingEnvironment(SUPER_CLASS); - assertGetDeclaredTypeOnNullProcessingEnvironment(ALL_TYPES); - assertGetDeclaredTypeOnNullProcessingEnvironment(ALL_SUPER_TYPES); - assertGetDeclaredTypeOnNullProcessingEnvironment(ALL_SUPER_CLASSES); - assertGetDeclaredTypeOnNullProcessingEnvironment(ALL_SUPER_INTERFACES); - assertGetDeclaredTypeOnNullProcessingEnvironment(SUPER_INTERFACES); - assertGetDeclaredTypeOnNullProcessingEnvironment(SUPER_TYPES); - - assertGetDeclaredTypeOnNullProcessingEnvironment(SELF_TYPE_PLUS_ALL_SUPER_TYPES); - assertGetDeclaredTypeOnNullProcessingEnvironment(SELF_TYPE_PLUS_ALL_SUPER_CLASSES); - assertGetDeclaredTypeOnNullProcessingEnvironment(SELF_TYPE_PLUS_ALL_SUPER_INTERFACES); - assertGetDeclaredTypeOnNullProcessingEnvironment(SELF_TYPE_PLUS_SUPER_CLASS); - assertGetDeclaredTypeOnNullProcessingEnvironment(SELF_TYPE_PLUS_SUPER_INTERFACES); - assertGetDeclaredTypeOnNullProcessingEnvironment(SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES); - } - - @Test - void testToStringOnClasses() { - assertToStringOnClasses(); - } - - @Test - void testToStringOnArrayTypes() { - assertToStringOnArrayTypes(); - } - - @Test - void testToStringOnCollectionTypes() { - assertToStringOnCollectionTypes(); - } - - @Test - void testToStringMapTypes() { - assertToStringOnMapTypes(); - } - - @Test - void testToStringOnNull() { - assertNull(TypeUtils.toString(NULL_TYPE_MIRROR)); - } - - @Test - void testTypeElementFinderOnNull() { - assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, true, true, true, true)); - - assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, true, true, true, false)); - - assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, true, true, false, true)); - - assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, true, true, false, false)); - - assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, true, false, true, true)); - - assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, false, false, true, false)); - - assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, false, false, false, true)); - - assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, false, false, false, false)); - - assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, false, true, true, true)); - - assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, false, true, true, false)); - - assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, false, true, false, true)); - - assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, false, true, false, false)); - - assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, false, false, true, true)); - - assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, false, false, true, false)); - - assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, false, false, false, true)); - - assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, false, false, false, false)); - } - - private void assertIsSameType(Element typeElement, Type type) { - assertTrue(isSameType(typeElement, type)); - assertTrue(isSameType(typeElement, type.getTypeName())); - assertTrue(isSameType(typeElement.asType(), type)); - assertTrue(isSameType(typeElement.asType(), type.getTypeName())); - } - - private void assertOfTypeMirrors(Class... types) { - Element[] elements = getElements(types); - assertEquals(getTypeMirrors(types), ofTypeMirrors(elements)); - } - - private void assertOfTypeElements(Class... types) { - List typesList = getTypeMirrors(types); - List typeElements = ofTypeElements(typesList); - for (TypeMirror typeMirror : typesList) { - assertTrue(typeElements.contains(ofTypeElement(typeMirror))); - } - } - - private void assertOfDeclaredTypes(Class... types) { - Element[] elements = getElements(types); - List declaredTypes = ofDeclaredTypes(elements); - assertDeclaredTypes(declaredTypes, types); - } - - private void assertIsArrayType(Type type) { - assertTrue(isArrayType(getFieldType(type, "integers"))); - assertTrue(isArrayType(getFieldType(type, "strings"))); - assertTrue(isArrayType(getFieldType(type, "primitiveTypeModels"))); - assertTrue(isArrayType(getFieldType(type, "models"))); - assertTrue(isArrayType(getFieldType(type, "colors"))); - } - - private void assertIsArrayType(Element element) { - assertTrue(isArrayType(findField(element, "integers"))); - assertTrue(isArrayType(findField(element, "strings"))); - assertTrue(isArrayType(findField(element, "primitiveTypeModels"))); - assertTrue(isArrayType(findField(element, "models"))); - assertTrue(isArrayType(findField(element, "colors"))); - } - - private void assertTypeMirrors(List typeMirrors, Type... types) { - int length = length(types); - for (int i = 0; i < length; i++) { - if (types[i] == null) { - length--; - } - } - assertEquals(length, typeMirrors.size()); - for (int i = 0; i < length; i++) { - assertSame(typeMirrors.get(i), getTypeMirror(types[i])); - } - } - - private void assertTypeElements(List typeElements, Type... types) { - int length = length(types); - for (int i = 0; i < length; i++) { - if (types[i] == null) { - length--; - } - } - assertEquals(length, typeElements.size()); - for (int i = 0; i < length; i++) { - assertSame(typeElements.get(i), getTypeElement(types[i])); - } - } - - private void assertDeclaredTypes(List declaredTypes, Type... types) { - int length = length(types); - for (int i = 0; i < length; i++) { - if (types[i] == null) { - length--; - } - } - assertEquals(length, declaredTypes.size()); - for (int i = 0; i < length; i++) { - assertSame(declaredTypes.get(i), getDeclaredType(types[i])); - } - } - - private void assertInterfaceTypeMirror(Element type, Type interfaceType) { - TypeMirror typeMirror = findInterfaceTypeMirror(type, interfaceType); - assertTrue(isSameType(typeMirror, interfaceType)); - - typeMirror = findInterfaceTypeMirror(type.asType(), interfaceType); - assertTrue(isSameType(typeMirror, interfaceType)); - } - - private void assertGetTypeMirrors(Type... types) { - List typeMirrors = TypeUtils.getTypeMirrors(processingEnv, types); - assertEquals(typeMirrors, getTypeMirrors(types)); - assertTypeMirrors(typeMirrors, types); - } - - private void assertGetTypeMirror(Type... types) { - int length = length(types); - for (int i = 0; i < length; i++) { - Type type = types[i]; - TypeMirror typeMirror = TypeUtils.getTypeMirror(processingEnv, type); - assertSame(getTypeMirror(type), typeMirror); - assertTrue(isSameType(typeMirror, type)); - } - } - - private void assertGetTypeMirrorOnNullProcessingEnvironment(Type... types) { - int length = length(types); - for (int i = 0; i < length; i++) { - Type type = types[i]; - TypeMirror typeMirror = TypeUtils.getTypeMirror(NULL_PROCESSING_ENVIRONMENT, type); - assertNull(typeMirror); - } - } - - private void assertGetTypeElementsWithProcessingEnvironment(Type... types) { - List typeElements = TypeUtils.getTypeElements(this.processingEnv, types); - assertEquals(getTypeElements(types), typeElements); - assertTypeElements(typeElements, types); - } - - private void assertGetTypeElementsOnNullProcessingEnvironment(Type... types) { - List typeElements = TypeUtils.getTypeElements(NULL_PROCESSING_ENVIRONMENT, types); - assertEmptyList(typeElements); - } - - private void assertGetDeclaredType(Type... types) { - int length = length(types); - for (int i = 0; i < length; i++) { - Type type = types[i]; - DeclaredType declaredType = TypeUtils.getDeclaredType(processingEnv, type); - assertSame(getDeclaredType(type), declaredType); - assertSame(getDeclaredType(type), TypeUtils.getDeclaredType(processingEnv, declaredType)); - assertTrue(isSameType(declaredType, type)); - } - } - - private void assertGetDeclaredTypeOnNullProcessingEnvironment(Type... types) { - int length = length(types); - for (int i = 0; i < length; i++) { - Type type = types[i]; - TypeMirror typeMirror = TypeUtils.getDeclaredType(NULL_PROCESSING_ENVIRONMENT, type); - assertNull(typeMirror); - } - } - - private void assertToStringOnMapTypes() { - assertToString(getFieldType(MapTypeModel.class, "strings")); - assertToString(getFieldType(MapTypeModel.class, "colors")); - assertToString(getFieldType(MapTypeModel.class, "primitiveTypeModels")); - assertToString(getFieldType(MapTypeModel.class, "models")); - assertToString(getFieldType(MapTypeModel.class, "modelArrays")); - } - - private void assertToStringOnCollectionTypes() { - assertToString(getFieldType(CollectionTypeModel.class, "strings")); - assertToString(getFieldType(CollectionTypeModel.class, "colors")); - assertToString(getFieldType(CollectionTypeModel.class, "primitiveTypeModels")); - assertToString(getFieldType(CollectionTypeModel.class, "models")); - assertToString(getFieldType(CollectionTypeModel.class, "modelArrays")); - } - - private void assertToStringOnArrayTypes() { - assertToString(getFieldType(ArrayTypeModel.class, "integers")); - assertToString(getFieldType(ArrayTypeModel.class, "strings")); - assertToString(getFieldType(ArrayTypeModel.class, "primitiveTypeModels")); - assertToString(getFieldType(ArrayTypeModel.class, "models")); - assertToString(getFieldType(ArrayTypeModel.class, "colors")); - } - - private TypeMirror getFieldType(Type type, String fieldName) { - TypeMirror typeMirror = getTypeMirror(type); - return findField(typeMirror, fieldName).asType(); - } - - private TypeMirror getFieldType(Element element, String fieldName) { - return findField(element, fieldName).asType(); - } - - private void assertToStringOnClasses() { - assertToString(NULL_TYPE); - assertToString(SELF_TYPE); - assertToString(SUPER_CLASS); - assertToString(ALL_TYPES); - assertToString(ALL_SUPER_TYPES); - assertToString(ALL_SUPER_CLASSES); - assertToString(ALL_SUPER_INTERFACES); - assertToString(SUPER_INTERFACES); - assertToString(SUPER_TYPES); - - assertToString(SELF_TYPE_PLUS_ALL_SUPER_TYPES); - assertToString(SELF_TYPE_PLUS_ALL_SUPER_CLASSES); - assertToString(SELF_TYPE_PLUS_ALL_SUPER_INTERFACES); - assertToString(SELF_TYPE_PLUS_SUPER_CLASS); - assertToString(SELF_TYPE_PLUS_SUPER_INTERFACES); - assertToString(SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES); - } - - private void assertToString(Type... types) { - int length = length(types); - for (int i = 0; i < length; i++) { - if (types[i] == null) { - length--; - } - } - for (int i = 0; i < length; i++) { - TypeMirror typeMirror = getTypeMirror(types[i]); - assertEquals(types[i].getTypeName(), TypeUtils.toString(typeMirror)); - } - } - - private void assertToString(TypeMirror type) { - assertEquals(type.toString(), TypeUtils.toString(type)); - } -} \ No newline at end of file From 3404443afcaa6cdd09448c4a15704509d0e63e32 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 19:04:24 +0800 Subject: [PATCH 12/79] Add microsphere-lang-model module Introduce a new microsphere-lang-model Maven module. Adds pom.xml with dependencies and build configuration, core language-model classes (e.g. StringAnnotationValue) and a comprehensive set of utility classes for annotation/element processing (AnnotationUtils, ClassUtils, ConstructorUtils, ElementUtils, ExecutableElementComparator, FieldUtils, MethodUtils, TypeUtils, Resolvable/JSON visitors, LoggerUtils, MessagerUtils, MemberUtils, etc.). Includes unit tests for the added utilities and elements to validate behavior. This module provides reusable helpers for working with javax.lang.model types and annotation processing within the Microsphere project. --- microsphere-lang-model/pom.xml | 133 + .../model/element/StringAnnotationValue.java | 50 + .../lang/model/util/AnnotationUtils.java | 1870 ++++++++++++ .../lang/model/util/ClassUtils.java | 109 + .../lang/model/util/ConstructorUtils.java | 293 ++ .../lang/model/util/ElementUtils.java | 734 +++++ .../util/ExecutableElementComparator.java | 93 + .../lang/model/util/FieldUtils.java | 763 +++++ .../util/JSONAnnotationValueVisitor.java | 196 ++ .../lang/model/util/JSONElementVisitor.java | 221 ++ .../lang/model/util/LoggerUtils.java | 54 + .../lang/model/util/MemberUtils.java | 423 +++ .../lang/model/util/MessagerUtils.java | 310 ++ .../lang/model/util/MethodUtils.java | 1165 ++++++++ .../ResolvableAnnotationValueVisitor.java | 200 ++ .../lang/model/util/TypeUtils.java | 2505 +++++++++++++++++ .../element/StringAnnotationValueTest.java | 53 + .../lang/model/util/AnnotationUtilsTest.java | 775 +++++ .../lang/model/util/ClassUtilsTest.java | 51 + .../lang/model/util/ConstructorUtilsTest.java | 150 + .../lang/model/util/ElementUtilsTest.java | 351 +++ .../util/ExecutableElementComparatorTest.java | 76 + .../lang/model/util/FieldUtilsTest.java | 412 +++ .../util/JSONAnnotationValueVisitorTest.java | 135 + .../model/util/JSONElementVisitorTest.java | 254 ++ .../lang/model/util/LoggerUtilsTest.java | 76 + .../lang/model/util/MemberUtilsTest.java | 173 ++ .../lang/model/util/MessagerUtilsTest.java | 81 + .../lang/model/util/MethodUtilsTest.java | 507 ++++ .../ResolvableAnnotationValueVisitorTest.java | 216 ++ .../lang/model/util/TypeUtilsTest.java | 1876 ++++++++++++ .../microsphere/lang/model/util/UtilTest.java | 88 + 32 files changed, 14393 insertions(+) create mode 100644 microsphere-lang-model/pom.xml create mode 100644 microsphere-lang-model/src/main/java/io/microsphere/lang/model/element/StringAnnotationValue.java create mode 100644 microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/AnnotationUtils.java create mode 100644 microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ClassUtils.java create mode 100644 microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ConstructorUtils.java create mode 100644 microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ElementUtils.java create mode 100644 microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ExecutableElementComparator.java create mode 100644 microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/FieldUtils.java create mode 100644 microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/JSONAnnotationValueVisitor.java create mode 100644 microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/JSONElementVisitor.java create mode 100644 microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/LoggerUtils.java create mode 100644 microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/MemberUtils.java create mode 100644 microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/MessagerUtils.java create mode 100644 microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/MethodUtils.java create mode 100644 microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ResolvableAnnotationValueVisitor.java create mode 100644 microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/TypeUtils.java create mode 100644 microsphere-lang-model/src/test/java/io/microsphere/lang/model/element/StringAnnotationValueTest.java create mode 100644 microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/AnnotationUtilsTest.java create mode 100644 microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ClassUtilsTest.java create mode 100644 microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ConstructorUtilsTest.java create mode 100644 microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ElementUtilsTest.java create mode 100644 microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ExecutableElementComparatorTest.java create mode 100644 microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/FieldUtilsTest.java create mode 100644 microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONAnnotationValueVisitorTest.java create mode 100644 microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONElementVisitorTest.java create mode 100644 microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/LoggerUtilsTest.java create mode 100644 microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/MemberUtilsTest.java create mode 100644 microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/MessagerUtilsTest.java create mode 100644 microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/MethodUtilsTest.java create mode 100644 microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ResolvableAnnotationValueVisitorTest.java create mode 100644 microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/TypeUtilsTest.java create mode 100644 microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/UtilTest.java diff --git a/microsphere-lang-model/pom.xml b/microsphere-lang-model/pom.xml new file mode 100644 index 000000000..2c674b268 --- /dev/null +++ b/microsphere-lang-model/pom.xml @@ -0,0 +1,133 @@ + + + + io.github.microsphere-projects + microsphere-java-parent + ${revision} + ../microsphere-java-parent/pom.xml + + 4.0.0 + + io.github.microsphere-projects + microsphere-lang-model + ${revision} + jar + + Microsphere :: Java :: Language Model + Microsphere Language Model + + + 2.1 + 2.3.1 + + + + + + + io.github.microsphere-projects + microsphere-java-core + ${revision} + + + + + org.junit.jupiter + junit-jupiter + test + + + + org.junit.jupiter + junit-jupiter-engine + test + + + + + io.github.microsphere-projects + microsphere-jdk-tools + ${revision} + test + + + + + io.github.microsphere-projects + microsphere-java-test + ${revision} + test + + + + + ch.qos.logback + logback-classic + test + + + + + javax.ws.rs + javax.ws.rs-api + ${javax.ws.rs.version} + test + + + + + javax.xml.ws + jaxws-api + ${jaxws-api.version} + test + + + + + org.springframework + spring-context + test + + + + org.springframework + spring-web + test + + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + + -proc:none + + + + org.apache.maven.plugins + maven-shade-plugin + + + package + + shade + + + + + io.github.microsphere-projects:microsphere-java-core + + + + + + + + + + \ No newline at end of file diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/element/StringAnnotationValue.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/element/StringAnnotationValue.java new file mode 100644 index 000000000..ba92765e6 --- /dev/null +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/element/StringAnnotationValue.java @@ -0,0 +1,50 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.lang.model.element; + +import io.microsphere.annotation.Immutable; + +import javax.lang.model.element.AnnotationValue; +import javax.lang.model.element.AnnotationValueVisitor; + +/** + * {@link AnnotationValue} for String type + * + * @author Mercy + * @see AnnotationValue + * @since 1.0.0 + */ +@Immutable +public class StringAnnotationValue implements AnnotationValue { + + private final String value; + + public StringAnnotationValue(String value) { + this.value = value; + } + + @Override + public Object getValue() { + return this.value; + } + + @Override + public R accept(AnnotationValueVisitor v, P p) { + return v.visitString(this.value, p); + } +} diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/AnnotationUtils.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/AnnotationUtils.java new file mode 100644 index 000000000..bbfce4988 --- /dev/null +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/AnnotationUtils.java @@ -0,0 +1,1870 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.lang.model.util; + +import io.microsphere.annotation.Immutable; +import io.microsphere.annotation.Nonnull; +import io.microsphere.annotation.Nullable; +import io.microsphere.util.Utils; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.AnnotatedConstruct; +import javax.lang.model.element.AnnotationMirror; +import javax.lang.model.element.AnnotationValue; +import javax.lang.model.element.AnnotationValueVisitor; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.TypeElement; +import javax.lang.model.type.DeclaredType; +import javax.lang.model.type.TypeMirror; +import java.lang.annotation.Annotation; +import java.lang.annotation.ElementType; +import java.lang.annotation.Target; +import java.lang.reflect.Type; +import java.util.Collection; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Objects; +import java.util.function.Predicate; + +import static io.microsphere.lang.model.util.MethodUtils.findDeclaredMethods; +import static io.microsphere.lang.model.util.MethodUtils.getDeclaredMethods; +import static io.microsphere.lang.model.util.MethodUtils.getMethodName; +import static io.microsphere.lang.model.util.TypeUtils.getAllTypeElements; +import static io.microsphere.lang.model.util.TypeUtils.getTypeElement; +import static io.microsphere.lang.model.util.TypeUtils.isSameType; +import static io.microsphere.lang.model.util.TypeUtils.ofTypeElement; +import static io.microsphere.collection.CollectionUtils.isEmpty; +import static io.microsphere.collection.CollectionUtils.size; +import static io.microsphere.collection.MapUtils.immutableEntry; +import static io.microsphere.collection.MapUtils.isEmpty; +import static io.microsphere.collection.MapUtils.newFixedLinkedHashMap; +import static io.microsphere.lang.function.Predicates.EMPTY_PREDICATE_ARRAY; +import static io.microsphere.lang.function.Streams.filterAll; +import static io.microsphere.util.ArrayUtils.isNotEmpty; +import static io.microsphere.util.StringUtils.isBlank; +import static java.util.Collections.emptyList; +import static java.util.Collections.emptyMap; +import static java.util.Collections.unmodifiableList; +import static java.util.Collections.unmodifiableMap; +import static java.util.stream.Collectors.toList; + +/** + * A utility interface for working with annotations in the {@code javax.lang.model.*} package. + *

+ * This interface provides methods to retrieve, filter, and check annotations and their attributes + * from various constructs such as {@link Element}, {@link TypeMirror}, and others commonly used + * in annotation processing. + *

+ * + *

Example Usage

+ * 
{@code
+ * // Retrieve a specific annotation from an element
+ * AnnotationMirror annotation = AnnotationUtils.getAnnotation(element, MyAnnotation.class);
+ *
+ * // Retrieve all annotations from a type
+ * List annotations = AnnotationUtils.getAnnotations(typeMirror);
+ *
+ * // Check if an annotation is present on an element
+ * boolean present = AnnotationUtils.isAnnotationPresent(element, MyAnnotation.class);
+ *
+ * // Find meta-annotations on an annotation
+ * AnnotationMirror metaAnnotation = AnnotationUtils.findMetaAnnotation(annotation, MyMetaAnnotation.class);
+ * }
+ * + *

+ * This interface is intended to be implemented by classes that provide static utility methods + * for handling annotations during annotation processing. It helps in organizing and reusing + * common operations related to annotations. + *

+ * + * @author Mercy + * @since 1.0.0 + */ +public interface AnnotationUtils extends Utils { + + /** + * The name of the attribute method : value() + */ + String VALUE_ATTRIBUTE_NAME = "value"; + + /** + * The default {@link AnnotationValueVisitor} + */ + AnnotationValueVisitor DEFAULT_ANNOTATION_VALUE_VISITOR = new ResolvableAnnotationValueVisitor(); + + /** + * The empty {@link ElementType} array + */ + @Immutable + ElementType[] EMPTY_ELEMENT_TYPE_ARRAY = new ElementType[0]; + + boolean WITH_DEFAULT = true; + + /** + * Retrieves the first {@link AnnotationMirror} of the specified annotation class from the given + * {@link AnnotatedConstruct}. If either the construct or the annotation class is {@code null}, + * this method returns {@code null}. + * + *

Example Usage

+ * 
{@code
+     * // Get an annotation directly present on a class
+     * TypeElement typeElement = ...; // obtain a TypeElement
+     * AnnotationMirror annotation = AnnotationUtils.getAnnotation(typeElement, MyAnnotation.class);
+     *
+     * // Get an annotation from an element that may inherit annotations from its parent
+     * Element element = ...; // obtain an Element
+     * annotation = AnnotationUtils.getAnnotation(element, MyAnnotation.class);
+     * }
+ * + * @param annotatedConstruct the annotated construct to search for annotations, may be {@code null} + * @param annotationClass the annotation class to look for, may be {@code null} + * @return the first matching {@link AnnotationMirror}, or {@code null} if none found + */ + static AnnotationMirror getAnnotation(AnnotatedConstruct annotatedConstruct, Class annotationClass) { + if (annotatedConstruct == null || annotationClass == null) { + return null; + } + return getAnnotation(annotatedConstruct, annotationClass.getName()); + } + + /** + * Retrieves the first {@link AnnotationMirror} of the specified annotation class name from the given + * {@link AnnotatedConstruct}. If either the construct or the annotation class name is {@code null}, + * this method returns {@code null}. + * + *

Example Usage

+ * 
{@code
+     * // Get an annotation by its class name from an element
+     * TypeElement typeElement = ...; // obtain a TypeElement
+     * String annotationClassName = "com.example.MyAnnotation";
+     * AnnotationMirror annotation = AnnotationUtils.getAnnotation(typeElement, annotationClassName);
+     *
+     * // Get an annotation from a method element
+     * Element methodElement = ...; // obtain a method Element
+     * annotation = AnnotationUtils.getAnnotation(methodElement, "com.example.AnotherAnnotation");
+     * }
+ * + * @param annotatedConstruct the annotated construct to search for annotations, may be {@code null} + * @param annotationClassName the fully qualified class name of the annotation to look for, may be {@code null} + * @return the first matching {@link AnnotationMirror}, or {@code null} if none found + */ + static AnnotationMirror getAnnotation(AnnotatedConstruct annotatedConstruct, CharSequence annotationClassName) { + if (annotatedConstruct == null || annotationClassName == null) { + return null; + } + List annotations = getAnnotations(annotatedConstruct, annotationClassName); + return annotations.isEmpty() ? null : annotations.get(0); + } + + /** + * Retrieves all {@link AnnotationMirror} instances from the given {@link AnnotatedConstruct}. + * If the annotated construct is {@code null}, this method returns an empty list. + * + *

Example Usage

+ * 
{@code
+     * // Retrieve all annotations from a class element
+     * TypeElement typeElement = ...; // obtain a TypeElement
+     * List annotations = AnnotationUtils.getAnnotations(typeElement);
+     *
+     * // Retrieve annotations from a method element
+     * Element methodElement = ...; // obtain a method Element
+     * annotations = AnnotationUtils.getAnnotations(methodElement);
+     * }
+ * + * @param annotatedConstruct the annotated construct to search for annotations, may be {@code null} + * @return a non-null immutable list of {@link AnnotationMirror} instances; never {@code null} + */ + @Nonnull + @Immutable + static List getAnnotations(AnnotatedConstruct annotatedConstruct) { + if (annotatedConstruct == null) { + return emptyList(); + } + return findAnnotations(annotatedConstruct, EMPTY_PREDICATE_ARRAY); + } + + /** + * Retrieves all {@link AnnotationMirror} instances of the specified annotation class from the given + * {@link AnnotatedConstruct}. If either the construct or the annotation class is {@code null}, + * this method returns an empty list. + * + *

Example Usage

+ * 
{@code
+     * // Retrieve all annotations of a specific type from a class element
+     * TypeElement typeElement = ...; // obtain a TypeElement
+     * List annotations = AnnotationUtils.getAnnotations(typeElement, MyAnnotation.class);
+     *
+     * // Retrieve annotations from a method element
+     * Element methodElement = ...; // obtain a method Element
+     * annotations = AnnotationUtils.getAnnotations(methodElement, AnotherAnnotation.class);
+     * }
+ * + * @param annotatedConstruct the annotated construct to search for annotations, may be {@code null} + * @param annotationClass the annotation class to look for, may be {@code null} + * @return a non-null immutable list of {@link AnnotationMirror} instances; never {@code null} + */ + @Nonnull + @Immutable + static List getAnnotations(AnnotatedConstruct annotatedConstruct, Class annotationClass) { + if (annotatedConstruct == null || annotationClass == null) { + return emptyList(); + } + return getAnnotations(annotatedConstruct, annotationClass.getTypeName()); + } + + /** + * Retrieves all {@link AnnotationMirror} instances of the specified annotation class name from the given + * {@link AnnotatedConstruct}. If either the construct or the annotation class name is {@code null}, + * this method returns an empty list. + * + *

Example Usage

+ * 
{@code
+     * // Retrieve annotations by their class name from a class element
+     * TypeElement typeElement = ...; // obtain a TypeElement
+     * String annotationClassName = "com.example.MyAnnotation";
+     * List annotations = AnnotationUtils.getAnnotations(typeElement, annotationClassName);
+     *
+     * // Retrieve annotations from a method element
+     * Element methodElement = ...; // obtain a method Element
+     * annotations = AnnotationUtils.getAnnotations(methodElement, "com.example.AnotherAnnotation");
+     * }
+ * + * @param annotatedConstruct the annotated construct to search for annotations, may be {@code null} + * @param annotationClassName the fully qualified class name of the annotation to look for, may be {@code null} + * @return a non-null immutable list of {@link AnnotationMirror} instances; never {@code null} + */ + @Nonnull + @Immutable + static List getAnnotations(AnnotatedConstruct annotatedConstruct, CharSequence annotationClassName) { + if (annotatedConstruct == null || annotationClassName == null) { + return emptyList(); + } + return findAnnotations(annotatedConstruct, annotation -> matchesAnnotationTypeName(annotation, annotationClassName)); + } + + /** + * Retrieves all {@link AnnotationMirror} instances from the given {@link TypeMirror}. + * If the type mirror is {@code null}, this method returns an empty list. + * + *

Example Usage

+ * 
{@code
+     * // Retrieve all annotations from a type mirror
+     * TypeMirror type = ...; // obtain a TypeMirror
+     * List annotations = AnnotationUtils.getAllAnnotations(type);
+     *
+     * // Handle cases where the type might be null
+     * annotations = AnnotationUtils.getAllAnnotations(null); // returns empty list
+     * }
+ * + * @param type the type mirror to search for annotations, may be {@code null} + * @return a non-null immutable list of {@link AnnotationMirror} instances; never {@code null} + */ + @Nonnull + @Immutable + static List getAllAnnotations(TypeMirror type) { + if (type == null) { + return emptyList(); + } + return getAllAnnotations(ofTypeElement(type)); + } + + /** + * Retrieves all {@link AnnotationMirror} instances from the given {@link Element}. + * If the element is {@code null}, this method returns an empty list. + * + *

This method is designed to provide a consistent way of retrieving annotations + * across different constructs in the annotation processing framework.

+ * + *

Example Usage

+ * 
{@code
+     * // Retrieve all annotations from a class element
+     * TypeElement typeElement = ...; // obtain a TypeElement
+     * List annotations = AnnotationUtils.getAllAnnotations(typeElement);
+     *
+     * // Retrieve annotations from a method element
+     * Element methodElement = ...; // obtain a method Element
+     * annotations = AnnotationUtils.getAllAnnotations(methodElement);
+     *
+     * // Handle cases where the element might be null
+     * annotations = AnnotationUtils.getAllAnnotations(null); // returns empty list
+     * }
+ * + * @param element the annotated element to search for annotations, may be {@code null} + * @return a non-null immutable list of {@link AnnotationMirror} instances; never {@code null} + */ + @Nonnull + @Immutable + static List getAllAnnotations(Element element) { + if (element == null) { + return emptyList(); + } + return findAllAnnotations(element, EMPTY_PREDICATE_ARRAY); + } + + /** + * Retrieves all {@link AnnotationMirror} instances of the specified annotation class from the given + * {@link TypeMirror}. If either the type or the annotation class is {@code null}, this method returns an empty list. + * + *

Example Usage

+ * 
{@code
+     * // Retrieve annotations from a type mirror
+     * TypeMirror type = ...; // obtain a TypeMirror
+     * List annotations = AnnotationUtils.getAllAnnotations(type, MyAnnotation.class);
+     *
+     * // Handle cases where the type might be null
+     * annotations = AnnotationUtils.getAllAnnotations(null, MyAnnotation.class); // returns empty list
+     *
+     * // Handle cases where the annotation class might be null
+     * annotations = AnnotationUtils.getAllAnnotations(type, null); // returns empty list
+     * }
+ * + * @param type the type mirror to search for annotations, may be {@code null} + * @param annotationClass the annotation class to look for, may be {@code null} + * @return a non-null immutable list of {@link AnnotationMirror} instances; never {@code null} + */ + @Nonnull + @Immutable + static List getAllAnnotations(TypeMirror type, Class annotationClass) { + if (type == null || annotationClass == null) { + return emptyList(); + } + return getAllAnnotations(ofTypeElement(type), annotationClass); + } + + /** + * Retrieves all {@link AnnotationMirror} instances of the specified annotation class from the given + * {@link Element}. If either the element or the annotation class is {@code null}, + * this method returns an empty list. + * + *

Example Usage

+ * 
{@code
+     * // Retrieve annotations from a class element
+     * TypeElement typeElement = ...; // obtain a TypeElement
+     * List annotations = AnnotationUtils.getAllAnnotations(typeElement, MyAnnotation.class);
+     *
+     * // Retrieve annotations from a method element
+     * Element methodElement = ...; // obtain a method Element
+     * annotations = AnnotationUtils.getAllAnnotations(methodElement, AnotherAnnotation.class);
+     *
+     * // Handle cases where the element might be null
+     * annotations = AnnotationUtils.getAllAnnotations(null, MyAnnotation.class); // returns empty list
+     *
+     * // Handle cases where the annotation class might be null
+     * annotations = AnnotationUtils.getAllAnnotations(typeElement, null); // returns empty list
+     * }
+ * + * @param element the annotated element to search for annotations, may be {@code null} + * @param annotationClass the annotation class to look for, may be {@code null} + * @return a non-null immutable list of {@link AnnotationMirror} instances; never {@code null} + */ + @Nonnull + @Immutable + static List getAllAnnotations(Element element, Class annotationClass) { + if (element == null || annotationClass == null) { + return emptyList(); + } + return getAllAnnotations(element, annotationClass.getTypeName()); + } + + /** + * Retrieves all {@link AnnotationMirror} instances of the specified annotation class name from the given + * {@link TypeMirror}. If either the type or the annotation class name is {@code null}, + * this method returns an empty list. + * + *

Example Usage

+ * 
{@code
+     * // Retrieve annotations from a type mirror
+     * TypeMirror type = ...; // obtain a TypeMirror
+     * String annotationClassName = "com.example.MyAnnotation";
+     * List annotations = AnnotationUtils.getAllAnnotations(type, annotationClassName);
+     *
+     * // Handle cases where the type might be null
+     * annotations = AnnotationUtils.getAllAnnotations(null, annotationClassName); // returns empty list
+     *
+     * // Handle cases where the annotation class name might be null
+     * annotations = AnnotationUtils.getAllAnnotations(type, null); // returns empty list
+     * }
+ * + * @param type the type mirror to search for annotations, may be {@code null} + * @param annotationClassName the fully qualified class name of the annotation to look for, may be {@code null} + * @return a non-null immutable list of {@link AnnotationMirror} instances; never {@code null} + */ + @Nonnull + @Immutable + static List getAllAnnotations(TypeMirror type, CharSequence annotationClassName) { + if (type == null || annotationClassName == null) { + return emptyList(); + } + return getAllAnnotations(ofTypeElement(type), annotationClassName); + } + + /** + * Retrieves all {@link AnnotationMirror} instances of the specified annotation class name from the given + * {@link Element}. If either the element or the annotation class name is {@code null}, + * this method returns an empty list. + * + *

Example Usage

+ * 
{@code
+     * // Retrieve annotations by their class name from a class element
+     * TypeElement typeElement = ...; // obtain a TypeElement
+     * String annotationClassName = "com.example.MyAnnotation";
+     * List annotations = AnnotationUtils.getAllAnnotations(typeElement, annotationClassName);
+     *
+     * // Retrieve annotations from a method element
+     * Element methodElement = ...; // obtain a method Element
+     * annotations = AnnotationUtils.getAllAnnotations(methodElement, "com.example.AnotherAnnotation");
+     *
+     * // Handle cases where the element might be null
+     * annotations = AnnotationUtils.getAllAnnotations(null, annotationClassName); // returns empty list
+     *
+     * // Handle cases where the annotation class name might be null
+     * annotations = AnnotationUtils.getAllAnnotations(typeElement, null); // returns empty list
+     * }
+ * + * @param element the annotated element to search for annotations, may be {@code null} + * @param annotationClassName the fully qualified class name of the annotation to look for, may be {@code null} + * @return a non-null immutable list of {@link AnnotationMirror} instances; never {@code null} + */ + @Nonnull + @Immutable + static List getAllAnnotations(Element element, CharSequence annotationClassName) { + if (element == null || annotationClassName == null) { + return emptyList(); + } + return findAllAnnotations(element, annotation -> matchesAnnotationTypeName(annotation, annotationClassName)); + } + + /** + * Retrieves all {@link AnnotationMirror} instances of the specified annotated type from the given + * {@link ProcessingEnvironment}. If either the processing environment or the annotated type is {@code null}, + * this method returns an empty list. + * + *

Example Usage

+ * 
{@code
+     * // Retrieve annotations for a specific type from the processing environment
+     * ProcessingEnvironment processingEnv = ...; // obtain a ProcessingEnvironment instance
+     * Type annotatedType = MyAnnotation.class; // specify the annotation type
+     * List annotations = AnnotationUtils.getAllAnnotations(processingEnv, annotatedType);
+     *
+     * // Handle cases where the processing environment might be null
+     * annotations = AnnotationUtils.getAllAnnotations(null, annotatedType); // returns empty list
+     *
+     * // Handle cases where the annotated type might be null
+     * annotations = AnnotationUtils.getAllAnnotations(processingEnv, null); // returns empty list
+     * }
+ * + * @param processingEnv the processing environment used to retrieve annotations, may be {@code null} + * @param annotatedType the annotated type to search for annotations, may be {@code null} + * @return a non-null immutable list of {@link AnnotationMirror} instances; never {@code null} + */ + @Nonnull + @Immutable + static List getAllAnnotations(ProcessingEnvironment processingEnv, Type annotatedType) { + if (processingEnv == null || annotatedType == null) { + return emptyList(); + } + return findAllAnnotations(processingEnv, annotatedType, EMPTY_PREDICATE_ARRAY); + } + + /** + * Retrieves the first {@link AnnotationMirror} of the specified annotation class from the given + * {@link TypeMirror}. If either the type or the annotation class is {@code null}, + * this method returns {@code null}. + * + *

Example Usage

+ * 
{@code
+     * // Retrieve an annotation from a type mirror
+     * TypeMirror type = ...; // obtain a TypeMirror instance
+     * AnnotationMirror annotation = AnnotationUtils.findAnnotation(type, MyAnnotation.class);
+     *
+     * // Handle cases where the type might be null
+     * annotation = AnnotationUtils.findAnnotation(null, MyAnnotation.class); // returns null
+     *
+     * // Handle cases where the annotation class might be null
+     * annotation = AnnotationUtils.findAnnotation(type, null); // returns null
+     * }
+ * + * @param type the type mirror to search for annotations, may be {@code null} + * @param annotationClass the annotation class to look for, may be {@code null} + * @return the first matching {@link AnnotationMirror}, or {@code null} if none found + */ + static AnnotationMirror findAnnotation(TypeMirror type, Class annotationClass) { + if (type == null || annotationClass == null) { + return null; + } + return findAnnotation(type, annotationClass.getTypeName()); + } + + /** + * Retrieves the first {@link AnnotationMirror} of the specified annotation class name from the given + * {@link TypeMirror}. If either the type or the annotation class name is {@code null}, + * this method returns {@code null}. + * + *

Example Usage

+ * 
{@code
+     * // Retrieve an annotation by its class name from a type mirror
+     * TypeMirror type = ...; // obtain a TypeMirror instance
+     * String annotationClassName = "com.example.MyAnnotation";
+     * AnnotationMirror annotation = AnnotationUtils.findAnnotation(type, annotationClassName);
+     *
+     * // Handle cases where the type might be null
+     * annotation = AnnotationUtils.findAnnotation(null, annotationClassName); // returns null
+     *
+     * // Handle cases where the annotation class name might be null
+     * annotation = AnnotationUtils.findAnnotation(type, null); // returns null
+     * }
+ * + * @param type the type mirror to search for annotations, may be {@code null} + * @param annotationClassName the fully qualified class name of the annotation to look for, may be {@code null} + * @return the first matching {@link AnnotationMirror}, or {@code null} if none found + */ + static AnnotationMirror findAnnotation(TypeMirror type, CharSequence annotationClassName) { + if (type == null || annotationClassName == null) { + return null; + } + return findAnnotation(ofTypeElement(type), annotationClassName); + } + + /** + * Retrieves the first {@link AnnotationMirror} of the specified annotation class from the given + * {@link Element}. If either the element or the annotation class is {@code null}, + * this method returns {@code null}. + * + *

Example Usage

+ * 
{@code
+     * // Retrieve an annotation from a class element
+     * TypeElement typeElement = ...; // obtain a TypeElement
+     * AnnotationMirror annotation = AnnotationUtils.findAnnotation(typeElement, MyAnnotation.class);
+     *
+     * // Retrieve an annotation from a method element
+     * Element methodElement = ...; // obtain a method Element
+     * annotation = AnnotationUtils.findAnnotation(methodElement, AnotherAnnotation.class);
+     *
+     * // Handle cases where the element might be null
+     * annotation = AnnotationUtils.findAnnotation(null, MyAnnotation.class); // returns null
+     *
+     * // Handle cases where the annotation class might be null
+     * annotation = AnnotationUtils.findAnnotation(typeElement, null); // returns null
+     * }
+ * + * @param element the annotated element to search for annotations, may be {@code null} + * @param annotationClass the annotation class to look for, may be {@code null} + * @return the first matching {@link AnnotationMirror}, or {@code null} if none found + */ + static AnnotationMirror findAnnotation(Element element, Class annotationClass) { + if (element == null || annotationClass == null) { + return null; + } + return findAnnotation(element, annotationClass.getTypeName()); + } + + /** + * Retrieves the first {@link AnnotationMirror} of the specified annotation class name from the given + * {@link Element}. If either the element or the annotation class name is {@code null}, + * this method returns {@code null}. + * + *

Example Usage

+ * 
{@code
+     * // Retrieve an annotation by its class name from a class element
+     * TypeElement typeElement = ...; // obtain a TypeElement
+     * String annotationClassName = "com.example.MyAnnotation";
+     * AnnotationMirror annotation = AnnotationUtils.findAnnotation(typeElement, annotationClassName);
+     *
+     * // Retrieve an annotation from a method element
+     * Element methodElement = ...; // obtain a method Element
+     * annotation = AnnotationUtils.findAnnotation(methodElement, "com.example.AnotherAnnotation");
+     *
+     * // Handle cases where the element might be null
+     * annotation = AnnotationUtils.findAnnotation(null, annotationClassName); // returns null
+     *
+     * // Handle cases where the annotation class name might be null
+     * annotation = AnnotationUtils.findAnnotation(typeElement, null); // returns null
+     * }
+ * + * @param element the annotated element to search for annotations, may be {@code null} + * @param annotationClassName the fully qualified class name of the annotation to look for, may be {@code null} + * @return the first matching {@link AnnotationMirror}, or {@code null} if none found + */ + static AnnotationMirror findAnnotation(Element element, CharSequence annotationClassName) { + if (element == null || annotationClassName == null) { + return null; + } + List annotations = findAllAnnotations(element, annotation -> matchesAnnotationTypeName(annotation, annotationClassName)); + return isEmpty(annotations) ? null : annotations.get(0); + } + + /** + * Retrieves the first meta-annotation of the specified meta-annotation class from the given annotated element. + * A meta-annotation is an annotation that is present on another annotation. If either the annotated element + * or the meta-annotation class is {@code null}, this method returns {@code null}. + * + *

Example Usage

+ * 
{@code
+     * // Retrieve a meta-annotation from an annotation on a class element
+     * TypeElement typeElement = ...; // obtain a TypeElement
+     * AnnotationMirror metaAnnotation = AnnotationUtils.findMetaAnnotation(typeElement, MyMetaAnnotation.class);
+     *
+     * // Retrieve a meta-annotation from an annotation on a method element
+     * Element methodElement = ...; // obtain a method Element
+     * metaAnnotation = AnnotationUtils.findMetaAnnotation(methodElement, AnotherMetaAnnotation.class);
+     *
+     * // Handle cases where the element might be null
+     * metaAnnotation = AnnotationUtils.findMetaAnnotation(null, MyMetaAnnotation.class); // returns null
+     *
+     * // Handle cases where the meta-annotation class might be null
+     * metaAnnotation = AnnotationUtils.findMetaAnnotation(typeElement, null); // returns null
+     * }
+ * + * @param annotatedConstruct the annotated element to search for meta-annotations, may be {@code null} + * @param metaAnnotationClass the annotation class to look for as a meta-annotation, may be {@code null} + * @return the first matching meta-{@link AnnotationMirror}, or {@code null} if none found + */ + static AnnotationMirror findMetaAnnotation(Element annotatedConstruct, Class metaAnnotationClass) { + if (annotatedConstruct == null || metaAnnotationClass == null) { + return null; + } + return findMetaAnnotation(annotatedConstruct, metaAnnotationClass.getName()); + } + + /** + * Retrieves the first meta-annotation of the specified meta-annotation class name from the given annotated element. + * A meta-annotation is an annotation that is present on another annotation. If either the annotated element + * or the meta-annotation class name is {@code null}, this method returns {@code null}. + * + *

Example Usage

+ * 
{@code
+     * // Retrieve a meta-annotation by its class name from a class element
+     * TypeElement typeElement = ...; // obtain a TypeElement
+     * String metaAnnotationClassName = "com.example.MyMetaAnnotation";
+     * AnnotationMirror metaAnnotation = AnnotationUtils.findMetaAnnotation(typeElement, metaAnnotationClassName);
+     *
+     * // Retrieve a meta-annotation from a method element
+     * Element methodElement = ...; // obtain a method Element
+     * metaAnnotation = AnnotationUtils.findMetaAnnotation(methodElement, "com.example.AnotherMetaAnnotation");
+     *
+     * // Handle cases where the element might be null
+     * metaAnnotation = AnnotationUtils.findMetaAnnotation(null, metaAnnotationClassName); // returns null
+     *
+     * // Handle cases where the meta-annotation class name might be null
+     * metaAnnotation = AnnotationUtils.findMetaAnnotation(typeElement, null); // returns null
+     * }
+ * + * @param annotatedConstruct the annotated element to search for meta-annotations, may be {@code null} + * @param metaAnnotationClassName the fully qualified class name of the meta-annotation to look for, may be {@code null} + * @return the first matching meta-{@link AnnotationMirror}, or {@code null} if none found + */ + static AnnotationMirror findMetaAnnotation(Element annotatedConstruct, CharSequence metaAnnotationClassName) { + if (annotatedConstruct == null || metaAnnotationClassName == null) { + return null; + } + + AnnotationMirror metaAnnotation = null; + + List annotations = getAllAnnotations(annotatedConstruct); + int size = size(annotations); + + for (int i = 0; i < size; i++) { + AnnotationMirror annotation = annotations.get(i); + if ((metaAnnotation = findAnnotation(annotation.getAnnotationType(), metaAnnotationClassName)) != null) { + break; + } + } + + return metaAnnotation; + } + + /** + * Checks if the specified annotation is present on the given element, either directly or as a meta-annotation. + * + *

Example Usage

+ * 
{@code
+     * // Check if an annotation is present on a class element
+     * TypeElement typeElement = ...; // obtain a TypeElement
+     * boolean present = AnnotationUtils.isAnnotationPresent(typeElement, MyAnnotation.class);
+     *
+     * // Check if an annotation is present on a method element
+     * Element methodElement = ...; // obtain a method Element
+     * present = AnnotationUtils.isAnnotationPresent(methodElement, AnotherAnnotation.class);
+     *
+     * // Handle cases where the element might be null
+     * present = AnnotationUtils.isAnnotationPresent(null, MyAnnotation.class); // returns false
+     *
+     * // Handle cases where the annotation class might be null
+     * present = AnnotationUtils.isAnnotationPresent(typeElement, null); // returns false
+     * }
+ * + * @param element the element to check for the presence of the annotation; may be {@code null} + * @param annotationClass the annotation class to look for; may be {@code null} + * @return {@code true} if the annotation is present (either directly or as a meta-annotation), + * {@code false} otherwise or if either parameter is {@code null} + */ + static boolean isAnnotationPresent(Element element, Class annotationClass) { + if (element == null || annotationClass == null) { + return false; + } + return findAnnotation(element, annotationClass) != null || findMetaAnnotation(element, annotationClass) != null; + } + + /** + * Checks if the specified annotation (by class name) is present on the given element, either directly or as a meta-annotation. + * + *

Example Usage

+ * 
{@code
+     * // Check if an annotation is present on a class element
+     * TypeElement typeElement = ...; // obtain a TypeElement
+     * String annotationClassName = "com.example.MyAnnotation";
+     * boolean present = AnnotationUtils.isAnnotationPresent(typeElement, annotationClassName);
+     *
+     * // Check if an annotation is present on a method element
+     * Element methodElement = ...; // obtain a method Element
+     * present = AnnotationUtils.isAnnotationPresent(methodElement, "com.example.AnotherAnnotation");
+     *
+     * // Handle cases where the element might be null
+     * present = AnnotationUtils.isAnnotationPresent(null, annotationClassName); // returns false
+     *
+     * // Handle cases where the annotation class name might be null
+     * present = AnnotationUtils.isAnnotationPresent(typeElement, null); // returns false
+     * }
+ * + * @param element the element to check for the presence of the annotation; may be {@code null} + * @param annotationClassName the fully qualified class name of the annotation to look for; may be {@code null} + * @return {@code true} if the annotation is present (either directly or as a meta-annotation), + * {@code false} otherwise or if either parameter is {@code null} + */ + static boolean isAnnotationPresent(Element element, CharSequence annotationClassName) { + if (element == null || annotationClassName == null) { + return false; + } + return findAnnotation(element, annotationClassName) != null || findMetaAnnotation(element, annotationClassName) != null; + } + + /** + * Retrieves all {@link AnnotationMirror} instances from the given {@link AnnotatedConstruct} + * that match the provided annotation filters. + * + *

If the annotated construct is {@code null}, this method returns an empty list. + * If no annotation filters are provided, all annotations present on the construct are returned. + * Otherwise, only annotations that satisfy all the provided predicates are included in the result.

+ * + *

Example Usage

+ * 
{@code
+     * // Retrieve all annotations from a class element
+     * TypeElement typeElement = ...; // obtain a TypeElement
+     * List allAnnotations = AnnotationUtils.findAnnotations(typeElement);
+     *
+     * // Retrieve annotations that match a specific condition
+     * List filteredAnnotations = AnnotationUtils.findAnnotations(typeElement,
+     *     annotation -> "com.example.MyAnnotation".contentEquals(annotation.getAnnotationType().asElement().toString()));
+     *
+     * // Retrieve annotations that match multiple conditions
+     * List multiFilteredAnnotations = AnnotationUtils.findAnnotations(typeElement,
+     *     annotation -> isAnnotationPresent(annotation, "com.example.MetaAnnotation"),
+     *     annotation -> annotation.getElementValues().size() > 1);
+     *
+     * // Handle cases where the annotated construct is null
+     * List annotations = AnnotationUtils.findAnnotations(null); // returns empty list
+     * }
+ * + * @param annotatedConstruct the annotated construct to search for annotations, may be {@code null} + * @param annotationFilters a varargs array of predicates used to filter annotations; may be empty or {@code null} + * @return a non-null immutable list of matching {@link AnnotationMirror} instances; never {@code null} + */ + @Nonnull + @Immutable + static List findAnnotations(AnnotatedConstruct annotatedConstruct, Predicate... annotationFilters) { + if (annotatedConstruct == null) { + return emptyList(); + } + + List annotations = (List) annotatedConstruct.getAnnotationMirrors(); + if (isEmpty(annotations)) { + return emptyList(); + } + + if (isNotEmpty(annotationFilters)) { + annotations = filterAll(annotations, annotationFilters); + } + + return annotations.isEmpty() ? emptyList() : unmodifiableList(annotations); + } + + /** + * Retrieves all {@link AnnotationMirror} instances from the given {@link TypeMirror}, applying the specified + * annotation filters to narrow down the results. If the type mirror is {@code null}, this method returns an empty list. + * + *

This method delegates to {@link #findAllAnnotations(TypeElement, Predicate[])} after converting the + * {@link TypeMirror} to a {@link TypeElement} using {@link TypeUtils#ofTypeElement(TypeMirror)}. + * + * @param type the type mirror to search for annotations, may be {@code null} + * @param annotationFilters a varargs array of predicates used to filter annotations; may be empty or {@code null} + * @return a non-null immutable list of matching {@link AnnotationMirror} instances; never {@code null} + */ + @Nonnull + @Immutable + static List findAllAnnotations(TypeMirror type, Predicate... annotationFilters) { + if (type == null) { + return emptyList(); + } + return findAllAnnotations(ofTypeElement(type), annotationFilters); + } + + @Nonnull + @Immutable + static List findAllAnnotations(TypeElement element, Predicate... annotationFilters) { + if (element == null) { + return emptyList(); + } + List typeElements = getAllTypeElements(element); + + List annotations = typeElements.stream() + .map(AnnotationUtils::getAnnotations) + .flatMap(Collection::stream) + .collect(toList()); + + if (isNotEmpty(annotationFilters)) { + annotations = filterAll(annotations, annotationFilters); + } + + return isEmpty(annotations) ? emptyList() : unmodifiableList(annotations); + } + + /** + * Retrieves all {@link AnnotationMirror} instances from the given {@link Element}, applying the specified + * annotation filters to narrow down the results. If the element is {@code null}, this method returns an empty list. + * + *

This method attempts to resolve the element into a {@link TypeElement}. If successful, it delegates to + * {@link #findAllAnnotations(TypeElement, Predicate[])} to retrieve annotations from the type hierarchy. + * Otherwise, it falls back to using {@link #findAnnotations(AnnotatedConstruct, Predicate[])} directly on the element.

+ * + * @param element the annotated element to search for annotations, may be {@code null} + * @param annotationFilters a varargs array of predicates used to filter annotations; may be empty or {@code null} + * @return a non-null immutable list of matching {@link AnnotationMirror} instances; never {@code null} + */ + @Nonnull + @Immutable + static List findAllAnnotations(Element element, Predicate... annotationFilters) { + if (element == null) { + return emptyList(); + } + + TypeElement typeElement = ofTypeElement(element); + + if (typeElement == null) { + return findAnnotations(element, annotationFilters); + } + + return findAllAnnotations(typeElement, annotationFilters); + } + + /** + * Retrieves all {@link AnnotationMirror} instances of the specified annotated type from the given + * {@link ProcessingEnvironment}. If either the processing environment or the annotated type is {@code null}, + * this method returns an empty list. + * + *

This method uses the fully qualified type name of the provided {@link Type} to locate the corresponding + * annotations. It delegates to the overloaded method that accepts a {@link CharSequence} for the type name.

+ * + * @param processingEnv the processing environment used to retrieve annotations, may be {@code null} + * @param annotatedType the annotated type to search for annotations, may be {@code null} + * @param annotationFilters a varargs array of predicates used to filter annotations; may be empty or {@code null} + * @return a non-null immutable list of {@link AnnotationMirror} instances; never {@code null} + */ + @Nonnull + @Immutable + static List findAllAnnotations(ProcessingEnvironment processingEnv, Type annotatedType, Predicate... annotationFilters) { + if (processingEnv == null || annotatedType == null) { + return emptyList(); + } + return findAllAnnotations(processingEnv, annotatedType.getTypeName(), annotationFilters); + } + + /** + * Retrieves all {@link AnnotationMirror} instances of the specified annotated type name from the given + * {@link ProcessingEnvironment}. If either the processing environment or the annotated type name is {@code null}, + * this method returns an empty list. + * + *

This method resolves the annotated type by delegating to {@link TypeUtils#getTypeElement(ProcessingEnvironment, CharSequence)}, + * and then uses the resolved type to find annotations with the provided filters.

+ * + * @param processingEnv the processing environment used to retrieve annotations, may be {@code null} + * @param annotatedTypeName the fully qualified class name of the annotation to look for, may be {@code null} + * @param annotationFilters a varargs array of predicates used to filter annotations; may be empty or {@code null} + * @return a non-null immutable list of matching {@link AnnotationMirror} instances; never {@code null} + */ + @Nonnull + @Immutable + static List findAllAnnotations(ProcessingEnvironment processingEnv, CharSequence annotatedTypeName, Predicate... annotationFilters) { + if (processingEnv == null || annotatedTypeName == null) { + return emptyList(); + } + return findAllAnnotations(getTypeElement(processingEnv, annotatedTypeName), annotationFilters); + } + + /** + * Checks if the given annotation mirror has the same type as the specified {@link Type}. + * + *

This method compares the fully qualified name of the annotation mirror's type with + * the provided type's name. Returns {@code false} if either parameter is {@code null}.

+ * + *

Example Usage

+ * 
{@code
+     * AnnotationMirror annotationMirror = ...; // obtain an AnnotationMirror instance
+     * Type annotationType = ...; // obtain a Type instance
+     *
+     * // Check if both are non-null and the types match
+     * boolean isMatch = AnnotationUtils.matchesAnnotationType(annotationMirror, annotationType);
+     *
+     * // Handle cases where the annotation mirror might be null
+     * isMatch = AnnotationUtils.matchesAnnotationType(null, annotationType); // returns false
+     *
+     * // Handle cases where the annotation type might be null
+     * isMatch = AnnotationUtils.matchesAnnotationType(annotationMirror, null); // returns false
+     * }
+ * + * @param annotationMirror the annotation mirror to compare; may be {@code null} + * @param annotationType the target type to match against; may be {@code null} + * @return {@code true} if both parameters are non-null and their types match by name; + * {@code false} otherwise + */ + static boolean matchesAnnotationType(AnnotationMirror annotationMirror, Type annotationType) { + if (annotationMirror == null || annotationType == null) { + return false; + } + return matchesAnnotationTypeName(annotationMirror, annotationType.getTypeName()); + } + + /** + * Checks if the given annotation mirror has the same type as the specified annotation class name. + * + *

This method compares the fully qualified name of the annotation mirror's type with + * the provided annotation class name. Returns {@code false} if either parameter is {@code null}.

+ * + *

Example Usage

+ * 
{@code
+     * AnnotationMirror annotationMirror = ...; // obtain an AnnotationMirror instance
+     * String annotationClassName = "com.example.MyAnnotation";
+     *
+     * // Check if both are non-null and the types match
+     * boolean isMatch = AnnotationUtils.matchesAnnotationTypeName(annotationMirror, annotationClassName);
+     *
+     * // Handle cases where the annotation mirror might be null
+     * isMatch = AnnotationUtils.matchesAnnotationTypeName(null, annotationClassName); // returns false
+     *
+     * // Handle cases where the annotation class name might be null
+     * isMatch = AnnotationUtils.matchesAnnotationTypeName(annotationMirror, null); // returns false
+     * }
+ * + * @param annotationMirror the annotation mirror to compare; may be {@code null} + * @param annotationTypeName the target annotation class name to match against; may be {@code null} + * @return {@code true} if both parameters are non-null and their types match by name; + * {@code false} otherwise + */ + static boolean matchesAnnotationTypeName(AnnotationMirror annotationMirror, CharSequence annotationTypeName) { + if (annotationMirror == null || annotationTypeName == null) { + return false; + } + return isSameType(annotationMirror.getAnnotationType(), annotationTypeName); + } + + /** + * Retrieves the name of the attribute method from the given {@link ExecutableElement}. + * + *

This method is typically used to extract the attribute name from an annotation method declaration. + * The returned name corresponds to the method's simple name as defined in the annotation interface.

+ * + *

Example Usage

+ * 
{@code
+     * // Given an annotation interface:
+     * public @interface MyAnnotation {
+     *     String value();
+     *     int priority() default 0;
+     * }
+     *
+     * // Retrieve attribute names from methods
+     * ExecutableElement valueMethod = ...; // method representing 'value()'
+     * ExecutableElement priorityMethod = ...; // method representing 'priority()'
+     *
+     * String valueName = AnnotationUtils.getAttributeName(valueMethod); // returns "value"
+     * String priorityName = AnnotationUtils.getAttributeName(priorityMethod); // returns "priority"
+     *
+     * // Handle cases where the executable element is null
+     * String name = AnnotationUtils.getAttributeName(null); // returns null
+     * }
+ * + * @param attributeMethod the executable element representing the annotation attribute method, may be {@code null} + * @return the name of the attribute method, or {@code null} if the provided element is {@code null} + */ + static String getAttributeName(ExecutableElement attributeMethod) { + return getMethodName(attributeMethod); + } + + /** + * Checks if the provided executable element represents an annotation attribute method + * with the specified name. + * + *

Example Usage

+ * 
{@code
+     * // Given an annotation interface:
+     * public @interface MyAnnotation {
+     *     String value();
+     *     int priority() default 0;
+     * }
+     *
+     * // Check if the executable element corresponds to the "value" method
+     * ExecutableElement valueMethod = ...; // method representing 'value()'
+     * boolean isValueMethod = AnnotationUtils.matchesAttributeMethod(valueMethod, "value"); // returns true
+     *
+     * // Check if the executable element corresponds to the "priority" method
+     * ExecutableElement priorityMethod = ...; // method representing 'priority()'
+     * boolean isPriorityMethod = AnnotationUtils.matchesAttributeMethod(priorityMethod, "priority"); // returns true
+     *
+     * // Handle cases where the executable element is null
+     * boolean result = AnnotationUtils.matchesAttributeMethod(null, "value"); // returns false
+     *
+     * // Handle cases where the attribute name is null or blank
+     * result = AnnotationUtils.matchesAttributeMethod(valueMethod, null); // returns false
+     * result = AnnotationUtils.matchesAttributeMethod(valueMethod, ""); // returns false
+     * }
+ * + * @param attributeMethod the executable element to check, may be {@code null} + * @param attributeName the expected name of the attribute method, may be {@code null} or blank + * @return {@code true} if the method is not null and its name matches the given attribute name; + * {@code false} otherwise + */ + static boolean matchesAttributeMethod(ExecutableElement attributeMethod, String attributeName) { + return attributeMethod != null && Objects.equals(getAttributeName(attributeMethod), attributeName); + } + + /** + * Checks if two given {@link AnnotationValue} instances are equal by comparing their values. + * + *

This method performs a deep comparison of the values contained within the annotation values. + * If both values are {@code null}, they are considered equal. If only one is {@code null}, they are not equal. + * Otherwise, the method compares the actual values using {@link Objects#equals(Object, Object)}.

+ * + *

Example Usage

+ * 
{@code
+     * AnnotationValue value1 = ...; // obtain an AnnotationValue instance
+     * AnnotationValue value2 = ...; // obtain another AnnotationValue instance
+     *
+     * // Check if both annotation values are equal
+     * boolean isEqual = AnnotationUtils.matchesAttributeValue(value1, value2);
+     *
+     * // Handle cases where either value is null
+     * isEqual = AnnotationUtils.matchesAttributeValue(null, value2); // returns false
+     * isEqual = AnnotationUtils.matchesAttributeValue(value1, null); // returns false
+     * }
+ * + * @param one the first annotation value to compare; may be {@code null} + * @param another the second annotation value to compare; may be {@code null} + * @return {@code true} if both annotation values are either {@code null} or their contents are equal; + * {@code false} otherwise + */ + static boolean matchesAttributeValue(AnnotationValue one, AnnotationValue another) { + if (one == another) { + return true; + } + if (one == null || another == null) { + return false; + } + Object oneValue = one.getValue(); + Object anotherValue = another.getValue(); + return Objects.equals(oneValue, anotherValue); + } + + /** + * Checks if the value of the given {@link AnnotationValue} matches the specified attribute value. + * + *

This method compares the actual value extracted from the annotation value with the provided + * attribute value. Returns {@code false} if either parameter is {@code null} or if the values do not match.

+ * + *

Example Usage

+ * 
{@code
+     * AnnotationValue annotationValue = ...; // obtain an AnnotationValue instance
+     * String expectedValue = "example";
+     * boolean isMatch = AnnotationUtils.matchesAttributeValue(annotationValue, expectedValue); // returns true if values match
+     *
+     * // Handle cases where the annotation value is null
+     * boolean result = AnnotationUtils.matchesAttributeValue(null, expectedValue); // returns false
+     *
+     * // Handle cases where the attribute value is null
+     * result = AnnotationUtils.matchesAttributeValue(annotationValue, null); // returns false
+     * }
+ * + * @param annotationValue the annotation value to compare; may be {@code null} + * @param attributeValue the target value to match against; may be {@code null} + * @return {@code true} if both parameters are non-null and their values match; + * {@code false} otherwise + */ + static boolean matchesAttributeValue(AnnotationValue annotationValue, Object attributeValue) { + return annotationValue != null && Objects.equals(annotationValue.getValue(), attributeValue); + } + + /** + * Checks if the provided annotation value matches the default value of the specified attribute method. + * + *

This method is useful when determining if an attribute value in an annotation is explicitly set or + * if it falls back to the default value declared in the annotation interface.

+ * + *

Example Usage

+ * 
{@code
+     * public @interface MyAnnotation {
+     *     String value() default "default";
+     * }
+     *
+     * AnnotationMirror annotation = ...; // obtained from an annotated element
+     * ExecutableElement attributeMethod = getAttributeMethod(annotation, "value");
+     * AnnotationValue annotationValue = getAttributeValue(annotation, "value");
+     *
+     * boolean isDefaultValue = matchesDefaultAttributeValue(attributeMethod, annotationValue);
+     * }

+ * + * @param attributeMethod the executable element representing the annotation attribute method, may be {@code null} + * @param annotationValue the annotation value to compare against the default, may be {@code null} + * @return {@code true} if both the attribute method and annotation value are non-null and the value matches the default; + * {@code false} otherwise + */ + static boolean matchesDefaultAttributeValue(ExecutableElement attributeMethod, AnnotationValue annotationValue) { + return attributeMethod != null && matchesAttributeValue(attributeMethod.getDefaultValue(), annotationValue); + } + + /** + * Retrieves a map of attribute names to their corresponding values from the first matching annotation of the specified class + * on the given annotated construct. This includes both explicitly set values and default values for attributes. + * + *

Example Usage

+ * 
{@code
+     * // Given an annotation interface:
+     * public @interface MyAnnotation {
+     *     String value() default "default";
+     *     int priority() default 0;
+     * }
+     *
+     * // Retrieve attributes from an annotated class
+     * TypeElement typeElement = ...; // obtain a TypeElement
+     * Map attributes = AnnotationUtils.getAttributesMap(typeElement, MyAnnotation.class);
+     *
+     * // Example output if MyAnnotation is applied with value="custom"
+     * // attributes will contain:
+     * // {
+     * //     "value" = "custom",
+     * //     "priority" = 0
+     * // }
+     *
+     * // Handle cases where the annotated construct is null
+     * attributes = AnnotationUtils.getAttributesMap(null, MyAnnotation.class); // returns empty map
+     *
+     * // Handle cases where the annotation class is null
+     * attributes = AnnotationUtils.getAttributesMap(typeElement, null); // returns empty map
+     * }
+ * + * @param annotatedConstruct the annotated construct (e.g., a class, method, or field) that may contain the annotation, + * may be {@code null} + * @param annotationClass the annotation class used to locate the annotation on the construct, must not be {@code null} + * @return a non-null immutable map of attribute names to their corresponding values; never {@code null}, + * returns an empty map if no annotation is found, the construct is {@code null}, or the annotation class is {@code null} + */ + @Nonnull + @Immutable + static Map getAttributesMap(AnnotatedConstruct annotatedConstruct, Class annotationClass) { + return getAttributesMap(annotatedConstruct, annotationClass, WITH_DEFAULT); + } + + /** + * Retrieves a map of attribute names to their corresponding values from the first matching annotation of the specified class + * on the given annotated construct. This includes both explicitly set values and default values for attributes if the + * {@code withDefault} flag is set to {@code true}. + * + *

Example Usage

+ * 
{@code
+     * // Given an annotation interface:
+     * public @interface MyAnnotation {
+     *     String value() default "default";
+     *     int priority() default 0;
+     * }
+     *
+     * // Retrieve attributes from an annotated class
+     * TypeElement typeElement = ...; // obtain a TypeElement
+     * Map attributes = AnnotationUtils.getAttributesMap(typeElement, MyAnnotation.class, true);
+     *
+     * // Example output if MyAnnotation is applied with value="custom"
+     * // attributes will contain:
+     * // {
+     * //     "value" = "custom",
+     * //     "priority" = 0
+     * // }
+     *
+     * // Handle cases where the annotated construct is null
+     * attributes = AnnotationUtils.getAttributesMap(null, MyAnnotation.class, true); // returns empty map
+     *
+     * // Handle cases where the annotation class is null
+     * attributes = AnnotationUtils.getAttributesMap(typeElement, null, true); // returns empty map
+     * }
+ * + * @param annotatedConstruct the annotated construct (e.g., a class, method, or field) that may contain the annotation, + * may be {@code null} + * @param annotationClass the annotation class used to locate the annotation on the construct, must not be {@code null} + * @param withDefault flag indicating whether to include default values for attributes that are not explicitly set; + * if {@code true}, default values will be included where applicable + * @return a non-null immutable map of attribute names to their corresponding values; never {@code null}, + * returns an empty map if no annotation is found, the construct is {@code null}, or the annotation class is {@code null} + */ + @Nonnull + @Immutable + static Map getAttributesMap(AnnotatedConstruct annotatedConstruct, Class annotationClass, boolean withDefault) { + return getAttributesMap(getAnnotation(annotatedConstruct, annotationClass), withDefault); + } + + /** + * Retrieves a map of attribute names to their corresponding values from the specified annotation. + * This includes both explicitly set values and default values for attributes. + * + *

Example Usage

+ * 
{@code
+     * // Given an annotation interface:
+     * public @interface MyAnnotation {
+     *     String value() default "default";
+     *     int priority() default 0;
+     * }
+     *
+     * // Retrieve attributes from an annotation instance
+     * AnnotationMirror annotation = ...; // obtain an AnnotationMirror instance
+     * Map attributes = AnnotationUtils.getAttributesMap(annotation);
+     *
+     * // Example output if MyAnnotation is applied with value="custom"
+     * // attributes will contain:
+     * // {
+     * //     "value" = "custom",
+     * //     "priority" = 0
+     * // }
+     *
+     * // Handle cases where the annotation is null
+     * Map emptyMap = AnnotationUtils.getAttributesMap(null); // returns empty map
+     * }
+ * + * @param annotation the specified annotation, may be {@code null} + * @return a non-null immutable map of attribute names to their corresponding values; never {@code null}, + * returns an empty map if the annotation is {@code null} + */ + @Nonnull + @Immutable + static Map getAttributesMap(AnnotationMirror annotation) { + return getAttributesMap(annotation, WITH_DEFAULT); + } + + /** + * Retrieves a map of attribute names to their corresponding values from the specified annotation. + * This includes both explicitly set values and default values for attributes if the + * {@code withDefault} flag is set to {@code true}. + * + *

Example Usage

+ * 
{@code
+     * // Given an annotation interface:
+     * public @interface MyAnnotation {
+     *     String value() default "default";
+     *     int priority() default 0;
+     * }
+     *
+     * // Retrieve attributes from an annotation instance with default values
+     * AnnotationMirror annotation = ...; // obtain an AnnotationMirror instance
+     * Map attributes = AnnotationUtils.getAttributesMap(annotation, true);
+     *
+     * // Example output if MyAnnotation is applied with value="custom"
+     * // attributes will contain:
+     * // {
+     * //     "value" = "custom",
+     * //     "priority" = 0
+     * // }
+     *
+     * // Retrieve attributes without including default values
+     * Map explicitAttributes = AnnotationUtils.getAttributesMap(annotation, false);
+     *
+     * // Handle cases where the annotation is null
+     * Map emptyMap = AnnotationUtils.getAttributesMap(null, true); // returns empty map
+     * }
+ * + * @param annotation the specified annotation, may be {@code null} + * @param withDefault flag indicating whether to include default values for attributes that are not explicitly set; + * if {@code true}, default values will be included where applicable + * @return a non-null immutable map of attribute names to their corresponding values; never {@code null}, + * returns an empty map if the annotation is {@code null} + */ + @Nonnull + @Immutable + static Map getAttributesMap(AnnotationMirror annotation, boolean withDefault) { + Map attributes = getElementValues(annotation, withDefault); + int size = attributes.size(); + if (size < 1) { + return emptyMap(); + } + Map attributesMap = newFixedLinkedHashMap(size); + for (Entry entry : attributes.entrySet()) { + ExecutableElement attributeMethod = entry.getKey(); + String attributeName = getAttributeName(attributeMethod); + Object attributeValue = getAttribute(entry); + attributesMap.put(attributeName, attributeValue); + } + return unmodifiableMap(attributesMap); + } + + /** + * Retrieves the map of annotation attribute methods to their corresponding values from the specified + * {@link AnnotatedConstruct} and annotation class. This method finds the first matching annotation on the construct + * and returns all its declared attribute values, including default values. + * + *

This method is a convenience overload that defaults to including default values. If the annotated construct + * is {@code null} or the annotation class is not present, an empty map is returned. + * + *

Example Usage

+ * 
{@code
+     * // Given an annotation interface:
+     * public @interface MyAnnotation {
+     *     String value() default "default";
+     *     int priority() default 0;
+     * }
+     *
+     * // Retrieve attribute values from an annotated class
+     * TypeElement typeElement = ...; // obtain a TypeElement
+     * Map attributes = AnnotationUtils.getElementValues(typeElement, MyAnnotation.class);
+     *
+     * // Example output if MyAnnotation is applied with value="custom"
+     * // attributes will contain:
+     * // {
+     * //     value(): "custom",
+     * //     priority(): 0
+     * // }
+     *
+     * // Handle cases where the annotated construct is null
+     * Map emptyMap = AnnotationUtils.getElementValues(null, MyAnnotation.class); // returns empty map
+     *
+     * // Handle cases where the annotation class is null
+     * emptyMap = AnnotationUtils.getElementValues(typeElement, null); // returns empty map
+     * }
+ * + * @param annotatedConstruct the annotated construct (e.g., a class, method, or field) that may contain the annotation, + * may be {@code null} + * @param annotationClass the annotation class used to locate the annotation on the construct, must not be {@code null} + * @return a non-null immutable map of executable elements (attribute methods) to their annotation values; never {@code null}, + * returns an empty map if no annotation is found or if the construct is {@code null} + */ + @Nonnull + @Immutable + static Map getElementValues(AnnotatedConstruct annotatedConstruct, Class annotationClass) { + return getElementValues(annotatedConstruct, annotationClass, WITH_DEFAULT); + } + + /** + * Retrieves the map of annotation attribute methods to their corresponding values from the specified + * {@link AnnotatedConstruct} and annotation class. This method finds the first matching annotation on the construct + * and returns all its declared attribute values, including default values if enabled. + * + *

If the annotated construct is {@code null} or the annotation class is not present, an empty map is returned. + * If the {@code withDefault} flag is set to {@code true}, this method includes default values for attributes + * that are not explicitly set.

+ * + *

Example Usage

+ * 
{@code
+     * // Given an annotation interface:
+     * public @interface MyAnnotation {
+     *     String value() default "default";
+     *     int priority() default 0;
+     * }
+     *
+     * // Retrieve attribute values from an annotated class with default values
+     * TypeElement typeElement = ...; // obtain a TypeElement
+     * Map attributes = AnnotationUtils.getElementValues(typeElement, MyAnnotation.class, true);
+     *
+     * // Example output if MyAnnotation is applied with value="custom"
+     * // attributes will contain:
+     * // {
+     * //     value(): "custom",
+     * //     priority(): 0
+     * // }
+     *
+     * // Retrieve attribute values without including default values
+     * Map explicitAttributes = AnnotationUtils.getElementValues(typeElement, MyAnnotation.class, false);
+     *
+     * // Handle cases where the annotated construct is null
+     * Map emptyMap = AnnotationUtils.getElementValues(null, MyAnnotation.class, true); // returns empty map
+     *
+     * // Handle cases where the annotation class is null
+     * emptyMap = AnnotationUtils.getElementValues(typeElement, null, true); // returns empty map
+     * }
+ * + * @param annotatedConstruct the annotated construct (e.g., a class, method, or field) that may contain the annotation, + * may be {@code null} + * @param annotationClass the annotation class used to locate the annotation on the construct, must not be {@code null} + * @param withDefault flag indicating whether to include default values for attributes that are not explicitly set; + * if {@code true}, default values will be included where applicable + * @return a non-null immutable map of executable elements (attribute methods) to their annotation values; never {@code null}, + * returns an empty map if no annotation is found or if the construct is {@code null} + */ + @Nonnull + @Immutable + static Map getElementValues(AnnotatedConstruct annotatedConstruct, Class annotationClass, boolean withDefault) { + return getElementValues(getAnnotation(annotatedConstruct, annotationClass), withDefault); + } + + /** + * Retrieves a map of annotation attribute methods to their corresponding values from the specified + * {@link AnnotationMirror}. This method includes both explicitly set values and default values for attributes. + * + *

If the provided annotation is {@code null}, an empty map is returned.

+ * + *

Example Usage

+ * 
{@code
+     * // Given an annotation interface:
+     * public @interface MyAnnotation {
+     *     String value() default "default";
+     *     int priority() default 0;
+     * }
+     *
+     * // Retrieve attribute values from an annotation instance
+     * AnnotationMirror annotation = ...; // obtain an AnnotationMirror instance
+     * Map attributes = AnnotationUtils.getElementValues(annotation);
+     *
+     * // Example output if MyAnnotation is applied with value="custom"
+     * // attributes will contain:
+     * // {
+     * //     value(): "custom",
+     * //     priority(): 0
+     * // }
+     *
+     * // Handle cases where the annotation is null
+     * Map emptyMap = AnnotationUtils.getElementValues(null); // returns empty map
+     * }
+ * + * @param annotation the annotation mirror to extract attribute values from, may be {@code null} + * @return a non-null immutable map of executable elements (attribute methods) to their annotation values; + * never {@code null}, returns an empty map if the annotation is {@code null} + */ + @Nonnull + @Immutable + static Map getElementValues(AnnotationMirror annotation) { + return getElementValues(annotation, WITH_DEFAULT); + } + + /** + * Retrieves a map of annotation attribute methods to their corresponding values from the specified + * {@link AnnotationMirror}. This method includes both explicitly set values and default values for attributes + * if the {@code withDefault} flag is set to {@code true}. + * + *

If the provided annotation is {@code null}, an empty map is returned.

+ * + *

Example Usage

+ * 
{@code
+     * // Given an annotation interface:
+     * public @interface MyAnnotation {
+     *     String value() default "default";
+     *     int priority() default 0;
+     * }
+     *
+     * // Retrieve attribute values from an annotation instance with default values
+     * AnnotationMirror annotation = ...; // obtain an AnnotationMirror instance
+     * Map attributes = AnnotationUtils.getElementValues(annotation, true);
+     *
+     * // Example output if MyAnnotation is applied with value="custom"
+     * // attributes will contain:
+     * // {
+     * //     value(): "custom",
+     * //     priority(): 0
+     * // }
+     *
+     * // Retrieve attribute values without including default values
+     * Map explicitAttributes = AnnotationUtils.getElementValues(annotation, false);
+     *
+     * // Handle cases where the annotation is null
+     * Map emptyMap = AnnotationUtils.getElementValues(null, true); // returns empty map
+     * }
+ * + * @param annotation the annotation mirror to extract attribute values from, may be {@code null} + * @param withDefault flag indicating whether to include default values for attributes that are not explicitly set; + * if {@code true}, default values will be included where applicable + * @return a non-null immutable map of executable elements (attribute methods) to their annotation values; + * never {@code null}, returns an empty map if the annotation is {@code null} + */ + @Nonnull + @Immutable + static Map getElementValues(AnnotationMirror annotation, boolean withDefault) { + if (annotation == null) { + return emptyMap(); + } + DeclaredType annotationType = annotation.getAnnotationType(); + List attributeMethods = getDeclaredMethods(annotationType); + int size = attributeMethods.size(); + Map attributes = newFixedLinkedHashMap(size); + Map elementValues = annotation.getElementValues(); + for (int i = 0; i < size; i++) { + ExecutableElement attributeMethod = attributeMethods.get(i); + AnnotationValue annotationValue = elementValues.get(attributeMethod); + if (withDefault && annotationValue == null) { + annotationValue = attributeMethod.getDefaultValue(); + } + if (annotationValue != null) { + attributes.put(attributeMethod, annotationValue); + } + } + return unmodifiableMap(attributes); + } + + /** + * Retrieves the attribute method and its corresponding annotation value from the specified annotation + * based on the given attribute name. If no explicit value is found and {@code withDefault} is true, + * it attempts to find and return the default value for the attribute. + * + *

If the provided annotation is null or the attribute name is blank, this method returns null.

+ * + *

Example Usage

+ * 
{@code
+     * AnnotationMirror annotation = ...; // obtain an AnnotationMirror instance
+     * String attributeName = "value"; // the name of the attribute to retrieve
+     *
+     * // Retrieve an attribute with default value lookup enabled
+     * Map.Entry attributeEntry = AnnotationUtils.getElementValue(annotation, attributeName, true);
+     *
+     * if (attributeEntry != null) {
+     *     ExecutableElement attributeMethod = attributeEntry.getKey();
+     *     AnnotationValue annotationValue = attributeEntry.getValue();
+     *     // process attribute method and value
+     * }
+     *
+     * // Retrieve an attribute without default value lookup
+     * attributeEntry = AnnotationUtils.getElementValue(annotation, attributeName, false);
+     *
+     * // Handle cases where the annotation is null
+     * attributeEntry = AnnotationUtils.getElementValue(null, attributeName, true); // returns null
+     *
+     * // Handle cases where the attribute name is blank or null
+     * attributeEntry = AnnotationUtils.getElementValue(annotation, null, true); // returns null
+     * }
+ * + * @param annotation the annotation mirror to extract the attribute value from, may be {@code null} + * @param attributeName the name of the attribute method to look for, may be blank + * @param withDefault flag indicating whether to include the default value if the attribute is not explicitly set; + * if true, the method will attempt to find and return the default value + * @return an entry containing the executable element (attribute method) and its corresponding annotation value; + * returns null if the annotation is null, the attribute name is blank, or the attribute method cannot be found + */ + @Nullable + @Immutable + static Entry getElementValue(AnnotationMirror annotation, String attributeName, boolean withDefault) { + if (annotation == null || isBlank(attributeName)) { + return null; + } + + ExecutableElement attributeMethod = null; + AnnotationValue annotationValue = null; + Map elementValues = annotation.getElementValues(); + for (Entry entry : elementValues.entrySet()) { + attributeMethod = entry.getKey(); + if (matchesAttributeMethod(attributeMethod, attributeName)) { + annotationValue = entry.getValue(); + break; + } + } + + if (withDefault && annotationValue == null) { // not found if the default value is required + DeclaredType annotationType = annotation.getAnnotationType(); + List attributeMethods = findDeclaredMethods(annotationType, method -> !elementValues.containsKey(method)); + int size = attributeMethods.size(); + for (int i = 0; i < size; i++) { + attributeMethod = attributeMethods.get(i); + if (matchesAttributeMethod(attributeMethod, attributeName)) { + annotationValue = attributeMethod.getDefaultValue(); + break; + } + } + } + + return immutableEntry(attributeMethod, annotationValue); + } + + /** + * Retrieves the attribute method and its corresponding annotation value from the specified element values map + * based on the given attribute name. + * + *

This method searches through the provided map of executable elements (attribute methods) to their annotation + * values to find a matching attribute by name. If no match is found, it returns {@code null}.

+ * + *

Example Usage

+ * 
{@code
+     * // Given an annotation interface:
+     * public @interface MyAnnotation {
+     *     String value() default "default";
+     *     int priority() default 0;
+     * }
+     *
+     * // Assume elementValues contains:
+     * // {
+     * //     value(): "custom",
+     * //     priority(): 5
+     * // }
+     *
+     * // Retrieve an existing attribute
+     * Entry entry = AnnotationUtils.getElementValue(elementValues, "value");
+     * if (entry != null) {
+     *     String value = (String) entry.getValue().getValue(); // returns "custom"
+     * }
+     *
+     * // Retrieve a non-existent attribute
+     * entry = AnnotationUtils.getElementValue(elementValues, "nonExistent"); // returns null
+     *
+     * // Handle cases where the element values map is null or empty
+     * entry = AnnotationUtils.getElementValue(null, "value"); // returns null
+     * }
+ * + * @param elementValues the map of executable elements (attribute methods) to their annotation values; + * may be {@code null} or empty + * @param attributeName the name of the attribute method to look for; may be {@code null} or blank + * @return an entry containing the executable element (attribute method) and its corresponding annotation value; + * returns {@code null} if the element values map is empty, the attribute name is blank, or no matching + * attribute is found + */ + @Nullable + static Entry getElementValue(Map elementValues, String attributeName) { + if (isEmpty(elementValues)) { + return null; + } + for (Entry entry : elementValues.entrySet()) { + if (matchesAttributeMethod(entry.getKey(), attributeName)) { + return entry; + } + } + return null; + } + + /** + * Retrieves the value of the specified attribute from the given annotation. + * + *

This method attempts to find the attribute by name in the provided annotation. If the attribute is not explicitly set, + * it will attempt to retrieve the default value associated with that attribute. If the attribute cannot be resolved or no value is found, + * this method returns {@code null}.

+ * + *

Example Usage

+ * 
{@code
+     * // Given an annotation interface:
+     * public @interface MyAnnotation {
+     *     String value() default "default";
+     *     int priority() default 0;
+     * }
+     *
+     * // Retrieve the value of the "value" attribute
+     * AnnotationMirror annotation = ...; // obtain an AnnotationMirror instance
+     * String value = AnnotationUtils.getAttribute(annotation, "value"); // returns "default" or explicit value
+     *
+     * // Retrieve the value of the "priority" attribute
+     * int priority = AnnotationUtils.getAttribute(annotation, "priority"); // returns 0 or explicit value
+     *
+     * // Handle cases where the annotation is null
+     * String result = AnnotationUtils.getAttribute(null, "value"); // returns null
+     *
+     * // Handle cases where the attribute name is blank or null
+     * result = AnnotationUtils.getAttribute(annotation, null); // returns null
+     * }
+ * + * @param the type of the attribute value to return + * @param annotation the annotation mirror to extract the attribute value from; may be {@code null} + * @param attributeName the name of the attribute method to look for; may be blank or {@code null} + * @return the value of the specified attribute if found, or the default value if available; + * returns {@code null} if the annotation is {@code null}, the attribute name is blank, + * or the attribute cannot be resolved + */ + @Nullable + static T getAttribute(AnnotationMirror annotation, String attributeName) { + return getAttribute(annotation, attributeName, WITH_DEFAULT); + } + + /** + * Retrieves the value of the specified attribute from the given annotation, optionally including the default value. + * + *

This method attempts to find the attribute by name in the provided annotation. If the attribute is not explicitly set, + * and the {@code withDefault} flag is set to {@code true}, it will attempt to retrieve the default value associated + * with that attribute. If the attribute cannot be resolved or no value is found, this method returns {@code null}.

+ * + *

Example Usage

+ * 
{@code
+     * // Given an annotation interface:
+     * public @interface MyAnnotation {
+     *     String value() default "default";
+     *     int priority() default 0;
+     * }
+     *
+     * // Retrieve the value of the "value" attribute including default
+     * AnnotationMirror annotation = ...; // obtain an AnnotationMirror instance
+     * String value = AnnotationUtils.getAttribute(annotation, "value", true); // returns "default" or explicit value
+     *
+     * // Retrieve the value of the "priority" attribute without default lookup
+     * int priority = AnnotationUtils.getAttribute(annotation, "priority", false); // returns 0 only if explicitly set
+     *
+     * // Handle cases where the annotation is null
+     * String result = AnnotationUtils.getAttribute(null, "value", true); // returns null
+     *
+     * // Handle cases where the attribute name is blank or null
+     * result = AnnotationUtils.getAttribute(annotation, null, true); // returns null
+     * }
+ * + * @param the type of the attribute value to return + * @param annotation the annotation mirror to extract the attribute value from; may be {@code null} + * @param attributeName the name of the attribute method to look for; may be blank or {@code null} + * @param withDefault flag indicating whether to include the default value if the attribute is not explicitly set; + * if {@code true}, the method will attempt to find and return the default value + * @return the value of the specified attribute if found, or the default value if available; + * returns {@code null} if the annotation is {@code null}, the attribute name is blank, + * or the attribute cannot be resolved + */ + @Nullable + static T getAttribute(AnnotationMirror annotation, String attributeName, boolean withDefault) { + Entry attributeEntry = getElementValue(annotation, attributeName, withDefault); + return getAttribute(attributeEntry); + } + + /** + * Retrieves the value of the specified attribute from the provided entry containing the attribute method + * and its corresponding annotation value. + * + *

If the entry is null or either the attribute method or annotation value is unresolved, this method returns {@code null}. + * Otherwise, it delegates to the default {@link AnnotationValueVisitor} to extract the attribute value.

+ * + *

Example Usage

+ * 
{@code
+     * // Given an annotation interface:
+     * public @interface MyAnnotation {
+     *     String value() default "default";
+     *     int priority() default 0;
+     * }
+     *
+     * // Assume elementValue contains the entry for "value" attribute
+     * Entry elementValue = ...; // obtain from AnnotationUtils.getElementValue()
+     * String value = AnnotationUtils.getAttribute(elementValue); // returns "default" or explicit value
+     *
+     * // Handle cases where the element value entry is null
+     * String result = AnnotationUtils.getAttribute(null); // returns null
+     * }
+ * + * @param the expected type of the attribute value + * @param elementValue an entry containing the attribute method and its corresponding annotation value; + * may be {@code null} + * @return the resolved value of the attribute if found; returns {@code null} if the entry is null, + * or if either the attribute method or annotation value is unresolved + */ + @Nullable + static T getAttribute(Entry elementValue) { + if (elementValue == null) { + return null; + } + + ExecutableElement attributeMethod = elementValue.getKey(); + AnnotationValue annotationValue = elementValue.getValue(); + + return (T) annotationValue.accept(DEFAULT_ANNOTATION_VALUE_VISITOR, attributeMethod); + } + + /** + * Retrieves the value of the default attribute method named {@code "value"} from the specified annotation. + * + *

This method delegates to {@link #getAttribute(AnnotationMirror, String)} to obtain the value of the annotation's + * {@code value()} method. Returns {@code null} if the annotation is {@code null} or if the value cannot be resolved.

+ * + *

Example Usage

+ * 
{@code
+     * // Given an annotation interface:
+     * public @interface MyAnnotation {
+     *     String value() default "default";
+     * }
+     *
+     * // Retrieve the "value" attribute from an annotation instance
+     * AnnotationMirror annotation = ...; // obtain an AnnotationMirror instance
+     * String value = AnnotationUtils.getValue(annotation); // returns "default" or explicit value
+     *
+     * // Handle cases where the annotation is null
+     * String result = AnnotationUtils.getValue(null); // returns null
+     * }
+ * + * @param the expected type of the attribute value + * @param annotation the annotation mirror to extract the value from; may be {@code null} + * @return the resolved value of the annotation's {@code value()} method if found; + * returns {@code null} if the annotation is {@code null} or the value cannot be resolved + */ + @Nullable + static T getValue(AnnotationMirror annotation) { + return getAttribute(annotation, VALUE_ATTRIBUTE_NAME); + } + + /** + * Retrieves the {@link ElementType} array from the specified annotation. + * + * @param annotation the specified annotation, may be {@code null} + * @return a non-null array of {@link ElementType}; never {@code null}, returns an empty array if the annotation is {@code null} + */ + /** + * Retrieves the {@link ElementType} array from the specified annotation. + * + *

This method checks the annotation's type for the presence of a {@link Target} annotation, + * which defines the element types the annotation can be applied to. If the provided annotation + * is {@code null}, this method returns an empty array.

+ * + *

Example Usage

+ * 
{@code
+     * AnnotationMirror annotation = ...; // obtain an AnnotationMirror instance
+     * ElementType[] elementTypes = AnnotationUtils.getElementTypes(annotation);
+     *
+     * // Handle cases where the annotation is null
+     * ElementType[] emptyTypes = AnnotationUtils.getElementTypes(null); // returns empty array
+     * }
+ * + * @param annotation the specified annotation, may be {@code null} + * @return a non-null array of {@link ElementType}; never {@code null}, returns an empty array if the annotation is {@code null} + */ + @Nonnull + static ElementType[] getElementTypes(AnnotationMirror annotation) { + return annotation == null ? EMPTY_ELEMENT_TYPE_ARRAY : getElementTypes(annotation.getAnnotationType()); + } + + /** + * Retrieves the {@link ElementType} array from the specified annotation type by checking + * the {@link Target} annotation associated with it. If the annotation type does not have a + * {@link Target} annotation, an empty array is returned. + * + *

Example Usage

+ * 
{@code
+     * // Given an annotation type:
+     * public @interface MyAnnotation {
+     * }
+     *
+     * DeclaredType annotationType = ...; // obtain a DeclaredType for MyAnnotation
+     * ElementType[] elementTypes = AnnotationUtils.getElementTypes(annotationType);
+     *
+     * // If MyAnnotation is annotated with @Target(ElementType.TYPE)
+     * // elementTypes will contain: { ElementType.TYPE }
+     *
+     * // Handle cases where the annotation type does not have a @Target annotation
+     * ElementType[] emptyTypes = AnnotationUtils.getElementTypes(annotationType); // returns empty array
+     * }
+ * + * @param annotationType the declared type of the annotation + * @return a non-null immutable array of {@link ElementType}; never {@code null}, + * returns an empty array if no {@link Target} annotation is present + */ + @Nonnull + static ElementType[] getElementTypes(DeclaredType annotationType) { + AnnotationMirror targetAnnotation = findAnnotation(annotationType, Target.class); + ElementType[] elementTypes = getValue(targetAnnotation); + return elementTypes == null ? EMPTY_ELEMENT_TYPE_ARRAY : elementTypes; + } +} diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ClassUtils.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ClassUtils.java new file mode 100644 index 000000000..1c2239399 --- /dev/null +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ClassUtils.java @@ -0,0 +1,109 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.lang.model.util; + +import io.microsphere.util.Utils; + +import javax.lang.model.type.TypeMirror; + +import static io.microsphere.lang.model.util.TypeUtils.ofTypeElement; +import static io.microsphere.constants.SymbolConstants.DOLLAR_CHAR; +import static io.microsphere.constants.SymbolConstants.DOT_CHAR; +import static io.microsphere.util.ClassLoaderUtils.getClassLoader; +import static io.microsphere.util.ClassLoaderUtils.resolveClass; + +/** + * The utilities class for {@link Class} + * + * @author Mercy + * @see Class + * @since 1.0.0 + */ +public interface ClassUtils extends Utils { + + /** + * Gets the fully qualified class name from the given {@link TypeMirror}. + * + *

+ * This method is useful when working with annotation processors or other + * compile-time code analysis tools that deal with type information represented + * as a {@link TypeMirror}. + *

+ * + *

Example Usage

+ * 
+     * TypeMirror type = processingEnv.getElementUtils().getTypeElement("com.example.MyClass").asType();
+     * String className = getClassName(type); // returns "com.example.MyClass"
+     *
+ * + * @param type the type mirror to extract the class name from + * @return the fully qualified class name as a String + */ + static String getClassName(TypeMirror type) { + return ofTypeElement(type).getQualifiedName().toString(); + } + + /** + * Loads the class represented by the given {@link TypeMirror}. + * + *

This method derives the fully qualified class name from the type mirror and + * delegates to the other {@link #loadClass(String)} method for class loading. + * It is particularly useful in annotation processors or compile-time tools where + * types are primarily accessed via their mirror representations. + * + *

Example Usage

+ * 
+     * TypeMirror type = processingEnv.getElementUtils().getTypeElement("com.example.MyClass").asType();
+     * Class clazz = ClassUtils.loadClass(type); // loads com.example.MyClass
+     *
+ * + * @param type the type mirror representing the class to load + * @return the resolved {@link Class}, or {@code null} if the class cannot be found + */ + static Class loadClass(TypeMirror type) { + return loadClass(getClassName(type)); + } + + /** + * Loads the class represented by the given fully qualified class name. + * + *

This method attempts to resolve the class using the provided class name and the class loader + * obtained from {@link ClassUtils}. If the class is not found, an attempt is made to resolve it + * as a nested or inner class by replacing the last dot ({@code .}) with a dollar sign ({@code $}). + * + *

Example Usage

+ * 
+     * Class clazz = ClassUtils.loadClass("com.example.MyClass");
+     * // If MyClass is an inner class, this may also attempt to load "com.example.My$Class"
+     *
+ * + * @param className the fully qualified name of the class to load + * @return the resolved {@link Class}, or {@code null} if the class cannot be found + */ + static Class loadClass(String className) { + ClassLoader classLoader = getClassLoader(ClassUtils.class); + Class klass = resolveClass(className, classLoader); + if (klass == null) { + int index = className.lastIndexOf(DOT_CHAR); + if (index > 0) { + className = className.substring(0, index) + DOLLAR_CHAR + className.substring(index + 1); + } + } + return resolveClass(className, classLoader); + } +} diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ConstructorUtils.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ConstructorUtils.java new file mode 100644 index 000000000..eb878ed96 --- /dev/null +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ConstructorUtils.java @@ -0,0 +1,293 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.lang.model.util; + +import io.microsphere.annotation.Immutable; +import io.microsphere.annotation.Nonnull; +import io.microsphere.annotation.Nullable; +import io.microsphere.util.Utils; + +import javax.lang.model.element.Element; +import javax.lang.model.element.ElementKind; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.TypeElement; +import javax.lang.model.type.TypeMirror; +import java.lang.reflect.Constructor; +import java.lang.reflect.Type; +import java.util.List; +import java.util.function.Predicate; + +import static io.microsphere.lang.model.util.ElementUtils.filterElements; +import static io.microsphere.lang.model.util.ElementUtils.matchParameterTypes; +import static io.microsphere.lang.model.util.MemberUtils.getDeclaredMembers; +import static io.microsphere.collection.CollectionUtils.isEmpty; +import static io.microsphere.collection.ListUtils.first; +import static io.microsphere.lang.function.Predicates.EMPTY_PREDICATE_ARRAY; +import static java.util.Collections.emptyList; +import static javax.lang.model.util.ElementFilter.constructorsIn; + +/** + * The utils class for {@link Constructor constructor} + * + * @author Mercy + * @see Constructor + * @see ExecutableElement + * @see ElementKind#CONSTRUCTOR + * @since 1.0.0 + */ +public interface ConstructorUtils extends Utils { + + /** + * Retrieves the list of declared constructors from the provided {@link TypeElement}. + *

+ * This method provides a null-safe way to obtain the constructors of a given type. + * If the input {@code type} is {@code null}, an empty list is returned. + *

+ * + *

Example Usage

+ * 
{@code
+     * TypeElement typeElement = ...; // Obtain a valid TypeElement
+     * List constructors = getDeclaredConstructors(typeElement);
+     * if (!constructors.isEmpty()) {
+     *     for (ExecutableElement constructor : constructors) {
+     *         System.out.println("Constructor: " + constructor);
+     *     }
+     * } else {
+     *     System.out.println("No constructors found.");
+     * }
+     * }
+ * + *

+ * This method is particularly useful when processing annotations during compilation, + * where it is necessary to inspect the constructors of a class without throwing exceptions + * for null inputs. + *

+ * + * @param type the {@link TypeElement} representing the type to retrieve constructors from + * @return a {@link List} of {@link ExecutableElement} objects representing the declared constructors; + * never {@code null}, but may be empty if no constructors are found or if the input is {@code null} + */ + @Nonnull + @Immutable + static List getDeclaredConstructors(TypeElement type) { + return type == null ? emptyList() : getDeclaredConstructors(type.asType()); + } + + /** + * Retrieves the list of declared constructors from the provided {@link TypeMirror}. + *

+ * This method provides a null-safe way to obtain the constructors of a given type. + * If the input {@code type} is {@code null}, an empty list is returned. + *

+ * + *

Example Usage

+ * 
{@code
+     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror
+     * List constructors = getDeclaredConstructors(typeMirror);
+     * if (!constructors.isEmpty()) {
+     *     for (ExecutableElement constructor : constructors) {
+     *         System.out.println("Constructor: " + constructor);
+     *     }
+     * } else {
+     *     System.out.println("No constructors found.");
+     * }
+     * }
+ * + *

+ * This method is particularly useful when processing annotations during compilation, + * where it is necessary to inspect the constructors of a class without throwing exceptions + * for null inputs. + *

+ * + * @param type the {@link TypeMirror} representing the type to retrieve constructors from + * @return a {@link List} of {@link ExecutableElement} objects representing the declared constructors; + * never {@code null}, but may be empty if no constructors are found or if the input is {@code null} + */ + @Nonnull + @Immutable + static List getDeclaredConstructors(TypeMirror type) { + return type == null ? emptyList() : findDeclaredConstructors(type, EMPTY_PREDICATE_ARRAY); + } + + /** + * Finds a declared constructor in the specified {@link TypeElement} that matches the given parameter types. + *

+ * This method provides a null-safe way to locate a constructor based on its parameter types. + * If the input {@code type} is {@code null}, or no matching constructor is found, {@code null} is returned. + *

+ * + *

Example Usage

+ * 
{@code
+     * TypeElement typeElement = ...; // Obtain a valid TypeElement
+     * Type[] paramTypes = new Type[] { String.class, int.class };
+     * ExecutableElement constructor = findConstructor(typeElement, paramTypes);
+     * if (constructor != null) {
+     *     System.out.println("Found constructor: " + constructor);
+     * } else {
+     *     System.out.println("Constructor not found.");
+     * }
+     * }
+ * + * @param type the {@link TypeElement} representing the type to search for constructors + * @param parameterTypes the array of {@link Type} objects representing the parameter types to match + * @return the matched {@link ExecutableElement} representing the constructor; may be {@code null} + */ + @Nullable + static ExecutableElement findConstructor(TypeElement type, Type... parameterTypes) { + return type == null ? null : findConstructor(type.asType(), parameterTypes); + } + + /** + * Finds a declared constructor in the specified {@link TypeMirror} that matches the given parameter types. + *

+ * This method provides a null-safe way to locate a constructor based on its parameter types. + * If the input {@code type} is {@code null}, or no matching constructor is found, {@code null} is returned. + *

+ * + *

Example Usage

+ * 
{@code
+     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror
+     * Type[] paramTypes = new Type[] { String.class, int.class };
+     * ExecutableElement constructor = findConstructor(typeMirror, paramTypes);
+     * if (constructor != null) {
+     *     System.out.println("Found constructor: " + constructor);
+     * } else {
+     *     System.out.println("Constructor not found.");
+     * }
+     * }
+ * + * @param type the {@link TypeMirror} representing the type to search for constructors + * @param parameterTypes the array of {@link Type} objects representing the parameter types to match + * @return the matched {@link ExecutableElement} representing the constructor; may be {@code null} + */ + @Nullable + static ExecutableElement findConstructor(TypeMirror type, Type... parameterTypes) { + if (type == null) { + return null; + } + return first(findDeclaredConstructors(type, constructor -> matchParameterTypes(constructor, parameterTypes))); + } + + /** + * Retrieves and filters the list of declared constructors from the provided {@link TypeElement}. + *

+ * This method provides a null-safe way to obtain the constructors of a given type. + * If the input {@code type} is {@code null}, an empty list is returned. + * The provided filters can be used to selectively include only those constructors that match the criteria. + *

+ * + *

Example Usage

+ * 
{@code
+     * TypeElement typeElement = ...; // Obtain a valid TypeElement
+     * // Get all declared constructors
+     * List allConstructors = findDeclaredConstructors(typeElement);
+     *
+     * // Get only constructors with specific parameter types
+     * List filteredConstructors = findDeclaredConstructors(typeElement,
+     *     constructor -> matchParameterTypes(constructor, String.class, int.class));
+     *
+     * if (!filteredConstructors.isEmpty()) {
+     *     for (ExecutableElement constructor : filteredConstructors) {
+     *         System.out.println("Matching Constructor: " + constructor);
+     *     }
+     * } else {
+     *     System.out.println("No matching constructors found.");
+     * }
+     * }
+ * + * @param type the {@link TypeElement} representing the type to retrieve constructors from + * @param constructorFilters optional predicates to filter the constructors; if none are provided, all constructors are included + * @return a {@link List} of {@link ExecutableElement} objects representing the filtered declared constructors; + * never {@code null}, but may be empty if no matching constructors are found or if the input is {@code null} + */ + @Nonnull + @Immutable + static List findDeclaredConstructors(TypeElement type, Predicate... constructorFilters) { + return type == null ? emptyList() : findDeclaredConstructors(type.asType(), constructorFilters); + } + + /** + * Retrieves and filters the list of declared constructors from the provided {@link TypeMirror}. + *

+ * This method provides a null-safe way to obtain the constructors of a given type. + * If the input {@code type} is {@code null}, an empty list is returned. + * The provided filters can be used to selectively include only those constructors that match the criteria. + *

+ * + * @param type the {@link TypeMirror} representing the type to retrieve constructors from + * @param constructorFilters optional predicates to filter the constructors; if none are provided, all constructors are included + * @return a {@link List} of {@link ExecutableElement} objects representing the filtered declared constructors; + * never {@code null}, but may be empty if no matching constructors are found or if the input is {@code null} + */ + @Nonnull + @Immutable + static List findDeclaredConstructors(TypeMirror type, Predicate... constructorFilters) { + return filterDeclaredConstructors(type, constructorFilters); + } + + /** + * Filters and retrieves the list of declared constructors from the provided {@link TypeMirror}. + *

+ * This method is responsible for extracting all declared constructors from the given type + * and applying the specified filters to narrow down the results. If the input {@code type} + * is {@code null}, an empty list is returned. + *

+ * + *

Example Usage

+ * 
{@code
+     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror
+     *
+     * // Get all declared constructors
+     * List allConstructors = filterDeclaredConstructors(typeMirror);
+     *
+     * // Get only constructors with specific parameter types
+     * List filteredConstructors = filterDeclaredConstructors(typeMirror,
+     *     constructor -> matchParameterTypes(constructor, String.class, int.class));
+     *
+     * if (!filteredConstructors.isEmpty()) {
+     *     for (ExecutableElement constructor : filteredConstructors) {
+     *         System.out.println("Matching Constructor: " + constructor);
+     *     }
+     * } else {
+     *     System.out.println("No matching constructors found.");
+     * }
+     * }
+ * + * @param type the {@link TypeMirror} representing the type to retrieve constructors from + * @param constructorFilters optional predicates to filter the constructors; if none are provided, all constructors are included + * @return a {@link List} of {@link ExecutableElement} objects representing the filtered declared constructors; + * never {@code null}, but may be empty if no matching constructors are found or if the input is {@code null} + */ + @Nonnull + @Immutable + static List filterDeclaredConstructors(TypeMirror type, Predicate... constructorFilters) { + if (type == null) { + return emptyList(); + } + + List declaredMembers = getDeclaredMembers(type, false); + if (isEmpty(declaredMembers)) { + return emptyList(); + } + + List constructors = constructorsIn(declaredMembers); + + return filterElements(constructors, constructorFilters); + } + +} diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ElementUtils.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ElementUtils.java new file mode 100644 index 000000000..f3d708d8a --- /dev/null +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ElementUtils.java @@ -0,0 +1,734 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.lang.model.util; + +import io.microsphere.annotation.Immutable; +import io.microsphere.annotation.Nonnull; +import io.microsphere.util.Utils; + +import javax.lang.model.element.Element; +import javax.lang.model.element.ElementKind; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.Modifier; +import javax.lang.model.element.VariableElement; +import java.lang.annotation.ElementType; +import java.lang.reflect.Type; +import java.util.List; +import java.util.Set; +import java.util.function.Predicate; + +import static io.microsphere.lang.model.util.TypeUtils.isSameType; +import static io.microsphere.collection.CollectionUtils.isEmpty; +import static io.microsphere.lang.function.Predicates.and; +import static io.microsphere.reflect.TypeUtils.getTypeNames; +import static io.microsphere.util.ArrayUtils.isNotEmpty; +import static io.microsphere.util.ArrayUtils.length; +import static java.util.Collections.emptyList; +import static java.util.Collections.unmodifiableList; +import static java.util.stream.Collectors.toList; +import static javax.lang.model.element.ElementKind.CLASS; +import static javax.lang.model.element.ElementKind.OTHER; +import static javax.lang.model.element.ElementKind.valueOf; +import static javax.lang.model.element.Modifier.PUBLIC; +import static javax.lang.model.element.Modifier.STATIC; + +/** + * The utility class for {@link Element} + * + * @author Mercy + * @see Element + * @see Enum + * @since 1.0.0 + */ +public interface ElementUtils extends Utils { + + /** + * Returns {@code true} if the specified {@link ElementKind} represents a class-like element, + * including: + *
    + *
  • {@link ElementKind#CLASS}
    • + *
  • {@link ElementKind#ENUM}
    • + *
  • {@link ElementKind#RECORD}
    • + *
+ * + *

This method serves as a convenience wrapper around {@link ElementKind#isClass()}. + * It also guards against null input by returning {@code false} when the argument is null. + * + *

Example Usage

+ * 
{@code
+     * ElementKind classKind = ElementKind.CLASS;
+     * boolean result = isClass(classKind); // returns true
+     *
+     * ElementKind methodKind = ElementKind.METHOD;
+     * result = isClass(methodKind); // returns false
+     *
+     * result = isClass(null); // returns false
+     * }
+ * + * @param kind the ElementKind to check, may be null + * @return {@code true} if the kind is a class-like element, {@code false} otherwise + * @see ElementKind#isClass() + */ + static boolean isClass(ElementKind kind) { + return kind != null && kind.isClass(); + } + + /** + * Returns {@code true} if this is a kind of interface: + * either {@code INTERFACE} or {@code ANNOTATION_TYPE}. + * + *

+ * This method serves as a convenience wrapper around {@link ElementKind#isInterface()}. + * It also guards against null input by returning {@code false} when the argument is null. + *

+ * + *

Example Usage

+ * 
{@code
+     * ElementKind interfaceKind = ElementKind.INTERFACE;
+     * boolean result = isInterface(interfaceKind); // returns true
+     *
+     * ElementKind annotationKind = ElementKind.ANNOTATION_TYPE;
+     * result = isInterface(annotationKind); // returns true
+     *
+     * ElementKind classKind = ElementKind.CLASS;
+     * result = isInterface(classKind); // returns false
+     *
+     * result = isInterface(null); // returns false
+     * }
+ * + * @param kind the ElementKind to check, may be null + * @return {@code true} if the kind is an interface-like element, {@code false} otherwise + * @see ElementKind#isInterface() + */ + static boolean isInterface(ElementKind kind) { + return kind != null && kind.isInterface(); + } + + /** + * Returns {@code true} if the specified {@link ElementKind} represents a declared type, + * which includes both {@linkplain #isClass(ElementKind) class-like} and + * {@linkplain #isInterface(ElementKind) interface-like} elements. + * + *

This method serves as a convenience wrapper that combines the checks for class and interface kinds. + * It also guards against null input by safely delegating to the respective methods. + * + *

Example Usage

+ * 
{@code
+     * ElementKind classKind = ElementKind.CLASS;
+     * boolean result = isDeclaredType(classKind); // returns true
+     *
+     * ElementKind interfaceKind = ElementKind.INTERFACE;
+     * result = isDeclaredType(interfaceKind); // returns true
+     *
+     * ElementKind methodKind = ElementKind.METHOD;
+     * result = isDeclaredType(methodKind); // returns false
+     *
+     * result = isDeclaredType(null); // returns false
+     * }
+ * + * @param kind the ElementKind to check, may be null + * @return {@code true} if the kind is a declared type, {@code false} otherwise + * @see #isClass(ElementKind) + * @see #isInterface(ElementKind) + */ + static boolean isDeclaredType(ElementKind kind) { + return isClass(kind) || isInterface(kind); + } + + /** + * Returns {@code true} if this is a kind of field: + * either {@code FIELD} or {@code ENUM_CONSTANT}. + * + *

+ * This method serves as a convenience wrapper around {@link ElementKind#isField()}. + * It also guards against null input by returning {@code false} when the argument is null. + *

+ * + *

Example Usage

+ * 
{@code
+     * ElementKind fieldKind = ElementKind.FIELD;
+     * boolean result = isField(fieldKind); // returns true
+     *
+     * ElementKind enumConstantKind = ElementKind.ENUM_CONSTANT;
+     * result = isField(enumConstantKind); // returns true
+     *
+     * ElementKind methodKind = ElementKind.METHOD;
+     * result = isField(methodKind); // returns false
+     *
+     * result = isField(null); // returns false
+     * }
+ * + * @param kind the ElementKind to check, may be null + * @return {@code true} if the kind is a field-like element, {@code false} otherwise + * @see ElementKind#isField() + */ + static boolean isField(ElementKind kind) { + return kind != null && kind.isField(); + } + + /** + * Returns {@code true} if this is a kind of executable: either + * {@code METHOD}, {@code CONSTRUCTOR}, {@code STATIC_INIT}, or + * {@code INSTANCE_INIT}. + * + *

This method serves as a convenience wrapper around {@link ElementKind#isExecutable()}. + * It also guards against null input by returning {@code false} when the argument is null. + * + *

Example Usage

+ * 
{@code
+     * ElementKind methodKind = ElementKind.METHOD;
+     * boolean result = isExecutable(methodKind); // returns true
+     *
+     * ElementKind constructorKind = ElementKind.CONSTRUCTOR;
+     * result = isExecutable(constructorKind); // returns true
+     *
+     * ElementKind staticInitKind = ElementKind.STATIC_INIT;
+     * result = isExecutable(staticInitKind); // returns true
+     *
+     * ElementKind instanceInitKind = ElementKind.INSTANCE_INIT;
+     * result = isExecutable(instanceInitKind); // returns true
+     *
+     * ElementKind classKind = ElementKind.CLASS;
+     * result = isExecutable(classKind); // returns false
+     *
+     * result = isExecutable(null); // returns false
+     * }
+ * + * @param kind the ElementKind to check, may be null + * @return {@code true} if the kind is an executable-like element, {@code false} otherwise + * @see ElementKind#isExecutable() + */ + static boolean isExecutable(ElementKind kind) { + if (kind != null) { + switch (kind) { + case METHOD: + case CONSTRUCTOR: + case STATIC_INIT: + case INSTANCE_INIT: + return true; + } + } + return false; + } + + /** + * Returns {@code true} if the specified {@link ElementKind} represents a member element, + * which includes both {@linkplain #isField(ElementKind) field-like} and + * {@linkplain #isExecutable(ElementKind) executable-like} elements. + * + *

This method serves as a convenience wrapper that combines the checks for field and executable kinds. + * It also guards against null input by safely delegating to the respective methods. + * + *

Example Usage

+ * 
{@code
+     * ElementKind fieldKind = ElementKind.FIELD;
+     * boolean result = isMember(fieldKind); // returns true
+     *
+     * ElementKind methodKind = ElementKind.METHOD;
+     * result = isMember(methodKind); // returns true
+     *
+     * ElementKind classKind = ElementKind.CLASS;
+     * result = isMember(classKind); // returns false
+     *
+     * result = isMember(null); // returns false
+     * }
+ * + * @param kind the ElementKind to check, may be null + * @return {@code true} if the kind is a member-like element, {@code false} otherwise + * @see #isField(ElementKind) + * @see #isExecutable(ElementKind) + */ + static boolean isMember(ElementKind kind) { + return isField(kind) || isExecutable(kind); + } + + /** + * Returns {@code true} if the specified {@link ElementKind} represents an initializer, + * either {@code STATIC_INIT} or {@code INSTANCE_INIT}. + * + *

+ * This method serves as a convenience wrapper around {@link ElementKind#isInitializer()}. + * It also guards against null input by returning {@code false} when the argument is null. + *

+ * + *

Example Usage

+ * 
{@code
+     * ElementKind staticInitKind = ElementKind.STATIC_INIT;
+     * boolean result = isInitializer(staticInitKind); // returns true
+     *
+     * ElementKind instanceInitKind = ElementKind.INSTANCE_INIT;
+     * result = isInitializer(instanceInitKind); // returns true
+     *
+     * ElementKind methodKind = ElementKind.METHOD;
+     * result = isInitializer(methodKind); // returns false
+     *
+     * result = isInitializer(null); // returns false
+     * }
+ * + * @param kind the ElementKind to check, may be null + * @return {@code true} if the kind is an initializer-like element, {@code false} otherwise + * @see ElementKind#isInitializer() + */ + static boolean isInitializer(ElementKind kind) { + if (kind != null) { + switch (kind) { + case STATIC_INIT: + case INSTANCE_INIT: + return true; + } + } + return false; + } + + /** + * Returns {@code true} if the specified {@link ElementKind} represents a variable-like element, + * including: + *
    + *
  • {@link ElementKind#ENUM_CONSTANT}
    • + *
  • {@link ElementKind#FIELD}
    • + *
  • {@link ElementKind#PARAMETER}
    • + *
  • {@link ElementKind#LOCAL_VARIABLE}
    • + *
  • {@link ElementKind#EXCEPTION_PARAMETER}
    • + *
  • {@link ElementKind#RESOURCE_VARIABLE}
    • + *
  • {@link ElementKind#BINDING_VARIABLE}
    • + *
+ * + *

This method serves as a convenience wrapper around {@link ElementKind#isVariable()}. + * It also guards against null input by returning {@code false} when the argument is null. + * + *

Example Usage

+ * 
{@code
+     * ElementKind enumConstantKind = ElementKind.ENUM_CONSTANT;
+     * boolean result = isVariable(enumConstantKind); // returns true
+     *
+     * ElementKind fieldKind = ElementKind.FIELD;
+     * result = isVariable(fieldKind); // returns true
+     *
+     * ElementKind parameterKind = ElementKind.PARAMETER;
+     * result = isVariable(parameterKind); // returns true
+     *
+     * ElementKind localVariableKind = ElementKind.LOCAL_VARIABLE;
+     * result = isVariable(localVariableKind); // returns true
+     *
+     * ElementKind exceptionParameterKind = ElementKind.EXCEPTION_PARAMETER;
+     * result = isVariable(exceptionParameterKind); // returns true
+     *
+     * ElementKind resourceVariableKind = ElementKind.RESOURCE_VARIABLE;
+     * result = isVariable(resourceVariableKind); // returns true
+     *
+     * ElementKind bindingVariableKind = ElementKind.BINDING_VARIABLE;
+     * result = isVariable(bindingVariableKind); // returns true
+     *
+     * ElementKind methodKind = ElementKind.METHOD;
+     * result = isVariable(methodKind); // returns false
+     *
+     * result = isVariable(null); // returns false
+     * }
+ * + * @param kind the ElementKind to check, may be null + * @return {@code true} if the kind is a variable-like element, {@code false} otherwise + * @see ElementKind#isVariable() + */ + static boolean isVariable(ElementKind kind) { + if (kind != null) { + switch (kind) { + case ENUM_CONSTANT: + case FIELD: + case PARAMETER: + case LOCAL_VARIABLE: + case EXCEPTION_PARAMETER: + case RESOURCE_VARIABLE: + return true; + } + // To be compatible with JDK 16 + return "BINDING_VARIABLE".equals(kind.name()); + } + return false; + } + + /** + * Converts the specified {@link ElementType} to an equivalent {@link ElementKind}. + * + *

+ * This method maps the provided {@link ElementType} to a corresponding {@link ElementKind}. + * If the provided {@code elementType} is {@code null}, this method returns {@link ElementKind#OTHER}. + *

+ * + *

Example Usage

+ * 
{@code
+     * ElementType typeElement = ElementType.TYPE;
+     * ElementKind result = toElementKind(typeElement); // returns ElementKind.CLASS
+     *
+     * ElementType typeUseElement = ElementType.TYPE_USE;
+     * result = toElementKind(typeUseElement); // returns ElementKind.CLASS
+     *
+     * ElementType fieldElement = ElementType.FIELD;
+     * result = toElementKind(fieldElement); // returns ElementKind.FIELD
+     *
+     * result = toElementKind(null); // returns ElementKind.OTHER
+     * }
+ * + * @param elementType the ElementType to convert, may be {@code null} + * @return the corresponding ElementKind, never {@code null} + */ + static ElementKind toElementKind(ElementType elementType) { + if (elementType == null) { + return OTHER; + } + switch (elementType) { + case TYPE: + case TYPE_USE: + return CLASS; + default: + return valueOf(elementType.name()); + } + } + + /** + * Checks whether the specified {@link ElementKind} matches the specified {@link ElementType}. + * + *

+ * This method compares the provided {@link ElementKind} with the result of converting the + * {@link ElementType} to an equivalent {@link ElementKind} using {@link #toElementKind(ElementType)}. + * If either argument is null, the comparison will return {@code false}. + *

+ * + *

Example Usage

+ * 
{@code
+     * ElementKind classKind = ElementKind.CLASS;
+     * ElementType typeElement = ElementType.TYPE;
+     * boolean result = matchesElementType(classKind, typeElement); // returns true
+     *
+     * ElementKind fieldKind = ElementKind.FIELD;
+     * ElementType typeUseElement = ElementType.TYPE_USE;
+     * result = matchesElementType(fieldKind, typeUseElement); // returns false
+     *
+     * result = matchesElementType(null, ElementType.TYPE); // returns false
+     * result = matchesElementType(ElementKind.CLASS, null); // returns false
+     * }
+ * + * @param elementKind the ElementKind to check, may be {@code null} + * @param elementType the ElementType to compare against, may be {@code null} + * @return {@code true} if the ElementKind matches the converted ElementType, {@code false} otherwise + * @see #toElementKind(ElementType) + */ + static boolean matchesElementType(ElementKind elementKind, ElementType elementType) { + return elementKind == toElementKind(elementType); + } + + /** + * Checks whether the specified {@link ElementKind} matches any of the specified {@link ElementType}s. + * + *

+ * This method converts each {@link ElementType} to its corresponding {@link ElementKind} + * using {@link #toElementKind(ElementType)}, and then compares it with the provided + * {@link ElementKind}. If any match is found, the method returns {@code true}. + *

+ * + *

Example Usage

+ * 
{@code
+     * ElementKind classKind = ElementKind.CLASS;
+     * boolean result = matchesElementType(classKind, ElementType.TYPE, ElementType.METHOD); // returns true
+     *
+     * result = matchesElementType(classKind, ElementType.FIELD, ElementType.CONSTRUCTOR); // returns false
+     *
+     * result = matchesElementType(null, ElementType.TYPE); // returns false
+     *
+     * result = matchesElementType(ElementKind.FIELD, (ElementType[]) null); // returns false
+     * }
+ * + * @param elementKind the ElementKind to check, may be {@code null} + * @param elementTypes the array of ElementTypes to match against, may be {@code null} + * @return {@code true} if the ElementKind matches any of the converted ElementTypes, {@code false} otherwise + * @see #toElementKind(ElementType) + * @see #matchesElementType(ElementKind, ElementType) + */ + static boolean matchesElementType(ElementKind elementKind, ElementType... elementTypes) { + int length = length(elementTypes); + if (length < 1) { + return false; + } + for (int i = 0; i < length; i++) { + if (matchesElementType(elementKind, elementTypes[i])) { + return true; + } + } + return false; + } + + /** + * Checks whether the specified {@link Element} matches any of the specified {@link ElementType}s. + * + *

+ * This method determines if the provided {@link Element} has a kind that matches any of the + * converted {@link ElementKind} values derived from the given {@link ElementType}s. + * It delegates to {@link #matchesElementType(ElementKind, ElementType...)} for the actual comparison. + *

+ * + *

Example Usage

+ * 
{@code
+     * Element element = ...; // an Element of kind CLASS
+     * boolean result = matchesElementType(element, ElementType.TYPE, ElementType.TYPE_USE); // returns true
+     *
+     * result = matchesElementType(element, ElementType.FIELD, ElementType.METHOD); // returns false
+     *
+     * result = matchesElementType(null, ElementType.TYPE); // returns false
+     *
+     * result = matchesElementType(element, (ElementType[]) null); // returns false
+     * }
+ * + * @param element the Element to check, may be {@code null} + * @param elementTypes the array of ElementTypes to match against, may be {@code null} + * @return {@code true} if the element matches any of the converted ElementTypes, {@code false} otherwise + * @see #matchesElementType(ElementKind, ElementType...) + */ + static boolean matchesElementType(Element element, ElementType... elementTypes) { + return element != null && matchesElementType(element.getKind(), elementTypes); + } + + /** + * Checks whether the specified {@link Element} matches the specified {@link ElementKind}. + * + *

+ * This method returns {@code false} if either the element or the kind is {@code null}. + * Otherwise, it compares the kind of the element with the provided {@link ElementKind}. + *

+ * + *

Example Usage

+ * 
{@code
+     * Element element = ...; // an Element of kind METHOD
+     * ElementKind methodKind = ElementKind.METHOD;
+     * boolean result = matchesElementKind(element, methodKind); // returns true
+     *
+     * result = matchesElementKind(null, methodKind); // returns false
+     * result = matchesElementKind(element, null); // returns false
+     * }
+ * + * @param member the Element to check, may be {@code null} + * @param kind the ElementKind to match, may be {@code null} + * @return {@code true} if the element is not null and its kind matches the specified kind; otherwise, {@code false} + */ + static boolean matchesElementKind(Element member, ElementKind kind) { + return member == null || kind == null ? false : kind.equals(member.getKind()); + } + + /** + * Checks whether the specified {@link Element} is public and non-static. + * + *

This method verifies if the provided element has the {@link Modifier#PUBLIC} modifier + * and does not have the {@link Modifier#STATIC} modifier. + * + *

Example Usage

+ * 
{@code
+     * Element methodElement = ...; // an Element with PUBLIC and non-STATIC modifiers
+     * boolean result = isPublicNonStatic(methodElement); // returns true
+     *
+     * Element staticMethodElement = ...; // an Element with PUBLIC and STATIC modifiers
+     * result = isPublicNonStatic(staticMethodElement); // returns false
+     *
+     * result = isPublicNonStatic(null); // returns false
+     * }
+ * + * @param member the Element to check, may be null + * @return {@code true} if the element is public and non-static; otherwise, {@code false} + */ + static boolean isPublicNonStatic(Element member) { + return hasModifiers(member, PUBLIC) && !hasModifiers(member, STATIC); + } + + /** + * Checks whether the specified {@link Element} has all of the specified {@link Modifier}s. + * + *

+ * This method returns {@code false} if the element is {@code null} or if the modifiers array is {@code null}. + * Otherwise, it verifies that the element contains all the provided modifiers. + *

+ * + *

Example Usage

+ * 
{@code
+     * Element methodElement = ...; // an Element with PUBLIC and STATIC modifiers
+     * boolean result = hasModifiers(methodElement, Modifier.PUBLIC, Modifier.STATIC); // returns true
+     *
+     * result = hasModifiers(methodElement, Modifier.PRIVATE); // returns false
+     *
+     * result = hasModifiers(null, Modifier.PUBLIC); // returns false
+     *
+     * result = hasModifiers(methodElement, (Modifier[]) null); // returns false
+     * }
+ * + * @param member the {@link Element} to check, may be {@code null} + * @param modifiers the array of {@link Modifier}s to match, may be {@code null} + * @return {@code true} if the element is not null and contains all specified modifiers; otherwise, {@code false} + */ + static boolean hasModifiers(Element member, Modifier... modifiers) { + if (member == null || modifiers == null) { + return false; + } + Set actualModifiers = member.getModifiers(); + for (Modifier modifier : modifiers) { + if (!actualModifiers.contains(modifier)) { + return false; + } + } + return true; + } + + /** + * Filters the provided list of {@link Element} objects based on the given array of {@link Predicate} conditions. + * + *

This method applies a logical AND combination of all provided predicates to filter the elements. + * If the input list is empty or the predicates array is null or empty, an empty list is returned.

+ * + *

Example Usage

+ * 
{@code
+     * List elements = ...; // a list of Elements
+     *
+     * // Filter public and static methods
+     * List filtered = filterElements(elements,
+     *     element -> ElementUtils.hasModifiers(element, Modifier.PUBLIC),
+     *     element -> ElementUtils.hasModifiers(element, Modifier.STATIC)
+     * );
+     *
+     * // Returns an empty list if no elements match
+     * filtered = filterElements(elements,
+     *     element -> ElementUtils.hasModifiers(element, Modifier.PRIVATE)
+     * );
+     *
+     * // Returns an empty list if input is null or predicates are null
+     * filtered = filterElements(null, (Predicate[]) null); // returns empty list
+     * }
+ * + * @param elements The list of elements to be filtered, may be {@code null} + * @param elementPredicates An array of predicates used to filter the elements, may be {@code null} + * @param The type of the elements, which must be a subclass of {@link Element} + * @return A filtered list of elements that match all the provided predicates. Returns an empty list if no elements match, + * or if the input list or predicate array is invalid. + */ + @Nonnull + @Immutable + static List filterElements(List elements, Predicate... elementPredicates) { + if (isEmpty(elements) || elementPredicates == null) { + return emptyList(); + } + if (isNotEmpty(elementPredicates)) { + Predicate predicate = and(elementPredicates); + elements = (List) elements.stream().filter(predicate).collect(toList()); + } + return elements.isEmpty() ? emptyList() : unmodifiableList(elements); + } + + /** + * Checks whether the parameter types of the given {@link ExecutableElement} match the specified {@link Type types}. + * + *

+ * This method compares the types of the parameters declared in the executable element with the provided expected types. + * It uses {@link TypeUtils#isSameType(Element, CharSequence)} to perform type comparison. + *

+ * + *

Example Usage

+ * 
{@code
+     * ExecutableElement methodElement = ...; // an executable element with parameters
+     * boolean result = matchParameterTypes(methodElement, String.class, int.class); // returns true if parameter types match
+     *
+     * result = matchParameterTypes(null, String.class); // returns false
+     * result = matchParameterTypes(methodElement, (Type[]) null); // returns false
+     * }
+ * + * @param executableElement the executable element whose parameters are to be checked, may be {@code null} + * @param parameterTypes the expected parameter types, may be {@code null} + * @return {@code true} if the parameter types match; {@code false} otherwise + */ + static boolean matchParameterTypes(ExecutableElement executableElement, Type... parameterTypes) { + return executableElement == null || parameterTypes == null ? false : + matchParameterTypeNames(executableElement.getParameters(), getTypeNames(parameterTypes)); + } + + /** + * Checks whether the parameter types of the given list of {@link VariableElement} parameters match the specified {@link Type types}. + * + *

+ * This method compares each parameter's type with the corresponding expected type by their fully qualified type names. + * It uses {@link TypeUtils#isSameType(Element, CharSequence)} to perform the type comparison. + *

+ * + *

Example Usage

+ * 
{@code
+     * List parameters = executableElement.getParameters();
+     * boolean result = matchParameterTypes(parameters, String.class, int.class); // returns true if types match
+     *
+     * result = matchParameterTypes(null, String.class); // returns false
+     * result = matchParameterTypes(parameters, (Type[]) null); // returns false
+     * }
+ * + * @param parameters the list of variable elements representing the parameters, may be {@code null} + * @param parameterTypes the expected parameter types, may be {@code null} + * @return {@code true} if all parameter types match their corresponding expected types; otherwise, {@code false} + */ + static boolean matchParameterTypes(List parameters, Type... parameterTypes) { + return parameters == null || parameterTypes == null ? false : matchParameterTypeNames(parameters, getTypeNames(parameterTypes)); + } + + /** + * Checks whether the parameter types of the given list of {@link VariableElement} parameters match the specified type names. + * + *

+ * This method compares each parameter's type with the corresponding expected type name using + * {@link TypeUtils#isSameType(Element, CharSequence)}. It ensures that both the number of parameters and their respective + * types match the provided array of type names. + *

+ * + *

Example Usage

+ * 
{@code
+     * List parameters = executableElement.getParameters();
+     *
+     * // Check if the parameters match String and int
+     * boolean result = matchParameterTypeNames(parameters, "java.lang.String", "int"); // returns true if match
+     *
+     * // Returns false if either parameter list or type names are null
+     * result = matchParameterTypeNames(null, "java.lang.String"); // returns false
+     * result = matchParameterTypeNames(parameters, (CharSequence[]) null); // returns false
+     *
+     * // Returns false if the size of parameters and type names do not match
+     * result = matchParameterTypeNames(Arrays.asList(param1, param2), "java.lang.String"); // returns false
+     * }
+ * + * @param parameters the list of variable elements representing the parameters, may be {@code null} + * @param parameterTypeNames the expected fully qualified type names of the parameters, may be {@code null} + * @return {@code true} if all parameter types match their corresponding type names; otherwise, {@code false} + */ + static boolean matchParameterTypeNames(List parameters, CharSequence... parameterTypeNames) { + if (parameters == null || parameterTypeNames == null) { + return false; + } + + int length = length(parameterTypeNames); + int size = parameters.size(); + + if (size != length) { + return false; + } + + for (int i = 0; i < size; i++) { + VariableElement parameter = parameters.get(i); + if (!isSameType(parameter, parameterTypeNames[i])) { + return false; + } + } + return true; + } +} diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ExecutableElementComparator.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ExecutableElementComparator.java new file mode 100644 index 000000000..ead937db0 --- /dev/null +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ExecutableElementComparator.java @@ -0,0 +1,93 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.lang.model.util; + +import io.microsphere.util.CharSequenceComparator; + +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.VariableElement; +import java.util.Comparator; +import java.util.List; + +/** + * The Comparator class for {@link ExecutableElement}, the comparison rule : + *
    + *
  1. Comparing to two {@link ExecutableElement#getSimpleName() element names} {@link String#compareTo(String) lexicographically}. + * If equals, go to step 2
    2. + *
  2. Comparing to the count of two parameters. If equals, go to step 3
    3. + *
  3. Comparing to the type names of parameters {@link String#compareTo(String) lexicographically}
    4. + *
+ * + *

Example Usage

+ * 
+ * class Example {
+ *     void methodA() {}
+ *     void methodB() {}
+ *     void methodB(String param1) {}
+ *     void methodB(String param1, int param2) {}
+ * }
+ *
+ * + *

When comparing methods:

+ *
    + *
  • {@code methodA} vs {@code methodB}: the names are compared lexicographically.
    • + *
  • {@code methodB()} vs {@code methodB(String)}: the number of parameters is compared.
    • + *
  • {@code methodB(String)} vs {@code methodB(String, int)}: the parameter type names are compared lexicographically.
    • + *
+ * + * @author Mercy + * @since 1.0.0 + */ +public class ExecutableElementComparator implements Comparator { + + /** + * The singleton instance + */ + public static final ExecutableElementComparator INSTANCE = new ExecutableElementComparator(); + + private ExecutableElementComparator() { + } + + @Override + public int compare(ExecutableElement e1, ExecutableElement e2) { + + if (e1.equals(e2)) { + return 0; + } + + // Step 1 + int value = CharSequenceComparator.INSTANCE.compare(e1.getSimpleName(), e2.getSimpleName()); + + if (value == 0) { // Step 2 + + List ps1 = e1.getParameters(); + List ps2 = e2.getParameters(); + + value = ps1.size() - ps2.size(); + + if (value == 0) { // Step 3 + for (int i = 0; i < ps1.size(); i++) { + value = CharSequenceComparator.INSTANCE.compare(ps1.get(i).asType().toString(), ps2.get(i).asType().toString()); + if (value != 0) { + break; + } + } + } + } + return value; + } +} diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/FieldUtils.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/FieldUtils.java new file mode 100644 index 000000000..3ded2017e --- /dev/null +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/FieldUtils.java @@ -0,0 +1,763 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.lang.model.util; + +import io.microsphere.annotation.Immutable; +import io.microsphere.annotation.Nonnull; +import io.microsphere.annotation.Nullable; +import io.microsphere.util.Utils; + +import javax.lang.model.element.Element; +import javax.lang.model.element.ElementKind; +import javax.lang.model.element.Modifier; +import javax.lang.model.element.VariableElement; +import javax.lang.model.type.TypeMirror; +import java.util.List; +import java.util.function.Predicate; + +import static io.microsphere.lang.model.util.ElementUtils.filterElements; +import static io.microsphere.lang.model.util.ElementUtils.hasModifiers; +import static io.microsphere.lang.model.util.ElementUtils.matchesElementKind; +import static io.microsphere.lang.model.util.MemberUtils.getDeclaredMembers; +import static io.microsphere.lang.model.util.TypeUtils.isEnumType; +import static io.microsphere.collection.CollectionUtils.isEmpty; +import static io.microsphere.lang.function.Predicates.EMPTY_PREDICATE_ARRAY; +import static io.microsphere.lang.function.Streams.filterFirst; +import static java.util.Collections.emptyList; +import static javax.lang.model.element.ElementKind.ENUM_CONSTANT; +import static javax.lang.model.element.ElementKind.FIELD; +import static javax.lang.model.element.Modifier.STATIC; +import static javax.lang.model.util.ElementFilter.fieldsIn; + +/** + * A utility interface for working with fields in the context of Java annotation processing. + *

+ * This interface provides a collection of static methods to retrieve, filter, and inspect + * {@link VariableElement fields} within a class or interface. It supports operations such as: + *

+ * + *
    + *
  • Retrieving fields by name
    • + *
  • Finding fields with specific modifiers (e.g., static, public)
    • + *
  • Filtering fields based on custom predicates
    • + *
  • Checking if a field is an enum constant or a non-static field
    • + *
  • Getting all declared or non-static fields from a type or element
    • + *
+ * + *

Example Usage

+ * 
{@code
+ * // Get a specific field by name
+ * VariableElement field = FieldUtils.getDeclaredField(element, "myField");
+ *
+ * // Get all non-static fields
+ * List nonStaticFields = FieldUtils.getNonStaticFields(type);
+ *
+ * // Find a field by name in the current class and its superclasses
+ * VariableElement fieldInHierarchy = FieldUtils.findField(type, "myField");
+ *
+ * // Check if a field is non-static
+ * boolean isNonStatic = FieldUtils.isNonStaticField(field);
+ *
+ * // Get all fields, including those from superclasses
+ * List allFields = FieldUtils.getAllDeclaredFields(element);
+ * }
+ * + * @author Mercy + * @since 1.0.0 + */ +public interface FieldUtils extends Utils { + + /** + * Retrieves the declared field with the specified name from the given element. + * + *

If the provided {@link Element} is null, this method returns null. It's typically used + * to retrieve a specific field from a class or interface element. + * + *

Example Usage

+ * 
{@code
+     * Element element = ...; // A class or interface element
+     * String fieldName = "myField";
+     * VariableElement field = getDeclaredField(element, fieldName);
+     * if (field != null) {
+     *     System.out.println("Found field: " + field.getSimpleName());
+     * } else {
+     *     System.out.println("Field not found.");
+     * }
+     * }
+ * + * @param element the element to search for the field; if null, null is returned + * @param fieldName the name of the field to find + * @return the VariableElement representing the declared field, or null if not found + */ + @Nullable + static VariableElement getDeclaredField(Element element, String fieldName) { + return element == null ? null : getDeclaredField(element.asType(), fieldName); + } + + /** + * Retrieves the declared field with the specified name from the given type. + * + *

If the provided {@link TypeMirror} is null, this method returns null. + * It searches for a field with the exact specified name in the given type, + * and returns the first match found. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror type = element.asType(); // A valid type from an element
+     * String fieldName = "myField";
+     * VariableElement field = getDeclaredField(type, fieldName);
+     * if (field != null) {
+     *     System.out.println("Found field: " + field.getSimpleName());
+     * } else {
+     *     System.out.println("Field not found.");
+     * }
+     * }
+ * + * @param type the type to search for the field; if null, null is returned + * @param fieldName the name of the field to find + * @return the VariableElement representing the declared field, or null if not found + */ + @Nullable + static VariableElement getDeclaredField(TypeMirror type, String fieldName) { + return filterFirst(findDeclaredFields(type, field -> fieldName.equals(field.getSimpleName().toString()))); + } + + /** + * Retrieves all declared fields from the given element without any filtering. + * + *

If the provided {@link Element} is null, this method returns an empty list. + * It's typically used to get all fields declared in a class or interface, + * excluding fields from superclasses or interfaces. + * + *

Example Usage

+ * 
{@code
+     * Element element = ...; // A class or interface element
+     * List fields = getDeclaredFields(element);
+     * for (VariableElement field : fields) {
+     *     System.out.println("Field: " + field.getSimpleName());
+     * }
+     * }
+ * + * @param element the element to retrieve declared fields from + * @return a list of VariableElement objects representing the declared fields, + * or an empty list if the element is null or no fields are found + */ + @Nonnull + @Immutable + static List getDeclaredFields(Element element) { + return findDeclaredFields(element, EMPTY_PREDICATE_ARRAY); + } + + /** + * Retrieves all declared fields from the given type without any filtering. + * + *

If the provided {@link TypeMirror} is null, this method returns an empty list. + * It's typically used to get all fields declared directly within a class or interface, + * excluding fields from superclasses or interfaces. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror type = element.asType(); // A valid type from an element
+     * List fields = getDeclaredFields(type);
+     * for (VariableElement field : fields) {
+     *     System.out.println("Declared field: " + field.getSimpleName());
+     * }
+     * }
+ * + * @param type the type to retrieve declared fields from + * @return a list of VariableElement objects representing the declared fields, + * or an empty list if the type is null or no fields are found + */ + @Nonnull + @Immutable + static List getDeclaredFields(TypeMirror type) { + return findDeclaredFields(type, EMPTY_PREDICATE_ARRAY); + } + + /** + * Retrieves all declared fields from the given element, including those from hierarchical types (e.g., superclasses), + * without any filtering. + * + *

If the provided {@link Element} is null, this method returns an empty list. It's typically used + * to get all fields declared directly within a class or interface, as well as those inherited from superclasses. + * + *

Example Usage

+ * 
{@code
+     * Element element = ...; // A class or interface element
+     * List fields = getAllDeclaredFields(element);
+     * for (VariableElement field : fields) {
+     *     System.out.println("Declared field (including hierarchical): " + field.getSimpleName());
+     * }
+     * }
+ * + * @param element the element to retrieve all declared fields from + * @return a list of VariableElement objects representing all declared fields, + * or an empty list if the element is null or no fields are found + */ + @Nonnull + @Immutable + static List getAllDeclaredFields(Element element) { + return findAllDeclaredFields(element, EMPTY_PREDICATE_ARRAY); + } + + /** + * Retrieves all declared fields from the given type, including those from hierarchical types (e.g., superclasses), + * without any filtering. + * + *

If the provided {@link TypeMirror} is null, this method returns an empty list. It's typically used + * to get all fields declared directly within a class or interface, as well as those inherited from superclasses. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror type = element.asType(); // A valid type from an element
+     * List fields = getAllDeclaredFields(type);
+     * for (VariableElement field : fields) {
+     *     System.out.println("Declared field (including hierarchical): " + field.getSimpleName());
+     * }
+     * }
+ * + * @param type the type to retrieve all declared fields from + * @return a list of VariableElement objects representing all declared fields, + * or an empty list if the type is null or no fields are found + */ + @Nonnull + @Immutable + static List getAllDeclaredFields(TypeMirror type) { + return findAllDeclaredFields(type, EMPTY_PREDICATE_ARRAY); + } + + /** + * Retrieves the first matching field with the specified name from the given element. + * + *

If the provided {@link Element} is null, this method returns null. + * It searches for a field with the exact specified name in the given element + * and returns the first match found. + * + *

Example Usage

+ * 
{@code
+     * Element element = ...; // A valid class or interface element
+     * String fieldName = "myField";
+     * VariableElement field = findField(element, fieldName);
+     * if (field != null) {
+     *     System.out.println("Found field: " + field.getSimpleName());
+     * } else {
+     *     System.out.println("Field not found.");
+     * }
+     * }
+ * + * @param element the element to search for the field; if null, null is returned + * @param fieldName the name of the field to find + * @return the VariableElement representing the first matching field, or null if not found + */ + @Nullable + static VariableElement findField(Element element, String fieldName) { + return element == null ? null : findField(element.asType(), fieldName); + } + + /** + * Retrieves the first matching field with the specified name from the given type. + * + *

This method searches for a field with the exact specified name in the given type, + * including all hierarchical types (e.g., superclasses), and returns the first match found. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror type = element.asType(); // A valid type from an element
+     * String fieldName = "myField";
+     * VariableElement field = findField(type, fieldName);
+     * if (field != null) {
+     *     System.out.println("Found field: " + field.getSimpleName());
+     * } else {
+     *     System.out.println("Field not found.");
+     * }
+     * }
+ * + * @param type the type to search for fields; if null, null is returned + * @param fieldName the name of the field to find + * @return the VariableElement representing the first matching field, or null if not found + */ + @Nullable + static VariableElement findField(TypeMirror type, String fieldName) { + return filterFirst(findAllDeclaredFields(type, field -> equalsFieldName(field, fieldName))); + } + + /** + * Retrieves the declared fields from the given element after applying the provided filters. + * + *

If the provided {@link Element} is null, this method returns an empty list. It searches + * for fields directly declared in the given element (excluding fields from superclasses or interfaces) + * and applies the specified filters to narrow down the results. + * + *

Example Usage

+ * 
{@code
+     * Element element = ...; // A class or interface element
+     * List allFields = findDeclaredFields(element); // Get all declared fields
+     *
+     * // Get only non-static fields
+     * List nonStaticFields = findDeclaredFields(element, FieldUtils::isNonStaticField);
+     *
+     * // Get fields matching a specific name
+     * String fieldName = "myField";
+     * List matchingFields = findDeclaredFields(element, field -> fieldName.equals(field.getSimpleName().toString()));
+     *
+     * // Get fields with multiple filters (e.g., non-static and public)
+     * List publicNonStaticFields = findDeclaredFields(element,
+     *     field -> field.getModifiers().contains(Modifier.PUBLIC),
+     *     FieldUtils::isNonStaticField
+     * );
+     * }
+ * + * @param element the element to retrieve declared fields from; if null, an empty list is returned + * @param fieldFilters the predicates used to filter the fields; optional + * @return a list of VariableElement objects representing the filtered declared fields + */ + @Nonnull + @Immutable + static List findDeclaredFields(Element element, Predicate... fieldFilters) { + return element == null ? emptyList() : findDeclaredFields(element.asType(), fieldFilters); + } + + /** + * Retrieves the declared fields from the given type after applying the provided filters. + * + *

This method searches for fields directly declared in the given type, + * excluding fields from superclasses or interfaces. It allows filtering + * the fields using the provided predicates to narrow down the results. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror type = element.asType(); // A valid type from an element
+     *
+     * // Get all declared fields
+     * List allFields = findDeclaredFields(type);
+     *
+     * // Get only non-static fields
+     * List nonStaticFields = findDeclaredFields(type, FieldUtils::isNonStaticField);
+     *
+     * // Get fields matching a specific name
+     * String fieldName = "myField";
+     * List matchingFields = findDeclaredFields(type, field -> "myField".equals(field.getSimpleName().toString()));
+     *
+     * // Get fields with multiple filters (e.g., non-static and public)
+     * List publicNonStaticFields = findDeclaredFields(type,
+     *     field -> field.getModifiers().contains(Modifier.PUBLIC),
+     *     FieldUtils::isNonStaticField
+     * );
+     * }
+ * + * @param type the type to retrieve declared fields from; if null, an empty list is returned + * @param fieldFilters the predicates used to filter the fields + * @return a list of VariableElement objects representing the filtered declared fields + */ + @Nonnull + @Immutable + static List findDeclaredFields(TypeMirror type, Predicate... fieldFilters) { + return filterDeclaredFields(type, false, fieldFilters); + } + + /** + * Retrieves all declared fields from the given element, including those from hierarchical types (e.g., superclasses), + * after applying the provided filters. + * + *

This method processes the given element and searches for all fields declared directly within it + * as well as those inherited from superclasses. The fields can be filtered using one or more predicates + * to narrow down the results. + * + *

Example Usage

+ * 
{@code
+     * Element element = ...; // A valid class or interface element
+     *
+     * // Get all declared fields (including from superclasses)
+     * List allFields = findAllDeclaredFields(element);
+     *
+     * // Get only non-static fields
+     * List nonStaticFields = findAllDeclaredFields(element, FieldUtils::isNonStaticField);
+     *
+     * // Get fields matching a specific name
+     * String fieldName = "myField";
+     * List matchingFields = findAllDeclaredFields(element, field -> "myField".equals(field.getSimpleName().toString()));
+     *
+     * // Get fields with multiple filters (e.g., non-static and public)
+     * List publicNonStaticFields = findAllDeclaredFields(element,
+     *     field -> field.getModifiers().contains(Modifier.PUBLIC),
+     *     FieldUtils::isNonStaticField
+     * );
+     * }
+ * + * @param element the element to retrieve all declared fields from; if null, an empty list is returned + * @param fieldFilters the predicates used to filter the fields; optional + * @return a list of VariableElement objects representing the filtered declared fields + */ + @Nonnull + @Immutable + static List findAllDeclaredFields(Element element, Predicate... fieldFilters) { + return element == null ? emptyList() : findAllDeclaredFields(element.asType(), fieldFilters); + } + + /** + * Retrieves all declared fields from the given type, including those from hierarchical types (e.g., superclasses), + * after applying the provided filters. + * + *

This method searches for fields directly declared in the given type as well as those inherited + * from superclasses. It allows filtering the fields using the provided predicates to narrow down the results. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror type = element.asType(); // A valid type from an element
+     *
+     * // Get all declared fields (including hierarchical)
+     * List allFields = findAllDeclaredFields(type);
+     *
+     * // Get only non-static fields
+     * List nonStaticFields = findAllDeclaredFields(type, FieldUtils::isNonStaticField);
+     *
+     * // Get fields matching a specific name
+     * String fieldName = "myField";
+     * List matchingFields = findAllDeclaredFields(type, field -> "myField".equals(field.getSimpleName().toString()));
+     *
+     * // Get fields with multiple filters (e.g., non-static and public)
+     * List publicNonStaticFields = findAllDeclaredFields(type,
+     *     field -> field.getModifiers().contains(Modifier.PUBLIC),
+     *     FieldUtils::isNonStaticField
+     * );
+     * }
+ * + * @param type the type to retrieve all declared fields from; if null, an empty list is returned + * @param fieldFilters the predicates used to filter the fields + * @return a list of VariableElement objects representing the filtered declared fields + */ + @Nonnull + @Immutable + static List findAllDeclaredFields(TypeMirror type, Predicate... fieldFilters) { + return filterDeclaredFields(type, true, fieldFilters); + } + + /** + * Filters and retrieves the declared fields from the given type based on the provided criteria. + * + *

This method is used to retrieve fields declared in the given type, optionally including fields + * from its superclasses or interfaces. The fields can be further filtered using one or more predicates + * to narrow down the results. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror type = element.asType(); // A valid type from an element
+     *
+     * // Get all declared fields (excluding hierarchical)
+     * List declaredFields = filterDeclaredFields(type, false);
+     *
+     * // Get all declared fields including hierarchical ones
+     * List allFields = filterDeclaredFields(type, true);
+     *
+     * // Get only non-static fields
+     * List nonStaticFields = filterDeclaredFields(type, false, FieldUtils::isNonStaticField);
+     *
+     * // Get fields matching a specific name
+     * String fieldName = "myField";
+     * List matchingFields = filterDeclaredFields(type, false,
+     *     field -> "myField".equals(field.getSimpleName().toString()));
+     *
+     * // Get fields with multiple filters (e.g., non-static and public)
+     * List publicNonStaticFields = filterDeclaredFields(type, true,
+     *     field -> field.getModifiers().contains(Modifier.PUBLIC),
+     *     FieldUtils::isNonStaticField
+     * );
+     * }
+ * + * @param type the type to retrieve declared fields from; if null, an empty list is returned + * @param includeHierarchicalTypes whether to include fields from hierarchical types (e.g., superclasses) + * @param fieldFilters the predicates used to filter the fields; optional + * @return a list of VariableElement objects representing the filtered declared fields + */ + @Nonnull + @Immutable + static List filterDeclaredFields(TypeMirror type, boolean includeHierarchicalTypes, Predicate... fieldFilters) { + if (type == null) { + return emptyList(); + } + + List declaredMembers = getDeclaredMembers(type, includeHierarchicalTypes); + if (isEmpty(declaredMembers)) { + return emptyList(); + } + + List fields = fieldsIn(declaredMembers); + + return filterElements(fields, fieldFilters); + } + + /** + * Determines whether the given field is an enum member field. + * + *

An enum member field is typically a public static final field that represents + * a constant within an enum declaration. This method checks if the field's enclosing + * element is an enum and if the field's kind matches {@link ElementKind#ENUM_CONSTANT}. + * + *

Example Usage

+ * 
{@code
+     * VariableElement field = ...; // A valid field element
+     * boolean isEnumMember = FieldUtils.isEnumMemberField(field);
+     * if (isEnumMember) {
+     *     System.out.println("The field is an enum member field.");
+     * } else {
+     *     System.out.println("The field is not an enum member field.");
+     * }
+     * }
+ * + * @param field the field to check; may be null + * @return true if the field is an enum member field, false otherwise + */ + static boolean isEnumMemberField(VariableElement field) { + if (field == null || !isEnumType(field.getEnclosingElement())) { + return false; + } + return ENUM_CONSTANT.equals(field.getKind()); + } + + /** + * Checks if the given field is a non-static field. + * + *

This method verifies whether the provided {@link VariableElement} represents a field + * that is not declared with the {@code static} modifier. It first checks if the element is + * a valid field (including enum constants) using the {@link #isField(VariableElement)} method, + * and then ensures that the field does not have the static modifier. + * + *

Example Usage

+ * 
{@code
+     * VariableElement field = ...; // A valid field element
+     * boolean isNonStatic = FieldUtils.isNonStaticField(field);
+     * if (isNonStatic) {
+     *     System.out.println("The field is non-static.");
+     * } else {
+     *     System.out.println("The field is static or not a valid field.");
+     * }
+     * }
+ * + * @param field the VariableElement to check; may be null + * @return true if the field is a valid field (as per {@link #isField(VariableElement)}) + * and does not have the 'static' modifier, false otherwise + */ + static boolean isNonStaticField(VariableElement field) { + return isField(field) && !hasModifiers(field, STATIC); + } + + /** + * Checks if the given element is a field or an enum constant. + * + *

This method determines whether the provided {@link VariableElement} represents a valid field + * or an enum constant. It returns {@code true} if the element's kind is either + * {@link ElementKind#FIELD} or {@link ElementKind#ENUM_CONSTANT}. + * + *

Example Usage

+ * 
{@code
+     * VariableElement field = ...; // A valid field element
+     * boolean isValidField = FieldUtils.isField(field);
+     * if (isValidField) {
+     *     System.out.println("The element is a valid field or enum constant.");
+     * } else {
+     *     System.out.println("The element is not a field or enum constant.");
+     * }
+     * }
+ * + * @param field the VariableElement to check; may be null + * @return true if the element is a field ({@link javax.lang.model.element.ElementKind#FIELD}) + * or an enum constant ({@link javax.lang.model.element.ElementKind#ENUM_CONSTANT}), false otherwise + */ + static boolean isField(VariableElement field) { + return matchesElementKind(field, FIELD) || isEnumMemberField(field); + } + + /** + * Checks if the given element is a field or an enum constant, and also has all the specified modifiers. + * + *

This method extends the {@link #isField(VariableElement)} method by additionally verifying that + * the field has all of the specified modifiers. It returns {@code true} only if the element is a valid field + * (including enum constants) and contains all the provided modifiers. + * + *

Example Usage

+ * 
{@code
+     * VariableElement field = ...; // A valid field element
+     *
+     * // Check if it's a public static field
+     * boolean isPublicStaticField = FieldUtils.isField(field, Modifier.PUBLIC, Modifier.STATIC);
+     * if (isPublicStaticField) {
+     *     System.out.println("The field is a public static field.");
+     * } else {
+     *     System.out.println("The field is not a public static field.");
+     * }
+     *
+     * // Check if it's a private field
+     * boolean isPrivateField = FieldUtils.isField(field, Modifier.PRIVATE);
+     * if (isPrivateField) {
+     *     System.out.println("The field is a private field.");
+     * } else {
+     *     System.out.println("The field is not a private field.");
+     * }
+     * }
+ * + * @param field the VariableElement to check; may be null + * @param modifiers the modifiers to match (e.g., Modifier.PUBLIC, Modifier.STATIC) + * @return true if the element is a field ({@link javax.lang.model.element.ElementKind#FIELD}) + * or an enum constant ({@link javax.lang.model.element.ElementKind#ENUM_CONSTANT}), + * and it has all of the specified modifiers, false otherwise + */ + static boolean isField(VariableElement field, Modifier... modifiers) { + return isField(field) && hasModifiers(field, modifiers); + } + + /** + * Retrieves all declared non-static fields from the given type. + * + *

This method returns a list of fields that are declared directly within the given type + * and are not marked as static. It does not include fields from superclasses or interfaces. + * If the provided {@link TypeMirror} is null, this method returns an empty list. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror type = element.asType(); // A valid type from an element
+     * List nonStaticFields = FieldUtils.getNonStaticFields(type);
+     * for (VariableElement field : nonStaticFields) {
+     *     System.out.println("Non-static field: " + field.getSimpleName());
+     * }
+     * }
+ * + * @param type the type to search for non-static fields; if null, an empty list is returned + * @return a list of VariableElement objects representing the non-static fields, + * or an empty list if the type is null or no non-static fields are found + */ + @Nonnull + @Immutable + static List getNonStaticFields(TypeMirror type) { + return findDeclaredFields(type, FieldUtils::isNonStaticField); + } + + /** + * Retrieves all declared non-static fields from the given element. + * + *

This method processes the provided element and retrieves all fields directly declared + * within it that are not marked as static. It excludes fields from superclasses or interfaces. + * If the provided element is null, this method returns an empty list. + * + *

Example Usage

+ * 
{@code
+     * Element element = ...; // A valid class or interface element
+     * List nonStaticFields = FieldUtils.getNonStaticFields(element);
+     * for (VariableElement field : nonStaticFields) {
+     *     System.out.println("Non-static field: " + field.getSimpleName());
+     * }
+     *
+     * // Handling null case
+     * List safeList = FieldUtils.getNonStaticFields(null);
+     * System.out.println(safeList.isEmpty()); // true
+     * }
+ * + * @param element the element to search for non-static fields; if null, an empty list is returned + * @return a list of VariableElement objects representing the non-static fields, + * or an empty list if the element is null or no non-static fields are found + */ + @Nonnull + @Immutable + static List getNonStaticFields(Element element) { + return element == null ? emptyList() : getNonStaticFields(element.asType()); + } + + /** + * Retrieves all non-static fields from the given type, including those from hierarchical types (e.g., superclasses). + * + *

This method searches for all fields declared directly within the given type, as well as those inherited + * from its superclasses or interfaces, and filters out only the non-static fields. If the provided {@link TypeMirror} + * is null, this method returns an empty list. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror type = element.asType(); // A valid type from an element
+     * List nonStaticFields = FieldUtils.getAllNonStaticFields(type);
+     * for (VariableElement field : nonStaticFields) {
+     *     System.out.println("Non-static field (including hierarchical): " + field.getSimpleName());
+     * }
+     *
+     * // Handling null case
+     * List safeList = FieldUtils.getAllNonStaticFields(null);
+     * System.out.println(safeList.isEmpty()); // true
+     * }
+ * + * @param type the type to retrieve all non-static fields from; if null, an empty list is returned + * @return a list of VariableElement objects representing all non-static fields, + * or an empty list if the type is null or no non-static fields are found + */ + @Nonnull + @Immutable + static List getAllNonStaticFields(TypeMirror type) { + return findAllDeclaredFields(type, FieldUtils::isNonStaticField); + } + + /** + * Retrieves all non-static fields from the given element, including those from superclasses and interfaces. + * + *

This method processes the provided element and retrieves all fields declared directly within it, + * as well as those inherited from superclasses or interfaces. It filters out only the non-static fields. + * If the provided element is null, this method returns an empty list. + * + *

Example Usage

+ * 
{@code
+     * Element element = ...; // A valid class or interface element
+     * List nonStaticFields = FieldUtils.getAllNonStaticFields(element);
+     * for (VariableElement field : nonStaticFields) {
+     *     System.out.println("Non-static field: " + field.getSimpleName());
+     * }
+     *
+     * // Handling null case
+     * List safeList = FieldUtils.getAllNonStaticFields(null);
+     * System.out.println(safeList.isEmpty()); // true
+     * }
+ * + * @param element the element to retrieve all non-static fields from; if null, an empty list is returned + * @return a list of VariableElement objects representing all non-static fields, + * or an empty list if the element is null or no non-static fields are found + */ + @Nonnull + @Immutable + static List getAllNonStaticFields(Element element) { + return element == null ? emptyList() : getAllNonStaticFields(element.asType()); + } + + /** + * Checks if the simple name of the given field matches the specified field name. + * + *

This method ensures both the {@link VariableElement} and the field name are non-null + * before comparing their string representations for equality. + * + *

Example Usage

+ * 
{@code
+     * VariableElement field = ...; // A valid field element
+     * CharSequence fieldName = "myField";
+     * boolean isMatch = equalsFieldName(field, fieldName);
+     * if (isMatch) {
+     *     System.out.println("Field name matches: " + fieldName);
+     * } else {
+     *     System.out.println("Field name does not match.");
+     * }
+     * }
+ * + * @param field the VariableElement representing the field; may be null + * @param fieldName the CharSequence representing the expected field name; may be null + * @return true if both the field and fieldName are non-null and their string representations match, false otherwise + */ + static boolean equalsFieldName(VariableElement field, CharSequence fieldName) { + return field != null && fieldName != null && field.getSimpleName().toString().equals(fieldName.toString()); + } +} diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/JSONAnnotationValueVisitor.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/JSONAnnotationValueVisitor.java new file mode 100644 index 000000000..01b074447 --- /dev/null +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/JSONAnnotationValueVisitor.java @@ -0,0 +1,196 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.lang.model.util; + +import javax.lang.model.element.AnnotationMirror; +import javax.lang.model.element.AnnotationValue; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.VariableElement; +import javax.lang.model.type.TypeMirror; +import javax.lang.model.util.SimpleAnnotationValueVisitor6; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; + +import static io.microsphere.constants.SymbolConstants.COMMA_CHAR; +import static io.microsphere.constants.SymbolConstants.LEFT_CURLY_BRACE_CHAR; +import static io.microsphere.constants.SymbolConstants.LEFT_SQUARE_BRACKET_CHAR; +import static io.microsphere.constants.SymbolConstants.RIGHT_CURLY_BRACE_CHAR; +import static io.microsphere.constants.SymbolConstants.RIGHT_SQUARE_BRACKET_CHAR; +import static io.microsphere.json.JSONUtils.append; +import static io.microsphere.json.JSONUtils.appendName; +import static io.microsphere.lang.model.util.AnnotationUtils.getAttributeName; +import static io.microsphere.lang.model.util.AnnotationUtils.getElementValues; +import static io.microsphere.lang.model.util.TypeUtils.getTypeName; + +/** + * A visitor implementation for converting {@link AnnotationValue} objects into JSON-formatted strings. + * This class extends {@link SimpleAnnotationValueVisitor6} and is designed to work with Java annotation + * processing tools to generate JSON representations of annotation values. + * + *

Example Usage

+ * 
{@code
+ * // Example 1: Visiting a simple annotation value
+ * AnnotationValue value = ...; // e.g., a String, int, or boolean value
+ * ExecutableElement method = ...; // the method corresponding to the annotation attribute
+ * StringBuilder jsonBuilder = new StringBuilder();
+ * JSONAnnotationValueVisitor visitor = new JSONAnnotationValueVisitor(jsonBuilder);
+ * visitor.visit(value, method); // Result: appends JSON key-value pair to jsonBuilder
+ *
+ * // Example 2: Visiting an array annotation value
+ * List arrayValues = ...; // list of annotation values
+ * visitor.visitArray(arrayValues, method); // Result: appends JSON array to jsonBuilder
+ *
+ * // Example 3: Visiting a nested annotation
+ * AnnotationMirror annotationMirror = ...;
+ * visitor.visitAnnotation(annotationMirror, method); // Result: appends JSON object to jsonBuilder
+ * }
+ * + *

This visitor is typically used during annotation processing to serialize annotation values + * into a structured JSON format, useful for configuration or metadata generation purposes. + * + * @author Mercy + * @see SimpleAnnotationValueVisitor6 + * @since 1.0.0 + */ +public class JSONAnnotationValueVisitor extends SimpleAnnotationValueVisitor6 { + + private final StringBuilder jsonBuilder; + + public JSONAnnotationValueVisitor(StringBuilder jsonBuilder) { + super(jsonBuilder); + this.jsonBuilder = jsonBuilder; + } + + @Override + public StringBuilder visitBoolean(boolean value, ExecutableElement attributeMethod) { + append(jsonBuilder, getAttributeName(attributeMethod), value); + return jsonBuilder; + } + + @Override + public StringBuilder visitByte(byte value, ExecutableElement attributeMethod) { + append(jsonBuilder, getAttributeName(attributeMethod), value); + return jsonBuilder; + } + + @Override + public StringBuilder visitChar(char value, ExecutableElement attributeMethod) { + append(jsonBuilder, getAttributeName(attributeMethod), value); + return jsonBuilder; + } + + @Override + public StringBuilder visitDouble(double value, ExecutableElement attributeMethod) { + append(jsonBuilder, getAttributeName(attributeMethod), value); + return jsonBuilder; + } + + @Override + public StringBuilder visitFloat(float value, ExecutableElement attributeMethod) { + append(jsonBuilder, getAttributeName(attributeMethod), value); + return jsonBuilder; + } + + @Override + public StringBuilder visitInt(int value, ExecutableElement attributeMethod) { + append(jsonBuilder, getAttributeName(attributeMethod), value); + return jsonBuilder; + } + + @Override + public StringBuilder visitLong(long value, ExecutableElement attributeMethod) { + append(jsonBuilder, getAttributeName(attributeMethod), value); + return jsonBuilder; + } + + @Override + public StringBuilder visitShort(short value, ExecutableElement attributeMethod) { + append(jsonBuilder, getAttributeName(attributeMethod), value); + return jsonBuilder; + } + + @Override + public StringBuilder visitString(String value, ExecutableElement attributeMethod) { + append(jsonBuilder, getAttributeName(attributeMethod), value); + return jsonBuilder; + } + + @Override + public StringBuilder visitType(TypeMirror value, ExecutableElement attributeMethod) { + append(jsonBuilder, getAttributeName(attributeMethod), getTypeName(value)); + return jsonBuilder; + } + + @Override + public StringBuilder visitEnumConstant(VariableElement value, ExecutableElement attributeMethod) { + append(jsonBuilder, getAttributeName(attributeMethod), value.getSimpleName().toString()); + return jsonBuilder; + } + + @Override + public StringBuilder visitAnnotation(AnnotationMirror value, ExecutableElement attributeMethod) { + Map elementValues = getElementValues(value); + Iterator> iterator = elementValues.entrySet().iterator(); + StringBuilder annotationJsonBuilder = new StringBuilder(); + annotationJsonBuilder.append(LEFT_CURLY_BRACE_CHAR); + JSONAnnotationValueVisitor visitor = new JSONAnnotationValueVisitor(annotationJsonBuilder); + while (iterator.hasNext()) { + Entry entry = iterator.next(); + AnnotationValue annotationValue = entry.getValue(); + visitor.visit(annotationValue, entry.getKey()); + if (iterator.hasNext()) { + annotationJsonBuilder.append(COMMA_CHAR); + } + } + annotationJsonBuilder.append(RIGHT_CURLY_BRACE_CHAR); + + return doAppend(attributeMethod, annotationJsonBuilder); + } + + @Override + public StringBuilder visitArray(List values, ExecutableElement attributeMethod) { + StringBuilder arrayJsonBuilder = new StringBuilder(); + + arrayJsonBuilder.append(LEFT_SQUARE_BRACKET_CHAR); + int size = values.size(); + JSONAnnotationValueVisitor visitor = new JSONAnnotationValueVisitor(arrayJsonBuilder); + for (int i = 0; i < size; i++) { + AnnotationValue annotationValue = values.get(i); + annotationValue.accept(visitor, null); + if (i < size - 1) { + arrayJsonBuilder.append(COMMA_CHAR); + } + } + arrayJsonBuilder.append(RIGHT_SQUARE_BRACKET_CHAR); + + return doAppend(attributeMethod, arrayJsonBuilder); + } + + @Override + public StringBuilder visitUnknown(AnnotationValue annotationValue, ExecutableElement attributeMethod) { + return jsonBuilder; + } + + protected StringBuilder doAppend(ExecutableElement attributeMethod, StringBuilder value) { + appendName(this.jsonBuilder, getAttributeName(attributeMethod)) + .append(value); + return this.jsonBuilder; + } +} diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/JSONElementVisitor.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/JSONElementVisitor.java new file mode 100644 index 000000000..36a20126c --- /dev/null +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/JSONElementVisitor.java @@ -0,0 +1,221 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.lang.model.util; + +import javax.lang.model.element.Element; +import javax.lang.model.element.ElementVisitor; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.PackageElement; +import javax.lang.model.element.TypeElement; +import javax.lang.model.element.TypeParameterElement; +import javax.lang.model.element.VariableElement; +import javax.lang.model.util.AbstractElementVisitor6; +import javax.lang.model.util.ElementKindVisitor6; +import java.util.List; + +import static java.lang.Boolean.FALSE; + +/** + * A specialized {@link ElementVisitor} implementation that traverses Java elements and generates JSON + * representations of the elements' metadata. + * + *

This abstract class extends {@link ElementKindVisitor6} to provide a foundation for creating + * JSON-based representations of various Java language elements such as packages, types, methods, + * fields, and type parameters. + * + *

Example Usage

+ * 
{@code
+ * public class CustomJSONElementVisitor extends JSONElementVisitor {
+ *     // Implement specific visit methods to customize JSON generation
+ * }
+ * }
+ * + *

Subclasses should implement or override the appropriate visit methods to customize how + * different Java elements are represented in JSON. + * + * @author Mercy + * @see ElementVisitor + * @see ElementKindVisitor6 + * @see AbstractElementVisitor6 + * @since 1.0.0 + */ +public abstract class JSONElementVisitor extends ElementKindVisitor6 { + + public JSONElementVisitor() { + super(FALSE); + } + + @Override + public final Boolean visitPackage(PackageElement e, StringBuilder jsonBuilder) { + return supportsPackage(e) && doVisitPackage(e, jsonBuilder); + } + + @Override + public final Boolean visitVariable(VariableElement e, StringBuilder stringBuilder) { + return supportsVariable(e) && super.visitVariable(e, stringBuilder); + } + + @Override + public final Boolean visitExecutable(ExecutableElement e, StringBuilder jsonBuilder) { + return supportsExecutable(e) && super.visitExecutable(e, jsonBuilder); + } + + @Override + public final Boolean visitType(TypeElement e, StringBuilder jsonBuilder) { + boolean appended = false; + if (supportsType(e) && super.visitType(e, jsonBuilder)) { + appended = true; + } + + // The declared members of the type element + if (visitMembers(e.getEnclosedElements(), jsonBuilder)) { + appended = true; + } + + return appended; + } + + @Override + public final Boolean visitTypeParameter(TypeParameterElement e, StringBuilder jsonBuilder) { + if (!supports(e)) { + return FALSE; + } + + boolean appended = false; + if (supportsTypeParameter(e) && doVisitTypeParameter(e, jsonBuilder)) { + appended = true; + } + + // The declared members of the type element + if (visitMembers(e.getEnclosedElements(), jsonBuilder)) { + appended = true; + } + + return appended; + } + + protected boolean visitMembers(List members, StringBuilder jsonBuilder) { + boolean appended = false; + for (Element member : members) { + if (member.accept(this, jsonBuilder)) { + appended = true; + } + } + return appended; + } + + /** + * Determines whether the specified element is supported for processing. + * + *

This method can be overridden to provide custom logic for deciding + * if an element should be processed by this visitor.

+ * + * @param e the element to check + * @return {@code true} if the element is supported; {@code false} otherwise + */ + protected boolean supports(Element e) { + return true; + } + + /** + * Determines whether the specified package element is supported for processing. + * + *

This method can be overridden to provide custom logic for deciding + * if a package element should be processed by this visitor.

+ * + * @param e the package element to check + * @return {@code true} if the package element is supported; {@code false} otherwise + */ + protected boolean supportsPackage(PackageElement e) { + return supports(e); + } + + /** + * Determines whether the specified variable element is supported for processing. + * + *

This method can be overridden to provide custom logic for deciding + * if a variable element should be processed by this visitor.

+ * + * @param e the variable element to check + * @return {@code true} if the variable element is supported; {@code false} otherwise + */ + protected boolean supportsVariable(VariableElement e) { + return supports(e); + } + + /** + * Determines whether the specified executable element is supported for processing. + * + *

This method can be overridden to provide custom logic for deciding + * if an executable element should be processed by this visitor.

+ * + * @param e the executable element to check + * @return {@code true} if the executable element is supported; {@code false} otherwise + */ + protected boolean supportsExecutable(ExecutableElement e) { + return supports(e); + } + + /** + * Determines whether the specified type element is supported for processing. + * + *

This method can be overridden to provide custom logic for deciding + * if a type element should be processed by this visitor.

+ * + * @param e the type element to check + * @return {@code true} if the type element is supported; {@code false} otherwise + */ + protected boolean supportsType(TypeElement e) { + return supports(e); + } + + /** + * Determines whether the specified type parameter element is supported for processing. + * + *

This method can be overridden to provide custom logic for deciding + * if a type parameter element should be processed by this visitor.

+ * + * @param e the type parameter element to check + * @return {@code true} if the type parameter element is supported; {@code false} otherwise + */ + protected boolean supportsTypeParameter(TypeParameterElement e) { + return supports(e); + } + + /** + * Visits a package element and appends its JSON representation to the builder. + * + * @param e the package element to visit + * @param jsonBuilder the string builder used to construct the JSON output + * @return {@code true} if any content was appended; {@code false} otherwise + */ + protected boolean doVisitPackage(PackageElement e, StringBuilder jsonBuilder) { + return super.visitPackage(e, jsonBuilder); + } + + /** + * Visits a type parameter element and appends its JSON representation to the builder. + * + * @param e the type parameter element to visit + * @param jsonBuilder the string builder used to construct the JSON output + * @return {@code true} if any content was appended; {@code false} otherwise + */ + protected boolean doVisitTypeParameter(TypeParameterElement e, StringBuilder jsonBuilder) { + return super.visitTypeParameter(e, jsonBuilder); + } +} diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/LoggerUtils.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/LoggerUtils.java new file mode 100644 index 000000000..4fed09a7f --- /dev/null +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/LoggerUtils.java @@ -0,0 +1,54 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.lang.model.util; + + +import io.microsphere.logging.Logger; +import io.microsphere.util.Utils; + +import static io.microsphere.logging.LoggerFactory.getLogger; + +/** + * Logger Utils + * + * @author Mercy + * @since 1.0.0 + */ +public interface LoggerUtils extends Utils { + + Logger LOGGER = getLogger("microsphere-lang-model"); + + static void trace(String format, Object... args) { + LOGGER.trace(format, args); + } + + static void debug(String format, Object... args) { + LOGGER.debug(format, args); + } + + static void info(String format, Object... args) { + LOGGER.info(format, args); + } + + static void warn(String format, Object... args) { + LOGGER.warn(format, args); + } + + static void error(String format, Object... args) { + LOGGER.error(format, args); + } +} diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/MemberUtils.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/MemberUtils.java new file mode 100644 index 000000000..addc57158 --- /dev/null +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/MemberUtils.java @@ -0,0 +1,423 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.lang.model.util; + +import io.microsphere.annotation.Immutable; +import io.microsphere.annotation.Nonnull; +import io.microsphere.util.Utils; + +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; +import javax.lang.model.type.TypeMirror; +import java.util.Collection; +import java.util.List; +import java.util.function.Predicate; + +import static io.microsphere.lang.model.util.ElementUtils.filterElements; +import static io.microsphere.lang.model.util.TypeUtils.getAllDeclaredTypes; +import static io.microsphere.lang.model.util.TypeUtils.ofTypeElement; +import static io.microsphere.lang.function.Predicates.EMPTY_PREDICATE_ARRAY; +import static java.util.Collections.emptyList; +import static java.util.stream.Collectors.toList; + +/** + * A utility interface for handling members (such as fields, methods, constructors) from types + * in the {@link javax.lang.model} package. + * + *

Overview

+ *

+ * This interface provides a set of static methods to retrieve and filter members of a type, + * including direct members and those inherited from superclasses and interfaces. + * It is designed to simplify the process of working with type elements and their enclosed elements + * during annotation processing. + *

+ * + *

Key Features

+ *
    + *
  • {@link #getDeclaredMembers(TypeMirror) getDeclaredMembers(TypeMirror)} - Retrieves directly declared members of a type.
    • + *
  • {@link #getAllDeclaredMembers(TypeMirror) getAllDeclaredMembers(TypeMirror)} - Retrieves all declared members, including those from superclasses and interfaces.
    • + *
  • {@link #findDeclaredMembers(TypeMirror, Predicate...) findDeclaredMembers(TypeMirror, Predicate...)} - Retrieves and filters declared members based on provided predicates.
    • + *
  • {@link #findAllDeclaredMembers(TypeMirror, Predicate...) findAllDeclaredMembers(TypeMirror, Predicate...)} - Retrieves all declared members and applies filtering via predicates.
    • + *
+ * + *

Example Usage

+ * 
{@code
+ * // Retrieve all declared methods from a TypeMirror
+ * List methods = findDeclaredMembers(typeMirror,
+ *     element -> element.getKind() == ElementKind.METHOD
+ * );
+ * }
+ * + * 
{@code
+ * // Retrieve all fields that start with "m_"
+ * List filteredFields = findDeclaredMembers(typeElement,
+ *     element -> element.getKind() == ElementKind.FIELD,
+ *     element -> element.getSimpleName().toString().startsWith("m_")
+ * );
+ * }
+ * + * @author Mercy + * @since 1.0.0 + */ +public interface MemberUtils extends Utils { + + /** + * Returns the directly declared members of the provided {@link TypeMirror}. + * If the given type is {@code null}, an empty list will be returned. + * + *

Example Usage

+ * 
+     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror instance
+     * List members = getDeclaredMembers(typeMirror);
+     * if (!members.isEmpty()) {
+     *     for (Element member : members) {
+     *         System.out.println("Declared member: " + member);
+     *     }
+     * }
+     *
+ * + * @param type the type mirror to retrieve declared members from + * @return a list of directly declared members, or an empty list if the type is {@code null} + */ + @Nonnull + @Immutable + static List getDeclaredMembers(TypeMirror type) { + return type == null ? emptyList() : getDeclaredMembers(ofTypeElement(type)); + } + + /** + * Returns the directly declared members of the provided {@link TypeElement}. + * If the given type is {@code null}, an empty list will be returned. + * + *

Example Usage

+ * 
{@code
+     * TypeElement typeElement = ...; // Obtain a valid TypeElement instance
+     * List members = getDeclaredMembers(typeElement);
+     * if (!members.isEmpty()) {
+     *     for (Element member : members) {
+     *         System.out.println("Declared member: " + member);
+     *     }
+     * }
+     * }
+ * + * @param type the type element to retrieve declared members from + * @return a list of directly declared members, or an empty list if the type is {@code null} + */ + @Nonnull + @Immutable + static List getDeclaredMembers(TypeElement type) { + return type == null ? emptyList() : findDeclaredMembers(type, EMPTY_PREDICATE_ARRAY); + } + + /** + * Returns all declared members (including those from superclasses and interfaces) of the provided {@link TypeMirror}. + * If the given type is {@code null}, an empty list will be returned. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror instance
+     * List allMembers = getAllDeclaredMembers(typeMirror);
+     * if (!allMembers.isEmpty()) {
+     *     for (Element member : allMembers) {
+     *         System.out.println("All declared member: " + member);
+     *     }
+     * }
+     * }
+ * + * @param type the type mirror to retrieve all declared members from + * @return a list of all declared members, or an empty list if the type is {@code null} + */ + @Nonnull + @Immutable + static List getAllDeclaredMembers(TypeMirror type) { + return type == null ? emptyList() : findAllDeclaredMembers(ofTypeElement(type), EMPTY_PREDICATE_ARRAY); + } + + /** + * Returns all declared members (including those from superclasses and interfaces) of the provided {@link TypeElement}. + * If the given type is {@code null}, an empty list will be returned. + * + *

Example Usage

+ * 
{@code
+     * TypeElement typeElement = ...; // Obtain a valid TypeElement instance
+     * List allMembers = getAllDeclaredMembers(typeElement);
+     * if (!allMembers.isEmpty()) {
+     *     for (Element member : allMembers) {
+     *         System.out.println("All declared member: " + member);
+     *     }
+     * }
+     * }
+ * + * @param type the type element to retrieve all declared members from + * @return a list of all declared members, or an empty list if the type is {@code null} + */ + @Nonnull + @Immutable + static List getAllDeclaredMembers(TypeElement type) { + return type == null ? emptyList() : findAllDeclaredMembers(type, EMPTY_PREDICATE_ARRAY); + } + + /** + * Returns the declared members of the provided {@link TypeMirror}, optionally including + * members from superclasses and interfaces. + * + *

If the given type is {@code null}, an empty list will be returned.

+ * + *

Example Usage

+ * 
{@code
+     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror instance
+     * boolean includeSuperMembers = true; // Include members from superclasses/interfaces
+     * List members = getDeclaredMembers(typeMirror, includeSuperMembers);
+     * for (Element member : members) {
+     *     System.out.println("Member: " + member);
+     * }
+     * }
+ * + * @param type the type mirror to retrieve declared members from + * @param includeHierarchicalTypes whether to include members from superclasses and interfaces + * @return a list of declared members, or an empty list if the type is {@code null} + */ + @Nonnull + @Immutable + static List getDeclaredMembers(TypeMirror type, boolean includeHierarchicalTypes) { + return includeHierarchicalTypes ? getAllDeclaredMembers(type) : getDeclaredMembers(type); + } + + /** + * Returns the declared members of the provided {@link TypeElement}, optionally including + * members from superclasses and interfaces. + * + *

If the given type is {@code null}, an empty list will be returned.

+ * + *

Example Usage

+ * 
{@code
+     * TypeElement typeElement = ...; // Obtain a valid TypeElement instance
+     * boolean includeSuperMembers = true; // Include members from superclasses/interfaces
+     * List members = getDeclaredMembers(typeElement, includeSuperMembers);
+     * for (Element member : members) {
+     *     System.out.println("Member: " + member);
+     * }
+     * }
+ * + * @param type the type element to retrieve declared members from + * @param includeHierarchicalTypes whether to include members from superclasses and interfaces + * @return a list of declared members, or an empty list if the type is {@code null} + */ + @Nonnull + @Immutable + static List getDeclaredMembers(TypeElement type, boolean includeHierarchicalTypes) { + return includeHierarchicalTypes ? getAllDeclaredMembers(type) : getDeclaredMembers(type); + } + + /** + * Returns the declared members of the provided {@link TypeMirror}, optionally filtered by one or more predicates. + * + *

If the given type is {@code null}, an empty list will be returned.

+ * + *

Example Usage

+ * 
{@code
+     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror instance
+     * List methods = findDeclaredMembers(typeMirror,
+     *     element -> element.getKind() == ElementKind.METHOD,
+     *     element -> element.getSimpleName().toString().startsWith("get")
+     * );
+     * for (Element method : methods) {
+     *     System.out.println("Matching method: " + method);
+     * }
+     * }
+ * + * @param the type of elements to filter + * @param type the type mirror to retrieve declared members from + * @param memberFilters the predicates used to filter members + * @return a list of declared members matching the filters, or an empty list if the type is {@code null} + */ + @Nonnull + @Immutable + static List findDeclaredMembers(TypeMirror type, Predicate... memberFilters) { + return type == null ? emptyList() : findDeclaredMembers(ofTypeElement(type), memberFilters); + } + + /** + * Returns the directly declared members of the provided {@link TypeElement}, optionally filtered by one or more predicates. + * + *

If the given type is {@code null}, an empty list will be returned.

+ * + *

Example Usage

+ * 
{@code
+     * TypeElement typeElement = ...; // Obtain a valid TypeElement instance
+     * List fields = findDeclaredMembers(typeElement,
+     *     element -> element.getKind() == ElementKind.FIELD,
+     *     element -> element.getSimpleName().toString().startsWith("m_")
+     * );
+     * for (Element field : fields) {
+     *     System.out.println("Matching field: " + field);
+     * }
+     * }
+ * + * @param the type of elements to filter + * @param type the type element to retrieve declared members from + * @param memberFilters the predicates used to filter members + * @return a list of declared members matching the filters, or an empty list if the type is {@code null} + */ + @Nonnull + @Immutable + static List findDeclaredMembers(TypeElement type, Predicate... memberFilters) { + if (type == null) { + return emptyList(); + } + return filterElements((List) type.getEnclosedElements(), memberFilters); + } + + /** + * Returns all declared members (including those from superclasses and interfaces) of the provided {@link TypeMirror}, + * optionally filtered by one or more predicates. + * + *

If the given type is {@code null}, an empty list will be returned.

+ * + *

Example Usage

+ * 
{@code
+     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror instance
+     * List methods = findAllDeclaredMembers(typeMirror,
+     *     element -> element.getKind() == ElementKind.METHOD,
+     *     element -> element.getSimpleName().toString().startsWith("get")
+     * );
+     * for (Element method : methods) {
+     *     System.out.println("Matching method: " + method);
+     * }
+     * }
+ * + * @param the type of elements to filter + * @param type the type mirror to retrieve all declared members from + * @param memberFilters the predicates used to filter members + * @return a list of all declared members matching the filters, or an empty list if the type is {@code null} + */ + @Nonnull + @Immutable + static List findAllDeclaredMembers(TypeMirror type, Predicate... memberFilters) { + return type == null ? emptyList() : findAllDeclaredMembers(ofTypeElement(type), memberFilters); + } + + /** + * Retrieves all declared members (fields, methods, constructors, etc.) from the given {@link TypeElement}, + * including those inherited from superclasses and implemented interfaces. + * + *

This method collects all declared members by traversing the type hierarchy and applying + * the provided filters to narrow down the results. + * + *

Example Usage

+ * 
{@code
+     * TypeElement typeElement = ...; // Obtain a valid TypeElement instance
+     * List fields = findAllDeclaredMembers(typeElement,
+     *     element -> element.getKind() == ElementKind.FIELD
+     * );
+     * for (Element field : fields) {
+     *     System.out.println("Field: " + field);
+     * }
+     * }
+ * + * 
{@code
+     * List methods = findAllDeclaredMembers(typeElement,
+     *     element -> element.getKind() == ElementKind.METHOD,
+     *     element -> element.getSimpleName().toString().startsWith("get")
+     * );
+     * for (Element method : methods) {
+     *     System.out.println("Getter method: " + method);
+     * }
+     * }
+ * + * @param the type of elements to filter + * @param type the type element to retrieve all declared members from + * @param memberFilters the predicates used to filter members + * @return a list of all declared members matching the filters, or an empty list if the type is {@code null} + */ + @Nonnull + @Immutable + static List findAllDeclaredMembers(TypeElement type, Predicate... memberFilters) { + if (type == null) { + return emptyList(); + } + List declaredMembers = (List) getAllDeclaredTypes(type) + .stream() + .map(MemberUtils::getDeclaredMembers) + .flatMap(Collection::stream) + .collect(toList()); + return filterElements(declaredMembers, memberFilters); + } + + /** + * Returns the declared members of the provided {@link TypeMirror}, optionally including + * members from superclasses and interfaces, and filtered by one or more predicates. + * + *

If the given type is {@code null}, an empty list will be returned.

+ * + *

Example Usage

+ * 
{@code
+     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror instance
+     * boolean includeSuperMembers = true; // Include members from superclasses/interfaces
+     * List methods = findDeclaredMembers(typeMirror, includeSuperMembers,
+     *     element -> element.getKind() == ElementKind.METHOD,
+     *     element -> element.getSimpleName().toString().startsWith("get")
+     * );
+     * for (Element method : methods) {
+     *     System.out.println("Matching method: " + method);
+     * }
+     * }
+ * + * @param the type of elements to filter + * @param type the type mirror to retrieve declared members from + * @param includeHierarchicalTypes whether to include members from superclasses and interfaces + * @param memberFilters the predicates used to filter members + * @return a list of declared members matching the filters, or an empty list if the type is {@code null} + */ + @Nonnull + @Immutable + static List findDeclaredMembers(TypeMirror type, boolean includeHierarchicalTypes, Predicate... memberFilters) { + return includeHierarchicalTypes ? findAllDeclaredMembers(type, memberFilters) : findDeclaredMembers(type, memberFilters); + } + + /** + * Returns the declared members of the provided {@link TypeElement}, optionally including + * members from superclasses and interfaces, and filtered by one or more predicates. + * + *

If the given type is {@code null}, an empty list will be returned.

+ * + *

Example Usage

+ * 
{@code
+     * TypeElement typeElement = ...; // Obtain a valid TypeElement instance
+     * boolean includeSuperMembers = true; // Include members from superclasses/interfaces
+     * List fields = findDeclaredMembers(typeElement, includeSuperMembers,
+     *     element -> element.getKind() == ElementKind.FIELD,
+     *     element -> element.getSimpleName().toString().startsWith("m_")
+     * );
+     * for (Element field : fields) {
+     *     System.out.println("Matching field: " + field);
+     * }
+     * }
+ * + * @param the type of elements to filter + * @param type the type element to retrieve declared members from + * @param all whether to include members from superclasses and interfaces + * @param memberFilters the predicates used to filter members + * @return a list of declared members matching the filters, or an empty list if the type is {@code null} + */ + @Nonnull + @Immutable + static List findDeclaredMembers(TypeElement type, boolean all, Predicate... memberFilters) { + return all ? findAllDeclaredMembers(type, memberFilters) : findDeclaredMembers(type, memberFilters); + } + +} diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/MessagerUtils.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/MessagerUtils.java new file mode 100644 index 000000000..63ad95180 --- /dev/null +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/MessagerUtils.java @@ -0,0 +1,310 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional inpatternion regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.lang.model.util; + +import io.microsphere.util.Utils; + +import javax.annotation.processing.Messager; +import javax.annotation.processing.ProcessingEnvironment; +import javax.tools.Diagnostic.Kind; + +import static io.microsphere.lang.model.util.LoggerUtils.debug; +import static io.microsphere.lang.model.util.LoggerUtils.error; +import static io.microsphere.lang.model.util.LoggerUtils.info; +import static io.microsphere.lang.model.util.LoggerUtils.warn; +import static io.microsphere.text.FormatUtils.format; +import static javax.tools.Diagnostic.Kind.ERROR; +import static javax.tools.Diagnostic.Kind.MANDATORY_WARNING; +import static javax.tools.Diagnostic.Kind.NOTE; +import static javax.tools.Diagnostic.Kind.WARNING; + +/** + * {@link Messager} utilities class + * + * @author Mercy + * @see Messager + * @since 1.0.0 + */ +public interface MessagerUtils extends Utils { + + /** + * Prints a note message using the {@link ProcessingEnvironment}'s {@link Messager}. + * + *

+ * This method formats the message using the provided pattern and arguments, + * and delegates to the underlying {@link Messager} obtained from the processing environment. + *

+ * + *

Example Usage

+ * 
+     * ProcessingEnvironment processingEnv = ...; // Obtain processing environment
+     * printNote(processingEnv, "Found {0} elements matching criteria", count);
+     *
+ * + * @param processingEnv the processing environment to obtain the messager from + * @param pattern the message pattern to format (supports {@link String#format} syntax) + * @param args the arguments for the message pattern + */ + static void printNote(ProcessingEnvironment processingEnv, String pattern, Object... args) { + printNote(processingEnv.getMessager(), pattern, args); + } + + /** + * Prints a note message using the provided {@link Messager}. + * + *

+ * This method formats the message using the provided pattern and arguments, + * and forwards it to the underlying {@link Messager}. + *

+ * + *

Example Usage

+ * 
+     * Messager messager = processingEnv.getMessager();
+     * printNote(messager, "Found {0} elements matching criteria", count);
+     *
+ * + * @param messager the messager to use for printing the message + * @param pattern the message pattern to format (supports {@link String#format} syntax) + * @param args the arguments for the message pattern + */ + /** + * Prints a note message using the provided {@link Messager}. + * + *

+ * This method formats the message using the provided pattern and arguments, + * and forwards it to the underlying {@link Messager}. + *

+ * + *

Example Usage

+ * 
+     * Messager messager = processingEnv.getMessager();
+     * printNote(messager, "Found {0} elements matching criteria", count);
+     *
+ * + * @param messager the messager to use for printing the message + * @param pattern the message pattern to format (supports {@link String#format} syntax) + * @param args the arguments for the message pattern + */ + static void printNote(Messager messager, String pattern, Object... args) { + printMessage(messager, NOTE, pattern, args); + } + + /** + * Prints a warning message using the {@link ProcessingEnvironment}'s {@link Messager}. + * + *

+ * This method formats the message using the provided pattern and arguments, + * and delegates to the underlying {@link Messager} obtained from the processing environment. + * The message will be logged at the warning level through both the {@link Messager} + * and internal logging utilities. + *

+ * + *

Example Usage

+ * 
+     * ProcessingEnvironment processingEnv = ...; // Obtain processing environment
+     * printWarning(processingEnv, "Found {0} deprecated elements", count);
+     *
+ * + * @param processingEnv the processing environment to obtain the messager from + * @param pattern the message pattern to format (supports {@link String#format} syntax) + * @param args the arguments for the message pattern + */ + static void printWarning(ProcessingEnvironment processingEnv, String pattern, Object... args) { + printWarning(processingEnv.getMessager(), pattern, args); + } + + /** + * Prints a warning message using the provided {@link Messager}. + * + *

+ * This method formats the message using the provided pattern and arguments, + * and forwards it to the underlying {@link Messager} as a warning level message. + * The message will also be logged through internal logging utilities at the warning level. + *

+ * + *

Example Usage

+ * 
+     * Messager messager = processingEnv.getMessager();
+     * printWarning(messager, "Found {0} deprecated elements", count);
+     *
+ * + * @param messager the messager to use for printing the message + * @param pattern the message pattern to format (supports {@link String#format} syntax) + * @param args the arguments for the message pattern + */ + static void printWarning(Messager messager, String pattern, Object... args) { + printMessage(messager, WARNING, pattern, args); + } + + /** + * Prints a mandatory warning message using the {@link ProcessingEnvironment}'s {@link Messager}. + * + *

+ * This method formats the message using the provided pattern and arguments, + * and delegates to the underlying {@link Messager} obtained from the processing environment. + * The message will be logged at the warning level through both the {@link Messager} + * and internal logging utilities. + *

+ * + *

Example Usage

+ * 
+     * ProcessingEnvironment processingEnv = ...; // Obtain processing environment
+     * printMandatoryWarning(processingEnv, "Found {0} obsolete elements", count);
+     *
+ * + * @param processingEnv the processing environment to obtain the messager from + * @param pattern the message pattern to format (supports {@link String#format} syntax) + * @param args the arguments for the message pattern + */ + static void printMandatoryWarning(ProcessingEnvironment processingEnv, String pattern, Object... args) { + printMandatoryWarning(processingEnv.getMessager(), pattern, args); + } + + /** + * Prints a mandatory warning message using the provided {@link Messager}. + * + *

+ * This method formats the message using the provided pattern and arguments, + * and forwards it to the underlying {@link Messager} as a mandatory warning level message. + * The message will also be logged through internal logging utilities at the warning level. + *

+ * + *

Example Usage

+ * 
+     * Messager messager = processingEnv.getMessager();
+     * printMandatoryWarning(messager, "Found {0} obsolete elements", count);
+     *
+ * + * @param messager the messager to use for printing the message + * @param pattern the message pattern to format (supports {@link String#format} syntax) + * @param args the arguments for the message pattern + */ + static void printMandatoryWarning(Messager messager, String pattern, Object... args) { + printMessage(messager, MANDATORY_WARNING, pattern, args); + } + + /** + * Prints an error message using the {@link ProcessingEnvironment}'s {@link Messager}. + * + *

+ * This method formats the message using the provided pattern and arguments, + * and delegates to the underlying {@link Messager} obtained from the processing environment. + * The message will be logged at the error level through both the {@link Messager} + * and internal logging utilities. + *

+ * + *

Example Usage

+ * 
+     * ProcessingEnvironment processingEnv = ...; // Obtain processing environment
+     * printError(processingEnv, "Failed to process {0} elements", count);
+     *
+ * + * @param processingEnv the processing environment to obtain the messager from + * @param pattern the message pattern to format (supports {@link String#format} syntax) + * @param args the arguments for the message pattern + */ + static void printError(ProcessingEnvironment processingEnv, String pattern, Object... args) { + printError(processingEnv.getMessager(), pattern, args); + } + + /** + * Prints an error message using the provided {@link Messager}. + * + *

+ * This method formats the message using the provided pattern and arguments, + * and forwards it to the underlying {@link Messager} as an error level message. + * The message will also be logged through internal logging utilities at the error level. + *

+ * + *

Example Usage

+ * 
+     * Messager messager = processingEnv.getMessager();
+     * printError(messager, "Failed to process {0} elements", count);
+     *
+ * + * @param messager the messager to use for printing the message + * @param pattern the message pattern to format (supports {@link String#format} syntax) + * @param args the arguments for the message pattern + */ + static void printError(Messager messager, String pattern, Object... args) { + printMessage(messager, ERROR, pattern, args); + } + + /** + * Prints a message of the specified kind using the {@link ProcessingEnvironment}'s {@link Messager}. + * + *

+ * This method retrieves the {@link Messager} from the provided {@link ProcessingEnvironment} + * and delegates to the {@link #printMessage(Messager, Kind, String, Object...)} method + * to handle message formatting and output. + *

+ * + *

Example Usage

+ * 
+     * ProcessingEnvironment processingEnv = ...; // Obtain processing environment
+     * printMessage(processingEnv, Kind.WARNING, "Found {0} deprecated elements", count);
+     *
+ * + * @param processingEnv the processing environment to obtain the messager from + * @param kind the kind of message to print (e.g., error, warning, note) + * @param pattern the message pattern to format (supports {@link String#format} syntax) + * @param args the arguments for the message pattern + */ + static void printMessage(ProcessingEnvironment processingEnv, Kind kind, String pattern, Object... args) { + printMessage(processingEnv.getMessager(), kind, pattern, args); + } + + /** + * Prints a message of the specified kind using the provided {@link Messager}. + * + *

+ * This method formats the message using the provided pattern and arguments, + * sends it to the annotation processor's messager, and also logs it using + * internal logging utilities at the appropriate level. + *

+ * + *

Example Usage

+ * 
+     * Messager messager = processingEnv.getMessager();
+     * printMessage(messager, Kind.ERROR, "Failed to process {0} elements", count);
+     *
+ * + * @param messager the messager to use for printing the message + * @param kind the kind of message to print (e.g., error, warning, note) + * @param pattern the message pattern to format (supports {@link String#format} syntax) + * @param args the arguments for the message pattern + */ + static void printMessage(Messager messager, Kind kind, String pattern, Object... args) { + String message = format(pattern, args); + messager.printMessage(kind, message); + switch (kind) { + case ERROR: + error(pattern, args); + break; + case WARNING: + case MANDATORY_WARNING: + warn(pattern, args); + break; + case NOTE: + info(pattern, args); + break; + default: + debug(pattern, args); + } + } +} diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/MethodUtils.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/MethodUtils.java new file mode 100644 index 000000000..925d3ee37 --- /dev/null +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/MethodUtils.java @@ -0,0 +1,1165 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.lang.model.util; + + +import io.microsphere.annotation.Immutable; +import io.microsphere.annotation.Nonnull; +import io.microsphere.annotation.Nullable; +import io.microsphere.util.Utils; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.TypeElement; +import javax.lang.model.element.VariableElement; +import javax.lang.model.type.TypeMirror; +import javax.lang.model.util.Elements; +import java.lang.reflect.Type; +import java.util.List; +import java.util.Objects; +import java.util.function.Predicate; + +import static io.microsphere.lang.model.util.ElementUtils.filterElements; +import static io.microsphere.lang.model.util.ElementUtils.isPublicNonStatic; +import static io.microsphere.lang.model.util.ElementUtils.matchParameterTypeNames; +import static io.microsphere.lang.model.util.ElementUtils.matchParameterTypes; +import static io.microsphere.lang.model.util.MemberUtils.getDeclaredMembers; +import static io.microsphere.lang.model.util.TypeUtils.isSameType; +import static io.microsphere.lang.model.util.TypeUtils.ofDeclaredType; +import static io.microsphere.collection.CollectionUtils.isEmpty; +import static io.microsphere.lang.function.Predicates.EMPTY_PREDICATE_ARRAY; +import static io.microsphere.lang.function.Predicates.and; +import static io.microsphere.lang.function.Streams.filterFirst; +import static io.microsphere.util.ArrayUtils.EMPTY_STRING_ARRAY; +import static io.microsphere.util.ArrayUtils.EMPTY_TYPE_ARRAY; +import static io.microsphere.util.ArrayUtils.isNotEmpty; +import static java.util.Collections.emptyList; +import static java.util.Collections.unmodifiableList; +import static java.util.stream.Collectors.toList; +import static javax.lang.model.element.ElementKind.METHOD; +import static javax.lang.model.util.ElementFilter.methodsIn; + +/** + * The utilities class for method in the package "javax.lang.model." + * + * @author Mercy + * @since 1.0.0 + */ +public interface MethodUtils extends Utils { + + /** + * Gets all declared methods of the specified {@link TypeElement}. + * + *

This method returns a list of methods directly declared in the given type element, + * excluding inherited methods. If the provided type element is {@code null}, an empty list is returned. + * + *

Example Usage

+ * 
{@code
+     * TypeElement typeElement = ...; // Obtain a valid TypeElement
+     * List methods = getDeclaredMethods(typeElement);
+     * for (ExecutableElement method : methods) {
+     *     System.out.println("Declared Method: " + method.getSimpleName());
+     * }
+     * }
+ * + * @param type the specified type element, may be null + * @return a list of executable elements representing all declared methods of the specified type, + * or an empty list if the input type is null + */ + @Nonnull + @Immutable + static List getDeclaredMethods(TypeElement type) { + return findDeclaredMethods(type, EMPTY_PREDICATE_ARRAY); + } + + /** + * Gets all declared methods of the specified {@link TypeMirror}. + * + *

This method returns a list of methods directly declared in the given type mirror, + * excluding inherited methods. If the provided type mirror is {@code null}, an empty list is returned. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror
+     * List methods = getDeclaredMethods(typeMirror);
+     * for (ExecutableElement method : methods) {
+     *     System.out.println("Declared Method: " + method.getSimpleName());
+     * }
+     * }
+ * + * @param type the specified type mirror, may be null + * @return a list of executable elements representing all declared methods of the specified type, + * or an empty list if the input type is null + */ + @Nonnull + @Immutable + static List getDeclaredMethods(TypeMirror type) { + return findDeclaredMethods(type, EMPTY_PREDICATE_ARRAY); + } + + /** + * Get all declared methods of the specified type element, including those inherited from superclasses and interfaces. + * + *

This method returns a list of methods directly declared in the given type element, including those + * inherited from superclasses and interfaces. If the provided type element is {@code null}, an empty list is returned. + * + *

Example Usage

+ * 
{@code
+     * TypeElement typeElement = ...; // Obtain a valid TypeElement
+     * List methods = getAllDeclaredMethods(typeElement);
+     * for (ExecutableElement method : methods) {
+     *     System.out.println("Declared Method (including inherited): " + method.getSimpleName());
+     * }
+     * }
+ * + * @param type the specified type element, may be null + * @return a list of executable elements representing all declared methods of the specified type, + * including those inherited from superclasses and interfaces, or an empty list if the input type is null + */ + @Nonnull + @Immutable + static List getAllDeclaredMethods(TypeElement type) { + return findAllDeclaredMethods(type, EMPTY_PREDICATE_ARRAY); + } + + /** + * Get all declared methods of the specified type mirror, including those inherited from superclasses and interfaces. + * + *

This method returns a list of methods directly declared in the given type mirror, including those + * inherited from superclasses and interfaces. If the provided type mirror is {@code null}, an empty list is returned. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror
+     * List methods = getAllDeclaredMethods(typeMirror);
+     * for (ExecutableElement method : methods) {
+     *     System.out.println("Declared Method (including inherited): " + method.getSimpleName());
+     * }
+     * }
+ * + * @param type the specified type mirror, may be null + * @return a list of executable elements representing all declared methods of the specified type, + * including those inherited from superclasses and interfaces, or an empty list if the input type is null + */ + @Nonnull + @Immutable + static List getAllDeclaredMethods(TypeMirror type) { + return findAllDeclaredMethods(type, EMPTY_PREDICATE_ARRAY); + } + + /** + * Find the declared methods of the specified {@link TypeElement}. + * + *

This method returns a list of methods directly declared in the given type element, + * excluding inherited methods. If the provided type element is {@code null}, an empty list is returned. + * Additional filters can be applied to narrow down the list of methods based on custom criteria. + * + *

Example Usage

+ * 
{@code
+     * TypeElement typeElement = ...; // Obtain a valid TypeElement
+     * List methods = findDeclaredMethods(typeElement);
+     * for (ExecutableElement method : methods) {
+     *     System.out.println("Declared Method: " + method.getSimpleName());
+     * }
+     * }
+ * + *

Filtering usage example: + * 

{@code
+     * List publicNonStaticMethods = findDeclaredMethods(typeElement, MethodUtils::isPublicNonStaticMethod);
+     * for (ExecutableElement method : publicNonStaticMethods) {
+     *     System.out.println("Public Non-Static Method: " + method.getSimpleName());
+     * }
+     * }
+ * + * @param type the specified type element, may be null + * @param methodFilters the filters for method elements + * @return a list of executable elements representing all declared methods of the specified type, + * or an empty list if the input type is null + */ + @Nonnull + @Immutable + static List findDeclaredMethods(TypeElement type, Predicate... methodFilters) { + return type == null ? emptyList() : findDeclaredMethods(type.asType(), methodFilters); + } + + /** + * Find the declared methods of the specified type mirror. + * + *

This method returns a list of methods directly declared in the given type mirror, + * excluding inherited methods. If the provided type mirror is {@code null}, an empty list is returned. + * Additional filters can be applied to narrow down the list of methods based on custom criteria. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror
+     * List methods = findDeclaredMethods(typeMirror);
+     * for (ExecutableElement method : methods) {
+     *     System.out.println("Declared Method: " + method.getSimpleName());
+     * }
+     * }
+ * + *

Filtering usage example: + * 

{@code
+     * List publicNonStaticMethods = findDeclaredMethods(typeMirror, MethodUtils::isPublicNonStaticMethod);
+     * for (ExecutableElement method : publicNonStaticMethods) {
+     *     System.out.println("Public Non-Static Method: " + method.getSimpleName());
+     * }
+     * }
+ * + * @param type the specified type mirror, may be null + * @param methodFilters the filters for method elements + * @return a list of executable elements representing all declared methods of the specified type, + * or an empty list if the input type is null + */ + @Nonnull + @Immutable + static List findDeclaredMethods(TypeMirror type, Predicate... methodFilters) { + return filterDeclaredMethods(type, false, methodFilters); + } + + /** + * Find all declared methods of the specified type element, including those inherited from superclasses and interfaces, + * and exclude methods declared in the specified excluded types. + * + *

Example Usage

+ * 
{@code
+     * TypeElement typeElement = ...; // Obtain a valid TypeElement
+     * List methods = findAllDeclaredMethods(typeElement);
+     * for (ExecutableElement method : methods) {
+     *     System.out.println("Declared Method (including inherited): " + method.getSimpleName());
+     * }
+     * }
+ * + *

Excluding methods from specific types: + * 

{@code
+     * List methodsExcludingObject = findAllDeclaredMethods(typeElement, Object.class);
+     * for (ExecutableElement method : methodsExcludingObject) {
+     *     System.out.println("Method excluding Object: " + method.getSimpleName());
+     * }
+     * }
+ * + * @param type the specified type element, may be null + * @param excludedTypes the types whose methods should be excluded from the result, optional + * @return a list of executable elements representing all declared methods of the specified type, + * including those inherited from superclasses and interfaces, but excluding those declared + * in the excluded types, or an empty list if the input type is null + */ + @Nonnull + @Immutable + static List findAllDeclaredMethods(TypeElement type, Type... excludedTypes) { + return type == null ? emptyList() : findAllDeclaredMethods(type.asType(), excludedTypes); + } + + /** + * Find all declared methods of the specified type mirror, including those inherited from superclasses and interfaces, + * and exclude methods declared in the specified excluded types. + * + *

This method returns a list of methods directly declared in the given type mirror, + * including those inherited from superclasses and interfaces. If the provided type mirror is {@code null}, + * an empty list is returned. Additional filtering can be applied to exclude methods declared in specific types. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror
+     * List methods = findAllDeclaredMethods(typeMirror);
+     * for (ExecutableElement method : methods) {
+     *     System.out.println("Declared Method (including inherited): " + method.getSimpleName());
+     * }
+     * }
+ * + *

Excluding methods from specific types: + * 

{@code
+     * List methodsExcludingObject = findAllDeclaredMethods(typeMirror, Object.class);
+     * for (ExecutableElement method : methodsExcludingObject) {
+     *     System.out.println("Method excluding Object: " + method.getSimpleName());
+     * }
+     * }
+ * + * @param type the specified type mirror, may be null + * @param excludedTypes the types whose methods should be excluded from the result, optional + * @return a list of executable elements representing all declared methods of the specified type, + * excluding those declared in the excluded types, or an empty list if the input type is null + */ + @Nonnull + @Immutable + static List findAllDeclaredMethods(TypeMirror type, Type... excludedTypes) { + if (type == null) { + return emptyList(); + } + return findAllDeclaredMethods(type, methodPredicateForExcludedTypes(excludedTypes)); + } + + /** + * Finds all public non-static methods declared in the specified {@link TypeElement}, excluding those inherited from superclasses or interfaces, + * and optionally excludes methods declared in the specified excluded types. + * + *

This method returns a list of executable elements representing public non-static methods directly declared in the given type element. + * If the provided type element is {@code null}, an empty list is returned. + * + *

Example Usage

+ * 
{@code
+     * TypeElement typeElement = ...; // Obtain a valid TypeElement
+     * List methods = findPublicNonStaticMethods(typeElement);
+     * for (ExecutableElement method : methods) {
+     *     System.out.println("Public Non-Static Method: " + method.getSimpleName());
+     * }
+     * }
+ * + *

Excluding methods from specific types: + * 

{@code
+     * List methodsExcludingObject = findPublicNonStaticMethods(typeElement, Object.class);
+     * for (ExecutableElement method : methodsExcludingObject) {
+     *     System.out.println("Public Non-Static Method (excluding Object): " + method.getSimpleName());
+     * }
+     * }
+ * + * @param type the specified type element, may be null + * @param excludedTypes the types whose methods should be excluded from the result, optional + * @return a list of executable elements representing all public non-static methods declared in the specified type, + * or an empty list if the input type is null + */ + @Nonnull + @Immutable + static List findPublicNonStaticMethods(TypeElement type, Type... excludedTypes) { + return type == null ? emptyList() : findPublicNonStaticMethods(ofDeclaredType(type), excludedTypes); + } + + /** + * Find all public non-static methods declared in the specified type mirror, excluding those inherited from superclasses or interfaces, + * and optionally exclude methods declared in the specified excluded types. + * + *

This method returns a list of executable elements representing public non-static methods directly declared in the given type. + * If the provided type is {@code null}, an empty list is returned. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror
+     * List methods = findPublicNonStaticMethods(typeMirror);
+     * for (ExecutableElement method : methods) {
+     *     System.out.println("Public Non-Static Method: " + method.getSimpleName());
+     * }
+     * }
+ * + *

Excluding methods from specific types: + * 

{@code
+     * List methodsExcludingObject = findPublicNonStaticMethods(typeMirror, Object.class);
+     * for (ExecutableElement method : methodsExcludingObject) {
+     *     System.out.println("Public Non-Static Method (excluding Object): " + method.getSimpleName());
+     * }
+     * }
+ * + * @param type the specified type mirror, may be null + * @param excludedTypes the types whose methods should be excluded from the result, optional + * @return a list of executable elements representing all public non-static methods declared in the specified type, + * excluding those declared in the excluded types, or an empty list if the input type is null + */ + @Nonnull + @Immutable + static List findPublicNonStaticMethods(TypeMirror type, Type... excludedTypes) { + if (type == null) { + return emptyList(); + } + + Predicate predicate = and(methodPredicateForExcludedTypes(excludedTypes), MethodUtils::isPublicNonStaticMethod); + + return findAllDeclaredMethods(type, predicate); + } + + /** + * Find all declared methods of the specified {@link TypeElement}, including those inherited from superclasses and interfaces, + * and optionally filter them using the provided predicates. + * + *

This method returns a list of methods directly declared in the given type element, + * including those inherited from superclasses and interfaces. If the provided type element is {@code null}, + * an empty list is returned. Additional filters can be applied to narrow down the list of methods based on custom criteria. + * + *

Example Usage

+ * 
{@code
+     * TypeElement typeElement = ...; // Obtain a valid TypeElement
+     * List methods = findAllDeclaredMethods(typeElement);
+     * for (ExecutableElement method : methods) {
+     *     System.out.println("Declared Method (including inherited): " + method.getSimpleName());
+     * }
+     * }
+ * + *

Filtering usage example: + * 

{@code
+     * List publicNonStaticMethods = findAllDeclaredMethods(typeElement, MethodUtils::isPublicNonStaticMethod);
+     * for (ExecutableElement method : publicNonStaticMethods) {
+     *     System.out.println("Public Non-Static Method: " + method.getSimpleName());
+     * }
+     * }
+ * + * @param type the specified type element, may be null + * @param methodFilters the filters for method elements, optional + * @return a list of executable elements representing all declared methods of the specified type, + * including those inherited from superclasses and interfaces, or an empty list if the input type is null + */ + @Nonnull + @Immutable + static List findAllDeclaredMethods(TypeElement type, Predicate... methodFilters) { + return type == null ? emptyList() : findAllDeclaredMethods(type.asType(), methodFilters); + } + + /** + * Finds all declared methods of the specified type mirror, including those inherited from superclasses and interfaces, + * and optionally filters them using the provided predicates. + * + *

This method returns a list of methods directly declared in the given type mirror, including those + * inherited from superclasses and interfaces. If the provided type mirror is {@code null}, an empty list is returned. + * Additional filters can be applied to narrow down the list of methods based on custom criteria. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror
+     * List methods = findAllDeclaredMethods(typeMirror);
+     * for (ExecutableElement method : methods) {
+     *     System.out.println("Declared Method (including inherited): " + method.getSimpleName());
+     * }
+     * }
+ * + *

Filtering usage example: + * 

{@code
+     * List publicNonStaticMethods = findAllDeclaredMethods(typeMirror, MethodUtils::isPublicNonStaticMethod);
+     * for (ExecutableElement method : publicNonStaticMethods) {
+     *     System.out.println("Public Non-Static Method: " + method.getSimpleName());
+     * }
+     * }
+ * + * @param type the specified type mirror, may be null + * @param methodFilters the filters for method elements, optional + * @return a list of executable elements representing all declared methods of the specified type, + * including those inherited from superclasses and interfaces, or an empty list if the input type is null + */ + @Nonnull + @Immutable + static List findAllDeclaredMethods(TypeMirror type, Predicate... methodFilters) { + return filterDeclaredMethods(type, true, methodFilters); + } + + /** + * Filters the declared methods of the specified type based on the given predicates. + * + *

This method returns a list of methods directly declared in the given type, + * optionally including those inherited from superclasses and interfaces. If the provided type is {@code null}, + * an empty list is returned. Additional filters can be applied to narrow down the list of methods based on custom criteria. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror
+     * List methods = filterDeclaredMethods(typeMirror, false);
+     * for (ExecutableElement method : methods) {
+     *     System.out.println("Declared Method: " + method.getSimpleName());
+     * }
+     * }
+ * + *

Filtering usage example: + * 

{@code
+     * List publicNonStaticMethods = filterDeclaredMethods(typeMirror, false, MethodUtils::isPublicNonStaticMethod);
+     * for (ExecutableElement method : publicNonStaticMethods) {
+     *     System.out.println("Public Non-Static Method: " + method.getSimpleName());
+     * }
+     * }
+ * + * @param type the type whose declared methods are to be filtered, may be null + * @param includeHierarchicalTypes whether to include methods from superclasses and interfaces + * @param methodFilters the predicates used to filter the methods, optional + * @return a list of executable elements representing the filtered methods, + * or an empty list if the input type is null or no methods match the filters + */ + @Nonnull + @Immutable + static List filterDeclaredMethods(TypeMirror type, boolean includeHierarchicalTypes, Predicate... methodFilters) { + if (type == null) { + return emptyList(); + } + + List declaredMembers = getDeclaredMembers(type, includeHierarchicalTypes); + if (isEmpty(declaredMembers)) { + return emptyList(); + } + + List methods = methodsIn(declaredMembers); + + return filterElements(methods, methodFilters); + } + + /** + * Checks if the given executable element is a method. + * + *

This method determines whether the provided executable element represents a method. + * If the element is {@code null}, the method returns {@code false}. + * + *

Example Usage

+ * 
{@code
+     * ExecutableElement executableElement = ...; // Obtain a valid ExecutableElement
+     * boolean isMethod = MethodUtils.isMethod(executableElement);
+     * if (isMethod) {
+     *     System.out.println("The element is a method.");
+     * } else {
+     *     System.out.println("The element is not a method.");
+     * }
+     * }
+ * + * @param method the executable element to check, may be null + * @return true if the element is a method, false otherwise + */ + static boolean isMethod(ExecutableElement method) { + return method != null && METHOD.equals(method.getKind()); + } + + /** + * Checks whether the given method is a public non-static method. + * + *

This method verifies if the provided executable element represents a method that is both public and non-static. + * If the method is {@code null}, the method returns {@code false}. + * + *

Example Usage

+ * 
{@code
+     * ExecutableElement method = ...; // Obtain a valid ExecutableElement
+     * boolean isPublicNonStatic = MethodUtils.isPublicNonStaticMethod(method);
+     * if (isPublicNonStatic) {
+     *     System.out.println("The method is a public non-static method.");
+     * } else {
+     *     System.out.println("The method is not a public non-static method.");
+     * }
+     * }
+ * + * @param method the executable element to check, may be null + * @return true if the method is a public non-static method, false otherwise + */ + static boolean isPublicNonStaticMethod(ExecutableElement method) { + return isMethod(method) && isPublicNonStatic(method); + } + + /** + * Finds a method with the specified name in the given type element, using an empty parameter type array as default. + * + *

This method searches for a method with the specified name in the given type element. + * If no method with the specified name is found, it returns {@code null}. + * The search considers methods declared directly in the type, excluding inherited methods. + * + *

Example Usage

+ * 
{@code
+     * TypeElement typeElement = ...; // Obtain a valid TypeElement
+     * String methodName = "myMethod";
+     * ExecutableElement method = MethodUtils.findMethod(typeElement, methodName);
+     *
+     * if (method != null) {
+     *     System.out.println("Found method: " + method.getSimpleName());
+     * } else {
+     *     System.out.println("Method not found.");
+     * }
+     * }
+ * + * @param type the type element to search for the method + * @param methodName the name of the method to find + * @return the first matching executable element representing the method, or null if none is found + */ + @Nullable + static ExecutableElement findMethod(TypeElement type, String methodName) { + return findMethod(type, methodName, EMPTY_TYPE_ARRAY); + } + + /** + * Finds a method with the specified name in the given type mirror, using an empty parameter type array as default. + * + *

This method searches for a method with the specified name in the given type mirror. + * If no method with the specified name is found, it returns {@code null}. + * The search considers methods declared directly in the type, excluding inherited methods. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror
+     * String methodName = "myMethod";
+     * ExecutableElement method = MethodUtils.findMethod(typeMirror, methodName);
+     *
+     * if (method != null) {
+     *     System.out.println("Found method: " + method.getSimpleName());
+     * } else {
+     *     System.out.println("Method not found.");
+     * }
+     * }
+ * + * @param type the type mirror to search for the method + * @param methodName the name of the method to find + * @return the first matching executable element representing the method, or null if none is found + */ + @Nullable + static ExecutableElement findMethod(TypeMirror type, String methodName) { + return findMethod(type, methodName, EMPTY_TYPE_ARRAY); + } + + /** + * Finds a method with the specified name and parameter types in the given {@link TypeElement}. + * + *

This method searches for a method with the specified name and exact parameter types + * directly declared in the provided type element, excluding inherited methods. + * If no matching method is found, it returns {@code null}. + * + *

Example Usage

+ * 
{@code
+     * TypeElement typeElement = ...; // Obtain a valid TypeElement
+     * String methodName = "myMethod";
+     * Type[] parameterTypes = new Type[] { String.class, int.class };
+     * ExecutableElement method = MethodUtils.findMethod(typeElement, methodName, parameterTypes);
+     *
+     * if (method != null) {
+     *     System.out.println("Found method: " + method.getSimpleName());
+     * } else {
+     *     System.out.println("Method not found.");
+     * }
+     * }
+ * + * @param type the specified type element, may be null + * @param methodName the name of the method to find, must not be null + * @param parameterTypes the parameter types of the method to match, must not be null + * @return the first matching executable element representing the method, or null if none is found + */ + @Nullable + static ExecutableElement findMethod(TypeElement type, String methodName, Type... parameterTypes) { + return type == null ? null : findMethod(type.asType(), methodName, parameterTypes); + } + + /** + * Finds a method with the specified name and parameter types in the given type mirror. + * + *

This method searches for a method with the specified name and exact parameter types + * directly declared in the provided type mirror, excluding inherited methods. + * If no matching method is found, it returns {@code null}. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror
+     * String methodName = "myMethod";
+     * Type[] parameterTypes = new Type[] { String.class, int.class };
+     * ExecutableElement method = MethodUtils.findMethod(typeMirror, methodName, parameterTypes);
+     *
+     * if (method != null) {
+     *     System.out.println("Found method: " + method.getSimpleName());
+     * }
+     * }
+ * + * @param type the type mirror to search for the method, may be null + * @param methodName the name of the method to find, must not be null + * @param parameterTypes the parameter types of the method to match, must not be null + * @return the first matching executable element representing the method, or null if none is found + */ + @Nullable + static ExecutableElement findMethod(TypeMirror type, String methodName, Type... parameterTypes) { + if (type == null || methodName == null || parameterTypes == null) { + return null; + } + List allDeclaredMethods = findAllDeclaredMethods(type, method -> matches(method, methodName, parameterTypes)); + return allDeclaredMethods.isEmpty() ? null : allDeclaredMethods.get(0); + } + + /** + * Finds a method with the specified name and parameter type names in the given {@link TypeElement}. + * + *

This method searches for a method with the specified name and exact parameter type names + * directly declared in the provided type element, excluding inherited methods. + * If no matching method is found, it returns {@code null}. + * + *

Example Usage

+ * 
{@code
+     * TypeElement typeElement = ...; // Obtain a valid TypeElement
+     * String methodName = "myMethod";
+     * CharSequence[] paramTypeNames = new CharSequence[] { "java.lang.String", "int" };
+     * ExecutableElement method = MethodUtils.findMethod(typeElement, methodName, paramTypeNames);
+     *
+     * if (method != null) {
+     *     System.out.println("Found method: " + method.getSimpleName());
+     * } else {
+     *     System.out.println("Method not found.");
+     * }
+     * }
+ * + * @param type the type element to search for the method, may be null + * @param methodName the name of the method to find, must not be null + * @param parameterTypeNames the names of the parameter types of the method to match, must not be null + * @return the first matching executable element representing the method, or null if none is found + */ + @Nullable + static ExecutableElement findMethod(TypeElement type, String methodName, CharSequence... parameterTypeNames) { + return type == null ? null : findMethod(type.asType(), methodName, parameterTypeNames); + } + + /** + * Finds a method with the specified name and parameter type names in the given type mirror. + * + *

This method searches for a method with the specified name and exact parameter type names + * directly declared in the provided type mirror, excluding inherited methods. + * If no matching method is found, it returns {@code null}. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror typeMirror = ...; // Obtain a valid TypeMirror
+     * String methodName = "myMethod";
+     * CharSequence[] paramTypeNames = new CharSequence[] { "java.lang.String", "int" };
+     * ExecutableElement method = MethodUtils.findMethod(typeMirror, methodName, paramTypeNames);
+     *
+     * if (method != null) {
+     *     System.out.println("Found method: " + method.getSimpleName());
+     * }
+     * }
+ * + * @param type the type mirror to search for the method, may be null + * @param methodName the name of the method to find, must not be null + * @param parameterTypeNames the names of the parameter types of the method to match, must not be null + * @return the first matching executable element representing the method, or null if none is found + */ + @Nullable + static ExecutableElement findMethod(TypeMirror type, String methodName, CharSequence... parameterTypeNames) { + if (type == null || methodName == null || parameterTypeNames == null) { + return null; + } + List allDeclaredMethods = findAllDeclaredMethods(type, method -> matches(method, methodName, parameterTypeNames)); + return allDeclaredMethods.isEmpty() ? null : allDeclaredMethods.get(0); + } + + /** + * Finds the overridden method in the specified type that corresponds to the given declaring method. + * + *

This method searches for a method in the provided type element that overrides the specified + * declaring method. It utilizes the processing environment to determine method overriding using + * the {@link Elements#overrides(ExecutableElement, ExecutableElement, TypeElement)} method. + * + *

Example Usage

+ * 
{@code
+     * ProcessingEnvironment processingEnv = ...; // Obtain a valid ProcessingEnvironment
+     * TypeElement typeElement = ...; // The type in which to find the overridden method
+     * ExecutableElement declaringMethod = ...; // The method being overridden
+     *
+     * ExecutableElement overriddenMethod = getOverrideMethod(processingEnv, typeElement, declaringMethod);
+     *
+     * if (overriddenMethod != null) {
+     *     System.out.println("Overridden Method Found: " + overriddenMethod.getSimpleName());
+     * } else {
+     *     System.out.println("No overridden method found.");
+     * }
+     * }
+ * + * @param processingEnv the processing environment used to determine overriding + * @param type the type element in which to search for the overridden method + * @param declaringMethod the method element whose override is to be found + * @return the overridden method in the specified type, or null if no such method exists + */ + @Nullable + static ExecutableElement getOverrideMethod(ProcessingEnvironment processingEnv, TypeElement type, ExecutableElement declaringMethod) { + Elements elements = processingEnv.getElementUtils(); + return filterFirst(getAllDeclaredMethods(type), method -> elements.overrides(method, declaringMethod, type)); + } + + /** + * Filters the given list of executable elements (methods) based on the provided predicates. + * + *

This method applies a set of filtering predicates to a list of methods and returns a new list + * containing only the methods that satisfy all the provided conditions. If no method matches, + * an empty list is returned. If no filters are provided, the original list is returned unchanged. + * + *

Example Usage

+ * 
{@code
+     * List methods = MethodUtils.getDeclaredMethods(typeElement);
+     * List publicNonStaticMethods = MethodUtils.filterMethods(methods, MethodUtils::isPublicNonStaticMethod);
+     *
+     * for (ExecutableElement method : publicNonStaticMethods) {
+     *     System.out.println("Public Non-Static Method: " + method.getSimpleName());
+     * }
+     * }
+ * + *

Multiple filters can be combined: + * 

{@code
+     * Predicate isPublic = method -> method.getModifiers().contains(Modifier.PUBLIC);
+     * Predicate isVoidReturnType = method -> "void".equals(TypeUtils.toString(method.getReturnType()));
+     *
+     * List filteredMethods = MethodUtils.filterMethods(methods, isPublic, isVoidReturnType);
+     * for (ExecutableElement method : filteredMethods) {
+     *     System.out.println("Public Method with Void Return Type: " + method.getSimpleName());
+     * }
+     * }
+ * + * @param methods the list of executable elements (methods) to be filtered + * @param methodFilters the array of predicates used for filtering the methods + * @return a filtered list of executable elements matching all the provided predicates, + * or an empty list if the input list is null or empty, or no methods match the filters + */ + @Nonnull + @Immutable + static List filterMethods(List methods, Predicate... methodFilters) { + if (isEmpty(methods)) { + return emptyList(); + } + + List filteredMethods = methods; + if (isNotEmpty(methodFilters)) { + Predicate combinedPredicate = and(methodFilters); + filteredMethods = methods.stream() + .filter(combinedPredicate) + .collect(toList()); + } + + return filteredMethods.isEmpty() ? emptyList() : unmodifiableList(filteredMethods); + } + + /** + * Gets the simple name of the method as a string. + * + *

If the provided method is null, this method returns null. + * Otherwise, it returns the simple name of the method as a string. + * + *

Example Usage

+ * 
{@code
+     * ExecutableElement method = ...; // Obtain a valid ExecutableElement representing a method
+     * String methodName = MethodUtils.getMethodName(method);
+     * if (methodName != null) {
+     *     System.out.println("Method Name: " + methodName);
+     * } else {
+     *     System.out.println("Method is null.");
+     * }
+     * }
+ * + * @param method the executable element representing the method, may be null + * @return the simple name of the method as a string, or null if the method is null + */ + @Nullable + static String getMethodName(ExecutableElement method) { + return method == null ? null : method.getSimpleName().toString(); + } + + /** + * Gets the return type name of the given method. + * + *

If the provided method is null, this method returns null. + * Otherwise, it returns the fully qualified name of the method's return type. + * + *

Example Usage

+ * 
{@code
+     * ExecutableElement method = ...; // Obtain a valid ExecutableElement representing a method
+     * String returnTypeName = MethodUtils.getReturnTypeName(method);
+     * if (returnTypeName != null) {
+     *     System.out.println("Return Type Name: " + returnTypeName);
+     * } else {
+     *     System.out.println("Method is null or has no return type.");
+     * }
+     * }
+ * + * @param method the executable element representing the method, may be null + * @return the fully qualified name of the method's return type as a string, or null if the method is null + */ + @Nullable + static String getReturnTypeName(ExecutableElement method) { + return method == null ? null : TypeUtils.toString(method.getReturnType()); + } + + /** + * Gets the parameter type mirrors of the given method. + * + *

This method returns a list of type mirrors representing the parameter types of the provided method. + * If the method is {@code null} or has no parameters, an empty list is returned. + * + *

Example Usage

+ * 
{@code
+     * ExecutableElement method = ...; // Obtain a valid ExecutableElement representing a method
+     * List parameterTypeMirrors = MethodUtils.getMethodParameterTypeMirrors(method);
+     *
+     * if (!parameterTypeMirrors.isEmpty()) {
+     *     for (TypeMirror typeMirror : parameterTypeMirrors) {
+     *         System.out.println("Parameter Type: " + TypeUtils.toString(typeMirror));
+     *     }
+     * } else {
+     *     System.out.println("Method is null or has no parameters.");
+     * }
+     * }
+ * + * @param method the executable element representing the method, may be null + * @return a list of type mirrors representing the parameter types of the method, + * or an empty list if the method is null or has no parameters + */ + @Nonnull + @Immutable + static List getMethodParameterTypeMirrors(ExecutableElement method) { + if (method == null) { + return emptyList(); + } + + List parameters = method.getParameters(); + if (parameters.isEmpty()) { + return emptyList(); + } + + List parameterTypes = parameters.stream() + .map(VariableElement::asType) + .collect(toList()); + + return unmodifiableList(parameterTypes); + } + + /** + * Gets the parameter type names of the given method. + * + *

This method returns an array of strings representing the fully qualified names + * of the parameter types of the provided method. If the method is {@code null} or has no parameters, + * an empty array is returned. + * + *

Example Usage

+ * 
{@code
+     * ExecutableElement method = ...; // Obtain a valid ExecutableElement representing a method
+     * String[] parameterTypeNames = MethodUtils.getMethodParameterTypeNames(method);
+     *
+     * if (parameterTypeNames.length > 0) {
+     *     for (String typeName : parameterTypeNames) {
+     *         System.out.println("Parameter Type: " + typeName);
+     *     }
+     * } else {
+     *     System.out.println("Method is null or has no parameters.");
+     * }
+     * }
+ * + * @param method the executable element representing the method, may be null + * @return an array of strings representing the fully qualified names of the parameter types, + * or an empty array if the method is null or has no parameters + */ + static String[] getMethodParameterTypeNames(ExecutableElement method) { + List parameterTypes = getMethodParameterTypeMirrors(method); + return parameterTypes.isEmpty() ? EMPTY_STRING_ARRAY : + parameterTypes.stream().map(TypeUtils::toString).toArray(String[]::new); + } + + /** + * Checks if the given method matches the specified method name and parameter types. + * + *

This method determines whether the provided executable element (method) has the same name + * and parameter types as specified. If the method is null or any of the parameters are null, + * the result will be false. + * + *

Example Usage

+ * 
{@code
+     * ExecutableElement method = ...; // Obtain a valid ExecutableElement
+     * boolean isMatch = matches(method, "myMethod", String.class, int.class);
+     * if (isMatch) {
+     *     System.out.println("The method matches the specified name and parameter types.");
+     * } else {
+     *     System.out.println("The method does not match.");
+     * }
+     * }
+ * + * @param method the executable element representing the method to check + * @param methodName the name of the method to match + * @param parameterTypes the parameter types of the method to match + * @return true if the method matches the given name and parameter types, false otherwise + */ + static boolean matches(ExecutableElement method, String methodName, Type... parameterTypes) { + return matchesMethod(method, methodName, parameterTypes); + } + + /** + * Checks if the given method matches the specified method name and parameter type names. + * + *

This method determines whether the provided executable element (method) has the same name + * and parameter type names as specified. If the method is null or any of the parameters are null, + * the result will be false. + * + *

Example Usage

+ * 
{@code
+     * ExecutableElement method = ...; // Obtain a valid ExecutableElement
+     * boolean isMatch = matches(method, "myMethod", "java.lang.String", "int");
+     * if (isMatch) {
+     *     System.out.println("The method matches the specified name and parameter type names.");
+     * } else {
+     *     System.out.println("The method does not match.");
+     * }
+     * }
+ * + * @param method the executable element representing the method to check + * @param methodName the name of the method to match + * @param parameterTypeNames the names of the parameter types to match + * @return true if the method matches the given name and parameter type names, false otherwise + */ + static boolean matches(ExecutableElement method, String methodName, CharSequence... parameterTypeNames) { + return matchesMethod(method, methodName, parameterTypeNames); + } + + /** + * Checks if the given method has the specified method name. + * + *

This method compares the simple name of the provided executable element (method) + * with the given method name. If either the method or the method name is {@code null}, + * the comparison is performed using {@link Objects#equals(Object, Object)}. + * + *

Example Usage

+ * 
{@code
+     * ExecutableElement method = ...; // Obtain a valid ExecutableElement
+     * boolean isMatch = MethodUtils.matchesMethodName(method, "myMethod");
+     *
+     * if (isMatch) {
+     *     System.out.println("The method name matches.");
+     * } else {
+     *     System.out.println("The method name does not match.");
+     * }
+     * }
+ * + * @param method the executable element representing the method to check + * @param methodName the name of the method to match, may be null + * @return true if the method's name matches the given method name, false otherwise + */ + static boolean matchesMethodName(ExecutableElement method, String methodName) { + return Objects.equals(getMethodName(method), methodName); + } + + /** + * Checks if the given method matches the specified method name and parameter types. + * + *

This method determines whether the provided executable element (method) has the same name + * and parameter types as specified. If the method is null or any of the parameters are null, + * the result will be false. + * + *

Example Usage

+ * 
{@code
+     * ExecutableElement method = ...; // Obtain a valid ExecutableElement
+     * boolean isMatch = MethodUtils.matchesMethod(method, "myMethod", String.class, int.class);
+     * if (isMatch) {
+     *     System.out.println("The method matches the specified name and parameter types.");
+     * } else {
+     *     System.out.println("The method does not match.");
+     * }
+     * }
+ * + * @param method the executable element representing the method to check + * @param methodName the name of the method to match + * @param parameterTypes the parameter types of the method to match + * @return true if the method matches the given name and parameter types, false otherwise + */ + static boolean matchesMethod(ExecutableElement method, String methodName, Type... parameterTypes) { + if (method == null || methodName == null || parameterTypes == null) { + return false; + } + + // Check if the method name matches + if (!matchesMethodName(method, methodName)) { + return false; + } + + // Check if the parameter types match + if (!matchParameterTypes(method, parameterTypes)) { + return false; + } + + return true; + } + + /** + * Checks if the given method matches the specified method name and parameter type names. + * + *

This method determines whether the provided executable element (method) has the same name + * and parameter type names as specified. If the method is null or any of the parameters are null, + * the result will be false. + * + *

Example Usage

+ * 
{@code
+     * ExecutableElement method = ...; // Obtain a valid ExecutableElement
+     * boolean isMatch = MethodUtils.matchesMethod(method, "myMethod", "java.lang.String", "int");
+     * if (isMatch) {
+     *     System.out.println("The method matches the specified name and parameter type names.");
+     * } else {
+     *     System.out.println("The method does not match.");
+     * }
+     * }
+ * + * @param method the executable element representing the method to check + * @param methodName the name of the method to match + * @param parameterTypeNames the names of the parameter types to match + * @return true if the method matches the given name and parameter type names, false otherwise + */ + static boolean matchesMethod(ExecutableElement method, String methodName, CharSequence... parameterTypeNames) { + if (method == null || methodName == null || parameterTypeNames == null) { + return false; + } + + // matches the name of method + if (!Objects.equals(getMethodName(method), methodName)) { + return false; + } + + if (!matchParameterTypeNames(method.getParameters(), parameterTypeNames)) { + return false; + } + + return true; + } + + /** + * Returns the enclosing element of the given executable method. + * + *

This method retrieves the element that directly encloses the provided method. + * If the method is {@code null}, the method returns {@code null}. + * + *

Example Usage

+ * 
{@code
+     * ExecutableElement method = ...; // Obtain a valid ExecutableElement
+     * Element enclosingElement = MethodUtils.getEnclosingElement(method);
+     * if (enclosingElement != null) {
+     *     System.out.println("Enclosing Element: " + enclosingElement.getSimpleName());
+     * } else {
+     *     System.out.println("Method is null or has no enclosing element.");
+     * }
+     * }
+ * + * @param method the executable element representing the method, may be null + * @return the enclosing element of the method, or null if the method is null + */ + @Nullable + static Element getEnclosingElement(ExecutableElement method) { + return method == null ? null : method.getEnclosingElement(); + } + + /** + * Creates a predicate that filters out methods declared in the specified excluded types. + * + *

This predicate can be used to exclude methods that are declared in certain types, + * such as standard Java types like {@link Object}, when searching or filtering through methods. + * If no excluded types are provided, the predicate will allow all methods. + * + *

Example Usage

+ * 
{@code
+     * Predicate excludeObjectMethods = methodPredicateForExcludedTypes(Object.class);
+     * List filteredMethods = findDeclaredMethods(typeMirror, excludeObjectMethods);
+     *
+     * for (ExecutableElement method : filteredMethods) {
+     *     System.out.println("Filtered Method: " + method.getSimpleName());
+     * }
+     * }
+ * + * @param excludedTypes the types whose methods should be excluded from the result, optional + * @return a predicate that returns {@code true} for methods not declared in any of the excluded types + */ + @Nonnull + static Predicate methodPredicateForExcludedTypes(Type... excludedTypes) { + return method -> { + boolean excluded = true; + Element declaredType = getEnclosingElement(method); + for (Type excludedType : excludedTypes) { + if (isSameType(declaredType, excludedType)) { + excluded = false; + break; + } + } + return excluded; + }; + } +} diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ResolvableAnnotationValueVisitor.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ResolvableAnnotationValueVisitor.java new file mode 100644 index 000000000..7a4653fe8 --- /dev/null +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ResolvableAnnotationValueVisitor.java @@ -0,0 +1,200 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.lang.model.util; + +import javax.lang.model.element.AnnotationMirror; +import javax.lang.model.element.AnnotationValue; +import javax.lang.model.element.AnnotationValueVisitor; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.VariableElement; +import javax.lang.model.type.ArrayType; +import javax.lang.model.type.TypeMirror; +import javax.lang.model.util.SimpleAnnotationValueVisitor6; +import java.lang.reflect.Method; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; + +import static io.microsphere.lang.model.util.AnnotationUtils.getAttributeName; +import static io.microsphere.lang.model.util.AnnotationUtils.getElementValues; +import static io.microsphere.lang.model.util.ClassUtils.loadClass; +import static io.microsphere.collection.MapUtils.newFixedLinkedHashMap; +import static io.microsphere.reflect.MethodUtils.findMethod; +import static io.microsphere.reflect.MethodUtils.invokeStaticMethod; +import static io.microsphere.util.ArrayUtils.newArray; +import static io.microsphere.util.ClassLoaderUtils.resolveClass; +import static java.lang.Enum.valueOf; +import static java.lang.reflect.Array.set; + +/** + * A visitor for resolving annotation values into their corresponding runtime representations. + * + *

This class extends {@link SimpleAnnotationValueVisitor6} to process annotation values and convert + * them into appropriate Java objects such as primitives, strings, enums, classes, annotations, and arrays. + * + *

Example Usage

+ * 
{@code
+ * // Create an instance with default settings
+ * ResolvableAnnotationValueVisitor visitor = new ResolvableAnnotationValueVisitor();
+ *
+ * // Visit an annotation value
+ * AnnotationValue annotationValue = ...; // Obtain from an annotation mirror
+ * Object resolvedValue = annotationValue.accept(visitor, executableElement);
+ * }
+ * + *

Custom behavior examples

+ * 
{@code
+ * // Create an instance that represents Class values as strings
+ * ResolvableAnnotationValueVisitor visitor = new ResolvableAnnotationValueVisitor(true);
+ *
+ * // Create an instance that handles nested annotations as maps
+ * ResolvableAnnotationValueVisitor visitor = new ResolvableAnnotationValueVisitor(false, true);
+ * }
+ * + * @author Mercy + * @see AnnotationValueVisitor + * @since 1.0.0 + */ +public class ResolvableAnnotationValueVisitor extends SimpleAnnotationValueVisitor6 { + + private static final Class ANNOTATION_PARSER_CLASS = resolveClass("sun.reflect.annotation.AnnotationParser"); + + private static final Method annotationForMapMethod = findMethod(ANNOTATION_PARSER_CLASS, "annotationForMap", Class.class, Map.class); + + private static final boolean DEFAULT_CLASS_VALUES_AS_STRING = false; + + private static final boolean DEFAULT_NESTED_ANNOTATIONS_AS_MAP = false; + + private final boolean classValuesAsString; + + private final boolean nestedAnnotationsAsMap; + + public ResolvableAnnotationValueVisitor() { + this(DEFAULT_CLASS_VALUES_AS_STRING, DEFAULT_NESTED_ANNOTATIONS_AS_MAP); + } + + public ResolvableAnnotationValueVisitor(boolean classValuesAsString) { + this(classValuesAsString, DEFAULT_NESTED_ANNOTATIONS_AS_MAP); + } + + public ResolvableAnnotationValueVisitor(boolean classValuesAsString, boolean nestedAnnotationsAsMap) { + this.classValuesAsString = classValuesAsString; + this.nestedAnnotationsAsMap = nestedAnnotationsAsMap; + } + + @Override + public Object visitBoolean(boolean b, ExecutableElement attributeMethod) { + return b; + } + + @Override + public Object visitByte(byte b, ExecutableElement attributeMethod) { + return b; + } + + @Override + public Object visitChar(char c, ExecutableElement attributeMethod) { + return c; + } + + @Override + public Object visitDouble(double d, ExecutableElement attributeMethod) { + return d; + } + + @Override + public Object visitFloat(float f, ExecutableElement attributeMethod) { + return f; + } + + @Override + public Object visitInt(int i, ExecutableElement attributeMethod) { + return i; + } + + @Override + public Object visitLong(long i, ExecutableElement attributeMethod) { + return i; + } + + @Override + public Object visitShort(short s, ExecutableElement attributeMethod) { + return s; + } + + @Override + public Object visitString(String s, ExecutableElement attributeMethod) { + return s; + } + + @Override + public Object visitType(TypeMirror t, ExecutableElement attributeMethod) { + return classValuesAsString ? t.toString() : loadClass(t); + } + + @Override + public Object visitEnumConstant(VariableElement c, ExecutableElement attributeMethod) { + Class enumClass = loadClass(c.asType()); + return valueOf(enumClass, c.toString()); + } + + @Override + public Object visitAnnotation(AnnotationMirror a, ExecutableElement attributeMethod) { + Map elementValues = getElementValues(a); + Map attributesMap = newFixedLinkedHashMap(elementValues.size()); + for (Entry entry : elementValues.entrySet()) { + ExecutableElement method = entry.getKey(); + String attributeName = getAttributeName(method); + Object attributeValue = entry.getValue().accept(this, method); + attributesMap.put(attributeName, attributeValue); + } + + if (nestedAnnotationsAsMap) { + return attributesMap; + } + + Class annotationClass = loadClass(a.getAnnotationType()); + return invokeStaticMethod(annotationForMapMethod, annotationClass, attributesMap); + } + + @Override + public Object visitArray(List values, ExecutableElement attributeMethod) { + int size = values.size(); + Class componentType = getComponentType(attributeMethod); + Object array = newArray(componentType, size); + for (int i = 0; i < size; i++) { + AnnotationValue value = values.get(i); + Object attributeValue = value.accept(this, attributeMethod); + set(array, i, attributeValue); + } + return array; + } + + Class getComponentType(ExecutableElement attributeMethod) { + if (classValuesAsString) { + return String.class; + } + ArrayType arrayType = (ArrayType) attributeMethod.getReturnType(); + return loadClass(arrayType.getComponentType()); + } + + @Override + public Object visitUnknown(AnnotationValue av, ExecutableElement attributeMethod) { + return av; + } +} diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/TypeUtils.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/TypeUtils.java new file mode 100644 index 000000000..06692f441 --- /dev/null +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/TypeUtils.java @@ -0,0 +1,2505 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.lang.model.util; + +import io.microsphere.annotation.Immutable; +import io.microsphere.annotation.Nonnull; +import io.microsphere.annotation.Nullable; +import io.microsphere.util.TypeFinder; +import io.microsphere.util.Utils; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; +import javax.lang.model.element.TypeParameterElement; +import javax.lang.model.type.DeclaredType; +import javax.lang.model.type.TypeMirror; +import javax.lang.model.util.Elements; +import java.lang.reflect.Type; +import java.util.Collection; +import java.util.List; +import java.util.Objects; +import java.util.function.Function; +import java.util.function.Predicate; + +import static io.microsphere.collection.CollectionUtils.isEmpty; +import static io.microsphere.collection.Lists.ofList; +import static io.microsphere.constants.SymbolConstants.GREATER_THAN_CHAR; +import static io.microsphere.constants.SymbolConstants.LESS_THAN_CHAR; +import static io.microsphere.lang.function.Predicates.EMPTY_PREDICATE_ARRAY; +import static io.microsphere.lang.function.Predicates.and; +import static io.microsphere.lang.function.Streams.filterFirst; +import static io.microsphere.reflect.MethodUtils.invokeMethod; +import static io.microsphere.reflect.TypeUtils.getTypeNames; +import static io.microsphere.util.ArrayUtils.contains; +import static io.microsphere.util.ArrayUtils.isEmpty; +import static io.microsphere.util.Assert.assertNoNullElements; +import static io.microsphere.util.ClassUtils.SIMPLE_TYPES; +import static java.lang.String.valueOf; +import static java.util.Collections.emptyList; +import static java.util.Collections.unmodifiableList; +import static java.util.stream.Collectors.toList; +import static java.util.stream.Stream.of; +import static javax.lang.model.element.ElementKind.ANNOTATION_TYPE; +import static javax.lang.model.element.ElementKind.CLASS; +import static javax.lang.model.element.ElementKind.ENUM; +import static javax.lang.model.element.ElementKind.INTERFACE; +import static javax.lang.model.type.TypeKind.ARRAY; + +/** + * The utilities class for type in the package "javax.lang.model.*" + * + * @author Mercy + * @since 1.0.0 + */ +public interface TypeUtils extends Utils { + + /** + * A list of names representing simple types in Java. + * Simple types include primitive types, void, and commonly used basic classes like String, Number, etc. + */ + @Nonnull + @Immutable + List SIMPLE_TYPE_NAMES = ofList( + SIMPLE_TYPES + .stream() + .map(Class::getName) + .toArray(String[]::new) + ); + + /** + * Get the superclass of the specified type + */ + @Nonnull + Function TYPE_ELEMENT_GET_SUPERCLASS = type -> ofTypeElement(type.getSuperclass()); + + /** + * Get the interfaces of the specified type + */ + @Nonnull + Function TYPE_ELEMENT_GET_INTERFACES = type -> type.getInterfaces() + .stream() + .map(TypeUtils::ofTypeElement) + .toArray(TypeElement[]::new); + + + /** + * Checks if the given Element represents a simple type. + * A simple type is defined as a basic data type that can be directly represented without further resolution. + * + *

+ * Examples of simple types include primitive types (e.g., int, boolean), + * built-in types like void, and commonly used basic classes like String or Number. + *

+ * + *

Example Usage

+ * 
{@code
+     * Element intElement = ...; // represents 'int'
+     * boolean isSimple = TypeUtils.isSimpleType(intElement); // returns true
+     *
+     * Element customClassElement = ...; // represents a custom class like 'MyClass'
+     * boolean isSimple = TypeUtils.isSimpleType(customClassElement); // returns false
+     * }
+ * + * @param element the element to check, may be null + * @return true if the element is a simple type, false otherwise + */ + static boolean isSimpleType(Element element) { + return element != null && isSimpleType(element.asType()); + } + + /** + * Checks whether the given {@link TypeMirror} represents a simple type. + * A simple type is one that can be directly represented without further resolution, + * such as primitive types, built-in types like void, or commonly recognized basic types. + * + *

+ * Examples of simple types include: + *

    + *
  • Primitive types: int, boolean, char, etc.
    • + *
  • Built-in types: void, java.lang.String, java.lang.Number
    • + *
+ *

+ * + *

Example Usage

+ * 
{@code
+     * TypeMirror intType = ...; // represents 'int'
+     * boolean isSimple = TypeUtils.isSimpleType(intType); // returns true
+     *
+     * TypeMirror customType = ...; // represents a custom class like 'MyClass'
+     * boolean isSimple = TypeUtils.isSimpleType(customType); // returns false
+     * }
+ * + * @param type the TypeMirror to check, may be null + * @return true if the type is a simple type; false otherwise + */ + static boolean isSimpleType(TypeMirror type) { + return type != null && SIMPLE_TYPE_NAMES.contains(type.toString()); + } + + /** + * Checks if the given Element and Type represent the same type. + * + *

+ * This method compares the type information of the provided Element and Type objects + * to determine if they represent the same type. If either parameter is null, the comparison + * is made based on whether both are null. + *

+ * + *

Example Usage

+ * 
{@code
+     * Element element = ...; // represents a type like String
+     * Type type = ...; // represents the same type as the element
+     * boolean isSame = TypeUtils.isSameType(element, type); // returns true
+     *
+     * Element element2 = ...; // represents a different type
+     * Type type2 = ...; // represents a different type
+     * boolean isSame2 = TypeUtils.isSameType(element2, type2); // returns false
+     * }
+ * + * @param element the Element to compare, may be null + * @param type the Type to compare, may be null + * @return true if both represent the same type; false otherwise + */ + static boolean isSameType(Element element, Type type) { + return isSameType(element == null ? null : element.asType(), type); + } + + /** + * Checks if the given Element and type name represent the same type. + * + *

+ * This method compares the type information of the provided Element and the fully qualified class name + * to determine if they represent the same type. If either parameter is null, the comparison + * is made based on whether both are null. + *

+ * + *

Example Usage

+ * 
{@code
+     * Element stringElement = ...; // represents 'java.lang.String'
+     * boolean isSame = TypeUtils.isSameType(stringElement, "java.lang.String"); // returns true
+     *
+     * Element customElement = ...; // represents 'com.example.MyClass'
+     * boolean isSame2 = TypeUtils.isSameType(customElement, "com.example.OtherClass"); // returns false
+     * }
+ * + * @param type the Element to compare, may be null + * @param typeName the fully qualified class name to compare, may be null + * @return true if both represent the same type; false otherwise + */ + static boolean isSameType(Element type, CharSequence typeName) { + return isSameType(type == null ? null : type.asType(), typeName); + } + + /** + * Checks if the given {@link TypeMirror} and {@link Type} represent the same type. + * + *

+ * This method compares the fully qualified type name of the {@link TypeMirror} with the + * {@link Type#getTypeName() type name} of the provided {@link Type} to determine if they + * represent the same type. If both are {@code null}, they are considered the same. + *

+ * + *

Example Usage

+ * 
{@code
+     * TypeMirror stringTypeMirror = element.asType(); // represents 'java.lang.String'
+     * Type stringType = Class.forName("java.lang.String");
+     * boolean isSame = TypeUtils.isSameType(stringTypeMirror, stringType); // returns true
+     *
+     * TypeMirror intTypeMirror = processingEnv.getTypeUtils().getPrimitiveType(TypeKind.INT);
+     * Type intType = int.class;
+     * boolean isSamePrimitive = TypeUtils.isSameType(intTypeMirror, intType); // returns true
+     *
+     * TypeMirror customTypeMirror = ...; // represents 'com.example.MyClass'
+     * Type customType = Class.forName("com.example.OtherClass");
+     * boolean isSameCustom = TypeUtils.isSameType(customTypeMirror, customType); // returns false
+     * }
+ * + * @param typeMirror the TypeMirror to compare, may be null + * @param type the Type to compare, may be null + * @return true if both represent the same type; false otherwise + */ + static boolean isSameType(TypeMirror typeMirror, Type type) { + return isSameType(typeMirror, type == null ? null : type.getTypeName()); + } + + /** + * Checks if the given TypeMirror and type name represent the same type. + * + *

+ * This method compares the fully qualified type name of the TypeMirror with the provided + * typeName to determine if they represent the same type. If both are null, they are considered + * the same. + *

+ * + *

Example Usage

+ * 
{@code
+     * TypeMirror stringTypeMirror = element.asType(); // represents 'java.lang.String'
+     * boolean isSame = TypeUtils.isSameType(stringTypeMirror, "java.lang.String"); // returns true
+     *
+     * TypeMirror customTypeMirror = ...; // represents 'com.example.MyClass'
+     * boolean isSameCustom = TypeUtils.isSameType(customTypeMirror, "com.example.OtherClass"); // returns false
+     * }
+ * + * @param type the TypeMirror to compare, may be null + * @param typeName the fully qualified class name to compare, may be null + * @return true if both represent the same type; false otherwise + */ + static boolean isSameType(TypeMirror type, CharSequence typeName) { + if (type == null && typeName == null) { + return true; + } + return Objects.equals(valueOf(type), valueOf(typeName)); + } + + /** + * Checks whether the given {@link TypeMirror} represents an array type. + * + *

+ * This method determines if the provided TypeMirror corresponds to an array type + * by checking its kind against the array type kind defined in the Java language model. + * If the provided TypeMirror is null, the method returns false. + *

+ * + *

Example Usage

+ * 
{@code
+     * TypeMirror arrayTypeMirror = processingEnv.getTypeUtils().getArrayType(...); // represents an array type
+     * boolean isArray = TypeUtils.isArrayType(arrayTypeMirror); // returns true
+     *
+     * TypeMirror stringTypeMirror = element.asType(); // represents 'java.lang.String'
+     * boolean isArray = TypeUtils.isArrayType(stringTypeMirror); // returns false
+     * }
+ * + * @param type the TypeMirror to check, may be null + * @return true if the type is an array type; false otherwise + */ + static boolean isArrayType(TypeMirror type) { + return type != null && ARRAY == type.getKind(); + } + + /** + * Checks whether the given Element represents an array type. + * + *

+ * This method determines if the provided Element corresponds to an array type + * by checking its kind against the array type kind defined in the Java language model. + * If the provided Element is null, the method returns false. + *

+ * + *

Example Usage

+ * 
{@code
+     * Element arrayElement = ...; // represents an array type like String[]
+     * boolean isArray = TypeUtils.isArrayType(arrayElement); // returns true
+     *
+     * Element stringElement = ...; // represents 'java.lang.String'
+     * boolean isArray = TypeUtils.isArrayType(stringElement); // returns false
+     * }
+ * + * @param element the Element to check, may be null + * @return true if the element represents an array type; false otherwise + */ + static boolean isArrayType(Element element) { + return element != null && isArrayType(element.asType()); + } + + /** + * Checks whether the given {@link TypeMirror} represents an enum type. + * + *

+ * This method determines if the provided TypeMirror corresponds to an enum type + * by checking its kind via the underlying element's {@link Element#getKind()}. + * If the provided TypeMirror is null or cannot be resolved to a declared type, + * the method returns false. + *

+ * + *

Example Usage

+ * 
{@code
+     * TypeMirror enumTypeMirror = element.asType(); // represents an enum type like MyEnum
+     * boolean isEnum = TypeUtils.isEnumType(enumTypeMirror); // returns true
+     *
+     * TypeMirror stringTypeMirror = element.asType(); // represents 'java.lang.String'
+     * boolean isEnum = TypeUtils.isEnumType(stringTypeMirror); // returns false
+     * }
+ * + * @param type the TypeMirror to check, may be null + * @return true if the type is an enum type; false otherwise + */ + static boolean isEnumType(TypeMirror type) { + DeclaredType declaredType = ofDeclaredType(type); + return declaredType != null && ENUM == declaredType.asElement().getKind(); + } + + /** + * Checks whether the given Element represents an enum type. + * + *

+ * This method determines if the provided Element corresponds to an enum type + * by checking its kind via the underlying element's {@link Element#getKind()}. + * If the provided Element is null or cannot be resolved to a declared type, + * the method returns false. + *

+ * + *

Example Usage

+ * 
{@code
+     * Element enumElement = ...; // represents an enum type like MyEnum
+     * boolean isEnum = TypeUtils.isEnumType(enumElement); // returns true
+     *
+     * Element stringElement = ...; // represents 'java.lang.String'
+     * boolean isEnum = TypeUtils.isEnumType(stringElement); // returns false
+     * }
+ * + * @param element the Element to check, may be null + * @return true if the element represents an enum type; false otherwise + */ + static boolean isEnumType(Element element) { + return element != null && isEnumType(element.asType()); + } + + /** + * Checks whether the given {@link TypeMirror} represents a class type. + * A class type is determined by checking if its corresponding element has the kind of a class. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror classTypeMirror = element.asType(); // represents a class like MyClass
+     * boolean isClass = TypeUtils.isClassType(classTypeMirror); // returns true
+     *
+     * TypeMirror interfaceTypeMirror = element.asType(); // represents an interface like MyInterface
+     * boolean isClass = TypeUtils.isClassType(interfaceTypeMirror); // returns false
+     * }
+ * + * @param type the TypeMirror to check, may be null + * @return true if the type is a class type; false otherwise + */ + static boolean isClassType(TypeMirror type) { + DeclaredType declaredType = ofDeclaredType(type); + return declaredType != null && isClassType(declaredType.asElement()); + } + + /** + * Checks whether the given Element represents a class type. + * A class type is determined by checking if its corresponding element has the kind of a class. + * + *

Example Usage

+ * 
{@code
+     * Element classElement = ...; // represents a class like MyClass
+     * boolean isClass = TypeUtils.isClassType(classElement); // returns true
+     *
+     * Element interfaceElement = ...; // represents an interface like MyInterface
+     * boolean isClass = TypeUtils.isClassType(interfaceElement); // returns false
+     * }
+ * + * @param element the Element to check, may be null + * @return true if the element represents a class type; false otherwise + */ + static boolean isClassType(Element element) { + return element != null && CLASS == element.getKind(); + } + + /** + * Checks whether the given {@link TypeMirror} represents a primitive type. + * A primitive type is one of the predefined types in Java such as int, boolean, etc. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror intTypeMirror = processingEnv.getTypeUtils().getPrimitiveType(TypeKind.INT);
+     * boolean isPrimitive = TypeUtils.isPrimitiveType(intTypeMirror); // returns true
+     *
+     * TypeMirror stringTypeMirror = elementUtils.getTypeElement("java.lang.String").asType();
+     * boolean isPrimitiveString = TypeUtils.isPrimitiveType(stringTypeMirror); // returns false
+     * }
+ * + * @param type the TypeMirror to check, may be null + * @return true if the type is a primitive type; false otherwise + */ + static boolean isPrimitiveType(TypeMirror type) { + return type != null && type.getKind().isPrimitive(); + } + + /** + * Checks whether the given Element represents a primitive type. + * A primitive type is one of the predefined types in Java such as int, boolean, etc. + * + *

Example Usage

+ * 
{@code
+     * Element intElement = ...; // represents 'int'
+     * boolean isPrimitive = TypeUtils.isPrimitiveType(intElement); // returns true
+     *
+     * Element stringElement = ...; // represents 'java.lang.String'
+     * boolean isPrimitiveString = TypeUtils.isPrimitiveType(stringElement); // returns false
+     * }
+ * + * @param element the Element to check, may be null + * @return true if the element represents a primitive type; false otherwise + */ + static boolean isPrimitiveType(Element element) { + return element != null && isPrimitiveType(element.asType()); + } + + /** + * Checks whether the given {@link TypeMirror} represents an interface type. + * An interface type is determined by checking if its corresponding element has the kind of an interface. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror interfaceTypeMirror = element.asType(); // represents an interface like MyInterface
+     * boolean isInterface = TypeUtils.isInterfaceType(interfaceTypeMirror); // returns true
+     *
+     * TypeMirror classTypeMirror = element.asType(); // represents a class like MyClass
+     * boolean isInterface = TypeUtils.isInterfaceType(classTypeMirror); // returns false
+     * }
+ * + * @param type the TypeMirror to check, may be null + * @return true if the type is an interface type; false otherwise + */ + static boolean isInterfaceType(TypeMirror type) { + DeclaredType declaredType = ofDeclaredType(type); + return declaredType != null && isInterfaceType(declaredType.asElement()); + } + + /** + * Checks whether the given Element represents an interface type. + * An interface type is determined by checking if its corresponding element has the kind of an interface. + * + *

Example Usage

+ * 
{@code
+     * Element interfaceElement = ...; // represents an interface like MyInterface
+     * boolean isInterface = TypeUtils.isInterfaceType(interfaceElement); // returns true
+     *
+     * Element classElement = ...; // represents a class like MyClass
+     * boolean isInterface = TypeUtils.isInterfaceType(classElement); // returns false
+     * }
+ * + * @param element the Element to check, may be null + * @return true if the element represents an interface type; false otherwise + */ + static boolean isInterfaceType(Element element) { + return element != null && INTERFACE == element.getKind(); + } + + /** + * Checks whether the given {@link TypeMirror} represents an annotation type. + * An annotation type is determined by checking if its corresponding element has the kind of an annotation. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror annotationTypeMirror = element.asType(); // represents an annotation like MyAnnotation
+     * boolean isAnnotation = TypeUtils.isAnnotationType(annotationTypeMirror); // returns true
+     *
+     * TypeMirror classTypeMirror = element.asType(); // represents a class like MyClass
+     * boolean isAnnotation = TypeUtils.isAnnotationType(classTypeMirror); // returns false
+     * }
+ * + * @param type the TypeMirror to check, may be null + * @return true if the type is an annotation type; false otherwise + */ + static boolean isAnnotationType(TypeMirror type) { + DeclaredType declaredType = ofDeclaredType(type); + return declaredType != null && isAnnotationType(declaredType.asElement()); + } + + /** + * Checks whether the given Element represents an annotation type. + * An annotation type is determined by checking if its corresponding element has the kind of an annotation. + * + *

Example Usage

+ * 
{@code
+     * Element annotationElement = ...; // represents an annotation like MyAnnotation
+     * boolean isAnnotation = TypeUtils.isAnnotationType(annotationElement); // returns true
+     *
+     * Element classElement = ...; // represents a class like MyClass
+     * boolean isAnnotation = TypeUtils.isAnnotationType(classElement); // returns false
+     * }
+ * + * @param element the Element to check, may be null + * @return true if the element represents an annotation type; false otherwise + */ + static boolean isAnnotationType(Element element) { + return element != null && ANNOTATION_TYPE == element.getKind(); + } + + /** + * Checks if the given Element is a TypeElement. + * + *

+ * This method verifies whether the provided Element represents a type element, + * such as a class, interface, enum, or annotation type. If the element is null, + * it returns false. + *

+ * + *

Example Usage

+ * 
{@code
+     * Element classElement = ...; // represents a class like MyClass
+     * boolean isType = TypeUtils.isTypeElement(classElement); // returns true
+     *
+     * Element packageElement = ...; // represents a package
+     * boolean isType = TypeUtils.isTypeElement(packageElement); // returns false
+     * }
+ * + * @param element The Element to check, may be null. + * @return true if the element is a TypeElement; false otherwise. + */ + static boolean isTypeElement(Element element) { + return element instanceof TypeElement; + } + + /** + * Checks if the given TypeMirror represents a TypeElement. + * A TypeElement is a type that corresponds to a class, interface, enum, or annotation type + * that has been explicitly defined in the source code. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror classTypeMirror = element.asType(); // represents a class like MyClass
+     * boolean isType = TypeUtils.isTypeElement(classTypeMirror); // returns true
+     *
+     * TypeMirror intTypeMirror = processingEnv.getTypeUtils().getPrimitiveType(TypeKind.INT);
+     * boolean isTypePrimitive = TypeUtils.isTypeElement(intTypeMirror); // returns false
+     *
+     * TypeMirror stringArrayTypeMirror = processingEnv.getTypeUtils().getArrayType(...); // represents String[]
+     * boolean isTypeArray = TypeUtils.isTypeElement(stringArrayTypeMirror); // returns false
+     * }
+ * + * @param type the TypeMirror to check, may be null + * @return true if the TypeMirror represents a TypeElement; false otherwise + */ + static boolean isTypeElement(TypeMirror type) { + DeclaredType declaredType = ofDeclaredType(type); + return declaredType != null && isTypeElement(declaredType.asElement()); + } + + /** + * Checks whether the given Element represents a declared type. + * A declared type is a type that corresponds to a class, interface, enum, or annotation type + * that has been explicitly defined in the source code. + * + *

Example Usage

+ * 
{@code
+     * Element classElement = ...; // represents a class like MyClass
+     * boolean isDeclared = TypeUtils.isDeclaredType(classElement); // returns true
+     *
+     * Element packageElement = ...; // represents a package
+     * boolean isDeclaredPackage = TypeUtils.isDeclaredType(packageElement); // returns false
+     * }
+ * + * @param element the Element to check, may be null + * @return true if the element represents a DeclaredType; false otherwise + */ + static boolean isDeclaredType(Element element) { + return element != null && isDeclaredType(element.asType()); + } + + /** + * Checks whether the given {@link TypeMirror} represents a declared type. + * A declared type is a type that corresponds to a class, interface, enum, or annotation type + * that has been explicitly defined in the source code. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror classTypeMirror = element.asType(); // represents a class like MyClass
+     * boolean isDeclared = TypeUtils.isDeclaredType(classTypeMirror); // returns true
+     *
+     * TypeMirror intTypeMirror = processingEnv.getTypeUtils().getPrimitiveType(TypeKind.INT);
+     * boolean isDeclaredPrimitive = TypeUtils.isDeclaredType(intTypeMirror); // returns false
+     *
+     * TypeMirror stringArrayTypeMirror = processingEnv.getTypeUtils().getArrayType(...); // represents String[]
+     * boolean isDeclaredArray = TypeUtils.isDeclaredType(stringArrayTypeMirror); // returns false
+     * }
+ * + * @param type the TypeMirror to check, may be null + * @return true if the type is a declared type; false otherwise + */ + static boolean isDeclaredType(TypeMirror type) { + return type instanceof DeclaredType; + } + + /** + * Converts the given Element to a TypeElement if it is an instance of TypeElement. + * + *

+ * This method checks if the provided Element represents a type element such as a class, interface, + * enum, or annotation type. If the element is null or not a TypeElement, this method returns null. + *

+ * + *

Example Usage

+ * 
{@code
+     * Element classElement = ...; // represents a class like MyClass
+     * TypeElement typeElement = TypeUtils.ofTypeElement(classElement); // returns a valid TypeElement
+     *
+     * Element packageElement = ...; // represents a package
+     * TypeElement typeElementForPackage = TypeUtils.ofTypeElement(packageElement); // returns null
+     * }
+ * + * @param element The Element to convert, may be null. + * @return The converted TypeElement if the element is a TypeElement; otherwise, null. + */ + static TypeElement ofTypeElement(Element element) { + return isTypeElement(element) ? (TypeElement) element : null; + } + + /** + * Converts the given TypeMirror to a TypeElement if it represents a declared type. + * + *

+ * This method checks if the provided TypeMirror corresponds to a declared type + * (such as a class, interface, enum, or annotation type). If it does, the corresponding + * TypeElement is returned. If the TypeMirror is null or not a declared type, + * this method returns null. + *

+ * + *

Example Usage

+ * 
{@code
+     * TypeMirror classTypeMirror = element.asType(); // represents a class like MyClass
+     * TypeElement typeElement = TypeUtils.ofTypeElement(classTypeMirror); // returns a valid TypeElement
+     *
+     * TypeMirror intTypeMirror = processingEnv.getTypeUtils().getPrimitiveType(TypeKind.INT);
+     * TypeElement primitiveTypeElement = TypeUtils.ofTypeElement(intTypeMirror); // returns null
+     * }
+ * + * @param type The TypeMirror to convert, may be null. + * @return The corresponding TypeElement if the TypeMirror represents a declared type; + * otherwise, null if the type is null or not a DeclaredType. + */ + @Nullable + static TypeElement ofTypeElement(TypeMirror type) { + DeclaredType declaredType = ofDeclaredType(type); + return ofTypeElement(declaredType); + } + + /** + * Converts the given DeclaredType to a TypeElement if it is not null. + * + *

This method attempts to convert the provided {@link DeclaredType} to a corresponding + * {@link TypeElement}. If the declared type is null, or if it cannot be resolved to a type element, + * this method returns null. + * + *

Example Usage

+ * 
{@code
+     * DeclaredType declaredType = ...; // represents a declared type like MyClass
+     * TypeElement typeElement = TypeUtils.ofTypeElement(declaredType); // returns a valid TypeElement if available
+     *
+     * DeclaredType nullDeclaredType = null;
+     * TypeElement nullTypeElement = TypeUtils.ofTypeElement(nullDeclaredType); // returns null
+     * }
+ * + * @param declaredType the DeclaredType to convert, may be null + * @return the corresponding TypeElement if the DeclaredType is not null; + * otherwise, null + */ + @Nullable + static TypeElement ofTypeElement(DeclaredType declaredType) { + if (declaredType != null) { + return ofTypeElement(declaredType.asElement()); + } + return null; + } + + /** + * Converts the given Element to a DeclaredType by first converting it to a TypeElement. + * If the element is null or cannot be converted to a DeclaredType, returns null. + * + *

+ * This method checks if the provided Element represents a type element (class, interface, enum, or annotation). + * If it does, the corresponding TypeElement is obtained, and its asType() method is called to retrieve the TypeMirror. + * Then, the TypeMirror is converted to a DeclaredType if it represents a declared type. + *

+ * + *

Example Usage

+ * 
{@code
+     * Element classElement = ...; // represents a class like MyClass
+     * DeclaredType declaredType = TypeUtils.ofDeclaredType(classElement); // returns a valid DeclaredType
+     *
+     * Element packageElement = ...; // represents a package
+     * DeclaredType packageDeclaredType = TypeUtils.ofDeclaredType(packageElement); // returns null
+     * }
+ * + * @param element The Element to convert, may be null. + * @return The corresponding DeclaredType if the element is valid and represents a declared type; + * otherwise, null if the element is null or conversion fails. + */ + @Nullable + static DeclaredType ofDeclaredType(Element element) { + return element == null ? null : ofDeclaredType(element.asType()); + } + + /** + * Converts the given TypeMirror to a DeclaredType if it represents a declared type. + * A declared type is a type that corresponds to a class, interface, enum, or annotation type + * that has been explicitly defined in the source code. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror classTypeMirror = element.asType(); // represents a class like MyClass
+     * DeclaredType declaredType = TypeUtils.ofDeclaredType(classTypeMirror); // returns a valid DeclaredType
+     *
+     * TypeMirror intTypeMirror = processingEnv.getTypeUtils().getPrimitiveType(TypeKind.INT);
+     * DeclaredType primitiveDeclaredType = TypeUtils.ofDeclaredType(intTypeMirror); // returns null
+     *
+     * TypeMirror stringArrayTypeMirror = processingEnv.getTypeUtils().getArrayType(...); // represents String[]
+     * DeclaredType arrayDeclaredType = TypeUtils.ofDeclaredType(stringArrayTypeMirror); // returns null
+     * }
+ * + * @param type The TypeMirror to convert, may be null. + * @return The corresponding DeclaredType if the TypeMirror represents a declared type; + * otherwise, null if the type is null or not a DeclaredType. + */ + @Nullable + static DeclaredType ofDeclaredType(TypeMirror type) { + return isDeclaredType(type) ? (DeclaredType) type : null; + } + + /** + * Converts an array of Elements to a List of TypeMirrors. + * If the input array is null or empty, returns an empty list. + * + *

Example Usage

+ * 
{@code
+     * Element classElement = ...; // represents a class like MyClass
+     * Element interfaceElement = ...; // represents an interface like MyInterface
+     *
+     * List typeMirrors = TypeUtils.ofTypeMirrors(classElement, interfaceElement);
+     * // typeMirrors now contains the TypeMirror of MyClass and MyInterface
+     *
+     * List emptyList = TypeUtils.ofTypeMirrors(); // returns an empty list
+     * }
+ * + * @param elements the array of Elements to convert + * @return a List of TypeMirrors derived from the given Elements + */ + @Nonnull + @Immutable + static List ofTypeMirrors(Element... elements) { + return ofTypeMirrors(ofList(elements)); + } + + /** + * Converts a collection of Elements to a list of TypeMirrors. + * Optionally applies an array of predicates to filter the resulting TypeMirrors. + * + *

Example Usage

+ * 
{@code
+     * Element classElement = ...; // represents a class like MyClass
+     * Element interfaceElement = ...; // represents an interface like MyInterface
+     *
+     * List typeMirrors = TypeUtils.ofTypeMirrors(Arrays.asList(classElement, interfaceElement));
+     * // typeMirrors now contains the TypeMirror of MyClass and MyInterface
+     *
+     * List emptyList = TypeUtils.ofTypeMirrors(Collections.emptyList()); // returns an empty list
+     * }
+ * + * @param elements The collection of Elements to convert. Must not be null. + * @return A list of TypeMirrors derived from the given Elements. + */ + @Nonnull + @Immutable + static List ofTypeMirrors(Collection elements) { + return ofTypeMirrors(elements, EMPTY_PREDICATE_ARRAY); + } + + @Nonnull + @Immutable + static List ofTypeMirrors(Collection elements, Predicate... typeFilters) { + return isEmpty(elements) ? emptyList() : + unmodifiableList(elements.stream().map(Element::asType).filter(and(typeFilters)).collect(toList())); + } + + /** + * Converts an array of TypeMirrors to a List of TypeElements. + * If the input array is null or empty, returns an empty list. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror classTypeMirror = element.asType(); // represents a class like MyClass
+     * TypeMirror interfaceTypeMirror = element.asType(); // represents an interface like MyInterface
+     *
+     * List typeElements = TypeUtils.ofTypeElements(classTypeMirror, interfaceTypeMirror);
+     * // typeElements now contains the TypeElement of MyClass and MyInterface
+     *
+     * List emptyList = TypeUtils.ofTypeElements(); // returns an empty list
+     * }
+ * + * @param types The array of TypeMirrors to convert. May be null or contain null elements. + * @return A List of TypeElements derived from the given TypeMirrors. + */ + @Nonnull + @Immutable + static List ofTypeElements(TypeMirror... types) { + return ofTypeElements(ofList(types)); + } + + /** + * Converts a collection of TypeMirrors to a list of TypeElements. + * Optionally applies an array of predicates to filter the resulting TypeElements. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror classTypeMirror = element.asType(); // represents a class like MyClass
+     * TypeMirror interfaceTypeMirror = element.asType(); // represents an interface like MyInterface
+     *
+     * List typeElements = TypeUtils.ofTypeElements(Arrays.asList(classTypeMirror, interfaceTypeMirror));
+     * // typeElements now contains the TypeElement of MyClass and MyInterface
+     *
+     * List emptyList = TypeUtils.ofTypeElements(Collections.emptyList()); // returns an empty list
+     * }
+ * + * @param types The collection of TypeMirrors to convert. Must not be null. + * @return A list of TypeElements derived from the given TypeMirrors. + */ + @Nonnull + @Immutable + static List ofTypeElements(Collection types) { + return ofTypeElements(types, EMPTY_PREDICATE_ARRAY); + } + + /** + * Converts a collection of TypeMirrors to a list of TypeElements. + * Optionally applies an array of predicates to filter the resulting TypeElements. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror classTypeMirror = element.asType(); // represents a class like MyClass
+     * TypeMirror interfaceTypeMirror = element.asType(); // represents an interface like MyInterface
+     *
+     * List typeElements = TypeUtils.ofTypeElements(Arrays.asList(classTypeMirror, interfaceTypeMirror));
+     * // typeElements now contains the TypeElement of MyClass and MyInterface
+     *
+     * List emptyList = TypeUtils.ofTypeElements(Collections.emptyList()); // returns an empty list
+     * }
+ * + * @param types The collection of TypeMirrors to convert. Must not be null. + * @param typeFilters Optional predicates to filter the TypeElements. May be null or empty. + * @return A list of TypeElements derived from the given TypeMirrors, filtered by the provided predicates. + */ + @Nonnull + @Immutable + static List ofTypeElements(Collection types, Predicate... typeFilters) { + return isEmpty(types) ? emptyList() : unmodifiableList( + types.stream() + .map(TypeUtils::ofTypeElement) + .filter(Objects::nonNull) + .filter(and(typeFilters)).collect(toList()) + ); + } + + /** + * Converts an array of Elements to a List of DeclaredTypes. + * If the input array is null or empty, returns an empty list. + * + *

Example Usage

+ * 
{@code
+     * Element classElement = ...; // represents a class like MyClass
+     * Element interfaceElement = ...; // represents an interface like MyInterface
+     *
+     * List declaredTypes = TypeUtils.ofDeclaredTypes(classElement, interfaceElement);
+     * // declaredTypes now contains the DeclaredType of MyClass and MyInterface
+     *
+     * List emptyList = TypeUtils.ofDeclaredTypes(); // returns an empty list
+     * }
+ * + * @param elements the array of Elements to convert + * @return a List of DeclaredTypes derived from the given Elements + */ + @Nonnull + @Immutable + static List ofDeclaredTypes(Element... elements) { + return ofDeclaredTypes(ofList(elements)); + } + + /** + * Converts a collection of Elements to a list of DeclaredTypes. + * Optionally applies an array of predicates to filter the resulting DeclaredTypes. + * + *

Example Usage

+ * 
{@code
+     * Element classElement = ...; // represents a class like MyClass
+     * Element interfaceElement = ...; // represents an interface like MyInterface
+     *
+     * List declaredTypes = TypeUtils.ofDeclaredTypes(Arrays.asList(classElement, interfaceElement));
+     * // declaredTypes now contains the DeclaredType of MyClass and MyInterface
+     *
+     * List emptyList = TypeUtils.ofDeclaredTypes(Collections.emptyList()); // returns an empty list
+     * }
+ * + * @param elements The collection of Elements to convert. Must not be null. + * @return A list of DeclaredTypes derived from the given Elements. + */ + @Nonnull + @Immutable + static List ofDeclaredTypes(Collection elements) { + return ofDeclaredTypes(elements, EMPTY_PREDICATE_ARRAY); + } + + /** + * Converts a collection of Elements to a list of DeclaredTypes. + * Optionally applies an array of predicates to filter the resulting DeclaredTypes. + * + *

Example Usage

+ * 
{@code
+     * Element classElement = ...; // represents a class like MyClass
+     * Element interfaceElement = ...; // represents an interface like MyInterface
+     *
+     * List declaredTypes = TypeUtils.ofDeclaredTypes(Arrays.asList(classElement, interfaceElement));
+     * // declaredTypes now contains the DeclaredType of MyClass and MyInterface
+     *
+     * List emptyList = TypeUtils.ofDeclaredTypes(Collections.emptyList()); // returns an empty list
+     * }
+ * + * @param elements The collection of Elements to convert. Must not be null. + * @param typeFilters Optional predicates to filter the DeclaredTypes. May be null or empty. + * @return A list of DeclaredTypes derived from the given Elements, filtered by the provided predicates. + */ + @Nonnull + @Immutable + static List ofDeclaredTypes(Collection elements, + Predicate... typeFilters) { + + if (isEmpty(elements)) { + return emptyList(); + } + + List declaredTypes = elements.stream() + .map(TypeUtils::ofTypeElement) + .filter(Objects::nonNull) + .map(Element::asType) + .map(TypeUtils::ofDeclaredType) + .filter(Objects::nonNull) + .filter(and(typeFilters)) + .collect(toList()); + + return declaredTypes.isEmpty() ? emptyList() : unmodifiableList(declaredTypes); + } + + /** + * Retrieves the TypeElement representing the superclass of the given TypeElement. + * + *

If the provided TypeElement is null or represents a class without a superclass + * (e.g., {@link Object}, an interface, or an enum), this method returns null. + * + *

Example Usage

+ * 
{@code
+     * TypeElement type = ...; // represents a class like MyClass which extends SomeBaseClass
+     * TypeElement superClass = TypeUtils.getTypeElementOfSuperclass(type);
+     * // superClass now represents SomeBaseClass if available
+     *
+     * TypeElement interfaceType = ...; // represents an interface
+     * TypeElement superClassForInterface = TypeUtils.getTypeElementOfSuperclass(interfaceType);
+     * // superClassForInterface will be null since interfaces do not have a superclass
+     *
+     * TypeElement objectType = processingEnv.getElementUtils().getTypeElement("java.lang.Object");
+     * TypeElement superClassForObject = TypeUtils.getTypeElementOfSuperclass(objectType);
+     * // superClassForObject will be null since Object has no superclass
+     * }
+ * + * @param type the TypeElement whose superclass is to be retrieved, may be null + * @return the TypeElement of the superclass if available; otherwise, null + */ + @Nullable + static TypeElement getTypeElementOfSuperclass(TypeElement type) { + return type == null ? null : ofTypeElement(type.getSuperclass()); + } + + /** + * Retrieves all TypeElements representing the superclasses and interfaces in the hierarchy of the given TypeElement. + * This includes both direct and indirect superclasses as well as implemented interfaces from the entire hierarchy. + * + *

Example Usage

+ * 
{@code
+     * TypeElement type = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
+     * List superTypes = TypeUtils.getAllTypeElementsOfSuperTypes(type);
+     * // superTypes now contains all superclasses and interfaces in the hierarchy of MyClass
+     *
+     * TypeElement interfaceType = processingEnv.getElementUtils().getTypeElement("com.example.MyInterface");
+     * List interfaceSuperTypes = TypeUtils.getAllTypeElementsOfSuperTypes(interfaceType);
+     * // interfaceSuperTypes now contains all superinterfaces of MyInterface
+     *
+     * List emptyList = TypeUtils.getAllTypeElementsOfSuperTypes(null); // returns an empty list
+     * }
+ * + * @param type The TypeElement whose hierarchy is to be explored, may be null. + * @return A list of TypeElements representing all superclasses and interfaces in the hierarchy of the provided TypeElement. + * Returns an empty list if the input is null or no super types exist. + */ + @Nonnull + @Immutable + static List getAllTypeElementsOfSuperTypes(TypeElement type) { + return findAllTypeElementsOfSuperTypes(type, EMPTY_PREDICATE_ARRAY); + } + + /** + * Retrieves all TypeElements representing the superclasses in the hierarchy of the given TypeElement. + * This includes direct and indirect superclasses, but excludes interfaces. + * + *

Example Usage

+ * 
{@code
+     * TypeElement type = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
+     * List superclasses = TypeUtils.getAllTypeElementsOfSuperclasses(type);
+     * // superclasses now contains all superclass TypeElements in the hierarchy of MyClass
+     *
+     * List emptyList = TypeUtils.getAllTypeElementsOfSuperclasses(null); // returns an empty list
+     * }
+ * + * @param type The TypeElement whose superclass hierarchy is to be explored, may be null. + * @return A list of TypeElements representing all superclasses in the hierarchy of the provided TypeElement. + * Returns an empty list if the input is null or no superclasses exist in the hierarchy. + */ + @Nonnull + @Immutable + static List getAllTypeElementsOfSuperclasses(TypeElement type) { + return findAllTypeElementsOfSuperclasses(type, EMPTY_PREDICATE_ARRAY); + } + + /** + * Retrieves the direct interface types implemented by the given TypeElement. + * This method only returns interfaces directly declared on the specified type, + * and does not include superinterfaces from the entire hierarchy. + * + *

Example Usage

+ * 
{@code
+     * TypeElement type = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
+     * List interfaces = TypeUtils.getTypeElementsOfInterfaces(type);
+     * // interfaces now contains the directly implemented interfaces of MyClass
+     *
+     * List emptyList = TypeUtils.getTypeElementsOfInterfaces(null); // returns an empty list
+     * }
+ * + * @param type The TypeElement whose directly implemented interfaces are to be retrieved, may be null. + * @return A list of TypeElements representing the directly implemented interfaces. + * Returns an empty list if the input is null or no interfaces are directly implemented. + */ + @Nonnull + @Immutable + static List getTypeElementsOfInterfaces(TypeElement type) { + return findTypeElementsOfInterfaces(type, EMPTY_PREDICATE_ARRAY); + } + + /** + * Retrieves all TypeElements representing the interfaces implemented in the entire hierarchy of the given TypeElement. + * This includes both directly and indirectly implemented interfaces from superclasses and superinterfaces. + * + *

Example Usage

+ * 
{@code
+     * TypeElement type = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
+     * List interfaces = TypeUtils.getAllTypeElementsOfInterfaces(type);
+     * // interfaces now contains all interfaces implemented by MyClass, including those from superclasses
+     *
+     * List emptyList = TypeUtils.getAllTypeElementsOfInterfaces(null); // returns an empty list
+     * }
+ * + * @param type The TypeElement whose interface hierarchy is to be explored, may be null. + * @return A list of TypeElements representing all implemented interfaces in the hierarchy of the provided TypeElement. + * Returns an empty list if the input is null or no interfaces are found in the hierarchy. + */ + @Nonnull + @Immutable + static List getAllTypeElementsOfInterfaces(TypeElement type) { + return findAllTypeElementsOfInterfaces(type, EMPTY_PREDICATE_ARRAY); + } + + /** + * Retrieves the directly associated TypeElements of the given TypeElement. + * This includes: + * - The type itself + * - Direct superclass (if any) + * - Directly implemented interfaces (if any) + * + *

This method does not traverse the entire hierarchy. It only includes direct relationships. + * + *

Example Usage

+ * 
{@code
+     * TypeElement type = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
+     * List directTypes = TypeUtils.getTypeElements(type);
+     * // directTypes contains:
+     * // - MyClass itself
+     * // - Its direct superclass (if any)
+     * // - Interfaces directly implemented by MyClass (if any)
+     *
+     * List emptyList = TypeUtils.getTypeElements(null); // returns an empty list
+     * }
+ * + * @param type The TypeElement to retrieve directly associated types from, may be null. + * @return A list of TypeElements representing the directly associated types. + * Returns an empty list if the input is null or no direct associations exist. + */ + @Nonnull + @Immutable + static List getTypeElements(TypeElement type) { + return getTypeElements(type, true, false, true, true); + } + + /** + * Retrieves all TypeElements associated with the given TypeElement, including: + * - The type itself + * - Direct and hierarchical superclasses + * - Direct and hierarchical interfaces + * + *

Example Usage

+ * 
{@code
+     * TypeElement type = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
+     * List allTypes = TypeUtils.getAllTypeElements(type);
+     * // allTypes contains:
+     * // - MyClass itself
+     * // - All superclasses in the hierarchy (e.g., Object, SomeBaseClass)
+     * // - All implemented interfaces, including those from superclasses and superinterfaces
+     *
+     * List emptyList = TypeUtils.getAllTypeElements(null); // returns an empty list
+     * }
+ * + * @param type The TypeElement to retrieve all associated types from, may be null. + * @return A list of TypeElements representing all associated types in the hierarchy. + * Returns an empty list if the input is null or no types are found. + */ + @Nonnull + @Immutable + static List getAllTypeElements(TypeElement type) { + return getTypeElements(type, true, true, true, true); + } + + /** + * Retrieves a list of TypeElements associated with the given TypeElement based on the specified inclusion criteria. + * + *

+ * This method allows fine-grained control over which types are included in the result: + *

+ * + *
    + *
  • {@code includeSelf} - Whether to include the given TypeElement itself in the result.
    • + *
  • {@code includeHierarchicalTypes} - Whether to include types from the entire hierarchy (e.g., superclasses and interfaces).
    • + *
  • {@code includeSuperclass} - Whether to include direct or hierarchical superclasses based on the value of includeHierarchicalTypes.
    • + *
  • {@code includeSuperInterfaces} - Whether to include direct or hierarchical interfaces based on the value of includeHierarchicalTypes.
    • + *
+ * + *

Example Usage

+ * 
{@code
+     * TypeElement type = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
+     *
+     * // Get the type itself and all direct superclasses and interfaces
+     * List directTypes = TypeUtils.getTypeElements(type, false, false, true, true);
+     *
+     * // Get the type itself and all hierarchical superclasses and interfaces
+     * List hierarchicalTypes = TypeUtils.getTypeElements(type, true, true, true, true);
+     *
+     * // Get only the direct superclasses without including interfaces
+     * List superclassesOnly = TypeUtils.getTypeElements(type, false, false, true, false);
+     *
+     * // Get only the hierarchical interfaces
+     * List interfacesOnly = TypeUtils.getTypeElements(type, false, true, false, true);
+     * }
+ * + * @param type The TypeElement to find associated types for, may be null. + * @param includeSelf Whether to include the type itself in the result. + * @param includeHierarchicalTypes Whether to include types from the entire hierarchy (e.g., superclasses and interfaces). + * @param includeSuperClasses Whether to include direct or hierarchical superclasses based on includeHierarchicalTypes. + * @param includeSuperInterfaces Whether to include direct or hierarchical interfaces based on includeHierarchicalTypes. + * @return A list of TypeElements representing the associated types according to the inclusion criteria. + * Returns an empty list if the input type is null or no matching types are found. + */ + @Nonnull + @Immutable + static List getTypeElements(TypeElement type, + boolean includeSelf, + boolean includeHierarchicalTypes, + boolean includeSuperClasses, + boolean includeSuperInterfaces) { + return findTypeElements(type, includeSelf, includeHierarchicalTypes, includeSuperClasses, includeSuperInterfaces, EMPTY_PREDICATE_ARRAY); + } + + /** + * Retrieves the TypeElements representing the interfaces directly implemented by the given TypeElement. + * This method only returns interfaces that are directly declared on the specified type, + * and does not include superinterfaces from the entire hierarchy. + * + *

Example Usage

+ * 
{@code
+     * TypeElement type = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
+     * List interfaces = TypeUtils.findTypeElementsOfInterfaces(type);
+     * // interfaces now contains the directly implemented interfaces of MyClass
+     *
+     * List emptyList = TypeUtils.findTypeElementsOfInterfaces(null); // returns an empty list
+     * }
+ * + * @param type The TypeElement whose directly implemented interfaces are to be retrieved, may be null. + * @param interfaceFilters Optional predicates to filter the resulting TypeElements. May be null or empty. + * @return A list of TypeElements representing the directly implemented interfaces. + * Returns an empty list if the input is null or no interfaces are directly implemented. + */ + @Nonnull + @Immutable + static List findTypeElementsOfInterfaces(TypeElement type, Predicate... interfaceFilters) { + return findTypeElements(type, false, false, false, true, interfaceFilters); + } + + /** + * Retrieves all TypeElements representing the superclasses in the hierarchy of the given TypeElement. + * This includes direct and indirect superclasses, but excludes interfaces. + * + *

Example Usage

+ * 
{@code
+     * TypeElement type = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
+     * List superclasses = TypeUtils.findAllTypeElementsOfSuperclasses(type);
+     * // superclasses now contains all superclass TypeElements in the hierarchy of MyClass
+     *
+     * List emptyList = TypeUtils.findAllTypeElementsOfSuperclasses(null); // returns an empty list
+     * }
+ * + * @param type The TypeElement whose superclass hierarchy is to be explored, may be null. + * @param typeFilters Optional predicates to filter the resulting TypeElements. May be null or empty. + * @return A list of TypeElements representing all superclasses in the hierarchy of the provided TypeElement. + * Returns an empty list if the input is null or no superclasses exist in the hierarchy. + */ + @Nonnull + @Immutable + static List findAllTypeElementsOfSuperclasses(TypeElement type, Predicate... typeFilters) { + return findTypeElements(type, false, true, true, false, typeFilters); + } + + /** + * Retrieves all TypeElements representing the interfaces implemented in the entire hierarchy of the given TypeElement. + * This includes both directly and indirectly implemented interfaces from superclasses and superinterfaces. + * + *

Example Usage

+ * 
{@code
+     * TypeElement type = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
+     * List interfaces = TypeUtils.findAllTypeElementsOfInterfaces(type);
+     * // interfaces now contains all interfaces implemented by MyClass, including those from superclasses
+     *
+     * List emptyList = TypeUtils.findAllTypeElementsOfInterfaces(null); // returns an empty list
+     * }
+ * + * @param type The TypeElement whose interface hierarchy is to be explored, may be null. + * @return A list of TypeElements representing all implemented interfaces in the hierarchy of the provided TypeElement. + * Returns an empty list if the input is null or no interfaces are found in the hierarchy. + */ + @Nonnull + @Immutable + static List findAllTypeElementsOfInterfaces(TypeElement type, Predicate... interfaceFilters) { + return findTypeElements(type, false, true, false, true, interfaceFilters); + } + + /** + * Retrieves all TypeElements representing the superclasses and interfaces in the hierarchy of the given TypeElement. + * This includes both direct and indirect superclasses as well as implemented interfaces from the entire hierarchy. + * Optionally applies an array of predicates to filter the resulting TypeElements. + * + *

Example Usage

+ * 
{@code
+     * TypeElement type = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
+     * List superTypes = TypeUtils.findAllTypeElementsOfSuperTypes(type);
+     * // superTypes now contains all superclasses and interfaces in the hierarchy of MyClass
+     *
+     * List filteredSuperTypes = TypeUtils.findAllTypeElementsOfSuperTypes(type,
+     *     t -> t.getQualifiedName().toString().startsWith("com.example"));
+     * // filteredSuperTypes contains only those superTypes whose qualified names start with "com.example"
+     *
+     * List emptyList = TypeUtils.findAllTypeElementsOfSuperTypes(null); // returns an empty list
+     * }
+ * + * @param type The TypeElement whose hierarchy is to be explored, may be null. + * @param typeFilters Optional predicates to filter the resulting TypeElements. May be null or empty. + * @return A list of TypeElements representing all superclasses and interfaces in the hierarchy of the provided TypeElement, + * filtered by the provided predicates. Returns an empty list if the input is null or no types are found in the hierarchy. + */ + @Nonnull + @Immutable + static List findAllTypeElementsOfSuperTypes(TypeElement type, Predicate... typeFilters) { + return findTypeElements(type, false, true, true, true, typeFilters); + } + + /** + * Finds and returns a list of TypeElements based on the specified criteria. + * + *

This method allows detailed control over which types are included in the result: + * - Whether to include the type itself + * - Whether to include hierarchical types (e.g., superclasses and interfaces) + * - Whether to include superclasses and/or interfaces based on the inclusion criteria

+ * + *

Example Usage

+ * 
{@code
+     * TypeElement type = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
+     *
+     * // Get the type itself and all direct superclasses and interfaces
+     * List directTypes = TypeUtils.findTypeElements(type, true, false, true, true);
+     *
+     * // Get all types in the hierarchy including superclasses and interfaces
+     * List hierarchicalTypes = TypeUtils.findTypeElements(type, true, true, true, true);
+     *
+     * // Get only direct superclasses without including interfaces
+     * List superclassesOnly = TypeUtils.findTypeElements(type, false, false, true, false);
+     *
+     * // Get only interfaces from the entire hierarchy
+     * List interfacesOnly = TypeUtils.findTypeElements(type, false, true, false, true);
+     * }
+ * + * @param type The TypeElement to start the search from, may be null. + * @param includeSelf Whether to include the type itself in the result. + * @param includeHierarchicalTypes Whether to include types from the entire hierarchy (e.g., superclasses and interfaces). + * @param includeSuperclass Whether to include direct or hierarchical superclasses based on includeHierarchicalTypes. + * @param includeSuperInterfaces Whether to include direct or hierarchical interfaces based on includeHierarchicalTypes. + * @param typeFilters Optional predicates to filter the resulting TypeElements. May be null or empty. + * @return A list of TypeElements matching the specified criteria. + * Returns an empty list if the input type is null or no matching types are found. + * @throws IllegalArgumentException if any element of 'typeFilters' array is null. + */ + @Nonnull + @Immutable + static List findTypeElements(TypeElement type, + boolean includeSelf, + boolean includeHierarchicalTypes, + boolean includeSuperclass, + boolean includeSuperInterfaces, + Predicate... typeFilters) throws IllegalArgumentException { + if (type == null) { + return emptyList(); + } + assertNoNullElements(typeFilters, () -> "Any element of 'typeFilters' array must not be null"); + return typeElementFinder(type, includeSelf, includeHierarchicalTypes, includeSuperclass, includeSuperInterfaces).findTypes(typeFilters); + } + + /** + * Retrieves the declared type of the superclass for the given Element. + * If the provided Element is null or does not represent a type with a superclass, + * this method will return null. + * + *

Example Usage

+ * 
{@code
+     * Element typeElement = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
+     * DeclaredType superClassType = TypeUtils.getDeclaredTypeOfSuperclass(typeElement);
+     * // superClassType now contains the DeclaredType of the superclass of MyClass, if available
+     *
+     * Element interfaceElement = processingEnv.getElementUtils().getTypeElement("com.example.MyInterface");
+     * DeclaredType superClassTypeForInterface = TypeUtils.getDeclaredTypeOfSuperclass(interfaceElement);
+     * // superClassTypeForInterface will be null since interfaces do not have a superclass
+     *
+     * DeclaredType nullCase = TypeUtils.getDeclaredTypeOfSuperclass(null);
+     * // nullCase will be null since the input is null
+     * }
+ * + * @param typeElement the Element to retrieve the superclass declared type from, may be null + * @return the DeclaredType representing the superclass of the given Element, or null if none exists + */ + @Nullable + static DeclaredType getDeclaredTypeOfSuperclass(Element typeElement) { + return typeElement == null ? null : getDeclaredTypeOfSuperclass(typeElement.asType()); + } + + /** + * Retrieves the declared type of the superclass for the given TypeMirror. + * If the provided TypeMirror is null or does not represent a type with a superclass, + * this method will return null. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror type = processingEnv.getTypeUtils().getDeclaredType(typeElement);
+     * DeclaredType superClassType = TypeUtils.getDeclaredTypeOfSuperclass(type);
+     * // superClassType contains the DeclaredType of the superclass if available
+     *
+     * DeclaredType nullCase = TypeUtils.getDeclaredTypeOfSuperclass(null);
+     * // nullCase will be null since the input is null
+     * }
+ * + * @param type the TypeMirror to retrieve the superclass declared type from, may be null + * @return the DeclaredType representing the superclass of the given TypeMirror, or null if none exists + */ + @Nullable + static DeclaredType getDeclaredTypeOfSuperclass(TypeMirror type) { + TypeElement superType = getTypeElementOfSuperclass(ofTypeElement(type)); + return superType == null ? null : ofDeclaredType(superType.asType()); + } + + /** + * Retrieves a list of declared types representing the interfaces directly implemented by the given Element. + * This method only returns interfaces that are directly declared on the specified type, + * and does not include interfaces from superclasses or superinterfaces. + * + *

Example Usage

+ * 
{@code
+     * Element typeElement = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
+     * List interfaces = TypeUtils.getDeclaredTypesOfInterfaces(typeElement);
+     * // interfaces now contains the directly implemented interfaces of MyClass
+     *
+     * List emptyList = TypeUtils.getDeclaredTypesOfInterfaces(null); // returns an empty list
+     * }
+ * + * @param element The Element whose directly implemented interfaces are to be retrieved, may be null. + * @return A list of DeclaredTypes representing the interfaces directly implemented by the given Element. + * Returns an empty list if the input is null or no interfaces are directly implemented. + */ + @Nonnull + @Immutable + static List getDeclaredTypesOfInterfaces(Element element) { + return element == null ? emptyList() : findDeclaredTypesOfInterfaces(element.asType(), EMPTY_PREDICATE_ARRAY); + } + + /** + * Retrieves a list of declared types representing the interfaces directly implemented by the given TypeMirror. + * This method only returns interfaces that are directly declared on the specified type, + * and does not include interfaces from superclasses or superinterfaces. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror type = processingEnv.getTypeUtils().getDeclaredType(typeElement);
+     * List interfaces = TypeUtils.getDeclaredTypesOfInterfaces(type);
+     * // interfaces now contains the directly implemented interfaces of the given type
+     *
+     * List emptyList = TypeUtils.getDeclaredTypesOfInterfaces(null); // returns an empty list
+     * }
+ * + * @param type The TypeMirror whose directly implemented interfaces are to be retrieved, may be null. + * @return A list of DeclaredTypes representing the interfaces directly implemented by the given TypeMirror. + * Returns an empty list if the input is null or no interfaces are directly implemented. + */ + @Nonnull + @Immutable + static List getDeclaredTypesOfInterfaces(TypeMirror type) { + return findDeclaredTypesOfInterfaces(type, EMPTY_PREDICATE_ARRAY); + } + + /** + * Retrieves a list of DeclaredTypes representing all superclasses in the hierarchy of the given Element. + * This includes both direct and indirect superclasses, traversing up through the entire type hierarchy. + * If the provided Element is null or does not have any superclasses, an empty list is returned. + * + *

Example Usage

+ * 
{@code
+     * Element typeElement = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
+     * List superclasses = TypeUtils.getAllDeclaredTypesOfSuperclasses(typeElement);
+     * // superclasses now contains all superclass DeclaredTypes in the hierarchy of MyClass
+     *
+     * List emptyList = TypeUtils.getAllDeclaredTypesOfSuperclasses(null); // returns an empty list
+     * }
+ * + * @param type The Element to retrieve superclass declared types from, may be null. + * @return A list of DeclaredTypes representing all superclasses in the hierarchy of the provided Element. + * Returns an empty list if the input is null or no superclasses exist in the hierarchy. + */ + @Nonnull + @Immutable + static List getAllDeclaredTypesOfSuperclasses(Element type) { + return type == null ? emptyList() : findAllDeclaredTypesOfSuperclasses(type.asType(), EMPTY_PREDICATE_ARRAY); + } + + /** + * Retrieves a list of DeclaredTypes representing all superclasses in the hierarchy of the given TypeMirror. + * This includes both direct and indirect superclasses, traversing up through the entire type hierarchy. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror type = processingEnv.getTypeUtils().getDeclaredType(typeElement);
+     * List superclasses = TypeUtils.getAllDeclaredTypesOfSuperclasses(type);
+     * // superclasses now contains all superclass DeclaredTypes in the hierarchy of the given type
+     *
+     * List emptyList = TypeUtils.getAllDeclaredTypesOfSuperclasses(null); // returns an empty list
+     * }
+ * + * @param type The TypeMirror whose superclass hierarchy is to be explored, may be null. + * @return A list of DeclaredTypes representing all superclasses in the hierarchy of the provided TypeMirror. + * Returns an empty list if the input is null or no superclasses exist in the hierarchy. + */ + @Nonnull + @Immutable + static List getAllDeclaredTypesOfSuperclasses(TypeMirror type) { + return findAllDeclaredTypesOfSuperclasses(type, EMPTY_PREDICATE_ARRAY); + } + + /** + * Retrieves a list of DeclaredTypes representing all interfaces implemented in the entire hierarchy + * of the given Element. This includes both directly and indirectly implemented interfaces from + * superclasses and superinterfaces. + * + *

Example Usage

+ * 
{@code
+     * Element typeElement = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
+     * List interfaces = TypeUtils.getAllDeclaredTypesOfInterfaces(typeElement);
+     * // interfaces now contains all interfaces implemented by MyClass, including those from superclasses
+     *
+     * List emptyList = TypeUtils.getAllDeclaredTypesOfInterfaces(null); // returns an empty list
+     * }
+ * + * @param type The Element whose interface hierarchy is to be explored, may be null. + * @return A list of DeclaredTypes representing all implemented interfaces in the hierarchy of + * the provided Element. Returns an empty list if the input is null or no interfaces + * are found in the hierarchy. + */ + @Nonnull + @Immutable + static List getAllDeclaredTypesOfInterfaces(Element type) { + return type == null ? emptyList() : findAllDeclaredTypesOfInterfaces(type.asType(), EMPTY_PREDICATE_ARRAY); + } + + /** + * Retrieves a list of DeclaredTypes representing all interfaces implemented in the entire hierarchy + * of the given TypeMirror. This includes both directly and indirectly implemented interfaces from + * superclasses and superinterfaces. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror type = processingEnv.getTypeUtils().getDeclaredType(typeElement);
+     * List interfaces = TypeUtils.getAllDeclaredTypesOfInterfaces(type);
+     * // interfaces now contains all interfaces implemented by the given type, including those from superclasses
+     *
+     * List emptyList = TypeUtils.getAllDeclaredTypesOfInterfaces(null); // returns an empty list
+     * }
+ * + * @param type The TypeMirror whose interface hierarchy is to be explored, may be null. + * @return A list of DeclaredTypes representing all implemented interfaces in the hierarchy of + * the provided TypeMirror. Returns an empty list if the input is null or no interfaces + * are found in the hierarchy. + */ + @Nonnull + @Immutable + static List getAllDeclaredTypesOfInterfaces(TypeMirror type) { + return findAllDeclaredTypesOfInterfaces(type, EMPTY_PREDICATE_ARRAY); + } + + /** + * Retrieves a list of DeclaredTypes representing all superclasses and interfaces in the hierarchy + * of the given Element. This includes both direct and indirect superclasses as well as implemented + * interfaces from the entire hierarchy. + * + *

Example Usage

+ * 
{@code
+     * Element typeElement = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
+     * List superTypes = TypeUtils.getAllDeclaredTypesOfSuperTypes(typeElement);
+     * // superTypes now contains all superclasses and interfaces in the hierarchy of MyClass
+     *
+     * List emptyList = TypeUtils.getAllDeclaredTypesOfSuperTypes(null); // returns an empty list
+     * }
+ * + * @param type The Element to retrieve super types from, may be null. + * @return A list of DeclaredTypes representing all superclasses and interfaces in the hierarchy + * of the provided Element. Returns an empty list if the input is null or no types are found. + */ + @Nonnull + @Immutable + static List getAllDeclaredTypesOfSuperTypes(Element type) { + return type == null ? emptyList() : findAllDeclaredTypesOfSuperTypes(type.asType(), EMPTY_PREDICATE_ARRAY); + } + + /** + * Retrieves a list of DeclaredTypes representing all superclasses and interfaces in the hierarchy + * of the given TypeMirror. This includes both direct and indirect superclasses as well as implemented + * interfaces from the entire hierarchy. + * + *

Example Usage

+ * 
{@code
+     * TypeMirror type = processingEnv.getTypeUtils().getDeclaredType(typeElement);
+     * List superTypes = TypeUtils.getAllDeclaredTypesOfSuperTypes(type);
+     * // superTypes now contains all superclasses and interfaces in the hierarchy of the given type
+     *
+     * List emptyList = TypeUtils.getAllDeclaredTypesOfSuperTypes(null); // returns an empty list
+     * }
+ * + * @param type The TypeMirror whose hierarchy is to be explored, may be null. + * @return A list of DeclaredTypes representing all superclasses and interfaces in the hierarchy of + * the provided TypeMirror. Returns an empty list if the input is null or no types are found. + */ + @Nonnull + @Immutable + static List getAllDeclaredTypesOfSuperTypes(TypeMirror type) { + return findAllDeclaredTypesOfSuperTypes(type, EMPTY_PREDICATE_ARRAY); + } + + /** + * Retrieves a list of DeclaredTypes representing all associated types of the given Element. + * This includes: + * - The type itself (if it is a declared type) + * - Direct and hierarchical superclasses + * - Direct and hierarchical interfaces implemented by the type + * + *

Example Usage

+ * 
{@code
+     * Element typeElement = processingEnv.getElementUtils().getTypeElement("com.example.MyClass");
+     * List allTypes = TypeUtils.getAllDeclaredTypes(typeElement);
+     * // allTypes now contains MyClass itself, its superclasses, and all implemented interfaces
+     *
+     * List emptyList = TypeUtils.getAllDeclaredTypes(null); // returns an empty list
+     * }
+ * + * @param type The Element to retrieve associated DeclaredTypes from, may be null. + * @return A list of DeclaredTypes derived from the given Element. Returns an empty list if + * the input is null or no DeclaredTypes are found. + */ + @Nonnull + @Immutable + static List getAllDeclaredTypes(Element type) { + return type == null ? emptyList() : findAllDeclaredTypes(type.asType(), EMPTY_PREDICATE_ARRAY); + } + + /** + * Retrieves a list of DeclaredTypes representing all associated types in the hierarchy of the given TypeMirror. + * This includes: + * - The type itself (if it is a declared type) + * - Direct and hierarchical superclasses + * - Direct and hierarchical interfaces implemented by the type + * + * @param type The TypeMirror to retrieve associated DeclaredTypes from, may be null. + * @return A list of DeclaredTypes representing all associated types in the hierarchy of the provided TypeMirror. + * Returns an empty list if the input is null or no DeclaredTypes are found. + */ + @Nonnull + @Immutable + static List getAllDeclaredTypes(TypeMirror type) { + return findAllDeclaredTypes(type, EMPTY_PREDICATE_ARRAY); + } + + /** + * Retrieves a list of DeclaredTypes associated with the given Element based on the specified inclusion criteria. + * A DeclaredType typically refers to a type that is explicitly declared in the code, such as classes, + * interfaces, enums, or annotation types. + * + * @param type The Element to retrieve DeclaredTypes from, may be null. + * @param includeSelf Whether to include the type itself in the result. + * @param includeHierarchicalTypes Whether to include types from the entire hierarchy (e.g., superclasses and interfaces). + * @param includeSuperClasses Whether to include direct or hierarchical superclasses based on includeHierarchicalTypes. + * @param includeSuperInterfaces Whether to include direct or hierarchical interfaces based on includeHierarchicalTypes. + * @return A list of DeclaredTypes derived from the given Element according to the inclusion criteria. + * Returns an empty list if the input is null or no DeclaredTypes are found. + */ + @Nonnull + @Immutable + static List getDeclaredTypes(Element type, + boolean includeSelf, + boolean includeHierarchicalTypes, + boolean includeSuperClasses, + boolean includeSuperInterfaces) { + return getDeclaredTypes(type.asType(), includeSelf, includeHierarchicalTypes, includeSuperClasses, includeSuperInterfaces); + } + + /** + * Retrieves a list of DeclaredTypes associated with the given TypeMirror based on the specified inclusion criteria. + * A DeclaredType typically refers to a type that is explicitly declared in the code, such as classes, + * interfaces, enums, or annotation types. + * + * @param type The TypeMirror to retrieve DeclaredTypes from, may be null. + * @param includeSelf Whether to include the type itself in the result. + * @param includeHierarchicalTypes Whether to include types from the entire hierarchy (e.g., superclasses and interfaces). + * @param includeSuperClasses Whether to include direct or hierarchical superclasses based on includeHierarchicalTypes. + * @param includeSuperInterfaces Whether to include direct or hierarchical interfaces based on includeHierarchicalTypes. + * @return A list of DeclaredTypes derived from the given TypeMirror according to the inclusion criteria. + * Returns an empty list if the input is null or no DeclaredTypes are found. + */ + @Nonnull + @Immutable + static List getDeclaredTypes(TypeMirror type, + boolean includeSelf, + boolean includeHierarchicalTypes, + boolean includeSuperClasses, + boolean includeSuperInterfaces) { + return findDeclaredTypes(type, includeSelf, includeHierarchicalTypes, includeSuperClasses, includeSuperInterfaces, EMPTY_PREDICATE_ARRAY); + } + + + /** + * Finds and returns a list of DeclaredTypes associated with the given TypeMirror, + * excluding any types that match the specified excludedTypes. + * + * @param type The TypeMirror to find associated DeclaredTypes from, may be null. + * @param excludedTypes The array of Types to exclude from the result. May be null or empty. + * @return A list of DeclaredTypes derived from the given TypeMirror, excluding the specified types. + * Returns an empty list if the input type is null or no matching DeclaredTypes are found. + */ + @Nonnull + @Immutable + static List findDeclaredTypes(TypeMirror type, Type... excludedTypes) { + return type == null ? emptyList() : findDeclaredTypes(ofTypeElement(type), excludedTypes); + } + + /** + * Finds and returns a list of DeclaredTypes associated with the given Element, + * excluding any types that match the specified excludedTypes. + * + * @param type The Element to find associated DeclaredTypes from, may be null. + * @param excludedTypes The array of Types to exclude from the result. May be null or empty. + * @return A list of DeclaredTypes derived from the given Element, excluding the specified types. + * Returns an empty list if the input type is null or no matching DeclaredTypes are found. + */ + @Nonnull + @Immutable + static List findDeclaredTypes(Element type, Type... excludedTypes) { + return type == null ? emptyList() : findDeclaredTypes(type, getTypeNames(excludedTypes)); + } + + /** + * Finds and returns a list of DeclaredTypes associated with the given TypeMirror, + * excluding any types whose names match the specified excludedTypeNames. + * + * @param type The TypeMirror to find associated DeclaredTypes from, may be null. + * @param excludedTypeNames An array of fully qualified type names to exclude from the result. + * May be null or empty. + * @return A list of DeclaredTypes derived from the given TypeMirror, excluding the specified types. + * Returns an empty list if the input type is null or no matching DeclaredTypes are found. + */ + @Nonnull + @Immutable + static List findDeclaredTypes(TypeMirror type, CharSequence... excludedTypeNames) { + return type == null ? emptyList() : findDeclaredTypes(ofTypeElement(type), excludedTypeNames); + } + + /** + * Finds and returns a list of DeclaredTypes associated with the given Element, + * excluding any types whose names match the specified excludedTypeNames. + * + * @param type The Element to find associated DeclaredTypes from, may be null. + * @param excludedTypeNames An array of fully qualified type names to exclude from the result. + * May be null or empty. + * @return A list of DeclaredTypes derived from the given Element, excluding the specified types. + * Returns an empty list if the input is null or no matching DeclaredTypes are found. + */ + @Nonnull + @Immutable + static List findDeclaredTypes(Element type, CharSequence... excludedTypeNames) { + return type == null ? emptyList() : findDeclaredTypes(type, false, false, true, true, t -> !contains(excludedTypeNames, t.toString())); + } + + /** + * Retrieves a list of DeclaredTypes representing the interfaces directly implemented by the given Element. + * This method only returns interfaces that are directly declared on the specified type, + * and does not include interfaces from superclasses or superinterfaces. + * + * @param type The Element whose directly implemented interfaces are to be retrieved, may be null. + * @param typeFilters Optional predicates to filter the resulting DeclaredTypes. May be null or empty. + * @return A list of DeclaredTypes representing the interfaces directly implemented by the given Element. + * Returns an empty list if the input is null or no interfaces are directly implemented. + */ + @Nonnull + @Immutable + static List findDeclaredTypesOfInterfaces(Element type, Predicate... typeFilters) { + return type == null ? emptyList() : findDeclaredTypesOfInterfaces(type.asType(), typeFilters); + } + + /** + * Retrieves a list of DeclaredTypes representing the interfaces directly implemented by the given TypeMirror. + * This method only returns interfaces that are directly declared on the specified type, + * and does not include interfaces from superclasses or superinterfaces. + * + * @param type The TypeMirror whose directly implemented interfaces are to be retrieved, may be null. + * @param typeFilters Optional predicates to filter the resulting DeclaredTypes. May be null or empty. + * @return A list of DeclaredTypes representing the interfaces directly implemented by the given TypeMirror. + * Returns an empty list if the input is null or no interfaces are directly implemented. + */ + @Nonnull + @Immutable + static List findDeclaredTypesOfInterfaces(TypeMirror type, Predicate... typeFilters) { + return type == null ? emptyList() : ofDeclaredTypes(getTypeElementsOfInterfaces(ofTypeElement(type)), typeFilters); + } + + /** + * Retrieves a list of DeclaredTypes representing all superclasses in the hierarchy of the given Element. + * This includes both direct and indirect superclasses, traversing up through the entire type hierarchy. + * Optionally applies an array of predicates to filter the resulting DeclaredTypes. + * + * @param type The Element to retrieve superclass declared types from, may be null. + * @param typeFilters Optional predicates to filter the resulting DeclaredTypes. May be null or empty. + * @return A list of DeclaredTypes representing all superclasses in the hierarchy of the provided Element. + * Returns an empty list if the input is null or no superclasses exist in the hierarchy. + */ + @Nonnull + @Immutable + static List findAllDeclaredTypesOfSuperclasses(Element type, Predicate... typeFilters) { + return type == null ? emptyList() : findAllDeclaredTypesOfSuperclasses(type.asType(), typeFilters); + } + + /** + * Retrieves a list of DeclaredTypes representing all superclasses in the hierarchy of the given TypeMirror. + * This includes both direct and indirect superclasses, traversing up through the entire type hierarchy. + * Optionally applies an array of predicates to filter the resulting DeclaredTypes. + * + * @param type The TypeMirror whose superclass hierarchy is to be explored, may be null. + * @param typeFilters Optional predicates to filter the resulting DeclaredTypes. May be null or empty. + * @return A list of DeclaredTypes representing all superclasses in the hierarchy of the provided TypeMirror, + * filtered by the provided predicates. Returns an empty list if the input is null or no superclasses + * exist in the hierarchy. + */ + @Nonnull + @Immutable + static List findAllDeclaredTypesOfSuperclasses(TypeMirror type, Predicate... typeFilters) { + return type == null ? emptyList() : ofDeclaredTypes(getAllTypeElementsOfSuperclasses(ofTypeElement(type)), typeFilters); + } + + /** + * Retrieves a list of DeclaredTypes representing all interfaces implemented in the entire hierarchy + * of the given Element. This includes both directly and indirectly implemented interfaces from + * superclasses and superinterfaces. Optionally applies an array of predicates to filter the resulting DeclaredTypes. + * + * @param type The Element whose interface hierarchy is to be explored, may be null. + * @param typeFilters Optional predicates to filter the resulting DeclaredTypes. May be null or empty. + * @return A list of DeclaredTypes representing all implemented interfaces in the hierarchy of + * the provided Element, filtered by the provided predicates. Returns an empty list if + * the input is null or no interfaces are found in the hierarchy. + */ + @Nonnull + @Immutable + static List findAllDeclaredTypesOfInterfaces(Element type, Predicate... typeFilters) { + return type == null ? emptyList() : findAllDeclaredTypesOfInterfaces(type.asType(), typeFilters); + } + + /** + * Retrieves a list of DeclaredTypes representing all interfaces implemented in the entire hierarchy + * of the given TypeMirror. This includes both directly and indirectly implemented interfaces from + * superclasses and superinterfaces. Optionally applies an array of predicates to filter the resulting DeclaredTypes. + * + * @param type The TypeMirror whose interface hierarchy is to be explored, may be null. + * @param typeFilters Optional predicates to filter the resulting DeclaredTypes. May be null or empty. + * @return A list of DeclaredTypes representing all implemented interfaces in the hierarchy of + * the provided TypeMirror, filtered by the provided predicates. Returns an empty list if + * the input is null or no interfaces are found in the hierarchy. + */ + @Nonnull + @Immutable + static List findAllDeclaredTypesOfInterfaces(TypeMirror type, Predicate... typeFilters) { + return type == null ? emptyList() : ofDeclaredTypes(getAllTypeElementsOfInterfaces(ofTypeElement(type)), typeFilters); + } + + /** + * Retrieves a list of DeclaredTypes representing all superclasses and interfaces in the hierarchy + * of the given Element. This includes both direct and indirect superclasses as well as implemented + * interfaces from the entire hierarchy. Optionally applies an array of predicates to filter the resulting DeclaredTypes. + * + * @param type The Element to retrieve superclass and interface declared types from, may be null. + * @param typeFilters Optional predicates to filter the resulting DeclaredTypes. May be null or empty. + * @return A list of DeclaredTypes representing all superclasses and interfaces in the hierarchy of + * the provided Element, filtered by the provided predicates. Returns an empty list if the + * input is null or no matching DeclaredTypes are found. + */ + @Nonnull + @Immutable + static List findAllDeclaredTypesOfSuperTypes(Element type, Predicate... typeFilters) { + return type == null ? emptyList() : findAllDeclaredTypesOfSuperTypes(type.asType(), typeFilters); + } + + /** + * Retrieves a list of DeclaredTypes representing all superclasses and interfaces in the hierarchy + * of the given TypeMirror. This includes both direct and indirect superclasses as well as implemented + * interfaces from the entire hierarchy. Optionally applies an array of predicates to filter the resulting DeclaredTypes. + * + * @param type The TypeMirror whose superclass and interface hierarchy is to be explored, may be null. + * @param typeFilters Optional predicates to filter the resulting DeclaredTypes. May be null or empty. + * @return A list of DeclaredTypes representing all superclasses and interfaces in the hierarchy of + * the provided TypeMirror, filtered by the provided predicates. Returns an empty list if the + * input is null or no matching DeclaredTypes are found. + */ + @Nonnull + @Immutable + static List findAllDeclaredTypesOfSuperTypes(TypeMirror type, Predicate... typeFilters) { + return type == null ? emptyList() : ofDeclaredTypes(getAllTypeElementsOfSuperTypes(ofTypeElement(type)), typeFilters); + } + + /** + * Retrieves a list of DeclaredTypes representing all associated types in the hierarchy + * of the given TypeMirror, excluding any types that match the specified excludedTypes. + * This includes: + * - The type itself (if it is a declared type) + * - Direct and hierarchical superclasses + * - Direct and hierarchical interfaces implemented by the type + * + * @param type The TypeMirror to retrieve associated DeclaredTypes from, may be null. + * @param excludedTypes The array of Types to exclude from the result. May be null or empty. + * @return A list of DeclaredTypes derived from the given TypeMirror, excluding the specified types. + * Returns an empty list if the input is null or no matching DeclaredTypes are found. + */ + @Nonnull + @Immutable + static List findAllDeclaredTypes(TypeMirror type, Type... excludedTypes) { + return type == null ? emptyList() : findAllDeclaredTypes(ofTypeElement(type), excludedTypes); + } + + /** + * Retrieves a list of DeclaredTypes representing all associated types in the hierarchy + * of the given Element, excluding any types that match the specified excludedTypes. + * This includes: + * - The type itself (if it is a declared type) + * - Direct and hierarchical superclasses + * - Direct and hierarchical interfaces implemented by the type + * + * @param type The Element to retrieve associated DeclaredTypes from, may be null. + * @param excludedTypes The array of Types to exclude from the result. May be null or empty. + * @return A list of DeclaredTypes derived from the given Element, excluding the specified types. + * Returns an empty list if the input is null or no matching DeclaredTypes are found. + */ + @Nonnull + @Immutable + static List findAllDeclaredTypes(Element type, Type... excludedTypes) { + return type == null ? emptyList() : findAllDeclaredTypes(type, getTypeNames(excludedTypes)); + } + + /** + * Retrieves a list of DeclaredTypes representing all associated types in the hierarchy + * of the given TypeMirror, excluding any types whose names match the specified excludedTypeNames. + * This includes: + * - The type itself (if it is a declared type) + * - Direct and hierarchical superclasses + * - Direct and hierarchical interfaces implemented by the type + * + * @param type The TypeMirror to retrieve associated DeclaredTypes from, may be null. + * @param excludedTypeNames An array of fully qualified type names to exclude from the result. + * May be null or empty. + * @return A list of DeclaredTypes derived from the given TypeMirror, excluding the specified types. + * Returns an empty list if the input type is null or no matching DeclaredTypes are found. + */ + @Nonnull + @Immutable + static List findAllDeclaredTypes(TypeMirror type, CharSequence... excludedTypeNames) { + return type == null ? emptyList() : findAllDeclaredTypes(ofTypeElement(type), excludedTypeNames); + } + + /** + * Retrieves a list of DeclaredTypes representing all associated types in the hierarchy + * of the given Element, excluding any types whose names match the specified excludedTypeNames. + * This includes: + * - The type itself (if it is a declared type) + * - Direct and hierarchical superclasses + * - Direct and hierarchical interfaces implemented by the type + * + * @param type The Element to retrieve associated DeclaredTypes from, may be null. + * @param excludedTypeNames An array of fully qualified type names to exclude from the result. + * May be null or empty. + * @return A list of DeclaredTypes derived from the given Element, excluding the specified types. + * Returns an empty list if the input is null or no matching DeclaredTypes are found. + */ + @Nonnull + @Immutable + static List findAllDeclaredTypes(Element type, CharSequence... excludedTypeNames) { + return type == null ? emptyList() : findAllDeclaredTypes(type, t -> !contains(excludedTypeNames, t.toString())); + } + + /** + * Retrieves a list of DeclaredTypes representing all associated types in the hierarchy + * of the given Element, filtered by the provided predicates. + * This includes: + * - The type itself (if it is a declared type) + * - Direct and hierarchical superclasses + * - Direct and hierarchical interfaces implemented by the type + * + * @param type The Element to retrieve associated DeclaredTypes from, may be null. + * @param typeFilters Optional predicates to filter the resulting DeclaredTypes. May be null or empty. + * @return A list of DeclaredTypes derived from the given Element, filtered by the provided predicates. + * Returns an empty list if the input is null or no matching DeclaredTypes are found. + */ + @Nonnull + @Immutable + static List findAllDeclaredTypes(Element type, Predicate... typeFilters) { + return type == null ? emptyList() : findAllDeclaredTypes(type.asType(), typeFilters); + } + + /** + * Retrieves a list of DeclaredTypes representing all associated types in the hierarchy + * of the given TypeMirror, filtered by the provided predicates. + * This includes: + * - The type itself (if it is a declared type) + * - Direct and hierarchical superclasses + * - Direct and hierarchical interfaces implemented by the type + * + * @param type The TypeMirror to retrieve associated DeclaredTypes from, may be null. + * @param typeFilters Optional predicates to filter the resulting DeclaredTypes. May be null or empty. + * @return A list of DeclaredTypes derived from the given TypeMirror, filtered by the provided predicates. + * Returns an empty list if the input is null or no matching DeclaredTypes are found. + */ + @Nonnull + @Immutable + static List findAllDeclaredTypes(TypeMirror type, Predicate... typeFilters) { + return type == null ? emptyList() : ofDeclaredTypes(getAllTypeElements(ofTypeElement(type)), typeFilters); + } + + /** + * Finds and returns a list of DeclaredTypes associated with the given Element based on the specified criteria. + * + *

A DeclaredType typically refers to a type that is explicitly declared in the code, such as classes, + * interfaces, enums, or annotation types. This method allows filtering based on whether to include: + * - The type itself + * - Direct or hierarchical superclasses (based on the includeHierarchicalTypes flag) + * - Direct or hierarchical interfaces (based on the includeHierarchicalTypes flag) + * + * @param type The Element to find associated DeclaredTypes from. May be null. + * @param includeSelf Whether to include the type itself in the result. + * @param includeHierarchicalTypes Whether to include types from the entire hierarchy (e.g., superclasses and interfaces). + * @param includeSuperClasses Whether to include direct or hierarchical superclasses based on includeHierarchicalTypes. + * @param includeSuperInterfaces Whether to include direct or hierarchical interfaces based on includeHierarchicalTypes. + * @param typeFilters Optional predicates to filter the resulting DeclaredTypes. May be null or empty. + * @return A list of DeclaredTypes matching the specified criteria. + * Returns an empty list if the input type is null or no matching types are found. + * @throws IllegalArgumentException if any element of 'typeFilters' array is null. + */ + @Nonnull + @Immutable + static List findDeclaredTypes(Element type, + boolean includeSelf, + boolean includeHierarchicalTypes, + boolean includeSuperClasses, + boolean includeSuperInterfaces, + Predicate... typeFilters) { + return type == null ? emptyList() : findDeclaredTypes(type.asType(), includeSelf, includeHierarchicalTypes, includeSuperClasses, includeSuperInterfaces, typeFilters); + } + + /** + * Finds and returns a list of DeclaredTypes associated with the given TypeMirror based on the specified criteria. + * + *

A DeclaredType typically refers to a type that is explicitly declared in the code, such as classes, + * interfaces, enums, or annotation types. This method allows filtering based on whether to include: + * - The type itself + * - Direct or hierarchical superclasses (based on the includeHierarchicalTypes flag) + * - Direct or hierarchical interfaces (based on the includeHierarchicalTypes flag) + * + * @param type The TypeMirror to find associated DeclaredTypes from. May be null. + * @param includeSelf Whether to include the type itself in the result. + * @param includeHierarchicalTypes Whether to include types from the entire hierarchy (e.g., superclasses and interfaces). + * @param includeSuperClasses Whether to include direct or hierarchical superclasses based on includeHierarchicalTypes. + * @param includeSuperInterfaces Whether to include direct or hierarchical interfaces based on includeHierarchicalTypes. + * @param typeFilters Optional predicates to filter the resulting DeclaredTypes. May be null or empty. + * @return A list of DeclaredTypes matching the specified criteria. + * Returns an empty list if the input type is null or no matching types are found. + * @throws IllegalArgumentException if any element of 'typeFilters' array is null. + */ + @Nonnull + @Immutable + static List findDeclaredTypes(TypeMirror type, + boolean includeSelf, + boolean includeHierarchicalTypes, + boolean includeSuperClasses, + boolean includeSuperInterfaces, + Predicate... typeFilters) { + return type == null ? emptyList() : ofDeclaredTypes(getTypeElements(ofTypeElement(type), includeSelf, includeHierarchicalTypes, includeSuperClasses, includeSuperInterfaces), typeFilters); + } + + /** + * Retrieves a list of TypeMirrors representing the interfaces directly implemented by the given TypeMirror. + * This method only returns interfaces that are directly declared on the specified type, + * and does not include interfaces from superclasses or superinterfaces. + * + * @param type The TypeMirror whose directly implemented interfaces are to be retrieved, may be null. + * @return A list of TypeMirrors representing the interfaces directly implemented by the given TypeMirror. + * Returns an empty list if the input is null or no interfaces are directly implemented. + */ + @Nonnull + @Immutable + static List getTypeMirrorsOfInterfaces(TypeMirror type) { + return type == null ? emptyList() : findTypeMirrorsOfInterfaces(type, EMPTY_PREDICATE_ARRAY); + } + + /** + * Retrieves a list of TypeMirrors representing the interfaces directly implemented by the given TypeElement. + * This method only returns interfaces that are directly declared on the specified type, + * and does not include interfaces from superclasses or superinterfaces. + * + * @param type The TypeElement whose directly implemented interfaces are to be retrieved, may be null. + * @return A list of TypeMirrors representing the interfaces directly implemented by the given TypeElement. + * Returns an empty list if the input is null or no interfaces are directly implemented. + */ + @Nonnull + @Immutable + static List getTypeMirrorsOfInterfaces(TypeElement type) { + return type == null ? emptyList() : findTypeMirrorsOfInterfaces(type, EMPTY_PREDICATE_ARRAY); + } + + /** + * Retrieves a list of TypeMirrors representing the interfaces directly implemented by the given TypeMirror. + * This method only returns interfaces that are directly declared on the specified type, + * and does not include interfaces from superclasses or superinterfaces. + * + * @param type The TypeMirror whose directly implemented interfaces are to be retrieved, may be null. + * @param interfaceFilters Optional predicates to filter the resulting TypeMirrors. May be null or empty. + * @return A list of TypeMirrors representing the interfaces directly implemented by the given TypeMirror, + * filtered by the provided predicates. Returns an empty list if the input is null or no interfaces + * are directly implemented. + */ + @Nonnull + @Immutable + static List findTypeMirrorsOfInterfaces(TypeMirror type, Predicate... interfaceFilters) { + return type == null ? emptyList() : findTypeMirrorsOfInterfaces(ofTypeElement(type), interfaceFilters); + } + + /** + * Retrieves a list of TypeMirrors representing the interfaces directly implemented by the given TypeElement. + * This method only returns interfaces that are directly declared on the specified type, + * and does not include interfaces from superclasses or superinterfaces. + * + * @param type The TypeElement whose directly implemented interfaces are to be retrieved, may be null. + * @param interfaceFilters Optional predicates to filter the resulting TypeMirrors. May be null or empty. + * @return A list of TypeMirrors representing the interfaces directly implemented by the given TypeElement, + * filtered by the provided predicates. Returns an empty list if the input is null or no interfaces + * are directly implemented. + */ + @Nonnull + @Immutable + static List findTypeMirrorsOfInterfaces(TypeElement type, Predicate... interfaceFilters) { + if (type == null) { + return emptyList(); + } + List typeMirrors = getTypeElementsOfInterfaces(type).stream() + .map(TypeElement::asType) + .filter(and(interfaceFilters)) + .collect(toList()); + return typeMirrors.isEmpty() ? emptyList() : typeMirrors; + } + + /** + * Retrieves a list of TypeMirrors representing all interfaces implemented in the entire hierarchy + * of the given TypeMirror. This includes both directly and indirectly implemented interfaces from + * superclasses and superinterfaces. + * + * @param type The TypeMirror whose interface hierarchy is to be explored, may be null. + * @return A list of TypeMirrors representing all implemented interfaces in the hierarchy of + * the provided TypeMirror. Returns an empty list if the input is null or no interfaces + * are found in the hierarchy. + */ + @Nonnull + @Immutable + static List getAllTypeMirrorsOfInterfaces(TypeMirror type) { + return findAllTypeMirrorsOfInterfaces(type, EMPTY_PREDICATE_ARRAY); + } + + /** + * Retrieves a list of TypeMirrors representing all interfaces implemented in the entire hierarchy + * of the given TypeElement. This includes both directly and indirectly implemented interfaces from + * superclasses and superinterfaces. + * + * @param type The TypeElement whose interface hierarchy is to be explored, may be null. + * @return A list of TypeMirrors representing all implemented interfaces in the hierarchy of + * the provided TypeElement. Returns an empty list if the input is null or no interfaces + * are found in the hierarchy. + */ + @Nonnull + @Immutable + static List getAllTypeMirrorsOfInterfaces(TypeElement type) { + return findAllTypeMirrorsOfInterfaces(type, EMPTY_PREDICATE_ARRAY); + } + + /** + * Retrieves a list of TypeMirrors representing all interfaces implemented in the entire hierarchy + * of the given TypeMirror. This includes both directly and indirectly implemented interfaces from + * superclasses and superinterfaces. Optionally applies an array of predicates to filter the resulting TypeMirrors. + * + * @param type The TypeMirror whose interface hierarchy is to be explored, may be null. + * @param interfaceFilters Optional predicates to filter the resulting TypeMirrors. May be null or empty. + * @return A list of TypeMirrors representing all implemented interfaces in the hierarchy of + * the provided TypeMirror, filtered by the provided predicates. Returns an empty list if + * the input is null or no interfaces are found in the hierarchy. + */ + @Nonnull + @Immutable + static List findAllTypeMirrorsOfInterfaces(TypeMirror type, Predicate... interfaceFilters) { + return type == null ? emptyList() : findAllTypeMirrorsOfInterfaces(ofTypeElement(type), interfaceFilters); + } + + /** + * Retrieves a list of TypeMirrors representing all interfaces implemented in the entire hierarchy + * of the given TypeElement. This includes both directly and indirectly implemented interfaces from + * superclasses and superinterfaces. Optionally applies an array of predicates to filter the resulting TypeMirrors. + * + * @param type The TypeElement whose interface hierarchy is to be explored, may be null. + * @param interfaceFilters Optional predicates to filter the resulting TypeMirrors. May be null or empty. + * @return A list of TypeMirrors representing all implemented interfaces in the hierarchy of + * the provided TypeElement, filtered by the provided predicates. Returns an empty list if + * the input is null or no interfaces are found in the hierarchy. + */ + @Nonnull + @Immutable + static List findAllTypeMirrorsOfInterfaces(TypeElement type, Predicate... interfaceFilters) { + if (type == null) { + return emptyList(); + } + List typeMirrors = getAllTypeElementsOfInterfaces(type).stream() + .map(TypeElement::asType) + .filter(and(interfaceFilters)) + .collect(toList()); + return typeMirrors.isEmpty() ? emptyList() : typeMirrors; + } + + /** + * Finds and returns the TypeMirror representing the specified interface type from the given Element. + * If the provided Element or interfaceType is null, returns null. + * + * @param type The Element to find the interface TypeMirror from. May be null. + * @param interfaceType The Type representing the interface to search for. May be null. + * @return The TypeMirror of the specified interface if found; otherwise, null. + */ + @Nullable + static TypeMirror findInterfaceTypeMirror(Element type, Type interfaceType) { + return findInterfaceTypeMirror(type, interfaceType.getTypeName()); + } + + /** + * Finds and returns the TypeMirror representing the specified interface type from the given TypeMirror. + * If the provided TypeMirror or interfaceType is null, returns null. + * + * @param type The TypeMirror to find the interface TypeMirror from. May be null. + * @param interfaceType The Type representing the interface to search for. May be null. + * @return The TypeMirror of the specified interface if found; otherwise, null. + */ + @Nullable + static TypeMirror findInterfaceTypeMirror(TypeMirror type, Type interfaceType) { + return findInterfaceTypeMirror(type, interfaceType.getTypeName()); + } + + /** + * Finds and returns the TypeMirror representing the specified interface type from the given Element. + * If the provided Element or interfaceClassName is null, returns null. + * + * @param type The Element to find the interface TypeMirror from. May be null. + * @param interfaceClassName The fully qualified class name of the interface to search for. May be null. + * @return The TypeMirror of the specified interface if found; otherwise, null. + */ + @Nullable + static TypeMirror findInterfaceTypeMirror(Element type, CharSequence interfaceClassName) { + return type == null ? null : findInterfaceTypeMirror(type.asType(), interfaceClassName); + } + + /** + * Finds and returns the TypeMirror representing the specified interface type from the given TypeMirror. + * If the provided TypeMirror or interfaceClassName is null, returns null. + * + *

This method searches through all interfaces implemented in the entire hierarchy of the given TypeMirror, + * including both directly and indirectly implemented interfaces from superclasses and superinterfaces. + * + * @param type The TypeMirror to find the interface TypeMirror from. May be null. + * @param interfaceClassName The fully qualified class name of the interface to search for. May be null. + * @return The TypeMirror of the specified interface if found; otherwise, null. + */ + @Nullable + static TypeMirror findInterfaceTypeMirror(TypeMirror type, CharSequence interfaceClassName) { + return filterFirst(getAllTypeMirrorsOfInterfaces(type), t -> isSameType(t, interfaceClassName)); + } + + /** + * Converts an array of Type objects to a list of TypeMirror instances using the provided ProcessingEnvironment. + * If the input array is null or empty, returns an empty list. + * + * @param processingEnv The ProcessingEnvironment used to resolve TypeMirrors. Must not be null. + * @param types The array of Type objects to convert. May contain null elements which will be ignored. + * @return A list of TypeMirror instances derived from the given Types. Returns an empty list if the input array is null or empty, + * or if no valid TypeMirror instances could be resolved. + */ + @Nonnull + @Immutable + static List getTypeMirrors(ProcessingEnvironment processingEnv, Type... types) { + if (isEmpty(types)) { + return emptyList(); + } + List typeMirrors = of(types) + .filter(Objects::nonNull) + .map(t -> getTypeMirror(processingEnv, t)) + .filter(Objects::nonNull) + .collect(toList()); + return typeMirrors.isEmpty() ? emptyList() : unmodifiableList(typeMirrors); + } + + /** + * Converts the given Type to a TypeMirror using the provided ProcessingEnvironment. + * + *

If the provided Type is null, this method returns null. Otherwise, it attempts + * to resolve the Type into a TypeElement and then retrieves its corresponding TypeMirror. + * + * @param processingEnv The ProcessingEnvironment used to resolve TypeMirrors. Must not be null. + * @param type The Type to convert to a TypeMirror. May be null. + * @return The resolved TypeMirror if available; otherwise, null. + */ + @Nullable + static TypeMirror getTypeMirror(ProcessingEnvironment processingEnv, Type type) { + TypeElement typeElement = getTypeElement(processingEnv, type); + return typeElement == null ? null : typeElement.asType(); + } + + /** + * Converts an array of Type objects to a list of TypeElement instances using the provided ProcessingEnvironment. + * If the input array is null or empty, returns an empty list. + * + * @param processingEnv The ProcessingEnvironment used to resolve TypeElements. Must not be null. + * @param types The array of Type objects to convert. May contain null elements which will be ignored. + * @return A list of TypeElement instances derived from the given Types. Returns an empty list if the input array is null or empty, + * or if no valid TypeElement instances could be resolved. + */ + @Nonnull + @Immutable + static List getTypeElements(ProcessingEnvironment processingEnv, Type... types) { + if (isEmpty(types)) { + return emptyList(); + } + List typeElements = of(types) + .filter(Objects::nonNull) + .map(t -> getTypeElement(processingEnv, t)) + .filter(Objects::nonNull) + .collect(toList()); + return typeElements.isEmpty() ? emptyList() : unmodifiableList(typeElements); + } + + /** + * Retrieves the TypeElement corresponding to the given Type using the provided ProcessingEnvironment. + * + *

If the provided {@link Type} is null, this method returns null. Otherwise, it attempts + * to resolve the Type into a TypeElement by first obtaining its fully qualified type name + * and then using the ElementUtils from the ProcessingEnvironment. + * + * @param processingEnv The ProcessingEnvironment used to resolve TypeElements. Must not be null. + * @param type The Type to convert to a TypeElement. May be null. + * @return The resolved TypeElement if available; otherwise, null. + */ + @Nullable + static TypeElement getTypeElement(ProcessingEnvironment processingEnv, Type type) { + return type == null ? null : getTypeElement(processingEnv, type.getTypeName()); + } + + /** + * Retrieves the TypeElement corresponding to the given TypeMirror using the provided ProcessingEnvironment. + * + *

If the provided {@link TypeMirror} is null, this method returns null. Otherwise, it attempts + * to resolve the TypeMirror into a TypeElement by first obtaining its fully qualified type name + * and then using the ElementUtils from the ProcessingEnvironment. + * + * @param processingEnv The ProcessingEnvironment used to resolve TypeElements. Must not be null. + * @param type The TypeMirror to convert to a TypeElement. May be null. + * @return The resolved TypeElement if available; otherwise, null. + */ + @Nullable + static TypeElement getTypeElement(ProcessingEnvironment processingEnv, TypeMirror type) { + return type == null ? null : getTypeElement(processingEnv, type.toString()); + } + + /** + * Retrieves the TypeElement corresponding to the given type name using the provided ProcessingEnvironment. + * + *

If the provided {@link ProcessingEnvironment} or typeName is null, this method returns null. + * Otherwise, it uses the ElementUtils from the ProcessingEnvironment to find and return the TypeElement. + * + * @param processingEnv The ProcessingEnvironment used to resolve TypeElements. Must not be null. + * @param typeName The fully qualified class name of the type to search for. May be null. + * @return The resolved TypeElement if available; otherwise, null. + */ + @Nullable + static TypeElement getTypeElement(ProcessingEnvironment processingEnv, CharSequence typeName) { + if (processingEnv == null || typeName == null) { + return null; + } + Elements elements = processingEnv.getElementUtils(); + return elements.getTypeElement(typeName); + } + + /** + * Retrieves the DeclaredType corresponding to the given Type using the provided ProcessingEnvironment. + * + *

If the provided {@link Type} is null, this method returns null. Otherwise, it attempts + * to resolve the Type into a DeclaredType by first obtaining its fully qualified type name + * and then using the ElementUtils from the ProcessingEnvironment to find the corresponding TypeElement. + * + * @param processingEnv The ProcessingEnvironment used to resolve DeclaredTypes. Must not be null. + * @param type The Type to convert to a DeclaredType. May be null. + * @return The resolved DeclaredType if available; otherwise, null. + */ + @Nullable + static DeclaredType getDeclaredType(ProcessingEnvironment processingEnv, Type type) { + return type == null ? null : getDeclaredType(processingEnv, type.getTypeName()); + } + + /** + * Retrieves the DeclaredType corresponding to the given TypeMirror using the provided ProcessingEnvironment. + * + *

If the provided {@link TypeMirror} is null, this method returns null. Otherwise, it attempts + * to resolve the TypeMirror into a DeclaredType by first obtaining its fully qualified type name + * and then using the ElementUtils from the ProcessingEnvironment to find the corresponding TypeElement. + * + * @param processingEnv The ProcessingEnvironment used to resolve DeclaredTypes. Must not be null. + * @param type The TypeMirror to convert to a DeclaredType. May be null. + * @return The resolved DeclaredType if available; otherwise, null. + */ + @Nullable + static DeclaredType getDeclaredType(ProcessingEnvironment processingEnv, TypeMirror type) { + return type == null ? null : getDeclaredType(processingEnv, type.toString()); + } + + /** + * Retrieves the DeclaredType corresponding to the given type name using the provided ProcessingEnvironment. + * + *

If the provided {@link ProcessingEnvironment} or typeName is null, this method returns null. + * Otherwise, it uses the ElementUtils from the ProcessingEnvironment to find and return the TypeElement, + * then converts it to a DeclaredType. + * + * @param processingEnv The ProcessingEnvironment used to resolve DeclaredTypes. Must not be null. + * @param typeName The fully qualified class name of the type to search for. May be null. + * @return The resolved DeclaredType if available; otherwise, null. + */ + @Nullable + static DeclaredType getDeclaredType(ProcessingEnvironment processingEnv, CharSequence typeName) { + return ofDeclaredType(getTypeElement(processingEnv, typeName)); + } + + /** + * Converts the given TypeMirror to its string representation. + * This method is typically used to obtain a readable and fully qualified name of the type, + * including any type parameters if present. + * + * @param type The TypeMirror to convert to a string, may be null. + * @return The string representation of the TypeMirror, or null if the input is null. + */ + @Nullable + static String toString(TypeMirror type) { + return getTypeName(type); + } + + /** + * Gets the fully qualified name of the given TypeMirror, including type parameters if present. + * + * @param type The TypeMirror to get the name from, may be null. + * @return The fully qualified name of the type including type parameters, or null if the input is null. + */ + @Nullable + static String getTypeName(TypeMirror type) { + if (type == null) { + return null; + } + TypeElement element = ofTypeElement(type); + if (element != null) { + List typeParameterElements = element.getTypeParameters(); + int typeParameterElementsSize = typeParameterElements.size(); + if (typeParameterElementsSize > 0) { + List typeMirrors = invokeMethod(type, "getTypeArguments"); + int size = typeMirrors.size(); + if (size > 0) { + StringBuilder typeBuilder = new StringBuilder(element.toString()); + typeBuilder.append(LESS_THAN_CHAR) + .append(typeMirrors) + .append(GREATER_THAN_CHAR); + return typeBuilder.toString(); + } + } + } + return type.toString(); + } + + /** + * Creates a TypeFinder instance for the specified TypeElement with configurable inclusion options. + * + *

This method allows searching for associated types based on the provided criteria: + * + *

    + *
  • {@code includeSelf} - Whether to include the type itself in the result.
    • + *
  • {@code includeHierarchicalTypes} - Whether to include types from the entire hierarchy (e.g., superclasses and interfaces).
    • + *
  • {@code includeSuperclass} - Whether to include direct or hierarchical superclasses based on includeHierarchicalTypes.
    • + *
  • {@code includeInterfaces} - Whether to include direct or hierarchical interfaces based on includeHierarchicalTypes.
    • + *
+ * + * @param typeElement The TypeElement to start the search from. Must not be null. + * @param includeSelf Whether to include the type itself in the result. + * @param includeHierarchicalTypes Whether to include types from the entire hierarchy. + * @param includeSuperclass Whether to include direct or hierarchical superclasses. + * @param includeInterfaces Whether to include direct or hierarchical interfaces. + * @return A TypeFinder instance configured with the given parameters. + * @throws IllegalArgumentException if any parameter is invalid or if assertions fail. + */ + @Nonnull + static TypeFinder typeElementFinder(TypeElement typeElement, boolean includeSelf, + boolean includeHierarchicalTypes, boolean includeSuperclass, boolean includeInterfaces) { + return new TypeFinder(typeElement, TYPE_ELEMENT_GET_SUPERCLASS, TYPE_ELEMENT_GET_INTERFACES, includeSelf, + includeHierarchicalTypes, includeSuperclass, includeInterfaces); + } +} \ No newline at end of file diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/element/StringAnnotationValueTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/element/StringAnnotationValueTest.java new file mode 100644 index 000000000..df77ef12c --- /dev/null +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/element/StringAnnotationValueTest.java @@ -0,0 +1,53 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.lang.model.element; + + +import io.microsphere.lang.model.util.ResolvableAnnotationValueVisitor; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +/** + * {@link StringAnnotationValue} Test + * + * @author Mercy + * @see StringAnnotationValue + * @since 1.0.0 + */ +class StringAnnotationValueTest { + + private StringAnnotationValue value; + + @BeforeEach + void setUp() { + this.value = new StringAnnotationValue("testing"); + } + + @Test + void testGetValue() { + assertEquals("testing", value.getValue()); + } + + @Test + void testAccept() { + ResolvableAnnotationValueVisitor visitor = new ResolvableAnnotationValueVisitor(); + assertEquals("testing", value.accept(visitor, null)); + } +} \ No newline at end of file diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/AnnotationUtilsTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/AnnotationUtilsTest.java new file mode 100644 index 000000000..4dec272bb --- /dev/null +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/AnnotationUtilsTest.java @@ -0,0 +1,775 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.lang.model.util; + +import io.microsphere.lang.model.element.StringAnnotationValue; +import io.microsphere.test.annotation.TestAnnotation; +import io.microsphere.test.model.Model; +import io.microsphere.test.service.TestService; +import io.microsphere.test.service.TestServiceImpl; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.cache.annotation.Cacheable; +import org.springframework.context.annotation.ComponentScan; +import org.springframework.context.annotation.ComponentScans; +import org.springframework.stereotype.Component; +import org.springframework.stereotype.Service; + +import javax.lang.model.element.AnnotationMirror; +import javax.lang.model.element.AnnotationValue; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.VariableElement; +import javax.lang.model.type.DeclaredType; +import javax.ws.rs.DefaultValue; +import javax.ws.rs.GET; +import javax.ws.rs.HttpMethod; +import javax.ws.rs.Path; +import javax.ws.rs.PathParam; +import javax.xml.ws.ServiceMode; +import java.io.Serializable; +import java.lang.annotation.Annotation; +import java.lang.annotation.Documented; +import java.lang.annotation.ElementType; +import java.lang.annotation.Inherited; +import java.lang.annotation.Target; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; + +import static io.microsphere.lang.function.Predicates.alwaysFalse; +import static io.microsphere.lang.function.Predicates.alwaysTrue; +import static io.microsphere.lang.model.util.AnnotationUtils.EMPTY_ELEMENT_TYPE_ARRAY; +import static io.microsphere.lang.model.util.AnnotationUtils.findAllAnnotations; +import static io.microsphere.lang.model.util.AnnotationUtils.findAnnotation; +import static io.microsphere.lang.model.util.AnnotationUtils.findAnnotations; +import static io.microsphere.lang.model.util.AnnotationUtils.findMetaAnnotation; +import static io.microsphere.lang.model.util.AnnotationUtils.getAllAnnotations; +import static io.microsphere.lang.model.util.AnnotationUtils.getAnnotation; +import static io.microsphere.lang.model.util.AnnotationUtils.getAnnotations; +import static io.microsphere.lang.model.util.AnnotationUtils.getAttribute; +import static io.microsphere.lang.model.util.AnnotationUtils.getAttributeName; +import static io.microsphere.lang.model.util.AnnotationUtils.getAttributesMap; +import static io.microsphere.lang.model.util.AnnotationUtils.getElementTypes; +import static io.microsphere.lang.model.util.AnnotationUtils.getElementValue; +import static io.microsphere.lang.model.util.AnnotationUtils.getElementValues; +import static io.microsphere.lang.model.util.AnnotationUtils.getValue; +import static io.microsphere.lang.model.util.AnnotationUtils.isAnnotationPresent; +import static io.microsphere.lang.model.util.AnnotationUtils.matchesAnnotationTypeName; +import static io.microsphere.lang.model.util.AnnotationUtils.matchesAttributeMethod; +import static io.microsphere.lang.model.util.AnnotationUtils.matchesAttributeValue; +import static io.microsphere.lang.model.util.AnnotationUtils.matchesDefaultAttributeValue; +import static io.microsphere.lang.model.util.FieldUtils.findField; +import static io.microsphere.lang.model.util.MethodUtils.findMethod; +import static io.microsphere.lang.model.util.MethodUtils.getAllDeclaredMethods; +import static io.microsphere.util.ArrayUtils.EMPTY_STRING_ARRAY; +import static io.microsphere.util.ArrayUtils.ofArray; +import static io.microsphere.util.StringUtils.EMPTY_STRING; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.TYPE; +import static java.util.Collections.emptyMap; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * The {@link AnnotationUtils} Test + * + * @author Mercy + * @since 1.0.0 + */ +class AnnotationUtilsTest extends UtilTest { + + @Test + void testGetAnnotation() { + asserGetAnnotation(Service.class); + } + + @Test + void testGetAnnotationWithClassName() { + asserGetAnnotation("org.springframework.stereotype.Service"); + } + + @Test + void testGetAnnotationOnNull() { + assertNull(getAnnotation(testTypeElement, NULL_CLASS)); + assertNull(getAnnotation(testTypeElement.asType(), NULL_CLASS)); + assertNull(getAnnotation(NULL_ANNOTATED_CONSTRUCT, NULL_CLASS)); + } + + @Test + void testGetAnnotationWithClassNameOnNull() { + assertNull(getAnnotation(testTypeElement, NULL_STRING)); + assertNull(getAnnotation(testTypeElement.asType(), NULL_STRING)); + assertNull(getAnnotation(NULL_ANNOTATED_CONSTRUCT, NULL_STRING)); + } + + @Test + void testGetAnnotations() { + List annotations = getAnnotations(testTypeElement); + assertEquals(4, annotations.size()); + assertAnnotation(annotations.get(0), Service.class); + assertAnnotation(annotations.get(1), ServiceMode.class); + assertAnnotation(annotations.get(2), ComponentScans.class); + assertAnnotation(annotations.get(3), TestAnnotation.class); + } + + @Test + void testGetAnnotationsOnNull() { + List annotations = getAnnotations(NULL_ANNOTATED_CONSTRUCT); + assertEmptyList(annotations); + } + + @Test + void testGetAnnotationsWithAnnotationClass() { + assertGetAnnotations(Service.class); + assertGetAnnotations(ServiceMode.class); + } + + @Test + void testGetAnnotationsWithAnnotationClassOnNull() { + assertTrue(getAnnotations(NULL_ANNOTATED_CONSTRUCT, NULL_CLASS).isEmpty()); + assertTrue(getAnnotations(testTypeElement, NULL_CLASS).isEmpty()); + assertTrue(getAnnotations(NULL_ANNOTATED_CONSTRUCT, Service.class).isEmpty()); + } + + @Test + void testGetAnnotationsWithAnnotationClassOnNotFound() { + List annotations = getAnnotations(testTypeElement, Override.class); + assertEquals(0, annotations.size()); + } + + @Test + void testGetAnnotationsWithAnnotationClassName() { + assertGetAnnotations("org.springframework.stereotype.Service"); + assertGetAnnotations("javax.xml.ws.ServiceMode"); + } + + @Test + void testGetAnnotationsWithAnnotationClassNameOnNull() { + assertTrue(getAnnotations(NULL_ANNOTATED_CONSTRUCT, NULL_STRING).isEmpty()); + assertTrue(getAnnotations(testTypeElement, NULL_STRING).isEmpty()); + assertTrue(getAnnotations(NULL_ANNOTATED_CONSTRUCT, "org.springframework.stereotype.Service").isEmpty()); + } + + @Test + void testGetAllAnnotations() { + List annotations = getAllAnnotations(testTypeElement); + assertEquals(5, annotations.size()); + + annotations = getAllAnnotations(testTypeMirror); + assertEquals(5, annotations.size()); + } + + @Test + void testGetAllAnnotationsOnNull() { + assertEmptyList(getAllAnnotations(NULL_ELEMENT)); + assertEmptyList(getAllAnnotations(NULL_TYPE_MIRROR)); + } + + @Test + void testGetAllAnnotationsWithAnnotationClass() { + List annotations = getAllAnnotations(testTypeElement, Override.class); + assertEquals(0, annotations.size()); + + annotations = getAllAnnotations(testTypeMirror, Override.class); + assertEquals(0, annotations.size()); + + annotations = getAllAnnotations(testTypeElement, Service.class); + assertEquals(1, annotations.size()); + + annotations = getAllAnnotations(testTypeMirror, Service.class); + assertEquals(1, annotations.size()); + + annotations = getAllAnnotations(processingEnv, TestServiceImpl.class); + assertEquals(5, annotations.size()); + } + + @Test + void testGetAllAnnotationsWithAnnotationClassOnNull() { + assertEmptyList(getAllAnnotations(NULL_ELEMENT, NULL_CLASS)); + assertEmptyList(getAllAnnotations(NULL_TYPE_MIRROR, NULL_CLASS)); + assertEmptyList(getAllAnnotations(NULL_PROCESSING_ENVIRONMENT, NULL_CLASS)); + + assertEmptyList(getAllAnnotations(NULL_ELEMENT, Service.class)); + assertEmptyList(getAllAnnotations(NULL_TYPE_MIRROR, Service.class)); + assertEmptyList(getAllAnnotations(NULL_PROCESSING_ENVIRONMENT, Service.class)); + + assertEmptyList(getAllAnnotations(testTypeElement, NULL_CLASS)); + assertEmptyList(getAllAnnotations(testTypeMirror, NULL_CLASS)); + assertEmptyList(getAllAnnotations(processingEnv, NULL_CLASS)); + } + + @Test + void testGetAllAnnotationsWithAnnotationClassName() { + List annotations = getAllAnnotations(testTypeElement, "java.lang.Override"); + assertEquals(0, annotations.size()); + + annotations = getAllAnnotations(testTypeMirror, "org.springframework.stereotype.Service"); + assertEquals(1, annotations.size()); + } + + @Test + void testGetAllAnnotationsWithAnnotationClassNameOnNull() { + assertEmptyList(getAllAnnotations(NULL_ELEMENT, NULL_STRING)); + assertEmptyList(getAllAnnotations(NULL_TYPE_MIRROR, NULL_STRING)); + + assertTrue(getAllAnnotations(NULL_ELEMENT, "org.springframework.stereotype.Service").isEmpty()); + assertTrue(getAllAnnotations(NULL_TYPE_MIRROR, "org.springframework.stereotype.Service").isEmpty()); + + assertEmptyList(getAllAnnotations(testTypeElement, NULL_STRING)); + assertEmptyList(getAllAnnotations(testTypeMirror, NULL_STRING)); + } + + @Test + void testFindAnnotation() { + assertFindAnnotation(Service.class); + assertFindAnnotation(Path.class); + } + + @Test + void testFindAnnotationOnNotFound() { + assertNull(findAnnotation(testTypeMirror, Target.class)); + assertNull(findAnnotation(testTypeElement, Target.class)); + assertNull(findAnnotation(testTypeMirror, Override.class)); + assertNull(findAnnotation(testTypeElement, Override.class)); + } + + @Test + void testFindAnnotationOnNull() { + assertNull(findAnnotation(NULL_ELEMENT, NULL_CLASS)); + assertNull(findAnnotation(NULL_TYPE_MIRROR, NULL_CLASS)); + assertNull(findAnnotation(testTypeMirror, NULL_CLASS)); + assertNull(findAnnotation(testTypeElement, NULL_CLASS)); + + assertNull(findAnnotation(NULL_ELEMENT, NULL_STRING)); + assertNull(findAnnotation(NULL_TYPE_MIRROR, NULL_STRING)); + assertNull(findAnnotation(testTypeMirror, NULL_STRING)); + assertNull(findAnnotation(testTypeElement, NULL_STRING)); + } + + @Test + void testFindMetaAnnotationWithAnnotationClass() { + getAllDeclaredMethods(getTypeElement(TestService.class)).forEach(method -> { + assertFindMetaAnnotation(method, HttpMethod.class); + }); + } + + @Test + void testFindMetaAnnotationWithAnnotationClassOnNotFound() { + assertNull(findMetaAnnotation(testTypeElement, Service.class)); + } + + @Test + void testFindMetaAnnotationWithAnnotationClassNameOnNotFound() { + assertNull(findMetaAnnotation(testTypeElement, "org.springframework.stereotype.Service")); + } + + @Test + void testFindMetaAnnotationWithAnnotationClassOnNull() { + assertNull(findMetaAnnotation(NULL_ELEMENT, NULL_CLASS)); + assertNull(findMetaAnnotation(NULL_ELEMENT, Service.class)); + assertNull(findMetaAnnotation(testTypeElement, NULL_CLASS)); + } + + @Test + void testFindMetaAnnotationWithAnnotationClassName() { + getAllDeclaredMethods(getTypeElement(TestService.class)).forEach(method -> { + assertFindMetaAnnotation(method, "javax.ws.rs.HttpMethod"); + }); + } + + @Test + void testFindMetaAnnotationWithAnnotationClassNameOnNull() { + assertNull(findMetaAnnotation(NULL_ELEMENT, NULL_STRING)); + assertNull(findMetaAnnotation(NULL_ELEMENT, "test")); + assertNull(findMetaAnnotation(testTypeElement, NULL_STRING)); + } + + @Test + void testFindAllAnnotationsWithTypeMirror() { + List annotations = findAllAnnotations(testTypeMirror, alwaysTrue()); + assertEquals(5, annotations.size()); + + annotations = findAllAnnotations(testTypeMirror, alwaysFalse()); + assertEmptyList(annotations); + } + + @Test + void testFindAllAnnotationsWithTypeElement() { + List annotations = findAllAnnotations(testTypeElement, alwaysTrue()); + assertEquals(5, annotations.size()); + + annotations = findAllAnnotations(testTypeElement, alwaysFalse()); + assertEmptyList(annotations); + } + + @Test + void testFindAllAnnotationsWithMethod() { + ExecutableElement method = findMethod(testTypeElement, "echo", String.class); + + List annotations = findAllAnnotations(method, alwaysTrue()); + assertEquals(1, annotations.size()); + assertAnnotation(annotations.get(0), Cacheable.class); + + method = findMethod(getTypeElement(TestService.class), "echo", String.class); + + annotations = findAllAnnotations(method); + assertEquals(1, annotations.size()); + assertAnnotation(annotations.get(0), GET.class); + } + + @Test + void testFindAllAnnotationsWithMethodParameters() { + ExecutableElement method = findMethod(getTypeElement(TestService.class), "echo", String.class); + List parameters = method.getParameters(); + assertEquals(1, parameters.size()); + + List annotations = findAllAnnotations(parameters.get(0), alwaysTrue()); + assertEquals(2, annotations.size()); + assertAnnotation(annotations.get(0), PathParam.class); + assertAnnotation(annotations.get(1), DefaultValue.class); + + method = findMethod(getTypeElement(TestService.class), "model", Model.class); + parameters = method.getParameters(); + assertEquals(1, parameters.size()); + + annotations = findAllAnnotations(parameters.get(0)); + assertEquals(1, annotations.size()); + assertAnnotation(annotations.get(0), PathParam.class); + } + + @Test + void testFindAllAnnotationsWithField() { + VariableElement field = findField(testTypeElement, "context"); + + List annotations = findAllAnnotations(field, alwaysTrue()); + assertEquals(1, annotations.size()); + assertAnnotation(annotations.get(0), Autowired.class); + + field = findField(testTypeElement, "environment"); + annotations = findAllAnnotations(field, alwaysTrue()); + assertEmptyList(annotations); + } + + @Test + void testFindAllAnnotationsWithTypeMirrorOnNull() { + assertEmptyList(findAllAnnotations(NULL_TYPE_MIRROR, alwaysTrue())); + assertEmptyList(findAllAnnotations(NULL_TYPE_MIRROR, alwaysFalse())); + } + + @Test + void testFindAllAnnotationsWithTypeElementOnNull() { + assertEmptyList(findAllAnnotations(NULL_TYPE_ELEMENT, alwaysTrue())); + assertEmptyList(findAllAnnotations(NULL_TYPE_ELEMENT, alwaysFalse())); + } + + @Test + void testFindAllAnnotationsWithElementOnNull() { + assertEmptyList(findAllAnnotations(NULL_ELEMENT, alwaysTrue())); + assertEmptyList(findAllAnnotations(NULL_ELEMENT, alwaysFalse())); + } + + @Test + void testFindAllAnnotationsOnNull() { + assertEmptyList(findAllAnnotations(NULL_PROCESSING_ENVIRONMENT, Service.class, alwaysTrue())); + assertEmptyList(findAllAnnotations(NULL_PROCESSING_ENVIRONMENT, Service.class, alwaysTrue())); + assertEmptyList(findAllAnnotations(NULL_PROCESSING_ENVIRONMENT, "org.springframework.stereotype.Service", alwaysFalse())); + assertEmptyList(findAllAnnotations(NULL_PROCESSING_ENVIRONMENT, "org.springframework.stereotype.Service", alwaysFalse())); + assertEmptyList(findAllAnnotations(processingEnv, NULL_TYPE, alwaysTrue())); + assertEmptyList(findAllAnnotations(processingEnv, NULL_TYPE, alwaysFalse())); + assertEmptyList(findAllAnnotations(processingEnv, NULL_STRING, alwaysTrue())); + assertEmptyList(findAllAnnotations(processingEnv, NULL_STRING, alwaysFalse())); + } + + @Test + void testMatchesAnnotationClass() { + AnnotationMirror annotation = findAnnotation(testTypeElement, Service.class); + assertTrue(AnnotationUtils.matchesAnnotationType(annotation, Service.class)); + } + + @Test + void testMatchesAnnotationClassOnNull() { + assertFalse(AnnotationUtils.matchesAnnotationType(NULL_ANNOTATION_MIRROR, Service.class)); + assertFalse(AnnotationUtils.matchesAnnotationType(findAnnotation(testTypeElement, Service.class), NULL_CLASS)); + } + + @Test + void testMatchesAnnotationTypeName() { + AnnotationMirror annotation = findAnnotation(testTypeElement, "org.springframework.stereotype.Service"); + assertTrue(matchesAnnotationTypeName(annotation, "org.springframework.stereotype.Service")); + } + + @Test + void testMatchesAnnotationTypeNameOnNull() { + assertFalse(matchesAnnotationTypeName(NULL_ANNOTATION_MIRROR, "org.springframework.stereotype.Service")); + assertFalse(matchesAnnotationTypeName(findAnnotation(testTypeElement, "org.springframework.stereotype.Service"), NULL_STRING)); + } + + @Test + void testGetAttribute() { + assertEquals("testService", getAttribute(findAnnotation(testTypeElement, Service.class), "value")); + assertEquals("testService", getAttribute(findAnnotation(testTypeElement, Service.class), "value", false)); + assertEquals("/echo", getAttribute(findAnnotation(testTypeElement, Path.class), "value")); + + assertNull(getAttribute(findAnnotation(testTypeElement, Path.class), NULL_STRING)); + assertNull(getAttribute(findAnnotation(testTypeElement, NULL_CLASS), NULL_STRING)); + + ExecutableElement echoMethod = findMethod(testTypeElement, "echo", String.class); + AnnotationMirror cacheableAnnotation = findAnnotation(echoMethod, Cacheable.class); + String[] cacheNames = getAttribute(cacheableAnnotation, "cacheNames"); + assertArrayEquals(ofArray("cache-1", "cache-2"), cacheNames); + + String key = getAttribute(cacheableAnnotation, "key"); + assertEquals(EMPTY_STRING, key); + + DeclaredType cacheableAnnotationType = cacheableAnnotation.getAnnotationType(); + AnnotationMirror targetAnnotation = findAnnotation(cacheableAnnotationType, Target.class); + ElementType[] elementTypes = getAttribute(targetAnnotation, "value"); + assertArrayEquals(ofArray(TYPE, METHOD), elementTypes); + + } + + @Test + void testGetValue() { + AnnotationMirror pathAnnotation = getAnnotation(getTypeElement(TestService.class), Path.class); + assertEquals("/echo", getValue(pathAnnotation)); + } + + @Test + void testIsAnnotationPresentOnAnnotationClass() { + assertTrue(isAnnotationPresent(testTypeElement, Service.class)); + assertTrue(isAnnotationPresent(testTypeElement, Component.class)); + assertTrue(isAnnotationPresent(testTypeElement, ServiceMode.class)); + assertTrue(isAnnotationPresent(testTypeElement, Inherited.class)); + assertTrue(isAnnotationPresent(testTypeElement, Documented.class)); + } + + @Test + void testIsAnnotationPresentOnAnnotationClassOnNull() { + assertFalse(isAnnotationPresent(NULL_ELEMENT, Service.class)); + assertFalse(isAnnotationPresent(testTypeElement, NULL_CLASS)); + assertFalse(isAnnotationPresent(testTypeElement, Override.class)); + } + + @Test + void testIsAnnotationPresentOnAnnotationClassName() { + assertTrue(isAnnotationPresent(testTypeElement, "org.springframework.stereotype.Service")); + assertTrue(isAnnotationPresent(testTypeElement, "org.springframework.stereotype.Component")); + assertTrue(isAnnotationPresent(testTypeElement, "javax.xml.ws.ServiceMode")); + assertTrue(isAnnotationPresent(testTypeElement, "java.lang.annotation.Inherited")); + assertTrue(isAnnotationPresent(testTypeElement, "java.lang.annotation.Documented")); + } + + @Test + void testIsAnnotationPresentOnAnnotationClassNameOnNull() { + assertFalse(isAnnotationPresent(NULL_ELEMENT, "org.springframework.stereotype.Service")); + assertFalse(isAnnotationPresent(testTypeElement, NULL_STRING)); + assertFalse(isAnnotationPresent(testTypeElement, "java.lang.Override")); + + } + + @Test + void testFindAnnotations() { + List annotations = findAnnotations(testTypeElement); + assertEquals(4, annotations.size()); + assertAnnotation(annotations.get(0), Service.class); + assertAnnotation(annotations.get(1), ServiceMode.class); + assertAnnotation(annotations.get(2), ComponentScans.class); + assertAnnotation(annotations.get(3), TestAnnotation.class); + + annotations = findAnnotations(testTypeElement, alwaysTrue()); + assertEquals(4, annotations.size()); + assertAnnotation(annotations.get(0), Service.class); + assertAnnotation(annotations.get(1), ServiceMode.class); + assertAnnotation(annotations.get(2), ComponentScans.class); + assertAnnotation(annotations.get(3), TestAnnotation.class); + + annotations = findAnnotations(testTypeElement, alwaysFalse()); + assertEmptyList(annotations); + } + + @Test + void testFindAnnotationsOnNotFound() { + assertEmptyList(findAnnotations(getTypeElement(Serializable.class))); + } + + @Test + void testFindAnnotationsOnNull() { + assertEmptyList(findAnnotations(NULL_ELEMENT)); + } + + @Test + void testGetAttributeName() { + Map elementValues = getElementValues(testTypeElement, TestAnnotation.class); + for (Entry entry : elementValues.entrySet()) { + ExecutableElement attributeMethod = entry.getKey(); + assertEquals(attributeMethod.getSimpleName().toString(), getAttributeName(attributeMethod)); + } + } + + @Test + void testMatchesAttributeMethod() { + Map elementValues = getElementValues(testTypeElement, TestAnnotation.class); + for (Entry entry : elementValues.entrySet()) { + ExecutableElement attributeMethod = entry.getKey(); + assertTrue(matchesAttributeMethod(attributeMethod, getAttributeName(attributeMethod))); + } + } + + @Test + void testMatchesAttributeMethodOnNull() { + assertFalse(matchesAttributeMethod(null, null)); + + Map elementValues = getElementValues(testTypeElement, TestAnnotation.class); + for (Entry entry : elementValues.entrySet()) { + ExecutableElement attributeMethod = entry.getKey(); + assertFalse(matchesAttributeMethod(attributeMethod, null)); + } + } + + @Test + void testMatchesAttributeValue() { + Map elementValues = getElementValues(testTypeElement, TestAnnotation.class); + for (Entry entry : elementValues.entrySet()) { + AnnotationValue annotationValue = entry.getValue(); + assertTrue(matchesAttributeValue(annotationValue, annotationValue)); + assertTrue(matchesAttributeValue(annotationValue, annotationValue.getValue())); + } + + assertTrue(matchesAttributeValue(new StringAnnotationValue(""), new StringAnnotationValue(""))); + } + + @Test + void testMatchesAttributeValueOnNull() { + assertTrue(matchesAttributeValue(null, null)); + assertFalse(matchesAttributeValue(null, (Object) null)); + + Map elementValues = getElementValues(testTypeElement, TestAnnotation.class); + for (Entry entry : elementValues.entrySet()) { + AnnotationValue annotationValue = entry.getValue(); + assertFalse(matchesAttributeValue(annotationValue, null)); + assertFalse(matchesAttributeValue(annotationValue, (Object) null)); + } + } + + @Test + void testMatchesDefaultAttributeValue() { + Map elementValues = getElementValues(testTypeElement, ServiceMode.class); + for (Entry entry : elementValues.entrySet()) { + ExecutableElement attributeMethod = entry.getKey(); + assertTrue(matchesDefaultAttributeValue(attributeMethod, attributeMethod.getDefaultValue())); + } + } + + @Test + void testGetElementValue() { + Map elementValues = getElementValues(testTypeElement, TestAnnotation.class); + for (Entry entry : elementValues.entrySet()) { + ExecutableElement attributeMethod = entry.getKey(); + String attributeName = getAttributeName(attributeMethod); + assertEquals(entry, getElementValue(elementValues, attributeName)); + } + + assertNull(getElementValue(elementValues, "unknown")); + } + + @Test + void testGetElementValueOnEmptyElementValues() { + AnnotationMirror annotation = findAnnotation(testTypeElement, ServiceMode.class); + Map elementValues = annotation.getElementValues(); + assertNull(getElementValue(elementValues, "value")); + } + + @Test + void testGetElementValueOnNull() { + assertNull(getElementValue(null, "value")); + } + + @Test + void testGetElementValuesMapOnAnnotatedClass() { + Map attributesMap = getAttributesMap(testTypeElement, Service.class); + assertEquals(1, attributesMap.size()); + assertEquals("testService", attributesMap.get("value")); + } + + @Test + void testGetElementValuesMapOnAnnotatedMethod() { + ExecutableElement method = findMethod(testTypeElement, "echo", String.class); + Map attributesMap = getAttributesMap(method, Cacheable.class); + assertEquals(9, attributesMap.size()); + assertArrayEquals(ofArray("cache-1", "cache-2"), (String[]) attributesMap.get("cacheNames")); + } + + @Test + void testGetElementValuesMapOnRepeatableAnnotation() { + Map attributesMap = getAttributesMap(testTypeElement, ComponentScans.class); + assertEquals(1, attributesMap.size()); + + ComponentScans componentScans = testClass.getAnnotation(ComponentScans.class); + ComponentScan[] componentScanArray = (ComponentScan[]) attributesMap.get("value"); + assertEquals(2, componentScanArray.length); + assertArrayEquals(componentScanArray, componentScans.value()); + } + + @Test + void testGetElementValuesMapOnNull() { + Map attributesMap = getAttributesMap(null, null); + assertSame(emptyMap(), attributesMap); + + attributesMap = getAttributesMap(testTypeElement, null); + assertSame(emptyMap(), attributesMap); + + attributesMap = getAttributesMap(null); + assertSame(emptyMap(), attributesMap); + } + + @Test + void testGetElementValuesOnAnnotatedClass() { + Map elementValues = getElementValues(testTypeElement, Service.class); + assertServiceAttributes(elementValues); + + elementValues = getElementValues(testTypeElement, Service.class, false); + assertServiceAttributes(elementValues); + } + + @Test + void testGetElementValuesOnAnnotatedMethod() { + ExecutableElement method = findMethod(testTypeElement, "echo", String.class); + Map elementValues = getElementValues(method, Cacheable.class, false); + assertEquals(1, elementValues.size()); + assertAttributeEntry(elementValues, "cacheNames", ofArray("cache-1", "cache-2")); + + + elementValues = getElementValues(method, Cacheable.class, true); + assertEquals(9, elementValues.size()); + assertAttributeEntry(elementValues, "value", EMPTY_STRING_ARRAY); + assertAttributeEntry(elementValues, "cacheNames", ofArray("cache-1", "cache-2")); + assertAttributeEntry(elementValues, "key", EMPTY_STRING); + assertAttributeEntry(elementValues, "keyGenerator", EMPTY_STRING); + assertAttributeEntry(elementValues, "cacheManager", EMPTY_STRING); + assertAttributeEntry(elementValues, "cacheResolver", EMPTY_STRING); + assertAttributeEntry(elementValues, "condition", EMPTY_STRING); + assertAttributeEntry(elementValues, "unless", EMPTY_STRING); + assertAttributeEntry(elementValues, "sync", false); + } + + @Test + void testGetElementValuesOnNull() { + Map elementValues = getElementValues(null); + assertSame(emptyMap(), elementValues); + } + + @Test + void testGetElementTypes() { + assertElementTypes(Service.class, TYPE); + assertElementTypes(ServiceMode.class, TYPE); + assertElementTypes(ComponentScans.class, TYPE); + assertElementTypes(TestAnnotation.class, TYPE); + } + + void assertElementTypes(Class annotationClass, ElementType... expectedElementTypes) { + AnnotationMirror annotationMirror = findAnnotation(this.testTypeElement, annotationClass); + assertArrayEquals(expectedElementTypes, getElementTypes(annotationMirror)); + } + + @Test + void testGetElementTypesOnNull() { + assertSame(EMPTY_ELEMENT_TYPE_ARRAY, getElementTypes((AnnotationMirror) null)); + assertSame(EMPTY_ELEMENT_TYPE_ARRAY, getElementTypes((DeclaredType) null)); + } + + void assertServiceAttributes(Map attributes) { + assertEquals(1, attributes.size()); + assertAttributeEntry(attributes, "value", "testService"); + } + + void assertAttributeEntry(Map attributes, String attributeName, Object attributeValue) { + for (Entry entry : attributes.entrySet()) { + ExecutableElement attributeMethod = entry.getKey(); + if (matchesAttributeMethod(attributeMethod, attributeName)) { + assertAttributeEntry(entry, attributeName, attributeValue); + break; + } + } + } + + void assertAttributeEntry(Entry attributeEntry, String attributeName, Object attributeValue) { + ExecutableElement attributeMethod = attributeEntry.getKey(); + AnnotationValue annotationValue = attributeEntry.getValue(); + assertEquals(attributeName, getAttributeName(attributeMethod)); + Object value = getAttribute(attributeEntry); + Class attributeValueClass = value.getClass(); + if (attributeValueClass.isArray()) { + Class componentType = attributeValueClass.getComponentType(); + if (String.class.equals(componentType)) { + assertArrayEquals((String[]) attributeValue, (String[]) value); + } + } else { + assertEquals(attributeValue, value); + } + } + + private void assertFindMetaAnnotation(Element element, Class annotationClass) { + assertAnnotation(findMetaAnnotation(element, annotationClass), annotationClass); + } + + private void assertFindMetaAnnotation(Element element, String annotationClassName) { + assertAnnotation(findMetaAnnotation(element, annotationClassName), annotationClassName); + } + + private void assertFindAnnotation(Class annotationClass) { + assertAnnotation(findAnnotation(testTypeMirror, annotationClass), annotationClass); + assertAnnotation(findAnnotation(testTypeElement, annotationClass), annotationClass); + assertAnnotation(findAnnotation(testTypeMirror, annotationClass.getName()), annotationClass); + assertAnnotation(findAnnotation(testTypeElement, annotationClass.getName()), annotationClass); + } + + private void asserGetAnnotation(Class annotationClass) { + AnnotationMirror annotation = getAnnotation(testTypeElement, annotationClass); + assertAnnotation(annotation, annotationClass); + } + + private void asserGetAnnotation(String annotationClassName) { + AnnotationMirror annotation = getAnnotation(testTypeElement, annotationClassName); + assertAnnotation(annotation, annotationClassName); + } + + private void assertGetAnnotations(Class annotationClass) { + List annotations = getAnnotations(testTypeElement, annotationClass); + assertEquals(1, annotations.size()); + assertAnnotation(annotations.get(0), annotationClass); + } + + private void assertGetAnnotations(String annotationClassName) { + List annotations = getAnnotations(testTypeElement, annotationClassName); + assertEquals(1, annotations.size()); + assertAnnotation(annotations.get(0), annotationClassName); + } + + private void assertAnnotation(AnnotationMirror annotation, Class annotationClass) { + assertTrue(AnnotationUtils.matchesAnnotationType(annotation, annotationClass)); + assertAnnotation(annotation, annotationClass.getName()); + } + + private void assertAnnotation(AnnotationMirror annotation, String annotationClassName) { + assertEquals(annotation.getAnnotationType().toString(), annotationClassName); + } +} diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ClassUtilsTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ClassUtilsTest.java new file mode 100644 index 000000000..5f6708723 --- /dev/null +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ClassUtilsTest.java @@ -0,0 +1,51 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.lang.model.util; + +import org.junit.jupiter.api.Test; +import org.springframework.context.annotation.ComponentScan; + +import static io.microsphere.lang.model.util.ClassUtils.getClassName; +import static io.microsphere.lang.model.util.ClassUtils.loadClass; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertSame; + +/** + * {@link ClassUtils} Test + * + * @author Mercy + * @see ClassUtils + * @since 1.0.0 + */ +class ClassUtilsTest extends UtilTest { + + @Test + void testGetClassName() { + assertEquals(this.testClassName, getClassName(this.testTypeMirror)); + } + + @Test + void testLoadClassOnTypeMirror() { + assertSame(this.testClass, loadClass(this.testTypeMirror)); + } + + @Test + void testLoadClass() { + assertSame(ComponentScan.Filter.class, loadClass("org.springframework.context.annotation.ComponentScan.Filter")); + } +} diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ConstructorUtilsTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ConstructorUtilsTest.java new file mode 100644 index 000000000..8fd8e5eb5 --- /dev/null +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ConstructorUtilsTest.java @@ -0,0 +1,150 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.lang.model.util; + + +import io.microsphere.test.annotation.processing.AbstractAnnotationProcessingTest; +import org.junit.jupiter.api.Test; +import org.springframework.core.env.Environment; + +import javax.lang.model.element.ExecutableElement; +import java.io.Serializable; +import java.util.List; + +import static io.microsphere.lang.function.Predicates.alwaysFalse; +import static io.microsphere.lang.function.Predicates.alwaysTrue; +import static io.microsphere.lang.model.util.ConstructorUtils.findConstructor; +import static io.microsphere.lang.model.util.ConstructorUtils.findDeclaredConstructors; +import static io.microsphere.lang.model.util.ConstructorUtils.getDeclaredConstructors; +import static io.microsphere.lang.model.util.ElementUtils.matchParameterTypes; +import static java.util.Collections.emptyList; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * {@link ConstructorUtils} Test + * + * @author Mercy + * @see ConstructorUtils + * @since 1.0.0 + */ +class ConstructorUtilsTest extends UtilTest { + + @Test + void testGetDeclaredConstructors() { + List constructors = getDeclaredConstructors(this.testTypeElement); + assertTestServiceImplConstructors(constructors); + + constructors = getDeclaredConstructors(this.testDeclaredType); + assertTestServiceImplConstructors(constructors); + } + + @Test + void testGetDeclaredConstructorsOnNull() { + assertSame(emptyList(), getDeclaredConstructors(NULL_TYPE_ELEMENT)); + assertSame(emptyList(), getDeclaredConstructors(NULL_TYPE_MIRROR)); + } + + @Test + void testFindConstructor() { + assertTestServiceImpl1stConstructor(ConstructorUtils.findConstructor(this.testTypeElement)); + assertTestServiceImpl1stConstructor(findConstructor(this.testDeclaredType)); + + assertTestServiceImpl2ndConstructor(ConstructorUtils.findConstructor(this.testTypeElement, Environment.class)); + assertTestServiceImpl2ndConstructor(findConstructor(this.testDeclaredType, Environment.class)); + } + + @Test + void testFindConstructorOnNull() { + assertNull(ConstructorUtils.findConstructor(NULL_TYPE_ELEMENT)); + assertNull(findConstructor(NULL_TYPE_MIRROR)); + + assertNull(ConstructorUtils.findConstructor(this.testTypeElement, null)); + assertNull(findConstructor(this.testDeclaredType, null)); + } + + @Test + void testFindConstructorOnMismatch() { + assertNull(ConstructorUtils.findConstructor(NULL_TYPE_ELEMENT, Object.class)); + assertNull(findConstructor(NULL_TYPE_MIRROR, Object.class)); + + assertNull(ConstructorUtils.findConstructor(NULL_TYPE_ELEMENT, Object.class, String.class)); + assertNull(findConstructor(NULL_TYPE_MIRROR, Object.class, String.class)); + + assertNull(ConstructorUtils.findConstructor(NULL_TYPE_ELEMENT, Object.class, String.class, Integer.class)); + assertNull(findConstructor(NULL_TYPE_MIRROR, Object.class, String.class, Integer.class)); + } + + @Test + void testFindConstructors() { + List constructors = findDeclaredConstructors(this.testTypeElement); + assertTestServiceImplConstructors(constructors); + + constructors = findDeclaredConstructors(this.testDeclaredType); + assertTestServiceImplConstructors(constructors); + + constructors = findDeclaredConstructors(this.testTypeElement, alwaysTrue()); + assertTestServiceImplConstructors(constructors); + + constructors = findDeclaredConstructors(this.testDeclaredType, alwaysTrue()); + assertTestServiceImplConstructors(constructors); + } + + @Test + void testFindConstructorsOnNull() { + assertSame(emptyList(), findDeclaredConstructors(NULL_TYPE_ELEMENT)); + assertSame(emptyList(), findDeclaredConstructors(NULL_TYPE_MIRROR)); + + assertSame(emptyList(), findDeclaredConstructors(this.testTypeElement, null)); + assertSame(emptyList(), findDeclaredConstructors(this.testDeclaredType, null)); + } + + @Test + void testFindConstructorsOnMismatch() { + assertSame(emptyList(), findDeclaredConstructors(this.testTypeElement, alwaysFalse())); + assertSame(emptyList(), findDeclaredConstructors(this.testDeclaredType, alwaysFalse())); + } + + @Test + void testFindConstructorsOnNotFound() { + assertSame(emptyList(), findDeclaredConstructors(getTypeElement(Serializable.class))); + assertSame(emptyList(), findDeclaredConstructors(getDeclaredType(Serializable.class))); + + assertSame(emptyList(), findDeclaredConstructors(getTypeElement(List.class))); + assertSame(emptyList(), findDeclaredConstructors(getDeclaredType(List.class))); + } + + void assertTestServiceImplConstructors(List constructors) { + assertEquals(2, constructors.size()); + assertTestServiceImpl1stConstructor(constructors.get(0)); + assertTestServiceImpl2ndConstructor(constructors.get(1)); + } + + void assertTestServiceImpl1stConstructor(ExecutableElement constructor) { + assertEquals(this.testTypeElement, constructor.getEnclosingElement()); + assertEquals(emptyList(), constructor.getParameters()); + } + + void assertTestServiceImpl2ndConstructor(ExecutableElement constructor) { + assertEquals(this.testTypeElement, constructor.getEnclosingElement()); + assertEquals(1, constructor.getParameters().size()); + assertTrue(matchParameterTypes(constructor, Environment.class)); + } +} \ No newline at end of file diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ElementUtilsTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ElementUtilsTest.java new file mode 100644 index 000000000..6fa9d8130 --- /dev/null +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ElementUtilsTest.java @@ -0,0 +1,351 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.lang.model.util; + + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.ReflectiveInvocationContext; + +import javax.lang.model.element.Element; +import javax.lang.model.element.ElementKind; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.VariableElement; +import java.lang.annotation.ElementType; +import java.lang.reflect.Method; +import java.util.List; + +import static io.microsphere.collection.ListUtils.ofList; +import static io.microsphere.lang.function.Predicates.alwaysFalse; +import static io.microsphere.lang.function.Predicates.alwaysTrue; +import static io.microsphere.lang.model.util.ElementUtils.filterElements; +import static io.microsphere.lang.model.util.ElementUtils.hasModifiers; +import static io.microsphere.lang.model.util.ElementUtils.isClass; +import static io.microsphere.lang.model.util.ElementUtils.isDeclaredType; +import static io.microsphere.lang.model.util.ElementUtils.isExecutable; +import static io.microsphere.lang.model.util.ElementUtils.isField; +import static io.microsphere.lang.model.util.ElementUtils.isInitializer; +import static io.microsphere.lang.model.util.ElementUtils.isInterface; +import static io.microsphere.lang.model.util.ElementUtils.isMember; +import static io.microsphere.lang.model.util.ElementUtils.isPublicNonStatic; +import static io.microsphere.lang.model.util.ElementUtils.isVariable; +import static io.microsphere.lang.model.util.ElementUtils.matchParameterTypeNames; +import static io.microsphere.lang.model.util.ElementUtils.matchParameterTypes; +import static io.microsphere.lang.model.util.ElementUtils.matchesElementKind; +import static io.microsphere.lang.model.util.ElementUtils.matchesElementType; +import static io.microsphere.lang.model.util.ElementUtils.toElementKind; +import static io.microsphere.lang.model.util.MemberUtils.getAllDeclaredMembers; +import static io.microsphere.lang.model.util.MemberUtils.getDeclaredMembers; +import static io.microsphere.lang.model.util.MethodUtils.findMethod; +import static java.lang.annotation.ElementType.PACKAGE; +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.ElementType.TYPE_USE; +import static java.lang.annotation.ElementType.values; +import static java.util.Collections.emptyList; +import static javax.lang.model.element.ElementKind.ANNOTATION_TYPE; +import static javax.lang.model.element.ElementKind.CLASS; +import static javax.lang.model.element.ElementKind.CONSTRUCTOR; +import static javax.lang.model.element.ElementKind.ENUM; +import static javax.lang.model.element.ElementKind.ENUM_CONSTANT; +import static javax.lang.model.element.ElementKind.EXCEPTION_PARAMETER; +import static javax.lang.model.element.ElementKind.FIELD; +import static javax.lang.model.element.ElementKind.INSTANCE_INIT; +import static javax.lang.model.element.ElementKind.INTERFACE; +import static javax.lang.model.element.ElementKind.LOCAL_VARIABLE; +import static javax.lang.model.element.ElementKind.METHOD; +import static javax.lang.model.element.ElementKind.OTHER; +import static javax.lang.model.element.ElementKind.PARAMETER; +import static javax.lang.model.element.ElementKind.RESOURCE_VARIABLE; +import static javax.lang.model.element.ElementKind.STATIC_INIT; +import static javax.lang.model.element.Modifier.PRIVATE; +import static javax.lang.model.util.ElementFilter.fieldsIn; +import static javax.lang.model.util.ElementFilter.methodsIn; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * {@link ElementUtils} Test + * + * @author Mercy + * @see ElementUtils + * @since 1.0.0 + */ +class ElementUtilsTest extends UtilTest { + + private ExecutableElement echoMethod; + + @Override + protected void beforeTest(ReflectiveInvocationContext invocationContext, ExtensionContext extensionContext) { + this.echoMethod = findMethod(testTypeElement, "echo", "java.lang.String"); + } + + @Test + void testMatchesElementTypeElementKind() { + assertTrue(matchesElementKind(echoMethod, METHOD)); + assertFalse(matchesElementKind(echoMethod, FIELD)); + } + + @Test + void testMatchesElementTypeElementKindOnNull() { + assertFalse(matchesElementKind(NULL_ELEMENT, FIELD)); + assertFalse(matchesElementKind(echoMethod, NULL_ELEMENT_KIND)); + } + + @Test + void testIsPublicNonStatic() { + methodsIn(getDeclaredMembers(testTypeElement)).forEach(method -> assertTrue(isPublicNonStatic(method))); + + // Integer#valueOf(String) is a public static method + assertFalse(isPublicNonStatic(findMethod(getTypeElement(Integer.class), "valueOf", String.class))); + } + + @Test + void testIsPublicNonStaticOnNull() { + assertFalse(isPublicNonStatic(NULL_ELEMENT)); + } + + @Test + void testHasModifiers() { + List members = getAllDeclaredMembers(testTypeElement.asType()); + List fields = fieldsIn(members); + assertTrue(hasModifiers(fields.get(0), PRIVATE)); + } + + @Test + void testHasModifiersOnNull() { + assertFalse(hasModifiers(NULL_ELEMENT)); + assertFalse(hasModifiers(testTypeElement, null)); + } + + @Test + void testIsClass() { + assertTrue(isClass(CLASS)); + assertTrue(isClass(ENUM)); + assertFalse(isClass(INTERFACE)); + } + + @Test + void testIsClassOnNull() { + assertFalse(isClass(null)); + } + + @Test + void testIsInterface() { + assertTrue(isInterface(INTERFACE)); + assertTrue(isInterface(ANNOTATION_TYPE)); + assertFalse(isInterface(CLASS)); + } + + @Test + void testIsInterfaceOnNull() { + assertFalse(isInterface(null)); + } + + @Test + void testIsDeclaredType() { + assertTrue(isDeclaredType(CLASS)); + assertTrue(isDeclaredType(ENUM)); + assertTrue(isDeclaredType(INTERFACE)); + assertTrue(isDeclaredType(ANNOTATION_TYPE)); + assertFalse(isDeclaredType(LOCAL_VARIABLE)); + } + + @Test + void testIsDeclaredTypeOnNull() { + assertFalse(isDeclaredType(null)); + } + + @Test + void testIsField() { + assertTrue(isField(FIELD)); + assertTrue(isField(ENUM_CONSTANT)); + assertFalse(isField(LOCAL_VARIABLE)); + } + + @Test + void testIsFieldOnNull() { + assertFalse(isField(null)); + } + + @Test + void testIsExecutable() { + assertTrue(isExecutable(METHOD)); + assertTrue(isExecutable(CONSTRUCTOR)); + assertTrue(isExecutable(STATIC_INIT)); + assertTrue(isExecutable(INSTANCE_INIT)); + assertFalse(isExecutable(CLASS)); + } + + @Test + void testIsExecutableOnNull() { + assertFalse(isExecutable(null)); + } + + @Test + void testIsMember() { + assertTrue(isMember(METHOD)); + assertTrue(isMember(CONSTRUCTOR)); + assertTrue(isMember(STATIC_INIT)); + assertTrue(isMember(INSTANCE_INIT)); + assertTrue(isMember(FIELD)); + assertTrue(isMember(ENUM_CONSTANT)); + assertFalse(isMember(CLASS)); + } + + @Test + void testIsMemberOnNull() { + assertFalse(isMember(null)); + } + + @Test + void testIsInitializer() { + assertTrue(isInitializer(STATIC_INIT)); + assertTrue(isInitializer(INSTANCE_INIT)); + assertFalse(isInitializer(METHOD)); + assertFalse(isInitializer(CONSTRUCTOR)); + assertFalse(isInitializer(CLASS)); + } + + @Test + void testIsInitializerOnNull() { + assertFalse(isInitializer(null)); + } + + @Test + void testIsVariable() { + assertTrue(isVariable(ENUM_CONSTANT)); + assertTrue(isVariable(FIELD)); + assertTrue(isVariable(PARAMETER)); + assertTrue(isVariable(LOCAL_VARIABLE)); + assertTrue(isVariable(EXCEPTION_PARAMETER)); + assertTrue(isVariable(RESOURCE_VARIABLE)); + assertFalse(isVariable(CLASS)); + } + + @Test + void testIsVariableOnNull() { + assertFalse(isVariable(null)); + } + + @Test + void testToElementKind() { + for (ElementType elementType : values()) { + assertElementKind(elementType); + } + } + + @Test + void testToElementKindOnNull() { + assertSame(OTHER, toElementKind(null)); + } + + @Test + void testMatchesElementType() { + for (ElementType elementType : values()) { + assertMatchesElementType(elementType); + } + } + + @Test + void testMatchesElementTypeOnNull() { + assertFalse(matchesElementType(null, (ElementType) null)); + assertFalse(matchesElementType(null, TYPE_USE)); + assertFalse(matchesElementType(toElementKind(TYPE_USE), (ElementType) null)); + } + + @Test + void testMatchesElementTypeWithArray() { + for (ElementType elementType : values()) { + assertTrue(matchesElementType(toElementKind(elementType), values())); + } + } + + @Test + void testMatchesElementTypeWithElement() { + matchesElementType(this.testTypeElement, TYPE); + } + + @Test + void testMatchesElementTypeWithArrayOnNull() { + assertFalse(matchesElementType(NULL_ELEMENT_KIND)); + assertFalse(matchesElementType(NULL_ELEMENT)); + + assertFalse(matchesElementType(NULL_ELEMENT_KIND, (ElementType[]) null)); + assertFalse(matchesElementType(NULL_ELEMENT, (ElementType[]) null)); + + assertFalse(matchesElementType(NULL_ELEMENT_KIND, TYPE_USE, PACKAGE)); + assertFalse(matchesElementType(NULL_ELEMENT, TYPE_USE, PACKAGE)); + + assertFalse(matchesElementType(toElementKind(TYPE_USE), (ElementType[]) null)); + } + + @Test + void testFilterElements() { + assertEmptyList(filterElements(ofList(testTypeElement), alwaysFalse())); + } + + @Test + void testFilterElementsOnNull() { + assertEmptyList(filterElements(NULL_LIST, alwaysTrue())); + List methods = ofList(echoMethod); + assertSame(emptyList(), filterElements(methods, NULL_PREDICATE_ARRAY)); + } + + @Test + void testFilterElementsOnEmpty() { + assertEmptyList(filterElements(emptyList(), alwaysTrue())); + List methods = ofList(echoMethod); + assertEquals(methods, filterElements(methods)); + } + + @Test + void testMatchParameterTypes() { + assertTrue(matchParameterTypes(echoMethod.getParameters(), String.class)); + assertFalse(matchParameterTypes(echoMethod.getParameters(), Object.class)); + } + + @Test + void testMatchParameterTypesOnNull() { + assertFalse(matchParameterTypes(NULL_LIST, String.class)); + assertFalse(matchParameterTypes(emptyList(), NULL_CLASS_ARRAY)); + } + + @Test + void testMatchParameterTypeNames() { + assertTrue(matchParameterTypeNames(echoMethod.getParameters(), "java.lang.String")); + assertFalse(matchParameterTypeNames(echoMethod.getParameters(), "java.lang.Object")); + } + + @Test + void testMatchParameterTypeNamesOnNull() { + assertFalse(matchParameterTypeNames(NULL_LIST, "java.lang.String")); + assertFalse(matchParameterTypeNames(emptyList(), NULL_STRING_ARRAY)); + } + + void assertElementKind(ElementType elementType) { + ElementKind elementKind = toElementKind(elementType); + assertNotNull(elementKind); + } + + void assertMatchesElementType(ElementType elementType) { + assertTrue(matchesElementType(toElementKind(elementType), elementType)); + } +} \ No newline at end of file diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ExecutableElementComparatorTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ExecutableElementComparatorTest.java new file mode 100644 index 000000000..de416226f --- /dev/null +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ExecutableElementComparatorTest.java @@ -0,0 +1,76 @@ +package io.microsphere.lang.model.util; + +import io.microsphere.test.annotation.processing.AbstractAnnotationProcessingTest; +import io.microsphere.test.service.TestService; +import org.junit.jupiter.api.Test; + +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.TypeElement; +import java.lang.reflect.Type; + +import static io.microsphere.lang.model.util.ExecutableElementComparator.INSTANCE; +import static io.microsphere.lang.model.util.MethodUtils.findMethod; +import static org.junit.jupiter.api.Assertions.assertEquals; + +/** + * {@link ExecutableElementComparator} Test + * + * @author Mercy + * @see ExecutableElementComparator + * @since 1.0.0 + */ +class ExecutableElementComparatorTest extends UtilTest { + + private final ExecutableElementComparator comparator = INSTANCE; + + @Test + void testCompareOnSameMethods() { + // Object#toString() + String methodName = "toString"; + ExecutableElement method = getMethod(methodName); + assertEquals(0, comparator.compare(method, method)); + } + + @Test + void testCompareOnDifferentMethods() { + assertEquals("toString".compareTo("hashCode"), comparator.compare(getMethod("toString"), getMethod("hashCode"))); + } + + @Test + void testCompareOnOverloadMethodsWithSameParameterCount() { + // Integer#valueOf(int) | Integer#valueOf(String) + TypeElement typeElement = getTypeElement(Integer.class); + String methodName = "valueOf"; + assertEquals(int.class.getName().compareTo(String.class.getName()), comparator.compare(findMethod(typeElement, methodName, int.class), findMethod(typeElement, methodName, String.class))); + } + + @Test + void testCompareOnOverloadMethodsWithDifferentParameterCount() { + // StringBuilder#append(char[]) | StringBuilder#append(char[],int,int) + TypeElement typeElement = getTypeElement(StringBuilder.class); + String methodName = "append"; + assertEquals(-2, comparator.compare( + findMethod(typeElement, methodName, char[].class), + findMethod(typeElement, methodName, char[].class, int.class, int.class))); + } + + @Test + void testCompare() { + // AutoCloseable#close() + assertEquals(0, comparator.compare(getMethod("close"), + findMethod(getTypeElement(AutoCloseable.class), "close"))); + + // TestService#echo(String) + assertEquals(0, comparator.compare(getMethod("echo", String.class), + findMethod(getTypeElement(TestService.class), "echo", String.class))); + } + + @Override + public boolean equals(Object object) { + return super.equals(object); + } + + private ExecutableElement getMethod(String methodName, Type... parameterTypes) { + return findMethod(testTypeElement, methodName, parameterTypes); + } +} \ No newline at end of file diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/FieldUtilsTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/FieldUtilsTest.java new file mode 100644 index 000000000..afa535fb0 --- /dev/null +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/FieldUtilsTest.java @@ -0,0 +1,412 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.lang.model.util; + +import io.microsphere.test.model.Color; +import io.microsphere.test.model.Model; +import org.junit.jupiter.api.Test; + +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.TypeElement; +import javax.lang.model.element.VariableElement; +import javax.lang.model.type.TypeMirror; +import java.io.Serializable; +import java.lang.annotation.ElementType; +import java.lang.reflect.Type; +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.List; +import java.util.concurrent.TimeUnit; + +import static io.microsphere.lang.function.Predicates.alwaysFalse; +import static io.microsphere.lang.function.Predicates.alwaysTrue; +import static io.microsphere.lang.model.util.FieldUtils.equalsFieldName; +import static io.microsphere.lang.model.util.FieldUtils.filterDeclaredFields; +import static io.microsphere.lang.model.util.FieldUtils.findAllDeclaredFields; +import static io.microsphere.lang.model.util.FieldUtils.findDeclaredFields; +import static io.microsphere.lang.model.util.FieldUtils.findField; +import static io.microsphere.lang.model.util.FieldUtils.getAllDeclaredFields; +import static io.microsphere.lang.model.util.FieldUtils.getAllNonStaticFields; +import static io.microsphere.lang.model.util.FieldUtils.getDeclaredField; +import static io.microsphere.lang.model.util.FieldUtils.getDeclaredFields; +import static io.microsphere.lang.model.util.FieldUtils.getNonStaticFields; +import static io.microsphere.lang.model.util.FieldUtils.isEnumMemberField; +import static io.microsphere.lang.model.util.FieldUtils.isField; +import static io.microsphere.lang.model.util.FieldUtils.isNonStaticField; +import static io.microsphere.lang.model.util.MethodUtils.findMethod; +import static io.microsphere.util.StringUtils.EMPTY_STRING; +import static javax.lang.model.element.Modifier.FINAL; +import static javax.lang.model.element.Modifier.PRIVATE; +import static javax.lang.model.element.Modifier.PUBLIC; +import static javax.lang.model.element.Modifier.STATIC; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * {@link FieldUtils} Test + * + * @author Mercy + * @since 1.0.0 + */ +class FieldUtilsTest extends UtilTest { + + @Test + void testGetDeclaredField() { + TypeElement type = getTypeElement(Model.class); + testGetDeclaredField(type, "f", float.class); + testGetDeclaredField(type, "d", double.class); + testGetDeclaredField(type, "tu", TimeUnit.class); + testGetDeclaredField(type, "str", String.class); + testGetDeclaredField(type, "bi", BigInteger.class); + testGetDeclaredField(type, "bd", BigDecimal.class); + } + + @Test + void testGetDeclaredFieldOnNotFound() { + TypeElement type = getTypeElement(Model.class); + assertNull(getDeclaredField(type, "b")); + assertNull(getDeclaredField(type, "s")); + assertNull(getDeclaredField(type, "i")); + assertNull(getDeclaredField(type, "l")); + assertNull(getDeclaredField(type, "z")); + } + + @Test + void testGetDeclaredFieldOnNull() { + assertNull(getDeclaredField(NULL_ELEMENT, "z")); + assertNull(getDeclaredField(NULL_TYPE_MIRROR, "z")); + } + + @Test + void testGetDeclaredFields() { + TypeElement type = getTypeElement(Model.class); + List fields = getDeclaredFields(type); + assertModelFields(fields); + + fields = getDeclaredFields(type.asType()); + assertModelFields(fields); + } + + @Test + void testGetDeclaredFieldsOnNull() { + assertTrue(getDeclaredFields(NULL_ELEMENT).isEmpty()); + assertTrue(getDeclaredFields(NULL_TYPE_MIRROR).isEmpty()); + } + + @Test + void testGetAllDeclaredFields() { + TypeElement type = getTypeElement(Model.class); + List fields = getAllDeclaredFields(type); + assertModelAllFields(fields); + } + + @Test + void testGetAllDeclaredFieldsOnNull() { + assertTrue(getAllDeclaredFields(NULL_ELEMENT).isEmpty()); + assertTrue(getAllDeclaredFields(NULL_TYPE_MIRROR).isEmpty()); + } + + @Test + void testFindField() { + TypeElement type = getTypeElement(Model.class); + testFindField(type, "f", float.class); + testFindField(type, "d", double.class); + testFindField(type, "tu", TimeUnit.class); + testFindField(type, "str", String.class); + testFindField(type, "bi", BigInteger.class); + testFindField(type, "bd", BigDecimal.class); + testFindField(type, "b", byte.class); + testFindField(type, "s", short.class); + testFindField(type, "i", int.class); + testFindField(type, "l", long.class); + testFindField(type, "z", boolean.class); + } + + @Test + void testFindFieldOnNull() { + TypeElement type = getTypeElement(Model.class); + assertNull(findField(NULL_ELEMENT, "f")); + assertNull(findField(NULL_ELEMENT, NULL_STRING)); + + assertNull(findField(NULL_TYPE_MIRROR, "f")); + assertNull(findField(NULL_TYPE_MIRROR, NULL_STRING)); + + assertNull(findField(type, NULL_STRING)); + assertNull(findField(type.asType(), NULL_STRING)); + } + + @Test + void testFindDeclaredFields() { + TypeElement type = getTypeElement(Model.class); + + List fields = findAllDeclaredFields(type, alwaysTrue()); + assertModelAllFields(fields); + + fields = findAllDeclaredFields(type, alwaysFalse()); + assertEmptyList(fields); + + fields = findDeclaredFields(type, f -> "f".equals(f.getSimpleName().toString())); + assertEquals(1, fields.size()); + assertEquals("f", fields.get(0).getSimpleName().toString()); + } + + @Test + void testFindDeclaredFieldsOnNull() { + assertEmptyList(findDeclaredFields(NULL_ELEMENT, alwaysTrue())); + assertEmptyList(findDeclaredFields(NULL_TYPE_MIRROR, alwaysTrue())); + } + + @Test + void testFindAllDeclaredFields() { + TypeElement type = getTypeElement(Model.class); + + List fields = findAllDeclaredFields(type, alwaysTrue()); + assertModelAllFields(fields); + + fields = findAllDeclaredFields(type, alwaysFalse()); + assertEmptyList(fields); + + fields = findAllDeclaredFields(type, f -> "f".equals(f.getSimpleName().toString())); + assertEquals(1, fields.size()); + assertEquals("f", fields.get(0).getSimpleName().toString()); + } + + @Test + void testFindAllDeclaredFieldsOnNull() { + assertEmptyList(findAllDeclaredFields(NULL_ELEMENT, alwaysTrue())); + assertEmptyList(findAllDeclaredFields(NULL_TYPE_MIRROR, alwaysTrue())); + } + + @Test + void testFilterDeclaredFieldsOnNull() { + assertFilterDeclaredFieldsReturningEmptyList(NULL_TYPE_MIRROR); + } + + @Test + void testFilterDeclaredFields() { + TypeMirror type = getTypeMirror(Model.class); + List fields = filterDeclaredFields(type, true, alwaysTrue()); + assertModelAllFields(fields); + + fields = filterDeclaredFields(type, true, alwaysFalse()); + assertEmptyList(fields); + + fields = filterDeclaredFields(type, false, alwaysTrue()); + assertModelFields(fields); + + fields = filterDeclaredFields(type, false, alwaysFalse()); + assertEmptyList(fields); + } + + @Test + void testFilterDeclaredFieldsOnNoDeclaredMembers() { + TypeMirror type = getTypeMirror(Serializable.class); + assertFilterDeclaredFieldsReturningEmptyList(type); + } + + @Test + void testFilterDeclaredFieldsOnNoDeclaredFields() { + TypeMirror type = getTypeMirror(Object.class); + assertFilterDeclaredFieldsReturningEmptyList(type); + } + + private void assertFilterDeclaredFieldsReturningEmptyList(TypeMirror type) { + assertEmptyList(filterDeclaredFields(type, true, alwaysTrue())); + assertEmptyList(filterDeclaredFields(type, false, alwaysTrue())); + assertEmptyList(filterDeclaredFields(type, true, alwaysFalse())); + assertEmptyList(filterDeclaredFields(type, false, alwaysFalse())); + assertEmptyList(filterDeclaredFields(type, true, NULL_PREDICATE_ARRAY)); + assertEmptyList(filterDeclaredFields(type, false, NULL_PREDICATE_ARRAY)); + assertEmptyList(filterDeclaredFields(type, true)); + assertEmptyList(filterDeclaredFields(type, false)); + } + + @Test + void testIsEnumField() { + TypeElement type = getTypeElement(Color.class); + + VariableElement field = findField(type, "RED"); + assertTrue(isEnumMemberField(field)); + + field = findField(type, "YELLOW"); + assertTrue(isEnumMemberField(field)); + + field = findField(type, "BLUE"); + assertTrue(isEnumMemberField(field)); + + type = getTypeElement(Model.class); + field = findField(type, "f"); + assertFalse(isEnumMemberField(field)); + + assertFalse(isEnumMemberField(NULL_FIELD)); + } + + @Test + void testIsNonStaticField() { + TypeElement type = getTypeElement(Model.class); + assertTrue(isNonStaticField(findField(type, "f"))); + } + + @Test + void testIsNonStaticFieldOnStaticField() { + TypeElement type = getTypeElement(Color.class); + for (Color color : Color.values()) { + assertFalse(isNonStaticField(findField(type, color.name()))); + } + } + + @Test + void testIsNonStaticFieldOnMethod() { + TypeElement type = getTypeElement(Model.class); + ExecutableElement method = findMethod(type, "setF", float.class); + for (VariableElement parameter : method.getParameters()) { + assertFalse(isNonStaticField(parameter)); + } + } + + @Test + void testIsField() { + TypeElement type = getTypeElement(Model.class); + assertTrue(isField(findField(type, "f"))); + assertTrue(isField(findField(type, "f"), PRIVATE)); + + type = getTypeElement(Color.class); + assertTrue(isField(findField(type, "BLUE"), PUBLIC, STATIC, FINAL)); + } + + @Test + void testIsFieldOnMethod() { + TypeElement type = getTypeElement(Model.class); + ExecutableElement method = findMethod(type, "getF"); + for (VariableElement parameter : method.getParameters()) { + assertFalse(isField(parameter)); + } + } + + @Test + void testIsFieldOnNull() { + assertFalse(isField(NULL_FIELD)); + assertFalse(isField(NULL_FIELD, PUBLIC, STATIC, FINAL)); + + TypeElement type = getTypeElement(Model.class); + assertFalse(isField(findField(type, "f"), NULL_MODIFIER_ARRAY)); + } + + @Test + void testGetNonStaticFields() { + TypeElement type = getTypeElement(Model.class); + + List fields = getNonStaticFields(type); + assertModelFields(fields); + + fields = getNonStaticFields(type.asType()); + assertModelFields(fields); + + assertTrue(getAllNonStaticFields(NULL_ELEMENT).isEmpty()); + assertTrue(getAllNonStaticFields(NULL_TYPE_MIRROR).isEmpty()); + } + + @Test + void testGetNonStaticFieldsOnNull() { + assertTrue(getNonStaticFields(NULL_TYPE_MIRROR).isEmpty()); + assertTrue(getNonStaticFields(NULL_ELEMENT).isEmpty()); + } + + @Test + void testGetNonStaticFieldsOnEnum() { + TypeElement type = getTypeElement(ElementType.class); + List fields = getNonStaticFields(type); + assertEmptyList(fields); + } + + @Test + void testGetAllNonStaticFields() { + TypeElement type = getTypeElement(Model.class); + + List fields = getAllNonStaticFields(type); + assertModelAllFields(fields); + + fields = getAllNonStaticFields(type.asType()); + assertModelAllFields(fields); + + assertTrue(getAllNonStaticFields(NULL_ELEMENT).isEmpty()); + assertTrue(getAllNonStaticFields(NULL_TYPE_MIRROR).isEmpty()); + } + + @Test + void testEqualsFieldName() { + TypeElement type = getTypeElement(Model.class); + String fieldName = "f"; + VariableElement field = findField(type, fieldName); + assertTrue(equalsFieldName(field, fieldName)); + assertFalse(equalsFieldName(field, "d")); + } + + @Test + void testEqualsFieldNameOnNull() { + TypeElement type = getTypeElement(Model.class); + String fieldName = "f"; + VariableElement field = findField(type, fieldName); + + assertFalse(equalsFieldName(NULL_FIELD, EMPTY_STRING)); + assertFalse(equalsFieldName(field, NULL_STRING)); + } + + private void assertModelFields(List fields) { + assertEquals(6, fields.size()); + assertEquals("d", fields.get(1).getSimpleName().toString()); + assertEquals("tu", fields.get(2).getSimpleName().toString()); + assertEquals("str", fields.get(3).getSimpleName().toString()); + assertEquals("bi", fields.get(4).getSimpleName().toString()); + assertEquals("bd", fields.get(5).getSimpleName().toString()); + } + + private void assertModelAllFields(List fields) { + assertEquals(11, fields.size()); + assertEquals("f", fields.get(0).getSimpleName().toString()); + assertEquals("d", fields.get(1).getSimpleName().toString()); + assertEquals("tu", fields.get(2).getSimpleName().toString()); + assertEquals("str", fields.get(3).getSimpleName().toString()); + assertEquals("bi", fields.get(4).getSimpleName().toString()); + assertEquals("bd", fields.get(5).getSimpleName().toString()); + assertEquals("b", fields.get(6).getSimpleName().toString()); + assertEquals("s", fields.get(7).getSimpleName().toString()); + assertEquals("i", fields.get(8).getSimpleName().toString()); + assertEquals("l", fields.get(9).getSimpleName().toString()); + assertEquals("z", fields.get(10).getSimpleName().toString()); + } + + private void testGetDeclaredField(TypeElement type, String fieldName, Type fieldType) { + VariableElement field = getDeclaredField(type, fieldName); + assertField(field, fieldName, fieldType); + + field = getDeclaredField(type.asType(), fieldName); + assertField(field, fieldName, fieldType); + } + + private void testFindField(TypeElement type, String fieldName, Type fieldType) { + VariableElement field = findField(type, fieldName); + assertField(field, fieldName, fieldType); + } + + private void assertField(VariableElement field, String fieldName, Type fieldType) { + assertEquals(fieldName, field.getSimpleName().toString()); + assertEquals(fieldType.getTypeName(), field.asType().toString()); + } +} diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONAnnotationValueVisitorTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONAnnotationValueVisitorTest.java new file mode 100644 index 000000000..6e4246323 --- /dev/null +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONAnnotationValueVisitorTest.java @@ -0,0 +1,135 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.lang.model.util; + + +import io.microsphere.test.annotation.TestAnnotation; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.ReflectiveInvocationContext; + +import javax.lang.model.element.AnnotationValue; +import javax.lang.model.element.ExecutableElement; +import java.lang.reflect.Method; +import java.util.Map; + +import static io.microsphere.lang.model.util.AnnotationUtils.getElementValue; +import static io.microsphere.lang.model.util.AnnotationUtils.getElementValues; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertSame; + +/** + * {@link JSONAnnotationValueVisitor} Test + * + * @author Mercy + * @see JSONAnnotationValueVisitor + * @since 1.0.0 + */ +class JSONAnnotationValueVisitorTest extends UtilTest { + + private StringBuilder jsonBuilder; + + private JSONAnnotationValueVisitor visitor; + + private Map testAnnotationAttributes; + + @Override + protected void beforeTest(ReflectiveInvocationContext invocationContext, ExtensionContext extensionContext) { + this.jsonBuilder = new StringBuilder(); + this.visitor = new JSONAnnotationValueVisitor(jsonBuilder); + this.testAnnotationAttributes = getElementValues(testTypeElement, TestAnnotation.class); + } + + @Test + void testVisitBoolean() { + testVisit("z", "\"z\":true"); + } + + @Test + void testVisitByte() { + testVisit("b", "\"b\":1"); + } + + @Test + void testVisitChar() { + testVisit("c", "\"c\":\"b\""); + } + + @Test + void testVisitDouble() { + testVisit("d", "\"d\":1.0"); + } + + @Test + void testVisitFloat() { + testVisit("f", "\"f\":1.0"); + } + + @Test + void testVisitInt() { + testVisit("i", "\"i\":1"); + } + + @Test + void testVisitLong() { + testVisit("l", "\"l\":1"); + } + + @Test + void testVisitShort() { + testVisit("s", "\"s\":1"); + } + + @Test + void testVisitString() { + testVisit("string", "\"string\":\"testService\""); + } + + @Test + void testVisitType() { + testVisit("type", "\"type\":\"io.microsphere.annotation.processor.GenericTestService\""); + } + + @Test + void testVisitEnumConstant() { + testVisit("timeUnit", "\"timeUnit\":\"HOURS\""); + } + + @Test + void testVisitAnnotation() { + testVisit("since", "\"since\":{\"module\":\"\",\"value\":\"1.0.0\"}"); + } + + @Test + void testVisitArray() { + testVisit("properties", "\"properties\":[{\"name\":\"key\",\"type\":\"java.lang.String\",\"defaultValue\":\"default-value\",\"required\":true,\"description\":\"description\",\"source\":[]},{\"name\":\"key2\",\"type\":\"java.lang.Integer\",\"defaultValue\":\"default-value2\",\"required\":true,\"description\":\"description2\",\"source\":[]},{\"name\":\"key3\",\"type\":\"java.lang.Class\",\"defaultValue\":\"default-value3\",\"required\":true,\"description\":\"description3\",\"source\":[]}]"); + } + + @Test + void testVisitUnknown() { + assertSame(this.jsonBuilder, visitor.visitUnknown(null, null)); + } + + void testVisit(String attributeName, String expectedJson) { + Map.Entry elementValue = getElementValue(this.testAnnotationAttributes, attributeName); + ExecutableElement attributeMethod = elementValue.getKey(); + AnnotationValue annotationValue = elementValue.getValue(); + StringBuilder jsonBuilder = visitor.visit(annotationValue, attributeMethod); + assertEquals(expectedJson, jsonBuilder.toString()); + } +} \ No newline at end of file diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONElementVisitorTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONElementVisitorTest.java new file mode 100644 index 000000000..4cc8234f9 --- /dev/null +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONElementVisitorTest.java @@ -0,0 +1,254 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.lang.model.util; + + +import io.microsphere.test.annotation.TestAnnotation; +import io.microsphere.test.annotation.processing.AbstractAnnotationProcessingTest; +import io.microsphere.test.model.Color; +import io.microsphere.test.model.StringArrayList; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.PackageElement; +import javax.lang.model.element.TypeElement; +import javax.lang.model.element.TypeParameterElement; +import javax.lang.model.element.VariableElement; +import javax.lang.model.type.TypeMirror; +import java.io.Serializable; +import java.util.List; + +import static io.microsphere.lang.model.util.TypeUtils.ofTypeElement; +import static java.lang.Boolean.TRUE; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * {@link JSONElementVisitor} Test + * + * @author Mercy + * @see JSONElementVisitor + * @since 1.0.0 + */ +class JSONElementVisitorTest extends UtilTest { + + private boolean supported; + + private StringBuilder jsonBuilder; + + private JSONElementVisitor visitor; + + + @BeforeEach + void setUp() { + this.supported = true; + this.jsonBuilder = new StringBuilder(); + this.visitor = new JSONElementVisitor() { + + @Override + protected boolean supports(Element e) { + super.supports(e); + return supported; + } + + @Override + protected boolean doVisitPackage(PackageElement e, StringBuilder jsonBuilder) { + super.doVisitPackage(e, jsonBuilder); + jsonBuilder.append("visitPackage"); + return TRUE; + } + + @Override + protected boolean doVisitTypeParameter(TypeParameterElement e, StringBuilder jsonBuilder) { + super.doVisitTypeParameter(e, jsonBuilder); + jsonBuilder.append("visitTypeParameter"); + return TRUE; + } + + @Override + public Boolean visitVariableAsEnumConstant(VariableElement e, StringBuilder stringBuilder) { + jsonBuilder.append("visitVariableAsEnumConstant"); + return TRUE; + } + + @Override + public Boolean visitVariableAsField(VariableElement e, StringBuilder stringBuilder) { + jsonBuilder.append("visitVariableAsField"); + return TRUE; + } + + @Override + public Boolean visitVariableAsParameter(VariableElement e, StringBuilder stringBuilder) { + jsonBuilder.append("visitVariableAsParameter"); + return TRUE; + } + + @Override + public Boolean visitExecutableAsConstructor(ExecutableElement e, StringBuilder stringBuilder) { + jsonBuilder.append("visitExecutableAsConstructor"); + return TRUE; + } + + @Override + public Boolean visitExecutableAsMethod(ExecutableElement e, StringBuilder stringBuilder) { + jsonBuilder.append("visitExecutableAsMethod"); + return TRUE; + } + + @Override + public Boolean visitTypeAsInterface(TypeElement e, StringBuilder stringBuilder) { + jsonBuilder.append("visitTypeAsInterface"); + return TRUE; + } + + @Override + public Boolean visitTypeAsEnum(TypeElement e, StringBuilder stringBuilder) { + jsonBuilder.append("visitTypeAsEnum"); + return TRUE; + } + + @Override + public Boolean visitTypeAsClass(TypeElement e, StringBuilder stringBuilder) { + jsonBuilder.append("visitTypeAsClass"); + return TRUE; + } + + @Override + public Boolean visitTypeAsAnnotationType(TypeElement e, StringBuilder stringBuilder) { + jsonBuilder.append("visitTypeAsAnnotationType"); + return TRUE; + } + }; + } + + @Test + void testVisitPackage() { + assertTrue(visitor.visitPackage(this.elements.getPackageElement("io.microsphere.annotation.processor.model.util"), jsonBuilder)); + assertJson("visitPackage"); + } + + @Test + void testVisitVariableOnUnsupported() { + supported = false; + assertFalse(visitor.visitVariable(null, jsonBuilder)); + } + + @Test + void testVisitVariableAsEnumConstant() { + VariableElement element = getField(Color.class, "RED"); + assertTrue(visitor.visitVariable(element, jsonBuilder)); + assertJson("visitVariableAsEnumConstant"); + + } + + @Test + void testVisitExecutableAsField() { + VariableElement element = getField(testClass, "context"); + assertTrue(visitor.visitVariable(element, jsonBuilder)); + assertJson("visitVariableAsField"); + } + + @Test + void testVisitVariableAsParameter() { + ExecutableElement method = getMethod(testClass, "echo", String.class); + for (VariableElement parameter : method.getParameters()) { + assertTrue(visitor.visitVariable(parameter, jsonBuilder)); + assertJson("visitVariableAsParameter"); + } + } + + @Test + void testVisitExecutableOnUnsupported() { + supported = false; + assertFalse(visitor.visitExecutable(null, jsonBuilder)); + } + + @Test + void testVisitExecutableAsConstructor() { + ExecutableElement constructor = getConstructor(testClass); + assertTrue(visitor.visitExecutable(constructor, jsonBuilder)); + assertJson("visitExecutableAsConstructor"); + } + + @Test + void testVisitExecutableAsMethod() { + ExecutableElement method = getMethod(testClass, "echo", String.class); + assertTrue(visitor.visitExecutable(method, jsonBuilder)); + assertJson("visitExecutableAsMethod"); + } + + @Test + void testVisitTypeOnUnsupported() { + supported = false; + TypeElement typeElement = getTypeElement(Serializable.class); + assertFalse(visitor.visitType(typeElement, jsonBuilder)); + } + + @Test + void testVisitTypeAsInterface() { + TypeElement typeElement = getTypeElement(Serializable.class); + assertTrue(visitor.visitType(typeElement, jsonBuilder)); + assertJson("visitTypeAsInterface"); + } + + @Test + void testVisitTypeAsEnum() { + TypeElement typeElement = getTypeElement(Color.class); + assertTrue(visitor.visitType(typeElement, jsonBuilder)); + assertTrue(jsonBuilder.toString().startsWith("visitTypeAsEnum")); + } + + @Test + void testVisitTypeAsClass() { + TypeElement typeElement = getTypeElement(testClass); + assertTrue(visitor.visitType(typeElement, jsonBuilder)); + assertTrue(jsonBuilder.toString().startsWith("visitTypeAsClass")); + } + + @Test + void testVisitTypeAsAnnotationType() { + TypeElement typeElement = getTypeElement(TestAnnotation.class); + assertTrue(visitor.visitType(typeElement, jsonBuilder)); + assertTrue(jsonBuilder.toString().startsWith("visitTypeAsAnnotationType")); + } + + @Test + void testVisitTypeParameterOnUnsupported() { + supported = false; + assertFalse(visitor.visitTypeParameter(null, jsonBuilder)); + } + + @Test + void testVisitTypeParameter() { + TypeElement typeElement = getTypeElement(StringArrayList.class); + TypeMirror superclass = typeElement.getSuperclass(); + TypeElement superTypeElement = ofTypeElement(superclass); + List typeParameters = superTypeElement.getTypeParameters(); + for (TypeParameterElement typeParameter : typeParameters) { + assertTrue(visitor.visitTypeParameter(typeParameter, jsonBuilder)); + assertJson("visitTypeParameter"); + } + } + + void assertJson(String expected) { + assertEquals(expected, jsonBuilder.toString()); + } +} \ No newline at end of file diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/LoggerUtilsTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/LoggerUtilsTest.java new file mode 100644 index 000000000..7f916931b --- /dev/null +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/LoggerUtilsTest.java @@ -0,0 +1,76 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.lang.model.util; + +import org.junit.jupiter.api.Test; + +import static io.microsphere.lang.model.util.LoggerUtils.LOGGER; +import static io.microsphere.lang.model.util.LoggerUtils.debug; +import static io.microsphere.lang.model.util.LoggerUtils.error; +import static io.microsphere.lang.model.util.LoggerUtils.info; +import static io.microsphere.lang.model.util.LoggerUtils.trace; +import static io.microsphere.lang.model.util.LoggerUtils.warn; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +/** + * {@link LoggerUtils} Test + * + * @author Mercy + * @since 1.0.0 + */ +class LoggerUtilsTest { + + @Test + void testLogger() { + assertNotNull(LOGGER); + } + + @Test + void testTrace() { + trace("Hello,World"); + trace("Hello,{}", "World"); + trace("{},{}", "Hello", "World"); + } + + @Test + void testDebug() { + debug("Hello,World"); + debug("Hello,{}", "World"); + debug("{},{}", "Hello", "World"); + } + + @Test + void testInfo() { + info("Hello,World"); + info("Hello,{}", "World"); + info("{},{}", "Hello", "World"); + } + + @Test + void testWarn() { + warn("Hello,World"); + warn("Hello,{}", "World"); + warn("{},{}", "Hello", "World"); + } + + @Test + void testError() { + error("Hello,World"); + error("Hello,{}", "World"); + error("{},{}", "Hello", "World"); + } +} diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/MemberUtilsTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/MemberUtilsTest.java new file mode 100644 index 000000000..bae09a873 --- /dev/null +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/MemberUtilsTest.java @@ -0,0 +1,173 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.lang.model.util; + +import io.microsphere.test.model.Model; +import org.junit.jupiter.api.Test; + +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; +import javax.lang.model.element.VariableElement; +import java.util.List; + +import static io.microsphere.lang.function.Predicates.alwaysFalse; +import static io.microsphere.lang.function.Predicates.alwaysTrue; +import static io.microsphere.lang.model.util.MemberUtils.findAllDeclaredMembers; +import static io.microsphere.lang.model.util.MemberUtils.findDeclaredMembers; +import static io.microsphere.lang.model.util.MemberUtils.getAllDeclaredMembers; +import static io.microsphere.lang.model.util.MemberUtils.getDeclaredMembers; +import static javax.lang.model.util.ElementFilter.fieldsIn; +import static org.junit.jupiter.api.Assertions.assertEquals; + +/** + * {@link MemberUtils} Test + * + * @author Mercy + * @since 1.0.0 + */ +class MemberUtilsTest extends UtilTest { + + @Test + void testGetDeclaredMembers() { + assertGetDeclaredMembersOfModel(); + } + + @Test + void testGetDeclaredMembersOnNull() { + assertEmptyList(getDeclaredMembers(NULL_TYPE_ELEMENT)); + assertEmptyList(getDeclaredMembers(NULL_TYPE_MIRROR)); + } + + @Test + void testGetAllDeclaredMembers() { + assertGetAllDeclaredMembersOfModel(); + } + + @Test + void testGetAllDeclaredMembersOnNull() { + assertEmptyList(getAllDeclaredMembers(NULL_TYPE_ELEMENT)); + assertEmptyList(getAllDeclaredMembers(NULL_TYPE_MIRROR)); + } + + @Test + void testGetDeclaredMembersOnAll() { + assertGetAllDeclaredMembersOfModel(getDeclaredMembers(getDeclaredType(Model.class), true)); + assertGetAllDeclaredMembersOfModel(getDeclaredMembers(getTypeElement(Model.class), true)); + } + + @Test + void testGetDeclaredMembersOnNotAll() { + assertGetDeclaredMembersOfModel(getDeclaredMembers(getDeclaredType(Model.class), false)); + assertGetDeclaredMembersOfModel(getDeclaredMembers(getTypeElement(Model.class), false)); + } + + @Test + void testFindDeclaredMembers() { + assertFindDeclaredMembersOfModel(); + } + + @Test + void testFindDeclaredMembersOnNull() { + assertEmptyList(findDeclaredMembers(NULL_TYPE_ELEMENT, alwaysTrue())); + assertEmptyList(findDeclaredMembers(NULL_TYPE_ELEMENT, alwaysFalse())); + assertEmptyList(findDeclaredMembers(NULL_TYPE_MIRROR, alwaysTrue())); + assertEmptyList(findDeclaredMembers(NULL_TYPE_MIRROR, alwaysFalse())); + } + + @Test + void testFindAllDeclaredMembers() { + assertFindAllDeclaredMembersOfModel(); + } + + @Test + void testFindAllDeclaredMembersOnNull() { + assertEmptyList(findAllDeclaredMembers(NULL_TYPE_ELEMENT, alwaysTrue())); + assertEmptyList(findAllDeclaredMembers(NULL_TYPE_ELEMENT, alwaysFalse())); + assertEmptyList(findAllDeclaredMembers(NULL_TYPE_MIRROR, alwaysTrue())); + assertEmptyList(findAllDeclaredMembers(NULL_TYPE_MIRROR, alwaysFalse())); + } + + @Test + void testFindDeclaredMembersOnAll() { + assertGetAllDeclaredMembersOfModel(findDeclaredMembers(getDeclaredType(Model.class), true, alwaysTrue())); + assertGetAllDeclaredMembersOfModel(findDeclaredMembers(getTypeElement(Model.class), true, alwaysTrue())); + } + + @Test + void testFindDeclaredMembersOnNotAll() { + assertGetDeclaredMembersOfModel(findDeclaredMembers(getDeclaredType(Model.class), false, alwaysTrue())); + assertGetDeclaredMembersOfModel(findDeclaredMembers(getTypeElement(Model.class), false, alwaysTrue())); + } + + private void assertFindDeclaredMembersOfModel() { + TypeElement type = getTypeElement(Model.class); + assertGetDeclaredMembersOfModel(findDeclaredMembers(type, alwaysTrue(), alwaysTrue())); + assertGetDeclaredMembersOfModel(findDeclaredMembers(type.asType(), alwaysTrue())); + + assertEmptyList(findDeclaredMembers(type, alwaysFalse())); + assertEmptyList(findDeclaredMembers(type.asType(), alwaysFalse())); + } + + private void assertFindAllDeclaredMembersOfModel() { + TypeElement type = getTypeElement(Model.class); + assertGetAllDeclaredMembersOfModel(findAllDeclaredMembers(type, alwaysTrue(), alwaysTrue())); + assertGetAllDeclaredMembersOfModel(findAllDeclaredMembers(type.asType(), alwaysTrue())); + + assertEmptyList(findAllDeclaredMembers(type, alwaysFalse())); + assertEmptyList(findAllDeclaredMembers(type.asType(), alwaysFalse())); + } + + private void assertGetDeclaredMembersOfModel() { + TypeElement type = getTypeElement(Model.class); + assertGetDeclaredMembersOfModel(getDeclaredMembers(type)); + assertGetDeclaredMembersOfModel(getDeclaredMembers(type.asType())); + } + + private void assertGetDeclaredMembersOfModel(List members) { + List fields = fieldsIn(members); + assertEquals(19, members.size()); + assertEquals(6, fields.size()); + assertEquals("f", fields.get(0).getSimpleName().toString()); + assertEquals("d", fields.get(1).getSimpleName().toString()); + assertEquals("tu", fields.get(2).getSimpleName().toString()); + assertEquals("str", fields.get(3).getSimpleName().toString()); + assertEquals("bi", fields.get(4).getSimpleName().toString()); + assertEquals("bd", fields.get(5).getSimpleName().toString()); + } + + private void assertGetAllDeclaredMembersOfModel() { + TypeElement type = getTypeElement(Model.class); + assertGetAllDeclaredMembersOfModel(getAllDeclaredMembers(type)); + assertGetAllDeclaredMembersOfModel(getAllDeclaredMembers(type.asType())); + } + + private void assertGetAllDeclaredMembersOfModel(List members) { + List fields = fieldsIn(members); + assertEquals(11, fields.size()); + assertEquals("f", fields.get(0).getSimpleName().toString()); + assertEquals("d", fields.get(1).getSimpleName().toString()); + assertEquals("tu", fields.get(2).getSimpleName().toString()); + assertEquals("str", fields.get(3).getSimpleName().toString()); + assertEquals("bi", fields.get(4).getSimpleName().toString()); + assertEquals("bd", fields.get(5).getSimpleName().toString()); + assertEquals("b", fields.get(6).getSimpleName().toString()); + assertEquals("s", fields.get(7).getSimpleName().toString()); + assertEquals("i", fields.get(8).getSimpleName().toString()); + assertEquals("l", fields.get(9).getSimpleName().toString()); + assertEquals("z", fields.get(10).getSimpleName().toString()); + } +} diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/MessagerUtilsTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/MessagerUtilsTest.java new file mode 100644 index 000000000..f91edab56 --- /dev/null +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/MessagerUtilsTest.java @@ -0,0 +1,81 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.lang.model.util; + + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.ReflectiveInvocationContext; + +import javax.annotation.processing.Messager; +import java.lang.reflect.Method; + +import static io.microsphere.lang.model.util.MessagerUtils.printError; +import static io.microsphere.lang.model.util.MessagerUtils.printMandatoryWarning; +import static io.microsphere.lang.model.util.MessagerUtils.printMessage; +import static io.microsphere.lang.model.util.MessagerUtils.printNote; +import static io.microsphere.lang.model.util.MessagerUtils.printWarning; +import static javax.tools.Diagnostic.Kind.OTHER; + +/** + * {@link MessagerUtils} Test + * + * @author Mercy + * @see MessagerUtils + * @see Messager + * @since 1.0.0 + */ +class MessagerUtilsTest extends UtilTest { + + private Messager messager; + + @Override + protected void beforeTest(ReflectiveInvocationContext invocationContext, ExtensionContext extensionContext) { + this.messager = this.processingEnv.getMessager(); + } + + @Test + void testPrintNote() { + printNote(this.processingEnv, "Hello, {}!", "printNote"); + printNote(this.messager, "Hello, {}!", "printNote"); + } + + @Test + void testPrintWarning() { + printWarning(this.processingEnv, "Hello, {}!", "printWarning"); + printWarning(this.messager, "Hello, {}!", "printWarning"); + } + + @Test + void testPrintMandatoryWarning() { + printMandatoryWarning(this.processingEnv, "Hello, {}!", "printMandatoryWarning"); + printMandatoryWarning(this.messager, "Hello, {}!", "printMandatoryWarning"); + } + + @Test + void testPrintError() { + printError(this.processingEnv, "Hello, {}!", "printError"); + printError(this.messager, "Hello, {}!", "printError"); + } + + @Test + void testPrintMessage() { + printMessage(this.processingEnv, OTHER, "Hello, {}!", "printMessage"); + printMessage(this.messager, OTHER, "Hello, {}!", "printMessage"); + } +} \ No newline at end of file diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/MethodUtilsTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/MethodUtilsTest.java new file mode 100644 index 000000000..931c71b18 --- /dev/null +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/MethodUtilsTest.java @@ -0,0 +1,507 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.lang.model.util; + +import io.microsphere.constants.Constants; +import io.microsphere.constants.PropertyConstants; +import io.microsphere.test.model.Model; +import io.microsphere.test.service.TestService; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.ReflectiveInvocationContext; + +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.TypeElement; +import javax.lang.model.type.TypeMirror; +import java.io.Serializable; +import java.lang.reflect.Method; +import java.lang.reflect.Type; +import java.util.List; +import java.util.Set; + +import static io.microsphere.collection.Lists.ofList; +import static io.microsphere.lang.function.Predicates.alwaysFalse; +import static io.microsphere.lang.function.Predicates.alwaysTrue; +import static io.microsphere.lang.model.util.ElementUtils.isPublicNonStatic; +import static io.microsphere.lang.model.util.MemberUtils.getDeclaredMembers; +import static io.microsphere.lang.model.util.MethodUtils.filterMethods; +import static io.microsphere.lang.model.util.MethodUtils.findAllDeclaredMethods; +import static io.microsphere.lang.model.util.MethodUtils.findDeclaredMethods; +import static io.microsphere.lang.model.util.MethodUtils.findMethod; +import static io.microsphere.lang.model.util.MethodUtils.findPublicNonStaticMethods; +import static io.microsphere.lang.model.util.MethodUtils.getAllDeclaredMethods; +import static io.microsphere.lang.model.util.MethodUtils.getDeclaredMethods; +import static io.microsphere.lang.model.util.MethodUtils.getEnclosingElement; +import static io.microsphere.lang.model.util.MethodUtils.getMethodName; +import static io.microsphere.lang.model.util.MethodUtils.getMethodParameterTypeMirrors; +import static io.microsphere.lang.model.util.MethodUtils.getMethodParameterTypeNames; +import static io.microsphere.lang.model.util.MethodUtils.getOverrideMethod; +import static io.microsphere.lang.model.util.MethodUtils.getReturnTypeName; +import static io.microsphere.lang.model.util.MethodUtils.isMethod; +import static io.microsphere.lang.model.util.MethodUtils.isPublicNonStaticMethod; +import static io.microsphere.lang.model.util.MethodUtils.matches; +import static io.microsphere.reflect.TypeUtils.getTypeNames; +import static io.microsphere.util.ArrayUtils.EMPTY_STRING_ARRAY; +import static io.microsphere.util.ArrayUtils.ofArray; +import static java.util.Collections.emptyList; +import static javax.lang.model.element.ElementKind.METHOD; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * {@link MethodUtils} Test + * + * @author Mercy + * @since 1.0.0 + */ +class MethodUtilsTest extends UtilTest { + + private List objectMethods; + + private int objectMethodsSize; + + @Override + protected void addCompiledClasses(Set> compiledClasses) { + compiledClasses.add(PropertyConstants.class); + } + + @Override + protected void beforeTest(ReflectiveInvocationContext invocationContext, ExtensionContext extensionContext) { + TypeElement type = getTypeElement(Object.class); + List methods = getDeclaredMethods(type); + this.objectMethods = methods; + this.objectMethodsSize = methods.size(); + } + + @Test + void testDeclaredMethods() { + TypeElement type = getTypeElement(Model.class); + List methods = getDeclaredMethods(type); + assertEquals(12, methods.size()); + + methods = getDeclaredMethods(type.asType()); + assertEquals(12, methods.size()); + } + + @Test + void testDeclaredMethodsOnNull() { + assertTrue(getDeclaredMethods(NULL_TYPE_ELEMENT).isEmpty()); + assertTrue(getDeclaredMethods(NULL_TYPE_MIRROR).isEmpty()); + } + + @Test + void testGetAllDeclaredMethods() { + TypeElement type = getTypeElement(Model.class); + List methods = getAllDeclaredMethods(type); + assertEquals(objectMethodsSize + 22, methods.size()); + + methods = getAllDeclaredMethods(type.asType()); + assertEquals(objectMethodsSize + 22, methods.size()); + } + + @Test + void testGetAllDeclaredMethodsOnNull() { + assertTrue(getAllDeclaredMethods(NULL_TYPE_ELEMENT).isEmpty()); + assertTrue(getAllDeclaredMethods(NULL_TYPE_MIRROR).isEmpty()); + } + + @Test + void testFindDeclaredMethods() { + List methods = findDeclaredMethods(testTypeElement, alwaysTrue()); + assertEquals(2, methods.size()); + + methods = findDeclaredMethods(testTypeMirror, alwaysTrue()); + assertEquals(2, methods.size()); + + methods = findDeclaredMethods(testTypeElement, alwaysFalse()); + assertEmptyList(methods); + + methods = findDeclaredMethods(testTypeMirror, alwaysFalse()); + assertEmptyList(methods); + } + + @Test + void testFindDeclaredMethodsOnNoMemberType() { + TypeElement typeElement = getTypeElement(Serializable.class); + List methods = findDeclaredMethods(typeElement, alwaysTrue()); + assertEmptyList(methods); + } + + @Test + void testFindDeclaredMethodsOnNoMethodType() { + TypeElement typeElement = getTypeElement(PropertyConstants.class); + List methods = findDeclaredMethods(typeElement, alwaysTrue()); + assertEmptyList(methods); + } + + @Test + void testFindAllDeclaredMethods() { + List methods = findAllDeclaredMethods(testTypeElement, alwaysTrue()); + assertEquals(objectMethodsSize + 14, methods.size()); + + methods = findAllDeclaredMethods(testTypeMirror, alwaysTrue()); + assertEquals(objectMethodsSize + 14, methods.size()); + + methods = findAllDeclaredMethods(testTypeElement, alwaysFalse()); + assertEmptyList(methods); + + methods = findAllDeclaredMethods(testTypeMirror, alwaysFalse()); + assertEmptyList(methods); + } + + @Test + void testFindAllDeclaredMethodsOnNoMemberType() { + TypeElement typeElement = getTypeElement(Serializable.class); + List methods = findAllDeclaredMethods(typeElement, alwaysTrue()); + assertEmptyList(methods); + } + + @Test + void testFindAllDeclaredMethodsOnNoMethodType() { + TypeElement typeElement = getTypeElement(Constants.class); + List methods = findAllDeclaredMethods(typeElement, alwaysTrue()); + assertEmptyList(methods); + } + + @Test + void testFindAllDeclaredMethodsOnNull() { + assertEmptyList(findAllDeclaredMethods(NULL_TYPE_ELEMENT, alwaysTrue())); + assertEmptyList(findAllDeclaredMethods(NULL_TYPE_ELEMENT, alwaysFalse())); + assertEmptyList(findAllDeclaredMethods(NULL_TYPE_MIRROR, alwaysTrue())); + assertEmptyList(findAllDeclaredMethods(NULL_TYPE_MIRROR, alwaysFalse())); + } + + @Test + void testFindAllDeclaredMethodsWithExcludedTypes() { + List methods = findAllDeclaredMethodsWithoutObjectType(); + assertEquals(14, methods.size()); + } + + @Test + void testFindAllDeclaredMethodsWithExcludedTypesOnNull() { + assertEmptyList(findAllDeclaredMethods(NULL_TYPE_ELEMENT, Object.class)); + assertEmptyList(findAllDeclaredMethods(NULL_TYPE_MIRROR, Object.class)); + } + + @Test + void testFindPublicNonStaticMethods() { + List methods = findPublicNonStaticMethods(testTypeElement, Object.class); + assertEquals(14, methods.size()); + + methods = findPublicNonStaticMethods(testTypeElement.asType(), Object.class); + assertEquals(14, methods.size()); + } + + @Test + void testFindPublicNonStaticMethodsOnNull() { + assertEmptyList(findPublicNonStaticMethods(NULL_TYPE_ELEMENT, Object.class)); + assertEmptyList(findPublicNonStaticMethods(NULL_TYPE_MIRROR, Object.class)); + } + + @Test + void testIsMethod() { + List members = getDeclaredMembers(testTypeElement); + for (Element member : members) { + if (member instanceof ExecutableElement) { + ExecutableElement element = (ExecutableElement) member; + assertEquals(METHOD == member.getKind(), isMethod(element)); + } + } + } + + @Test + void testIsMethodOnNull() { + assertFalse(isMethod(NULL_METHOD)); + } + + @Test + void testIsPublicNonStaticMethod() { + List members = getDeclaredMembers(testTypeElement); + for (Element member : members) { + if (member instanceof ExecutableElement) { + ExecutableElement element = (ExecutableElement) member; + switch (member.getKind()) { + case METHOD: + assertEquals(isPublicNonStaticMethod(element), isPublicNonStatic(element)); + break; + case CONSTRUCTOR: + assertFalse(isPublicNonStaticMethod(element)); + break; + } + } + } + + // Integer#valueOf(String) is a public static method + assertFalse(isPublicNonStaticMethod(findMethod(getTypeElement(Integer.class), "valueOf", String.class))); + + } + + @Test + void testIsPublicNonStaticMethodOnNull() { + assertFalse(isPublicNonStaticMethod(NULL_METHOD)); + } + + @Test + void testFindMethod() { + // Test methods from java.lang.Object + // Object#toString() + Type type = Model.class; + assertFindMethod(type, "toString"); + + // Object#hashCode() + assertFindMethod(type, "hashCode"); + + // Object#getClass() + assertFindMethod(type, "getClass"); + + // Object#finalize() + assertFindMethod(type, "finalize"); + + // Object#clone() + assertFindMethod(type, "clone"); + + // Object#notify() + assertFindMethod(type, "notify"); + + // Object#notifyAll() + assertFindMethod(type, "notifyAll"); + + // Object#wait(long) + assertFindMethod(type, "wait", long.class); + + // Object#wait(long,int) + assertFindMethod(type, "wait", long.class, int.class); + + // Object#equals(Object) + assertFindMethod(type, "equals", Object.class); + } + + @Test + void testFindMethodOnNotFound() { + assertNull(findMethod(testTypeElement, "notFound")); + assertNull(findMethod(testTypeElement, "notFound", String.class)); + assertNull(findMethod(testTypeElement, "notFound", "java.lang.String")); + + assertNull(findMethod(testTypeMirror, "notFound")); + assertNull(findMethod(testTypeMirror, "notFound", String.class)); + assertNull(findMethod(testTypeMirror, "notFound", "java.lang.String")); + } + + @Test + void testFindMethodOnNull() { + assertNull(findMethod(NULL_TYPE_ELEMENT, "toString")); + assertNull(findMethod(NULL_TYPE_ELEMENT, "toString", String.class)); + assertNull(findMethod(NULL_TYPE_ELEMENT, "toString", "java.lang.String")); + assertNull(findMethod(NULL_TYPE_ELEMENT, "toString", NULL_TYPE_ARRAY)); + assertNull(findMethod(NULL_TYPE_ELEMENT, "toString", NULL_STRING_ARRAY)); + + assertNull(findMethod(NULL_TYPE_MIRROR, "toString")); + assertNull(findMethod(NULL_TYPE_MIRROR, "toString", String.class)); + assertNull(findMethod(NULL_TYPE_MIRROR, "toString", "java.lang.String")); + assertNull(findMethod(NULL_TYPE_MIRROR, "toString", NULL_TYPE_ARRAY)); + assertNull(findMethod(NULL_TYPE_MIRROR, "toString", NULL_STRING_ARRAY)); + + assertNull(findMethod(testTypeElement, NULL_STRING)); + assertNull(findMethod(testTypeElement, NULL_STRING, String.class)); + assertNull(findMethod(testTypeElement, NULL_STRING, "java.lang.String")); + assertNull(findMethod(testTypeElement, NULL_STRING, NULL_TYPE_ARRAY)); + assertNull(findMethod(testTypeElement, NULL_STRING, NULL_STRING_ARRAY)); + + assertNull(findMethod(testTypeMirror, NULL_STRING)); + assertNull(findMethod(testTypeMirror, NULL_STRING, String.class)); + assertNull(findMethod(testTypeMirror, NULL_STRING, "java.lang.String")); + assertNull(findMethod(testTypeMirror, NULL_STRING, NULL_TYPE_ARRAY)); + assertNull(findMethod(testTypeMirror, NULL_STRING, NULL_STRING_ARRAY)); + + + assertNull(findMethod(testTypeElement, "toString", NULL_TYPE_ARRAY)); + assertNull(findMethod(testTypeElement, "toString", NULL_STRING_ARRAY)); + + assertNull(findMethod(testTypeMirror, "toString", NULL_TYPE_ARRAY)); + assertNull(findMethod(testTypeMirror, "toString", NULL_STRING_ARRAY)); + } + + @Test + void testGetOverrideMethod() { + List methods = findAllDeclaredMethodsWithoutObjectType(); + + ExecutableElement overrideMethod = getOverrideMethod(processingEnv, testTypeElement, methods.get(0)); + assertNull(overrideMethod); + + ExecutableElement declaringMethod = findMethod(getTypeElement(TestService.class), "echo", "java.lang.String"); + + overrideMethod = getOverrideMethod(processingEnv, testTypeElement, declaringMethod); + assertEquals(methods.get(0), overrideMethod); + } + + @Test + void testFilterMethods() { + + } + + @Test + void testFilterMethodsOnNull() { + assertEmptyList(filterMethods(NULL_LIST, alwaysTrue())); + assertEmptyList(filterMethods(NULL_LIST, NULL_PREDICATE_ARRAY)); + } + + @Test + void testFilterMethodsOnEmpty() { + assertEmptyList(filterMethods(emptyList(), alwaysTrue())); + assertEmptyList(filterMethods(emptyList(), NULL_PREDICATE_ARRAY)); + } + + @Test + void testFilterMethodsOnReturningEmptyList() { + List methods = getDeclaredMethods(testTypeElement); + assertEmptyList(filterMethods(methods, alwaysFalse())); + assertEquals(methods, filterMethods(methods)); + } + + @Test + void testGetMethodName() { + ExecutableElement method = findMethod(testTypeElement, "echo", "java.lang.String"); + assertEquals("echo", getMethodName(method)); + assertNull(getMethodName(NULL_METHOD)); + } + + @Test + void testGetMethodNameOnNull() { + assertNull(getMethodName(NULL_METHOD)); + } + + @Test + void testReturnTypeName() { + ExecutableElement method = findMethod(testTypeElement, "echo", "java.lang.String"); + assertEquals("java.lang.String", getReturnTypeName(method)); + } + + @Test + void testReturnTypeNameOnNull() { + assertNull(getReturnTypeName(NULL_METHOD)); + } + + @Test + void testMatchParameterTypeNames() { + String[] parameterTypeNames = ofArray("java.lang.String"); + ExecutableElement method = findMethod(testTypeElement, "echo", parameterTypeNames); + assertArrayEquals(parameterTypeNames, getMethodParameterTypeNames(method)); + } + + @Test + void testMatchParameterTypeNamesOnNull() { + assertSame(EMPTY_STRING_ARRAY, getMethodParameterTypeNames(NULL_METHOD)); + } + + @Test + void testMatchParameterTypes() { + ExecutableElement method = findMethod(testTypeElement, "toString"); + assertEmptyList(getMethodParameterTypeMirrors(method)); + + method = findMethod(testTypeElement, "equals", Object.class); + List parameterTypes = getMethodParameterTypeMirrors(method); + assertEquals(ofList(parameterTypes.toArray(EMPTY_TYPE_MIRROR_ARRAY)), parameterTypes); + } + + @Test + void testMatchParameterTypesOnNull() { + assertEmptyList(getMethodParameterTypeMirrors(NULL_METHOD)); + } + + @Test + void testMatches() { + assertFindMethod(testClass, "echo", String.class); + } + + @Test + void tstMatchesOnFalse() { + ExecutableElement method = findMethod(testTypeElement, "echo", String.class); + + Type[] parameterTypes = ofArray(String.class, String.class); + String[] parameterTypeNames = getTypeNames(parameterTypes); + assertFalse(matches(method, "echo", parameterTypes)); + assertFalse(matches(method, "echo", parameterTypeNames)); + + parameterTypes = ofArray(Object.class); + parameterTypeNames = getTypeNames(parameterTypes); + assertFalse(matches(method, "echo", parameterTypes)); + assertFalse(matches(method, "echo", parameterTypeNames)); + } + + @Test + void testMatchesOnNull() { + String methodName = "echo"; + Type[] parameterTypes = ofArray(String.class); + String[] parameterTypeNames = getTypeNames(parameterTypes); + ExecutableElement method = findMethod(testTypeElement, methodName, parameterTypes); + + assertFalse(matches(NULL_METHOD, NULL_STRING, parameterTypes)); + assertFalse(matches(method, NULL_STRING, parameterTypes)); + assertFalse(matches(method, methodName, NULL_TYPE_ARRAY)); + + assertFalse(matches(NULL_METHOD, NULL_STRING, parameterTypeNames)); + assertFalse(matches(method, NULL_STRING, parameterTypeNames)); + assertFalse(matches(method, methodName, NULL_STRING_ARRAY)); + } + + @Test + void testGetEnclosingElement() { + String methodName = "echo"; + Type[] parameterTypes = ofArray(String.class); + ExecutableElement method = findMethod(testTypeElement, methodName, parameterTypes); + assertSame(testTypeElement, getEnclosingElement(method)); + } + + @Test + void testGetEnclosingElementOnNull() { + assertNull(getEnclosingElement(NULL_METHOD)); + } + + private void assertFindMethod(Type type, String methodName, Type... parameterTypes) { + TypeElement typeElement = getTypeElement(type); + String[] parameterTypeNames = getTypeNames(parameterTypes); + + ExecutableElement method = findMethod(typeElement, methodName, parameterTypes); + assertMatchesMethod(method, methodName, parameterTypes); + + method = findMethod(typeElement, methodName, parameterTypeNames); + assertMatchesMethod(method, methodName, parameterTypes); + + method = findMethod(typeElement.asType(), methodName, parameterTypes); + assertMatchesMethod(method, methodName, parameterTypes); + + method = findMethod(typeElement.asType(), methodName, parameterTypeNames); + assertMatchesMethod(method, methodName, parameterTypeNames); + } + + private void assertMatchesMethod(ExecutableElement method, String methodName, Type... parameterTypes) { + assertTrue(matches(method, methodName, parameterTypes)); + } + + private void assertMatchesMethod(ExecutableElement method, String methodName, String... parameterTypeNames) { + assertTrue(matches(method, methodName, parameterTypeNames)); + } + + private List findAllDeclaredMethodsWithoutObjectType() { + return findAllDeclaredMethods(testTypeElement, Object.class); + } +} diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ResolvableAnnotationValueVisitorTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ResolvableAnnotationValueVisitorTest.java new file mode 100644 index 000000000..a177dad1f --- /dev/null +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ResolvableAnnotationValueVisitorTest.java @@ -0,0 +1,216 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.lang.model.util; + +import io.microsphere.test.annotation.TestAnnotation; +import io.microsphere.test.service.GenericTestService; +import io.microsphere.test.service.TestService; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.ReflectiveInvocationContext; + +import javax.lang.model.element.AnnotationValue; +import javax.lang.model.element.AnnotationValueVisitor; +import javax.lang.model.element.ExecutableElement; +import java.io.Serializable; +import java.lang.reflect.Method; +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.Map.Entry; + +import static io.microsphere.lang.model.util.AnnotationUtils.getElementValue; +import static io.microsphere.lang.model.util.AnnotationUtils.getElementValues; +import static java.util.Objects.deepEquals; +import static java.util.concurrent.TimeUnit.HOURS; +import static java.util.stream.Stream.of; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * {@link ResolvableAnnotationValueVisitor} Test + * + * @author Mercy + * @see ResolvableAnnotationValueVisitor + * @since 1.0.0 + */ +class ResolvableAnnotationValueVisitorTest extends UtilTest { + + private ResolvableAnnotationValueVisitor visitor; + + private ResolvableAnnotationValueVisitor visitor1; + + private ResolvableAnnotationValueVisitor visitor2; + + static final boolean BOOLEAN_VALUE = true; + + static final byte BYTE_VALUE = 1; + + static final char CHAR_VALUE = 'b'; + + static final double DOUBLE_VALUE = 1.0D; + + static final float FLOAT_VALUE = 1.0F; + + static final int INT_VALUE = 1; + + static final long LONG_VALUE = 1L; + + static final short SHORT_VALUE = 1; + + static final String STRING_VALUE = "testService"; + + static final Class TYPE_VALUE = GenericTestService.class; + + static final Class[] TYPES_VALUE = {TestService.class, AutoCloseable.class, Serializable.class}; + + private Map testAnnotationAttributes; + + @Override + protected void beforeTest(ReflectiveInvocationContext invocationContext, ExtensionContext extensionContext) { + this.visitor = new ResolvableAnnotationValueVisitor(); + this.visitor1 = new ResolvableAnnotationValueVisitor(true); + this.visitor2 = new ResolvableAnnotationValueVisitor(true, true); + this.testAnnotationAttributes = getElementValues(testTypeElement, TestAnnotation.class); + } + + @Test + void testVisitBoolean() { + assertEquals(BOOLEAN_VALUE, visitor.visitBoolean(BOOLEAN_VALUE, null)); + assertVisit(this.visitor, "z", BOOLEAN_VALUE); + assertVisit(this.visitor1, "z", BOOLEAN_VALUE); + assertVisit(this.visitor2, "z", BOOLEAN_VALUE); + } + + @Test + void testVisitByte() { + assertEquals(BYTE_VALUE, visitor.visitByte(BYTE_VALUE, null)); + assertVisit(this.visitor, "b", BYTE_VALUE); + assertVisit(this.visitor1, "b", BYTE_VALUE); + assertVisit(this.visitor2, "b", BYTE_VALUE); + } + + @Test + void testVisitChar() { + assertEquals(CHAR_VALUE, visitor.visitChar(CHAR_VALUE, null)); + assertVisit(this.visitor, "c", CHAR_VALUE); + assertVisit(this.visitor1, "c", CHAR_VALUE); + assertVisit(this.visitor2, "c", CHAR_VALUE); + } + + @Test + void testVisitDouble() { + assertEquals(DOUBLE_VALUE, visitor.visitDouble(DOUBLE_VALUE, null)); + assertVisit(this.visitor, "d", DOUBLE_VALUE); + assertVisit(this.visitor1, "d", DOUBLE_VALUE); + assertVisit(this.visitor2, "d", DOUBLE_VALUE); + } + + @Test + void testVisitFloat() { + assertEquals(FLOAT_VALUE, visitor.visitFloat(FLOAT_VALUE, null)); + assertVisit(this.visitor, "f", FLOAT_VALUE); + assertVisit(this.visitor1, "f", FLOAT_VALUE); + assertVisit(this.visitor2, "f", FLOAT_VALUE); + } + + @Test + void testVisitInt() { + assertEquals(INT_VALUE, visitor.visitInt(INT_VALUE, null)); + assertVisit(this.visitor, "i", INT_VALUE); + assertVisit(this.visitor1, "i", INT_VALUE); + assertVisit(this.visitor2, "i", INT_VALUE); + } + + @Test + void testVisitLong() { + assertEquals(LONG_VALUE, visitor.visitLong(LONG_VALUE, null)); + assertVisit(this.visitor, "l", LONG_VALUE); + assertVisit(this.visitor1, "l", LONG_VALUE); + assertVisit(this.visitor2, "l", LONG_VALUE); + } + + @Test + void testVisitShort() { + assertEquals(SHORT_VALUE, visitor.visitShort(SHORT_VALUE, null)); + assertVisit(this.visitor, "s", SHORT_VALUE); + assertVisit(this.visitor1, "s", SHORT_VALUE); + assertVisit(this.visitor2, "s", SHORT_VALUE); + } + + @Test + void testVisitString() { + assertEquals(STRING_VALUE, visitor.visitString(STRING_VALUE, null)); + assertVisit(this.visitor, "string", STRING_VALUE); + assertVisit(this.visitor1, "string", STRING_VALUE); + assertVisit(this.visitor1, "string", STRING_VALUE); + } + + @Test + void testVisitType() { + assertEquals(TYPE_VALUE, visitor.visitType(getTypeMirror(TYPE_VALUE), null)); + assertVisit(this.visitor, "type", TYPE_VALUE); + assertVisit(this.visitor1, "type", TYPE_VALUE.getName()); + assertVisit(this.visitor2, "type", TYPE_VALUE.getName()); + } + + @Test + void testVisitEnumConstant() { + assertVisit(this.visitor, "timeUnit", HOURS); + assertVisit(this.visitor1, "timeUnit", HOURS); + assertVisit(this.visitor2, "timeUnit", HOURS); + } + + @Test + void testVisitAnnotation() { + String attributeName = "since"; + + Map attributesMap = new LinkedHashMap<>(); + attributesMap.put("module", ""); + attributesMap.put("value", "1.0.0"); + + TestAnnotation testAnnotation = testClass.getAnnotation(TestAnnotation.class); + + assertVisit(this.visitor, attributeName, testAnnotation.since()); + assertVisit(this.visitor1, attributeName, testAnnotation.since()); + assertVisit(this.visitor2, attributeName, attributesMap); + } + + @Test + void testVisitArray() { + assertVisit(this.visitor, "types", TYPES_VALUE); + assertVisit(this.visitor1, "types", of(TYPES_VALUE).map(Class::getName).toArray(String[]::new)); + assertVisit(this.visitor2, "types", of(TYPES_VALUE).map(Class::getName).toArray(String[]::new)); + } + + @Test + void testVisitUnknown() { + for (Entry elementValue : this.testAnnotationAttributes.entrySet()) { + ExecutableElement attributeMethod = elementValue.getKey(); + AnnotationValue annotationValue = elementValue.getValue(); + assertSame(annotationValue, visitor.visitUnknown(annotationValue, attributeMethod)); + } + } + + void assertVisit(AnnotationValueVisitor visitor, String attributeName, Object expectedValue) { + Entry elementValue = getElementValue(this.testAnnotationAttributes, attributeName); + ExecutableElement attributeMethod = elementValue.getKey(); + AnnotationValue annotationValue = elementValue.getValue(); + assertTrue(deepEquals(expectedValue, annotationValue.accept(visitor, attributeMethod))); + } +} diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/TypeUtilsTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/TypeUtilsTest.java new file mode 100644 index 000000000..9e73f8b5c --- /dev/null +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/TypeUtilsTest.java @@ -0,0 +1,1876 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.lang.model.util; + +import io.microsphere.test.model.ArrayTypeModel; +import io.microsphere.test.model.CollectionTypeModel; +import io.microsphere.test.model.Color; +import io.microsphere.test.model.MapTypeModel; +import io.microsphere.test.model.Model; +import io.microsphere.test.model.PrimitiveTypeModel; +import io.microsphere.test.service.DefaultTestService; +import io.microsphere.test.service.GenericTestService; +import io.microsphere.test.service.TestService; +import io.microsphere.test.service.TestServiceImpl; +import org.junit.jupiter.api.Test; + +import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; +import javax.lang.model.type.DeclaredType; +import javax.lang.model.type.TypeKind; +import javax.lang.model.type.TypeMirror; +import java.io.Serializable; +import java.lang.reflect.Type; +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.Date; +import java.util.EventListener; +import java.util.List; +import java.util.Set; +import java.util.concurrent.TimeUnit; +import java.util.function.Predicate; + +import static io.microsphere.collection.ListUtils.ofList; +import static io.microsphere.lang.function.Predicates.alwaysFalse; +import static io.microsphere.lang.function.Predicates.alwaysTrue; +import static io.microsphere.lang.model.util.FieldUtils.findField; +import static io.microsphere.lang.model.util.FieldUtils.getDeclaredFields; +import static io.microsphere.lang.model.util.MethodUtils.findMethod; +import static io.microsphere.lang.model.util.TypeUtils.findAllDeclaredTypes; +import static io.microsphere.lang.model.util.TypeUtils.findAllDeclaredTypesOfInterfaces; +import static io.microsphere.lang.model.util.TypeUtils.findAllDeclaredTypesOfSuperTypes; +import static io.microsphere.lang.model.util.TypeUtils.findAllDeclaredTypesOfSuperclasses; +import static io.microsphere.lang.model.util.TypeUtils.findAllTypeElementsOfInterfaces; +import static io.microsphere.lang.model.util.TypeUtils.findAllTypeElementsOfSuperclasses; +import static io.microsphere.lang.model.util.TypeUtils.findAllTypeMirrorsOfInterfaces; +import static io.microsphere.lang.model.util.TypeUtils.findDeclaredTypes; +import static io.microsphere.lang.model.util.TypeUtils.findDeclaredTypesOfInterfaces; +import static io.microsphere.lang.model.util.TypeUtils.findInterfaceTypeMirror; +import static io.microsphere.lang.model.util.TypeUtils.findTypeElements; +import static io.microsphere.lang.model.util.TypeUtils.findTypeElementsOfInterfaces; +import static io.microsphere.lang.model.util.TypeUtils.findTypeMirrorsOfInterfaces; +import static io.microsphere.lang.model.util.TypeUtils.getAllDeclaredTypes; +import static io.microsphere.lang.model.util.TypeUtils.getAllDeclaredTypesOfInterfaces; +import static io.microsphere.lang.model.util.TypeUtils.getAllDeclaredTypesOfSuperTypes; +import static io.microsphere.lang.model.util.TypeUtils.getAllDeclaredTypesOfSuperclasses; +import static io.microsphere.lang.model.util.TypeUtils.getAllTypeElements; +import static io.microsphere.lang.model.util.TypeUtils.getAllTypeElementsOfInterfaces; +import static io.microsphere.lang.model.util.TypeUtils.getAllTypeElementsOfSuperTypes; +import static io.microsphere.lang.model.util.TypeUtils.getAllTypeElementsOfSuperclasses; +import static io.microsphere.lang.model.util.TypeUtils.getAllTypeMirrorsOfInterfaces; +import static io.microsphere.lang.model.util.TypeUtils.getDeclaredTypeOfSuperclass; +import static io.microsphere.lang.model.util.TypeUtils.getDeclaredTypes; +import static io.microsphere.lang.model.util.TypeUtils.getDeclaredTypesOfInterfaces; +import static io.microsphere.lang.model.util.TypeUtils.getTypeElementOfSuperclass; +import static io.microsphere.lang.model.util.TypeUtils.getTypeElementsOfInterfaces; +import static io.microsphere.lang.model.util.TypeUtils.getTypeMirrorsOfInterfaces; +import static io.microsphere.lang.model.util.TypeUtils.isAnnotationType; +import static io.microsphere.lang.model.util.TypeUtils.isArrayType; +import static io.microsphere.lang.model.util.TypeUtils.isClassType; +import static io.microsphere.lang.model.util.TypeUtils.isDeclaredType; +import static io.microsphere.lang.model.util.TypeUtils.isEnumType; +import static io.microsphere.lang.model.util.TypeUtils.isInterfaceType; +import static io.microsphere.lang.model.util.TypeUtils.isPrimitiveType; +import static io.microsphere.lang.model.util.TypeUtils.isSameType; +import static io.microsphere.lang.model.util.TypeUtils.isSimpleType; +import static io.microsphere.lang.model.util.TypeUtils.isTypeElement; +import static io.microsphere.lang.model.util.TypeUtils.ofDeclaredType; +import static io.microsphere.lang.model.util.TypeUtils.ofDeclaredTypes; +import static io.microsphere.lang.model.util.TypeUtils.ofTypeElement; +import static io.microsphere.lang.model.util.TypeUtils.ofTypeElements; +import static io.microsphere.lang.model.util.TypeUtils.ofTypeMirrors; +import static io.microsphere.lang.model.util.TypeUtils.typeElementFinder; +import static io.microsphere.reflect.TypeUtils.getTypeNames; +import static io.microsphere.util.ArrayUtils.EMPTY_STRING_ARRAY; +import static io.microsphere.util.ArrayUtils.combine; +import static io.microsphere.util.ArrayUtils.length; +import static io.microsphere.util.ArrayUtils.ofArray; +import static java.util.Collections.emptyList; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * The {@link TypeUtils} Test + * + * @author Mercy + * @since 1.0.0 + */ +class TypeUtilsTest extends UtilTest { + + /** + * self type + */ + private static final Class SELF_TYPE = TestServiceImpl.class; + + /** + * super class + */ + private static final Class SUPER_CLASS = GenericTestService.class; + + /** + * all types + */ + private static final Type[] ALL_TYPES = ofArray(SELF_TYPE, SUPER_CLASS, DefaultTestService.class, Object.class, TestService.class, EventListener.class, AutoCloseable.class, Serializable.class); + + /** + * all super types + */ + private static final Type[] ALL_SUPER_TYPES = ofArray(SUPER_CLASS, DefaultTestService.class, Object.class, TestService.class, EventListener.class, AutoCloseable.class, Serializable.class); + + /** + * all super classes + */ + private static final Type[] ALL_SUPER_CLASSES = ofArray(SUPER_CLASS, DefaultTestService.class, Object.class); + + /** + * all super interfaces + */ + private static final Type[] ALL_SUPER_INTERFACES = ofArray(TestService.class, EventListener.class, AutoCloseable.class, Serializable.class); + + /** + * super interfaces + */ + private static final Type[] SUPER_INTERFACES = ofArray(TestService.class, AutoCloseable.class, Serializable.class); + + /** + * super class + super interfaces + */ + private static final Type[] SUPER_TYPES = combine(SUPER_CLASS, SUPER_INTERFACES); + + /** + * self type + all super types = all types + */ + private static final Type[] SELF_TYPE_PLUS_ALL_SUPER_TYPES = combine(SELF_TYPE, ALL_SUPER_TYPES); + + /** + * self type + all super classes + */ + private static final Type[] SELF_TYPE_PLUS_ALL_SUPER_CLASSES = combine(SELF_TYPE, ALL_SUPER_CLASSES); + + /** + * self type + all super interfaces + */ + private static final Type[] SELF_TYPE_PLUS_ALL_SUPER_INTERFACES = combine(SELF_TYPE, ALL_SUPER_INTERFACES); + + /** + * self type + super class + */ + private static final Type[] SELF_TYPE_PLUS_SUPER_CLASS = ofArray(SELF_TYPE, SUPER_CLASS); + + /** + * self type + super interfaces + */ + private static final Type[] SELF_TYPE_PLUS_SUPER_INTERFACES = combine(SELF_TYPE, SUPER_INTERFACES); + + /** + * self type + super class + super interfaces + */ + private static final Type[] SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES = combine(SELF_TYPE, SUPER_TYPES); + + @Override + protected void addCompiledClasses(Set> compiledClasses) { + compiledClasses.add(ArrayTypeModel.class); + compiledClasses.add(CollectionTypeModel.class); + compiledClasses.add(Color.class); + compiledClasses.add(MapTypeModel.class); + } + + @Test + void testIsSimpleType() { + assertTrue(isSimpleType(getTypeElement(Void.class))); + assertTrue(isSimpleType(getTypeElement(Boolean.class))); + assertTrue(isSimpleType(getTypeElement(Character.class))); + assertTrue(isSimpleType(getTypeElement(Byte.class))); + assertTrue(isSimpleType(getTypeElement(Short.class))); + assertTrue(isSimpleType(getTypeElement(Integer.class))); + assertTrue(isSimpleType(getTypeElement(Long.class))); + assertTrue(isSimpleType(getTypeElement(Float.class))); + assertTrue(isSimpleType(getTypeElement(Double.class))); + assertTrue(isSimpleType(getTypeElement(String.class))); + assertTrue(isSimpleType(getTypeElement(BigDecimal.class))); + assertTrue(isSimpleType(getTypeElement(BigInteger.class))); + assertTrue(isSimpleType(getTypeElement(Date.class))); + assertTrue(isSimpleType(getTypeElement(Object.class))); + + assertFalse(isSimpleType(getTypeElement(getClass()))); + } + + @Test + void testIsSimpleTypeOnNull() { + assertFalse(isSimpleType(NULL_TYPE_ELEMENT)); + assertFalse(isSimpleType(NULL_TYPE_MIRROR)); + } + + @Test + void testIsSameType() { + assertIsSameType(testTypeElement, testClass); + + assertFalse(isSameType(getDeclaredType(String.class), "java.lang.Void")); + } + + @Test + void testIsSameTypeOnNull() { + assertFalse(isSameType(NULL_TYPE_MIRROR, testClass)); + assertFalse(isSameType(NULL_TYPE_MIRROR, testClassName)); + assertFalse(isSameType(NULL_ELEMENT, testClass)); + assertFalse(isSameType(NULL_ELEMENT, testClassName)); + + assertFalse(isSameType(testTypeElement, NULL_TYPE)); + assertFalse(isSameType(testTypeElement, NULL_STRING)); + + assertFalse(isSameType(testTypeMirror, NULL_TYPE)); + assertFalse(isSameType(testTypeMirror, NULL_STRING)); + + assertTrue(isSameType(NULL_TYPE_MIRROR, NULL_TYPE)); + assertTrue(isSameType(NULL_TYPE_MIRROR, NULL_STRING)); + assertTrue(isSameType(NULL_ELEMENT, NULL_TYPE)); + assertTrue(isSameType(NULL_ELEMENT, NULL_STRING)); + } + + @Test + void testIsArrayTypeOnTypeMirror() { + assertIsArrayType(ArrayTypeModel.class); + + assertFalse(isArrayType(getTypeMirror(Color.class))); + assertFalse(isArrayType(getTypeMirror(ArrayTypeModel.class))); + } + + @Test + void testIsArrayTypeOnElement() { + assertIsArrayType(getTypeElement(ArrayTypeModel.class)); + + assertFalse(isArrayType(getTypeElement(Color.class))); + assertFalse(isArrayType(getTypeElement(ArrayTypeModel.class))); + } + + @Test + void testIsArrayTypeOnNull() { + assertFalse(isArrayType(NULL_ELEMENT)); + assertFalse(isArrayType(NULL_TYPE_MIRROR)); + } + + @Test + void testIsEnumType() { + assertTrue(isEnumType(getDeclaredType(Color.class))); + assertFalse(isEnumType(getTypeElement(ArrayTypeModel.class))); + } + + @Test + void testIsEnumTypeOnNull() { + assertFalse(isEnumType(NULL_ELEMENT)); + assertFalse(isEnumType(NULL_TYPE_MIRROR)); + } + + @Test + void testIsClassType() { + // class + assertTrue(isClassType(getTypeElement(ArrayTypeModel.class))); + assertTrue(isClassType(getDeclaredType(ArrayTypeModel.class))); + + assertTrue(isClassType(getTypeElement(Model.class))); + assertTrue(isClassType(getDeclaredType(Model.class))); + + // enum + assertFalse(isClassType(getTypeElement(TimeUnit.class))); + assertFalse(isClassType(getDeclaredType(TimeUnit.class))); + + // interface + assertFalse(isClassType(getTypeElement(Serializable.class))); + assertFalse(isClassType(getDeclaredType(Serializable.class))); + } + + @Test + void testIsClassTypeOnNull() { + assertFalse(isClassType(NULL_ELEMENT)); + assertFalse(isClassType(NULL_TYPE_MIRROR)); + } + + @Test + void testIsPrimitiveType() { + TypeElement type = getTypeElement(PrimitiveTypeModel.class); + + getDeclaredFields(type).forEach(t -> { + assertTrue(isPrimitiveType(t)); + assertTrue(isPrimitiveType(t.asType())); + }); + + assertFalse(isPrimitiveType(getTypeElement(ArrayTypeModel.class))); + } + + @Test + void testIsPrimitiveTypeOnNull() { + assertFalse(isPrimitiveType(NULL_ELEMENT)); + assertFalse(isPrimitiveType(NULL_TYPE_MIRROR)); + } + + @Test + void testIsInterfaceType() { + assertTrue(isInterfaceType(getTypeElement(CharSequence.class))); + assertTrue(isInterfaceType(getDeclaredType(CharSequence.class))); + + assertFalse(isInterfaceType(getTypeElement(Model.class))); + assertFalse(isInterfaceType(getDeclaredType(Model.class))); + } + + @Test + void testIsInterfaceTypeOnNull() { + assertFalse(isInterfaceType(NULL_ELEMENT)); + assertFalse(isInterfaceType(NULL_TYPE_MIRROR)); + } + + @Test + void testIsAnnotationType() { + assertTrue(isAnnotationType(getTypeElement(Override.class))); + assertTrue(isAnnotationType(getDeclaredType(Override.class))); + + assertFalse(isAnnotationType(getTypeElement(Model.class))); + assertFalse(isAnnotationType(getDeclaredType(Model.class))); + } + + @Test + void testIsAnnotationTypeOnNull() { + assertFalse(isAnnotationType(NULL_ELEMENT)); + assertFalse(isAnnotationType(NULL_TYPE_MIRROR)); + } + + @Test + void testIsTypeElement() { + assertTrue(isTypeElement(testTypeElement)); + assertTrue(isTypeElement(testTypeMirror)); + assertTrue(isTypeElement(getFieldType(testTypeElement, "context"))); + + // primitive type + assertFalse(isTypeElement(getTypeMirror(int.class))); + } + + @Test + void testIsTypeElementOnNull() { + assertFalse(isTypeElement(NULL_ELEMENT)); + assertFalse(isTypeElement(NULL_TYPE_MIRROR)); + } + + @Test + void testIsDeclaredType() { + assertTrue(isDeclaredType(testTypeElement)); + assertTrue(isDeclaredType(testTypeMirror)); + assertFalse(isDeclaredType(types.getNullType())); + assertFalse(isDeclaredType(types.getPrimitiveType(TypeKind.BYTE))); + assertFalse(isDeclaredType(types.getArrayType(types.getPrimitiveType(TypeKind.BYTE)))); + + // field + assertFalse(isDeclaredType(findField(getTypeMirror(PrimitiveTypeModel.class), "z"))); + + // method + assertFalse(isDeclaredType(findMethod(testTypeElement, "close"))); + } + + @Test + void testIsDeclaredTypeOnNull() { + assertFalse(isDeclaredType(NULL_ELEMENT)); + assertFalse(isDeclaredType(NULL_TYPE_MIRROR)); + } + + @Test + void testOfTypeElement() { + assertEquals(testTypeElement, ofTypeElement(testTypeElement)); + assertEquals(testTypeElement, ofTypeElement(testTypeMirror)); + } + + @Test + void testOfTypeElementOnNull() { + assertNull(ofTypeElement(NULL_ELEMENT)); + assertNull(ofTypeElement(NULL_TYPE_MIRROR)); + } + + @Test + void testOfDeclaredType() { + assertEquals(testTypeMirror, testDeclaredType); + assertEquals(testTypeMirror, ofDeclaredType(testTypeMirror)); + assertEquals(testDeclaredType, ofDeclaredType(testTypeMirror)); + } + + @Test + void testOfDeclaredTypeOnNull() { + assertNull(ofDeclaredType(NULL_ELEMENT)); + assertNull(ofDeclaredType(NULL_TYPE_MIRROR)); + } + + @Test + void testOfTypeMirrors() { + assertOfTypeMirrors(String.class, SELF_TYPE, Color.class); + } + + @Test + void testOfTypeMirrorsOnNull() { + assertEmptyList(ofTypeMirrors(EMPTY_ELEMENT_ARRAY)); + assertEmptyList(ofTypeMirrors(NULL_COLLECTION)); + } + + @Test + void testOfTypeMirrorsOnEmpty() { + assertEmptyList(ofTypeMirrors(EMPTY_ELEMENT_ARRAY)); + assertEmptyList(ofTypeMirrors(emptyList())); + } + + @Test + void testOfTypeElements() { + assertOfTypeElements(String.class, SELF_TYPE, Color.class); + } + + @Test + void testOfTypeElementsOnNull() { + assertEmptyList(ofTypeElements(NULL_TYPE_MIRROR_ARRAY)); + assertEmptyList(ofTypeElements(NULL_COLLECTION)); + } + + @Test + void testOfTypeElementsOnEmpty() { + assertEmptyList(ofTypeElements(EMPTY_TYPE_MIRROR_ARRAY)); + assertEmptyList(ofTypeElements(emptyList())); + } + + @Test + void testOfDeclaredTypes() { + assertOfDeclaredTypes(String.class, SELF_TYPE, Color.class); + } + + @Test + void testOfDeclaredTypesWithFilter() { + List declaredTypes = ofDeclaredTypes(ofList(getTypeElement(String.class), getTypeElement(TestServiceImpl.class), getTypeElement(Color.class)), t -> true); + assertDeclaredTypes(declaredTypes, String.class, SELF_TYPE, Color.class); + } + + @Test + void testOfDeclaredTypesOnNull() { + assertEmptyList(ofDeclaredTypes(NULL_ELEMENT_ARRAY)); + assertEmptyList(ofDeclaredTypes(NULL_COLLECTION)); + } + + @Test + void testOfDeclaredTypesOnEmpty() { + assertEmptyList(ofDeclaredTypes(emptyList())); + } + + @Test + void testGetTypeElementOfSuperclass() { + TypeElement superTypeElement = getTypeElementOfSuperclass(testTypeElement); + assertEquals(getTypeElement(GenericTestService.class), superTypeElement); + + superTypeElement = getTypeElementOfSuperclass(superTypeElement); + assertEquals(getTypeElement(DefaultTestService.class), superTypeElement); + + superTypeElement = getTypeElementOfSuperclass(superTypeElement); + assertEquals(getTypeElement(Object.class), superTypeElement); + + assertNull(getTypeElementOfSuperclass(superTypeElement)); + } + + @Test + void testGetTypeElementOfSuperclassOnNull() { + assertNull(getTypeElementOfSuperclass(NULL_TYPE_ELEMENT)); + } + + @Test + void testGetAllTypeElementsOfSuperclasses() { + List allSuperTypes = getAllTypeElementsOfSuperclasses(testTypeElement); + assertTypeElements(allSuperTypes, ALL_SUPER_CLASSES); + } + + @Test + void testGetAllTypeElementsOfSuperclassesOnNull() { + assertEmptyList(getAllTypeElementsOfSuperclasses(NULL_TYPE_ELEMENT)); + } + + @Test + void testGetTypeElementsOfInterfaces() { + List typeElements = getTypeElementsOfInterfaces(testTypeElement); + assertTypeElements(typeElements, SUPER_INTERFACES); + } + + @Test + void testGetTypeElementsOfInterfacesOnNull() { + assertEmptyList(getTypeElementsOfInterfaces(NULL_TYPE_ELEMENT)); + } + + @Test + void testGetAllTypeElementsOfInterfaces() { + List typeElements = getAllTypeElementsOfInterfaces(testTypeElement); + assertTypeElements(typeElements, ALL_SUPER_INTERFACES); + } + + @Test + void testGetAllTypeElementsOfInterfacesOnNull() { + assertEmptyList(getAllTypeElementsOfInterfaces(NULL_TYPE_ELEMENT)); + } + + @Test + void testGetAllTypeElements() { + List allTypeElements = getAllTypeElements(testTypeElement); + assertTypeElements(allTypeElements, ALL_TYPES); + } + + @Test + void testGetAllTypeElementsOnNull() { + assertEmptyList(getAllTypeElements(NULL_TYPE_ELEMENT)); + } + + @Test + void testGetTypeElementsWithNoArgument() { + List typeElements = TypeUtils.getTypeElements(testTypeElement); + assertTypeElements(typeElements, SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES); + } + + @Test + void testGetTypeElements() { + // true true true true : all types + List typeElements = TypeUtils.getTypeElements(testTypeElement, true, true, true, true); + assertTypeElements(typeElements, ALL_TYPES); + assertEquals(getAllTypeElements(testTypeElement), typeElements); + + // true true true false : self type + all super classes + typeElements = TypeUtils.getTypeElements(testTypeElement, true, true, true, false); + assertTypeElements(typeElements, SELF_TYPE_PLUS_ALL_SUPER_CLASSES); + + // true true false true : self type + all super interfaces + typeElements = TypeUtils.getTypeElements(testTypeElement, true, true, false, true); + assertTypeElements(typeElements, SELF_TYPE_PLUS_ALL_SUPER_INTERFACES); + + // true true false false : self type + typeElements = TypeUtils.getTypeElements(testTypeElement, true, true, false, false); + assertTypeElements(typeElements, SELF_TYPE); + + // true false true true : self type + super class + super interfaces + typeElements = TypeUtils.getTypeElements(testTypeElement, true, false, true, true); + assertTypeElements(typeElements, SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES); + + // true false true false : self type + super class + typeElements = TypeUtils.getTypeElements(testTypeElement, true, false, true, false); + assertTypeElements(typeElements, SELF_TYPE_PLUS_SUPER_CLASS); + + // true false false true : self type + super interfaces + typeElements = TypeUtils.getTypeElements(testTypeElement, true, false, false, true); + assertTypeElements(typeElements, SELF_TYPE_PLUS_SUPER_INTERFACES); + + // true false false false : self type + typeElements = TypeUtils.getTypeElements(testTypeElement, true, false, false, false); + assertTypeElements(typeElements, SELF_TYPE); + + // false true true true : all super types + typeElements = TypeUtils.getTypeElements(testTypeElement, false, true, true, true); + assertTypeElements(typeElements, ALL_SUPER_TYPES); + assertEquals(getAllTypeElementsOfSuperTypes(testTypeElement), typeElements); + + // false true true false : all super classes + typeElements = TypeUtils.getTypeElements(testTypeElement, false, true, true, false); + assertTypeElements(typeElements, ALL_SUPER_CLASSES); + assertEquals(getAllTypeElementsOfSuperclasses(testTypeElement), typeElements); + + // false true false true : all super interfaces + typeElements = TypeUtils.getTypeElements(testTypeElement, false, true, false, true); + assertTypeElements(typeElements, ALL_SUPER_INTERFACES); + assertEquals(getAllTypeElementsOfInterfaces(testTypeElement), typeElements); + + // false true false false : nothing + typeElements = TypeUtils.getTypeElements(testTypeElement, false, true, false, false); + assertTypeElements(typeElements); + assertEmptyList(typeElements); + + // false false true true : super class + super interfaces + typeElements = TypeUtils.getTypeElements(testTypeElement, false, false, true, true); + assertTypeElements(typeElements, SUPER_TYPES); + + // false false true false : super class + typeElements = TypeUtils.getTypeElements(testTypeElement, false, false, true, false); + assertTypeElements(typeElements, SUPER_CLASS); + assertEquals(ofList(getTypeElementOfSuperclass(testTypeElement)), typeElements); + + // false false false true : super interfaces + typeElements = TypeUtils.getTypeElements(testTypeElement, false, false, false, true); + assertTypeElements(typeElements, SUPER_INTERFACES); + assertEquals(ofList(getTypeElementsOfInterfaces(testTypeElement)), typeElements); + + // false false false false : nothing + typeElements = TypeUtils.getTypeElements(testTypeElement, false, false, false, false); + assertTypeElements(typeElements); + assertEmptyList(typeElements); + } + + @Test + void testGetTypeElementsOnNull() { + assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, true, true, true, true)); + assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, true, true, true, false)); + assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, true, true, false, true)); + assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, true, true, false, false)); + + assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, true, false, true, true)); + assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, false, false, true, false)); + assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, false, false, false, true)); + assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, false, false, false, false)); + + assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, false, true, true, true)); + assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, false, true, true, false)); + assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, false, true, false, true)); + assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, false, true, false, false)); + + assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, false, false, true, true)); + assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, false, false, true, false)); + assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, false, false, false, true)); + assertEmptyList(TypeUtils.getTypeElements(NULL_TYPE_ELEMENT, false, false, false, false)); + } + + @Test + void testFindAllTypeElementsOfSuperclasses() { + List typeElements = findAllTypeElementsOfSuperclasses(testTypeElement, alwaysTrue()); + assertTypeElements(typeElements, ALL_SUPER_CLASSES); + assertEquals(getAllTypeElementsOfSuperclasses(testTypeElement), typeElements); + + assertEmptyList(findAllTypeElementsOfSuperclasses(testTypeElement, alwaysFalse())); + } + + @Test + void testFindAllTypeElementsOfSuperclassesOnNull() { + assertEmptyList(findAllTypeElementsOfSuperclasses(NULL_TYPE_ELEMENT, alwaysTrue())); + assertEmptyList(findAllTypeElementsOfSuperclasses(NULL_TYPE_ELEMENT, alwaysFalse())); + } + + @Test + void testFindAllTypeElementsOfInterfaces() { + List typeElements = findAllTypeElementsOfInterfaces(testTypeElement, alwaysTrue()); + assertTypeElements(typeElements, ALL_SUPER_INTERFACES); + assertEquals(getAllTypeElementsOfInterfaces(testTypeElement), typeElements); + + assertEmptyList(findAllTypeElementsOfInterfaces(testTypeElement, alwaysFalse())); + } + + @Test + void testFindAllTypeElementsOfInterfacesOnNull() { + assertEmptyList(findAllTypeElementsOfInterfaces(NULL_TYPE_ELEMENT, alwaysTrue())); + assertEmptyList(findAllTypeElementsOfInterfaces(NULL_TYPE_ELEMENT, alwaysFalse())); + } + + @Test + void testFindTypeElementsOfInterfaces() { + List typeElements = findTypeElementsOfInterfaces(testTypeElement, alwaysTrue()); + assertTypeElements(typeElements, SUPER_INTERFACES); + assertEquals(getTypeElementsOfInterfaces(testTypeElement), typeElements); + + assertEmptyList(findTypeElementsOfInterfaces(testTypeElement, alwaysFalse())); + } + + @Test + void testFindTypeElementsOfInterfacesOnNull() { + assertEmptyList(findTypeElementsOfInterfaces(NULL_TYPE_ELEMENT, alwaysTrue())); + assertEmptyList(findTypeElementsOfInterfaces(NULL_TYPE_ELEMENT, alwaysFalse())); + } + + @Test + void testFindTypeElements() { + // true true true true : all types + List typeElements = findTypeElements(testTypeElement, true, true, true, true, alwaysTrue()); + assertTypeElements(typeElements, ALL_TYPES); + assertEquals(getAllTypeElements(testTypeElement), typeElements); + + // true true true false : self type + all super classes + typeElements = findTypeElements(testTypeElement, true, true, true, false, alwaysTrue()); + assertTypeElements(typeElements, SELF_TYPE_PLUS_ALL_SUPER_CLASSES); + + // true true false true : self type + all super interfaces + typeElements = findTypeElements(testTypeElement, true, true, false, true, alwaysTrue()); + assertTypeElements(typeElements, SELF_TYPE_PLUS_ALL_SUPER_INTERFACES); + + // true true false false : self type + typeElements = findTypeElements(testTypeElement, true, true, false, false, alwaysTrue()); + assertTypeElements(typeElements, SELF_TYPE); + + // true false true true : self type + super class + super interfaces + typeElements = findTypeElements(testTypeElement, true, false, true, true, alwaysTrue()); + assertTypeElements(typeElements, SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES); + + // true false true false : self type + super class + typeElements = findTypeElements(testTypeElement, true, false, true, false, alwaysTrue()); + assertTypeElements(typeElements, SELF_TYPE_PLUS_SUPER_CLASS); + + // true false false true : self type + super interfaces + typeElements = findTypeElements(testTypeElement, true, false, false, true, alwaysTrue()); + assertTypeElements(typeElements, SELF_TYPE_PLUS_SUPER_INTERFACES); + + // true false false false : self type + typeElements = findTypeElements(testTypeElement, true, false, false, false, alwaysTrue()); + assertTypeElements(typeElements, SELF_TYPE); + + // false true true true : all super types + typeElements = findTypeElements(testTypeElement, false, true, true, true, alwaysTrue()); + assertTypeElements(typeElements, ALL_SUPER_TYPES); + assertEquals(getAllTypeElementsOfSuperTypes(testTypeElement), typeElements); + + // false true true false : all super classes + typeElements = findTypeElements(testTypeElement, false, true, true, false, alwaysTrue()); + assertTypeElements(typeElements, ALL_SUPER_CLASSES); + assertEquals(getAllTypeElementsOfSuperclasses(testTypeElement), typeElements); + + // false true false true : all super interfaces + typeElements = findTypeElements(testTypeElement, false, true, false, true, alwaysTrue()); + assertTypeElements(typeElements, ALL_SUPER_INTERFACES); + assertEquals(getAllTypeElementsOfInterfaces(testTypeElement), typeElements); + + // false true false false : nothing + typeElements = findTypeElements(testTypeElement, false, true, false, false, alwaysTrue()); + assertTypeElements(typeElements); + assertEmptyList(typeElements); + + // false false true true : super types + typeElements = findTypeElements(testTypeElement, false, false, true, true, alwaysTrue()); + assertTypeElements(typeElements, SUPER_TYPES); + + // false false true false : super class + typeElements = findTypeElements(testTypeElement, false, false, true, false, alwaysTrue()); + assertTypeElements(typeElements, SUPER_CLASS); + assertEquals(ofList(getTypeElementOfSuperclass(testTypeElement)), typeElements); + + // false false false true : super interfaces + typeElements = findTypeElements(testTypeElement, false, false, false, true, alwaysTrue()); + assertTypeElements(typeElements, SUPER_INTERFACES); + assertEquals(ofList(getTypeElementsOfInterfaces(testTypeElement)), typeElements); + + // false false false false : nothing + typeElements = findTypeElements(testTypeElement, false, false, false, false, alwaysTrue()); + assertTypeElements(typeElements); + assertEmptyList(typeElements); + } + + @Test + void testFindTypeElementsOnNullFilterElement() { + assertThrows(IllegalArgumentException.class, + () -> findTypeElements(testTypeElement, true, true, true, true, new Predicate[]{null})); + } + + + @Test + void testGetDeclaredTypeOfSuperclass() { + DeclaredType superDeclaredType = getDeclaredTypeOfSuperclass(testTypeMirror); + assertEquals(superDeclaredType, getTypeElement(GenericTestService.class).asType()); + + superDeclaredType = getDeclaredTypeOfSuperclass(superDeclaredType); + assertEquals(superDeclaredType, getTypeElement(DefaultTestService.class).asType()); + + superDeclaredType = getDeclaredTypeOfSuperclass(superDeclaredType); + assertEquals(superDeclaredType, getTypeElement(Object.class).asType()); + + assertNull(getDeclaredTypeOfSuperclass(superDeclaredType)); + } + + @Test + void testGetDeclaredTypeOfSuperclassOnNull() { + assertNull(getDeclaredTypeOfSuperclass(NULL_ELEMENT)); + assertNull(getDeclaredTypeOfSuperclass(NULL_TYPE_MIRROR)); + } + + @Test + void testGetDeclaredTypesOfInterfaces() { + List declaredTypes = getDeclaredTypesOfInterfaces(testTypeMirror); + assertDeclaredTypes(declaredTypes, SUPER_INTERFACES); + } + + @Test + void testGetDeclaredTypesOfInterfacesOnNull() { + assertEmptyList(getDeclaredTypesOfInterfaces(NULL_ELEMENT)); + assertEmptyList(getDeclaredTypesOfInterfaces(NULL_TYPE_MIRROR)); + } + + @Test + void testGetAllDeclaredTypesOfSuperclasses() { + List declaredTypes = getAllDeclaredTypesOfSuperclasses(testTypeMirror); + assertDeclaredTypes(declaredTypes, ALL_SUPER_CLASSES); + } + + @Test + void testGetAllDeclaredTypesOfSuperclassesOnNull() { + assertEmptyList(getAllDeclaredTypesOfSuperclasses(NULL_ELEMENT)); + assertEmptyList(getAllDeclaredTypesOfSuperclasses(NULL_TYPE_MIRROR)); + } + + @Test + void testGetAllDeclaredTypesOfInterfaces() { + List declaredTypes = getAllDeclaredTypesOfInterfaces(testTypeMirror); + assertDeclaredTypes(declaredTypes, ALL_SUPER_INTERFACES); + } + + @Test + void testGetAllDeclaredTypesOfInterfacesOnNull() { + assertEmptyList(getAllDeclaredTypesOfInterfaces(NULL_ELEMENT)); + assertEmptyList(getAllDeclaredTypesOfInterfaces(NULL_TYPE_MIRROR)); + } + + @Test + void testGetAllDeclaredTypesOfSuperTypes() { + List declaredTypes = getAllDeclaredTypesOfSuperTypes(testTypeMirror); + assertDeclaredTypes(declaredTypes, ALL_SUPER_TYPES); + } + + @Test + void testGetAllDeclaredTypesOfSuperTypesOnNull() { + assertEmptyList(getAllDeclaredTypesOfSuperTypes(NULL_ELEMENT)); + assertEmptyList(getAllDeclaredTypesOfSuperTypes(NULL_TYPE_MIRROR)); + } + + @Test + void testGetAllDeclaredTypes() { + List declaredTypes = getAllDeclaredTypes(testTypeMirror); + assertDeclaredTypes(declaredTypes, ALL_TYPES); + } + + @Test + void testGetAllDeclaredTypesOnNull() { + assertEmptyList(getAllDeclaredTypes(NULL_ELEMENT)); + assertEmptyList(getAllDeclaredTypes(NULL_TYPE_MIRROR)); + } + + @Test + void testGetDeclaredTypes() { + // true true true true : all types + List declaredTypes = getDeclaredTypes(testTypeElement, true, true, true, true); + assertDeclaredTypes(declaredTypes, ALL_TYPES); + assertEquals(getAllDeclaredTypes(testTypeElement), declaredTypes); + + // true true true false : self type + all super classes + declaredTypes = getDeclaredTypes(testTypeElement, true, true, true, false); + assertDeclaredTypes(declaredTypes, SELF_TYPE_PLUS_ALL_SUPER_CLASSES); + + // true true false true : self type + all super interfaces + declaredTypes = getDeclaredTypes(testTypeElement, true, true, false, true); + assertDeclaredTypes(declaredTypes, SELF_TYPE_PLUS_ALL_SUPER_INTERFACES); + + // true true false false : self type + declaredTypes = getDeclaredTypes(testTypeElement, true, true, false, false); + assertDeclaredTypes(declaredTypes, SELF_TYPE); + + // true false true true : self type + super class + super interfaces + declaredTypes = getDeclaredTypes(testTypeElement, true, false, true, true); + assertDeclaredTypes(declaredTypes, SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES); + + // true false true false : self type + super class + declaredTypes = getDeclaredTypes(testTypeElement, true, false, true, false); + assertDeclaredTypes(declaredTypes, SELF_TYPE_PLUS_SUPER_CLASS); + + // true false false true : self type + super interfaces + declaredTypes = getDeclaredTypes(testTypeElement, true, false, false, true); + assertDeclaredTypes(declaredTypes, SELF_TYPE_PLUS_SUPER_INTERFACES); + + // true false false false : self type + declaredTypes = getDeclaredTypes(testTypeElement, true, false, false, false); + assertDeclaredTypes(declaredTypes, SELF_TYPE); + + // false true true true : all super types + declaredTypes = getDeclaredTypes(testTypeElement, false, true, true, true); + assertDeclaredTypes(declaredTypes, ALL_SUPER_TYPES); + assertEquals(getAllDeclaredTypesOfSuperTypes(testTypeElement), declaredTypes); + + // false true true false : all super classes + declaredTypes = getDeclaredTypes(testTypeElement, false, true, true, false); + assertDeclaredTypes(declaredTypes, ALL_SUPER_CLASSES); + assertEquals(getAllDeclaredTypesOfSuperclasses(testTypeElement), declaredTypes); + + // false true false true : all super interfaces + declaredTypes = getDeclaredTypes(testTypeElement, false, true, false, true); + assertDeclaredTypes(declaredTypes, ALL_SUPER_INTERFACES); + assertEquals(getAllDeclaredTypesOfInterfaces(testTypeElement), declaredTypes); + + // false true false false : nothing + declaredTypes = getDeclaredTypes(testTypeElement, false, true, false, false); + assertDeclaredTypes(declaredTypes); + assertEmptyList(declaredTypes); + + // false false true true : super class + super interfaces + declaredTypes = getDeclaredTypes(testTypeElement, false, false, true, true); + assertDeclaredTypes(declaredTypes, SUPER_TYPES); + + // false false true false : super class + declaredTypes = getDeclaredTypes(testTypeElement, false, false, true, false); + assertDeclaredTypes(declaredTypes, SUPER_CLASS); + assertEquals(ofList(getDeclaredTypeOfSuperclass(testTypeElement)), declaredTypes); + + // false false false true : super interfaces + declaredTypes = getDeclaredTypes(testTypeElement, false, false, false, true); + assertDeclaredTypes(declaredTypes, SUPER_INTERFACES); + assertEquals(ofList(getDeclaredTypesOfInterfaces(testTypeElement)), declaredTypes); + + // false false false false : nothing + declaredTypes = getDeclaredTypes(testTypeElement, false, false, false, false); + assertDeclaredTypes(declaredTypes); + assertEmptyList(declaredTypes); + } + + @Test + void testFindDeclaredTypesWithExcludedTypes() { + List declaredTypes = findDeclaredTypes(testTypeElement, SUPER_CLASS); + assertDeclaredTypes(declaredTypes, SUPER_INTERFACES); + + declaredTypes = findDeclaredTypes(testTypeElement, getTypeNames(SUPER_CLASS)); + assertDeclaredTypes(declaredTypes, SUPER_INTERFACES); + + declaredTypes = findDeclaredTypes(testTypeElement, SUPER_INTERFACES); + assertDeclaredTypes(declaredTypes, SUPER_CLASS); + + declaredTypes = findDeclaredTypes(testTypeElement, getTypeNames(SUPER_INTERFACES)); + assertDeclaredTypes(declaredTypes, SUPER_CLASS); + + declaredTypes = findDeclaredTypes(testTypeMirror, SUPER_CLASS); + assertDeclaredTypes(declaredTypes, SUPER_INTERFACES); + + declaredTypes = findDeclaredTypes(testTypeMirror, getTypeNames(SUPER_CLASS)); + assertDeclaredTypes(declaredTypes, SUPER_INTERFACES); + + declaredTypes = findDeclaredTypes(testTypeMirror, SUPER_INTERFACES); + assertDeclaredTypes(declaredTypes, SUPER_CLASS); + + declaredTypes = findDeclaredTypes(testTypeMirror, getTypeNames(SUPER_INTERFACES)); + assertDeclaredTypes(declaredTypes, SUPER_CLASS); + } + + @Test + void testFindDeclaredTypesWithExcludedTypesOnNull() { + assertEmptyList(findDeclaredTypes(NULL_ELEMENT, NULL_TYPE_ARRAY)); + assertEmptyList(findDeclaredTypes(NULL_ELEMENT, EMPTY_TYPE_ARRAY)); + assertEmptyList(findDeclaredTypes(NULL_ELEMENT, ALL_TYPES)); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, NULL_TYPE_ARRAY)); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, EMPTY_TYPE_ARRAY)); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, ALL_TYPES)); + } + + @Test + void testFindDeclaredTypesWithExcludedTypeNamesOnNull() { + assertEmptyList(findDeclaredTypes(NULL_ELEMENT, NULL_STRING_ARRAY)); + assertEmptyList(findDeclaredTypes(NULL_ELEMENT, EMPTY_STRING_ARRAY)); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, NULL_STRING_ARRAY)); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, EMPTY_STRING_ARRAY)); + } + + @Test + void testFindDeclaredTypesOfInterfaces() { + List declaredTypes = findDeclaredTypesOfInterfaces(testTypeMirror, alwaysTrue()); + assertDeclaredTypes(declaredTypes, SUPER_INTERFACES); + + findDeclaredTypesOfInterfaces(testTypeElement, alwaysTrue()); + assertDeclaredTypes(declaredTypes, SUPER_INTERFACES); + + declaredTypes = findDeclaredTypesOfInterfaces(testTypeMirror, alwaysFalse()); + assertEmptyList(declaredTypes); + + declaredTypes = findDeclaredTypesOfInterfaces(testTypeElement, alwaysFalse()); + assertEmptyList(declaredTypes); + } + + @Test + void testFindDeclaredTypesOfInterfacesOnNull() { + assertEmptyList(findDeclaredTypesOfInterfaces(NULL_ELEMENT, alwaysTrue())); + assertEmptyList(findDeclaredTypesOfInterfaces(NULL_ELEMENT, alwaysFalse())); + assertEmptyList(findDeclaredTypesOfInterfaces(NULL_TYPE_MIRROR, alwaysTrue())); + assertEmptyList(findDeclaredTypesOfInterfaces(NULL_TYPE_MIRROR, alwaysTrue())); + } + + @Test + void testFindAllDeclaredTypesOfSuperclasses() { + List declaredTypes = findAllDeclaredTypesOfSuperclasses(testTypeElement, alwaysTrue()); + assertDeclaredTypes(declaredTypes, ALL_SUPER_CLASSES); + + declaredTypes = findAllDeclaredTypesOfSuperclasses(testTypeMirror, alwaysFalse()); + assertEmptyList(declaredTypes); + } + + @Test + void testFindAllDeclaredTypesOfSuperclassesOnNull() { + assertEmptyList(findAllDeclaredTypesOfSuperclasses(NULL_ELEMENT, alwaysTrue())); + assertEmptyList(findAllDeclaredTypesOfSuperclasses(NULL_ELEMENT, alwaysFalse())); + assertEmptyList(findAllDeclaredTypesOfSuperclasses(NULL_TYPE_MIRROR, alwaysTrue())); + assertEmptyList(findAllDeclaredTypesOfSuperclasses(NULL_TYPE_MIRROR, alwaysFalse())); + } + + @Test + void testFindAllDeclaredTypesOfInterfaces() { + List declaredTypes = findAllDeclaredTypesOfInterfaces(testTypeElement, alwaysTrue()); + assertDeclaredTypes(declaredTypes, ALL_SUPER_INTERFACES); + + declaredTypes = findAllDeclaredTypesOfInterfaces(testTypeMirror, alwaysFalse()); + assertEmptyList(declaredTypes); + } + + @Test + void testFindAllDeclaredTypesOfInterfacesOnNull() { + assertEmptyList(findAllDeclaredTypesOfInterfaces(NULL_ELEMENT, alwaysTrue())); + assertEmptyList(findAllDeclaredTypesOfInterfaces(NULL_ELEMENT, alwaysFalse())); + assertEmptyList(findAllDeclaredTypesOfInterfaces(NULL_TYPE_MIRROR, alwaysTrue())); + assertEmptyList(findAllDeclaredTypesOfInterfaces(NULL_TYPE_MIRROR, alwaysFalse())); + } + + @Test + void testFindAllDeclaredTypesOfSuperTypes() { + List declaredTypes = findAllDeclaredTypesOfSuperTypes(testTypeMirror, alwaysTrue()); + assertDeclaredTypes(declaredTypes, ALL_SUPER_TYPES); + + findAllDeclaredTypesOfSuperTypes(testTypeElement, alwaysTrue()); + assertDeclaredTypes(declaredTypes, ALL_SUPER_TYPES); + + declaredTypes = findAllDeclaredTypesOfSuperTypes(testTypeMirror, alwaysFalse()); + assertEmptyList(declaredTypes); + + declaredTypes = findAllDeclaredTypesOfSuperTypes(testTypeElement, alwaysFalse()); + assertEmptyList(declaredTypes); + } + + @Test + void testFindAllDeclaredTypesOfSuperTypesOnNull() { + assertEmptyList(findAllDeclaredTypesOfSuperTypes(NULL_ELEMENT)); + assertEmptyList(findAllDeclaredTypesOfSuperTypes(NULL_TYPE_MIRROR)); + } + + @Test + void testFindAllDeclaredTypes() { + List declaredTypes = findAllDeclaredTypes(testTypeElement, alwaysTrue()); + assertDeclaredTypes(declaredTypes, ALL_TYPES); + + declaredTypes = findAllDeclaredTypes(testTypeMirror, alwaysFalse()); + assertEmptyList(declaredTypes); + } + + @Test + void testFindAllDeclaredTypesOnNull() { + assertEmptyList(findAllDeclaredTypes(NULL_ELEMENT, alwaysTrue())); + assertEmptyList(findAllDeclaredTypes(NULL_ELEMENT, alwaysFalse())); + assertEmptyList(findAllDeclaredTypes(NULL_TYPE_MIRROR, alwaysTrue())); + assertEmptyList(findAllDeclaredTypes(NULL_TYPE_MIRROR, alwaysFalse())); + } + + @Test + void testFindAllDeclaredTypesWithExcludedTypes() { + List declaredTypes = findAllDeclaredTypes(testTypeElement, testClass); + assertDeclaredTypes(declaredTypes, ALL_SUPER_TYPES); + + + declaredTypes = findAllDeclaredTypes(testTypeMirror, testClass); + assertDeclaredTypes(declaredTypes, ALL_SUPER_TYPES); + } + + @Test + void testFindAllDeclaredTypesWithExcludedTypeNames() { + List declaredTypes = findAllDeclaredTypes(testTypeElement, testClassName); + assertDeclaredTypes(declaredTypes, ALL_SUPER_TYPES); + + declaredTypes = findAllDeclaredTypes(testTypeMirror, testClassName); + assertDeclaredTypes(declaredTypes, ALL_SUPER_TYPES); + } + + @Test + void testFindAllDeclaredTypesWithExcludedTypesOnNull() { + assertEmptyList(findAllDeclaredTypes(NULL_ELEMENT, NULL_TYPE_ARRAY)); + assertEmptyList(findAllDeclaredTypes(NULL_ELEMENT, EMPTY_TYPE_ARRAY)); + assertEmptyList(findAllDeclaredTypes(NULL_ELEMENT, ALL_TYPES)); + assertEmptyList(findAllDeclaredTypes(NULL_TYPE_MIRROR, NULL_TYPE_ARRAY)); + assertEmptyList(findAllDeclaredTypes(NULL_TYPE_MIRROR, EMPTY_TYPE_ARRAY)); + assertEmptyList(findAllDeclaredTypes(NULL_TYPE_MIRROR, ALL_TYPES)); + } + + @Test + void testFindAllDeclaredTypesWithExcludedTypeNamesOnNull() { + assertEmptyList(findAllDeclaredTypes(NULL_ELEMENT, NULL_STRING_ARRAY)); + assertEmptyList(findAllDeclaredTypes(NULL_ELEMENT, EMPTY_STRING_ARRAY)); + assertEmptyList(findAllDeclaredTypes(NULL_TYPE_MIRROR, NULL_STRING_ARRAY)); + assertEmptyList(findAllDeclaredTypes(NULL_TYPE_MIRROR, EMPTY_STRING_ARRAY)); + } + + @Test + void testFindDeclaredTypes() { + // true true true true : all types + List declaredTypes = findDeclaredTypes(testTypeElement, true, true, true, true, alwaysTrue()); + assertDeclaredTypes(declaredTypes, ALL_TYPES); + assertEquals(getAllDeclaredTypes(testTypeElement), declaredTypes); + + // true true true false : self type + all super classes + declaredTypes = findDeclaredTypes(testTypeElement, true, true, true, false, alwaysTrue()); + assertDeclaredTypes(declaredTypes, SELF_TYPE_PLUS_ALL_SUPER_CLASSES); + + // true true false true : self type + all super interfaces + declaredTypes = findDeclaredTypes(testTypeElement, true, true, false, true, alwaysTrue()); + assertDeclaredTypes(declaredTypes, SELF_TYPE_PLUS_ALL_SUPER_INTERFACES); + + // true true false false : self type + declaredTypes = findDeclaredTypes(testTypeElement, true, true, false, false, alwaysTrue()); + assertDeclaredTypes(declaredTypes, SELF_TYPE); + + // true false true true : self type + super class + super interfaces + declaredTypes = findDeclaredTypes(testTypeElement, true, false, true, true, alwaysTrue()); + assertDeclaredTypes(declaredTypes, SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES); + + // true false true false : self type + super class + declaredTypes = findDeclaredTypes(testTypeElement, true, false, true, false, alwaysTrue()); + assertDeclaredTypes(declaredTypes, SELF_TYPE_PLUS_SUPER_CLASS); + + // true false false true : self type + super interfaces + declaredTypes = findDeclaredTypes(testTypeElement, true, false, false, true, alwaysTrue()); + assertDeclaredTypes(declaredTypes, SELF_TYPE_PLUS_SUPER_INTERFACES); + + // true false false false : self type + declaredTypes = findDeclaredTypes(testTypeElement, true, false, false, false, alwaysTrue()); + assertDeclaredTypes(declaredTypes, SELF_TYPE); + + // false true true true : all super types + declaredTypes = findDeclaredTypes(testTypeElement, false, true, true, true, alwaysTrue()); + assertDeclaredTypes(declaredTypes, ALL_SUPER_TYPES); + assertEquals(getAllDeclaredTypesOfSuperTypes(testTypeElement), declaredTypes); + + // false true true false : all super classes + declaredTypes = findDeclaredTypes(testTypeElement, false, true, true, false, alwaysTrue()); + assertDeclaredTypes(declaredTypes, ALL_SUPER_CLASSES); + assertEquals(getAllDeclaredTypesOfSuperclasses(testTypeElement), declaredTypes); + + // false true false true : all super interfaces + declaredTypes = findDeclaredTypes(testTypeElement, false, true, false, true, alwaysTrue()); + assertDeclaredTypes(declaredTypes, ALL_SUPER_INTERFACES); + assertEquals(getAllDeclaredTypesOfInterfaces(testTypeElement), declaredTypes); + + // false true false false : nothing + declaredTypes = findDeclaredTypes(testTypeElement, false, true, false, false, alwaysTrue()); + assertDeclaredTypes(declaredTypes); + assertEmptyList(declaredTypes); + + // false false true true : super class + super interfaces + declaredTypes = findDeclaredTypes(testTypeElement, false, false, true, true, alwaysTrue()); + assertDeclaredTypes(declaredTypes, SUPER_TYPES); + + // false false true false : super class + declaredTypes = findDeclaredTypes(testTypeElement, false, false, true, false, alwaysTrue()); + assertDeclaredTypes(declaredTypes, SUPER_CLASS); + assertEquals(ofList(getDeclaredTypeOfSuperclass(testTypeElement)), declaredTypes); + + // false false false true : super interfaces + declaredTypes = findDeclaredTypes(testTypeElement, false, false, false, true, alwaysTrue()); + assertDeclaredTypes(declaredTypes, SUPER_INTERFACES); + assertEquals(ofList(getDeclaredTypesOfInterfaces(testTypeElement)), declaredTypes); + + // false false false false : nothing + declaredTypes = findDeclaredTypes(testTypeElement, false, false, false, false, alwaysTrue()); + assertDeclaredTypes(declaredTypes); + assertEmptyList(declaredTypes); + } + + @Test + void testFindDeclaredTypesOnNull() { + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, true, true, true, true, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, true, true, true, true, alwaysFalse())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, true, true, true, true, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, true, true, true, true, alwaysFalse())); + + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, true, true, true, false, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, true, true, true, false, alwaysFalse())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, true, true, true, false, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, true, true, true, false, alwaysFalse())); + + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, true, true, false, true, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, true, true, false, true, alwaysFalse())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, true, true, false, true, alwaysFalse())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, true, true, false, true, alwaysFalse())); + + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, true, true, false, false, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, true, true, false, false, alwaysFalse())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, true, true, false, false, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, true, true, false, false, alwaysFalse())); + + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, true, false, true, true, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, true, false, true, true, alwaysFalse())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, true, false, true, true, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, true, false, true, true, alwaysFalse())); + + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, false, true, false, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, false, true, false, alwaysFalse())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, false, true, false, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, false, true, false, alwaysFalse())); + + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, false, false, true, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, false, false, true, alwaysFalse())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, false, false, true, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, false, false, true, alwaysFalse())); + + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, false, false, false, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, false, false, false, alwaysFalse())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, false, false, false, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, false, false, false, alwaysFalse())); + + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, true, true, true, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, true, true, true, alwaysFalse())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, true, true, true, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, true, true, true, alwaysFalse())); + + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, true, true, false, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, true, true, false, alwaysFalse())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, true, true, false, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, true, true, false, alwaysFalse())); + + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, true, false, true, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, true, false, true, alwaysFalse())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, true, false, true, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, true, false, true, alwaysFalse())); + + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, true, false, false, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, true, false, false, alwaysFalse())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, true, false, false, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, true, false, false, alwaysFalse())); + + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, false, true, true, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, false, true, true, alwaysFalse())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, false, true, true, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, false, true, true, alwaysFalse())); + + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, false, true, false, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, false, true, false, alwaysFalse())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, false, true, false, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, false, true, false, alwaysFalse())); + + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, false, false, true, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, false, false, true, alwaysFalse())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, false, false, true, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, false, false, true, alwaysFalse())); + + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, false, false, false, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_ELEMENT, false, false, false, false, alwaysFalse())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, false, false, false, alwaysTrue())); + assertEmptyList(findDeclaredTypes(NULL_TYPE_MIRROR, false, false, false, false, alwaysFalse())); + } + + @Test + void testGetTypeMirrorsOfInterfaces() { + List typeMirrors = getTypeMirrorsOfInterfaces(testTypeMirror); + assertTypeMirrors(typeMirrors, SUPER_INTERFACES); + + typeMirrors = getTypeMirrorsOfInterfaces(testTypeElement); + assertTypeMirrors(typeMirrors, SUPER_INTERFACES); + + typeMirrors = getTypeMirrorsOfInterfaces(getTypeElement(Object.class)); + assertEmptyList(typeMirrors); + + typeMirrors = getTypeMirrorsOfInterfaces(getTypeMirror(Object.class)); + assertSame(typeMirrors, typeMirrors); + } + + @Test + void testGetTypeMirrorsOfInterfacesOnNull() { + List typeMirrors = getTypeMirrorsOfInterfaces(NULL_TYPE_MIRROR); + assertEmptyList(typeMirrors); + + typeMirrors = getTypeMirrorsOfInterfaces(NULL_TYPE_ELEMENT); + assertEmptyList(typeMirrors); + } + + @Test + void testFindTypeMirrorsOfInterfaces() { + List typeMirrors = findTypeMirrorsOfInterfaces(testTypeMirror, alwaysTrue()); + assertTypeMirrors(typeMirrors, SUPER_INTERFACES); + + typeMirrors = findTypeMirrorsOfInterfaces(testTypeElement, alwaysTrue()); + assertTypeMirrors(typeMirrors, SUPER_INTERFACES); + + typeMirrors = findTypeMirrorsOfInterfaces(testTypeMirror, alwaysFalse()); + assertEmptyList(typeMirrors); + + typeMirrors = findTypeMirrorsOfInterfaces(testTypeElement, alwaysFalse()); + assertEmptyList(typeMirrors); + + typeMirrors = findTypeMirrorsOfInterfaces(getTypeElement(Object.class), alwaysTrue()); + assertEmptyList(typeMirrors); + + typeMirrors = findTypeMirrorsOfInterfaces(getTypeElement(Object.class), alwaysFalse()); + assertEmptyList(typeMirrors); + + typeMirrors = findTypeMirrorsOfInterfaces(getTypeMirror(Object.class), alwaysTrue()); + assertSame(typeMirrors, typeMirrors); + + typeMirrors = findTypeMirrorsOfInterfaces(getTypeMirror(Object.class), alwaysFalse()); + assertSame(typeMirrors, typeMirrors); + } + + @Test + void testFindTypeMirrorsOfInterfacesOnNull() { + List typeMirrors = findTypeMirrorsOfInterfaces(NULL_TYPE_MIRROR, alwaysTrue()); + assertEmptyList(typeMirrors); + + typeMirrors = findTypeMirrorsOfInterfaces(NULL_TYPE_ELEMENT, alwaysTrue()); + assertEmptyList(typeMirrors); + + typeMirrors = findTypeMirrorsOfInterfaces(NULL_TYPE_MIRROR, alwaysFalse()); + assertEmptyList(typeMirrors); + + typeMirrors = findTypeMirrorsOfInterfaces(NULL_TYPE_ELEMENT, alwaysFalse()); + assertEmptyList(typeMirrors); + } + + @Test + void testGetAllTypeMirrorsOfInterfaces() { + List typeMirrors = getAllTypeMirrorsOfInterfaces(testTypeMirror); + assertTypeMirrors(typeMirrors, ALL_SUPER_INTERFACES); + + typeMirrors = getAllTypeMirrorsOfInterfaces(testTypeElement); + assertTypeMirrors(typeMirrors, ALL_SUPER_INTERFACES); + + typeMirrors = getAllTypeMirrorsOfInterfaces(getTypeElement(Object.class)); + assertEmptyList(typeMirrors); + + typeMirrors = getAllTypeMirrorsOfInterfaces(getTypeMirror(Object.class)); + assertSame(typeMirrors, typeMirrors); + } + + @Test + void testGetAllTypeMirrorsOfInterfacesOnNull() { + List typeMirrors = getAllTypeMirrorsOfInterfaces(NULL_TYPE_MIRROR); + assertEmptyList(typeMirrors); + + typeMirrors = getAllTypeMirrorsOfInterfaces(NULL_TYPE_ELEMENT); + assertEmptyList(typeMirrors); + } + + @Test + void testFindAllTypeMirrorsOfInterfaces() { + List typeMirrors = findAllTypeMirrorsOfInterfaces(testTypeMirror, alwaysTrue()); + assertTypeMirrors(typeMirrors, ALL_SUPER_INTERFACES); + + typeMirrors = findAllTypeMirrorsOfInterfaces(testTypeElement, alwaysTrue()); + assertTypeMirrors(typeMirrors, ALL_SUPER_INTERFACES); + + typeMirrors = findAllTypeMirrorsOfInterfaces(testTypeMirror, alwaysFalse()); + assertEmptyList(typeMirrors); + + typeMirrors = findAllTypeMirrorsOfInterfaces(testTypeElement, alwaysFalse()); + assertEmptyList(typeMirrors); + + typeMirrors = findAllTypeMirrorsOfInterfaces(getTypeElement(Object.class), alwaysTrue()); + assertEmptyList(typeMirrors); + + typeMirrors = findAllTypeMirrorsOfInterfaces(getTypeElement(Object.class), alwaysFalse()); + assertEmptyList(typeMirrors); + + typeMirrors = findAllTypeMirrorsOfInterfaces(getTypeMirror(Object.class), alwaysTrue()); + assertSame(typeMirrors, typeMirrors); + + typeMirrors = findAllTypeMirrorsOfInterfaces(getTypeMirror(Object.class), alwaysFalse()); + assertSame(typeMirrors, typeMirrors); + } + + @Test + void testFindAllTypeMirrorsOfInterfacesOnNull() { + List typeMirrors = findAllTypeMirrorsOfInterfaces(NULL_TYPE_MIRROR, alwaysTrue()); + assertEmptyList(typeMirrors); + + typeMirrors = findAllTypeMirrorsOfInterfaces(NULL_TYPE_MIRROR, alwaysFalse()); + assertEmptyList(typeMirrors); + + typeMirrors = findAllTypeMirrorsOfInterfaces(NULL_TYPE_ELEMENT, alwaysTrue()); + assertEmptyList(typeMirrors); + + typeMirrors = findAllTypeMirrorsOfInterfaces(NULL_TYPE_MIRROR, alwaysFalse()); + assertEmptyList(typeMirrors); + } + + @Test + void testFindInterfaceTypeMirror() { + for (Type interfaceType : ALL_SUPER_INTERFACES) { + assertInterfaceTypeMirror(testTypeElement, interfaceType); + } + + for (Type superClass : ALL_SUPER_CLASSES) { + assertNull(findInterfaceTypeMirror(testTypeElement, superClass)); + assertNull(findInterfaceTypeMirror(testTypeMirror, superClass)); + } + } + + @Test + void testFindInterfaceTypeMirrorOnNull() { + for (Type type : ALL_TYPES) { + assertNull(findInterfaceTypeMirror(NULL_ELEMENT, type)); + assertNull(findInterfaceTypeMirror(NULL_TYPE_MIRROR, type)); + } + } + + @Test + void testGetTypeMirrors() { + assertGetTypeMirrors(NULL_TYPE); + assertGetTypeMirrors(SELF_TYPE); + assertGetTypeMirrors(SUPER_CLASS); + assertGetTypeMirrors(ALL_TYPES); + assertGetTypeMirrors(ALL_SUPER_TYPES); + assertGetTypeMirrors(ALL_SUPER_CLASSES); + assertGetTypeMirrors(ALL_SUPER_INTERFACES); + assertGetTypeMirrors(SUPER_INTERFACES); + assertGetTypeMirrors(SUPER_TYPES); + + assertGetTypeMirrors(SELF_TYPE_PLUS_ALL_SUPER_TYPES); + assertGetTypeMirrors(SELF_TYPE_PLUS_ALL_SUPER_CLASSES); + assertGetTypeMirrors(SELF_TYPE_PLUS_ALL_SUPER_INTERFACES); + assertGetTypeMirrors(SELF_TYPE_PLUS_SUPER_CLASS); + assertGetTypeMirrors(SELF_TYPE_PLUS_SUPER_INTERFACES); + assertGetTypeMirrors(SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES); + } + + @Test + void testGetTypeMirrorsOnNull() { + assertGetTypeMirrors(NULL_TYPE); + assertGetTypeMirrors(NULL_TYPE_ARRAY); + assertGetTypeMirrors(EMPTY_TYPE_ARRAY); + + TypeUtils.getTypeMirrors(NULL_PROCESSING_ENVIRONMENT, SELF_TYPE); + TypeUtils.getTypeMirrors(NULL_PROCESSING_ENVIRONMENT, SUPER_CLASS); + TypeUtils.getTypeMirrors(NULL_PROCESSING_ENVIRONMENT, ALL_TYPES); + TypeUtils.getTypeMirrors(NULL_PROCESSING_ENVIRONMENT, ALL_SUPER_TYPES); + TypeUtils.getTypeMirrors(NULL_PROCESSING_ENVIRONMENT, ALL_SUPER_CLASSES); + TypeUtils.getTypeMirrors(NULL_PROCESSING_ENVIRONMENT, ALL_SUPER_INTERFACES); + TypeUtils.getTypeMirrors(NULL_PROCESSING_ENVIRONMENT, SUPER_INTERFACES); + TypeUtils.getTypeMirrors(NULL_PROCESSING_ENVIRONMENT, SUPER_TYPES); + + TypeUtils.getTypeMirrors(NULL_PROCESSING_ENVIRONMENT, SELF_TYPE_PLUS_ALL_SUPER_TYPES); + TypeUtils.getTypeMirrors(NULL_PROCESSING_ENVIRONMENT, SELF_TYPE_PLUS_ALL_SUPER_CLASSES); + TypeUtils.getTypeMirrors(NULL_PROCESSING_ENVIRONMENT, SELF_TYPE_PLUS_ALL_SUPER_INTERFACES); + TypeUtils.getTypeMirrors(NULL_PROCESSING_ENVIRONMENT, SELF_TYPE_PLUS_SUPER_CLASS); + TypeUtils.getTypeMirrors(NULL_PROCESSING_ENVIRONMENT, SELF_TYPE_PLUS_SUPER_INTERFACES); + TypeUtils.getTypeMirrors(NULL_PROCESSING_ENVIRONMENT, SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES); + } + + @Test + void testGetTypeMirror() { + assertGetTypeMirror(NULL_TYPE); + assertGetTypeMirror(SELF_TYPE); + assertGetTypeMirror(SUPER_CLASS); + assertGetTypeMirror(ALL_TYPES); + assertGetTypeMirror(ALL_SUPER_TYPES); + assertGetTypeMirror(ALL_SUPER_CLASSES); + assertGetTypeMirror(ALL_SUPER_INTERFACES); + assertGetTypeMirror(SUPER_INTERFACES); + assertGetTypeMirror(SUPER_TYPES); + + assertGetTypeMirror(SELF_TYPE_PLUS_ALL_SUPER_TYPES); + assertGetTypeMirror(SELF_TYPE_PLUS_ALL_SUPER_CLASSES); + assertGetTypeMirror(SELF_TYPE_PLUS_ALL_SUPER_INTERFACES); + assertGetTypeMirror(SELF_TYPE_PLUS_SUPER_CLASS); + assertGetTypeMirror(SELF_TYPE_PLUS_SUPER_INTERFACES); + assertGetTypeMirror(SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES); + } + + @Test + void testGetTypeMirrorOnNull() { + assertNull(TypeUtils.getTypeMirror(this.processingEnv, NULL_TYPE)); + assertNull(getTypeMirror(NULL_TYPE)); + + assertGetTypeMirrorOnNullProcessingEnvironment(SELF_TYPE); + assertGetTypeMirrorOnNullProcessingEnvironment(SUPER_CLASS); + assertGetTypeMirrorOnNullProcessingEnvironment(ALL_TYPES); + assertGetTypeMirrorOnNullProcessingEnvironment(ALL_SUPER_TYPES); + assertGetTypeMirrorOnNullProcessingEnvironment(ALL_SUPER_CLASSES); + assertGetTypeMirrorOnNullProcessingEnvironment(ALL_SUPER_INTERFACES); + assertGetTypeMirrorOnNullProcessingEnvironment(SUPER_INTERFACES); + assertGetTypeMirrorOnNullProcessingEnvironment(SUPER_TYPES); + + assertGetTypeMirrorOnNullProcessingEnvironment(SELF_TYPE_PLUS_ALL_SUPER_TYPES); + assertGetTypeMirrorOnNullProcessingEnvironment(SELF_TYPE_PLUS_ALL_SUPER_CLASSES); + assertGetTypeMirrorOnNullProcessingEnvironment(SELF_TYPE_PLUS_ALL_SUPER_INTERFACES); + assertGetTypeMirrorOnNullProcessingEnvironment(SELF_TYPE_PLUS_SUPER_CLASS); + assertGetTypeMirrorOnNullProcessingEnvironment(SELF_TYPE_PLUS_SUPER_INTERFACES); + assertGetTypeMirrorOnNullProcessingEnvironment(SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES); + } + + @Test + void testGetTypeElementsWithProcessingEnvironment() { + assertGetTypeElementsWithProcessingEnvironment(SELF_TYPE); + assertGetTypeElementsWithProcessingEnvironment(SUPER_CLASS); + assertGetTypeElementsWithProcessingEnvironment(ALL_TYPES); + assertGetTypeElementsWithProcessingEnvironment(ALL_SUPER_TYPES); + assertGetTypeElementsWithProcessingEnvironment(ALL_SUPER_CLASSES); + assertGetTypeElementsWithProcessingEnvironment(ALL_SUPER_INTERFACES); + assertGetTypeElementsWithProcessingEnvironment(SUPER_INTERFACES); + assertGetTypeElementsWithProcessingEnvironment(SUPER_TYPES); + + assertGetTypeElementsWithProcessingEnvironment(SELF_TYPE_PLUS_ALL_SUPER_TYPES); + assertGetTypeElementsWithProcessingEnvironment(SELF_TYPE_PLUS_ALL_SUPER_CLASSES); + assertGetTypeElementsWithProcessingEnvironment(SELF_TYPE_PLUS_ALL_SUPER_INTERFACES); + assertGetTypeElementsWithProcessingEnvironment(SELF_TYPE_PLUS_SUPER_CLASS); + assertGetTypeElementsWithProcessingEnvironment(SELF_TYPE_PLUS_SUPER_INTERFACES); + assertGetTypeElementsWithProcessingEnvironment(SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES); + } + + @Test + void testGetTypeElementsWithProcessingEnvironmentOnNull() { + assertEmptyList(TypeUtils.getTypeElements(this.processingEnv, NULL_TYPE)); + assertEmptyList(TypeUtils.getTypeElements(this.processingEnv, NULL_TYPE_ARRAY)); + assertEmptyList(TypeUtils.getTypeElements(this.processingEnv, EMPTY_TYPE_ARRAY)); + + assertGetTypeElementsOnNullProcessingEnvironment(SELF_TYPE); + assertGetTypeElementsOnNullProcessingEnvironment(SUPER_CLASS); + assertGetTypeElementsOnNullProcessingEnvironment(ALL_TYPES); + assertGetTypeElementsOnNullProcessingEnvironment(ALL_SUPER_TYPES); + assertGetTypeElementsOnNullProcessingEnvironment(ALL_SUPER_CLASSES); + assertGetTypeElementsOnNullProcessingEnvironment(ALL_SUPER_INTERFACES); + assertGetTypeElementsOnNullProcessingEnvironment(SUPER_INTERFACES); + assertGetTypeElementsOnNullProcessingEnvironment(SUPER_TYPES); + + assertGetTypeElementsOnNullProcessingEnvironment(SELF_TYPE_PLUS_ALL_SUPER_TYPES); + assertGetTypeElementsOnNullProcessingEnvironment(SELF_TYPE_PLUS_ALL_SUPER_CLASSES); + assertGetTypeElementsOnNullProcessingEnvironment(SELF_TYPE_PLUS_ALL_SUPER_INTERFACES); + assertGetTypeElementsOnNullProcessingEnvironment(SELF_TYPE_PLUS_SUPER_CLASS); + assertGetTypeElementsOnNullProcessingEnvironment(SELF_TYPE_PLUS_SUPER_INTERFACES); + assertGetTypeElementsOnNullProcessingEnvironment(SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES); + } + + @Test + void testGetTypeElement() { + assertEquals(testTypeElement, TypeUtils.getTypeElement(processingEnv, testClassName)); + } + + @Test + void testGetTypeElementOnTypeMirror() { + assertEquals(testTypeElement, TypeUtils.getTypeElement(processingEnv, testTypeMirror)); + } + + @Test + void testGetTypeElementOnType() { + assertEquals(testTypeElement, TypeUtils.getTypeElement(processingEnv, SELF_TYPE)); + } + + @Test + void testGetTypeElementOnNull() { + assertNull(TypeUtils.getTypeElement(processingEnv, NULL_TYPE)); + assertNull(TypeUtils.getTypeElement(processingEnv, NULL_TYPE_MIRROR)); + assertNull(TypeUtils.getTypeElement(processingEnv, NULL_STRING)); + assertNull(TypeUtils.getTypeElement(NULL_PROCESSING_ENVIRONMENT, NULL_STRING)); + } + + @Test + void testGetDeclaredType() { + assertGetDeclaredType(NULL_TYPE); + assertGetDeclaredType(SELF_TYPE); + assertGetDeclaredType(SUPER_CLASS); + assertGetDeclaredType(ALL_TYPES); + assertGetDeclaredType(ALL_SUPER_TYPES); + assertGetDeclaredType(ALL_SUPER_CLASSES); + assertGetDeclaredType(ALL_SUPER_INTERFACES); + assertGetDeclaredType(SUPER_INTERFACES); + assertGetDeclaredType(SUPER_TYPES); + + assertGetDeclaredType(SELF_TYPE_PLUS_ALL_SUPER_TYPES); + assertGetDeclaredType(SELF_TYPE_PLUS_ALL_SUPER_CLASSES); + assertGetDeclaredType(SELF_TYPE_PLUS_ALL_SUPER_INTERFACES); + assertGetDeclaredType(SELF_TYPE_PLUS_SUPER_CLASS); + assertGetDeclaredType(SELF_TYPE_PLUS_SUPER_INTERFACES); + assertGetDeclaredType(SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES); + } + + @Test + void testGetDeclaredTypeOnNull() { + assertNull(TypeUtils.getDeclaredType(this.processingEnv, NULL_TYPE)); + assertNull(TypeUtils.getDeclaredType(this.processingEnv, NULL_TYPE_MIRROR)); + assertNull(TypeUtils.getDeclaredType(this.processingEnv, NULL_STRING)); + + assertNull(getDeclaredType(NULL_TYPE)); + + assertGetDeclaredTypeOnNullProcessingEnvironment(SELF_TYPE); + assertGetDeclaredTypeOnNullProcessingEnvironment(SUPER_CLASS); + assertGetDeclaredTypeOnNullProcessingEnvironment(ALL_TYPES); + assertGetDeclaredTypeOnNullProcessingEnvironment(ALL_SUPER_TYPES); + assertGetDeclaredTypeOnNullProcessingEnvironment(ALL_SUPER_CLASSES); + assertGetDeclaredTypeOnNullProcessingEnvironment(ALL_SUPER_INTERFACES); + assertGetDeclaredTypeOnNullProcessingEnvironment(SUPER_INTERFACES); + assertGetDeclaredTypeOnNullProcessingEnvironment(SUPER_TYPES); + + assertGetDeclaredTypeOnNullProcessingEnvironment(SELF_TYPE_PLUS_ALL_SUPER_TYPES); + assertGetDeclaredTypeOnNullProcessingEnvironment(SELF_TYPE_PLUS_ALL_SUPER_CLASSES); + assertGetDeclaredTypeOnNullProcessingEnvironment(SELF_TYPE_PLUS_ALL_SUPER_INTERFACES); + assertGetDeclaredTypeOnNullProcessingEnvironment(SELF_TYPE_PLUS_SUPER_CLASS); + assertGetDeclaredTypeOnNullProcessingEnvironment(SELF_TYPE_PLUS_SUPER_INTERFACES); + assertGetDeclaredTypeOnNullProcessingEnvironment(SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES); + } + + @Test + void testToStringOnClasses() { + assertToStringOnClasses(); + } + + @Test + void testToStringOnArrayTypes() { + assertToStringOnArrayTypes(); + } + + @Test + void testToStringOnCollectionTypes() { + assertToStringOnCollectionTypes(); + } + + @Test + void testToStringMapTypes() { + assertToStringOnMapTypes(); + } + + @Test + void testToStringOnNull() { + assertNull(TypeUtils.toString(NULL_TYPE_MIRROR)); + } + + @Test + void testTypeElementFinderOnNull() { + assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, true, true, true, true)); + + assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, true, true, true, false)); + + assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, true, true, false, true)); + + assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, true, true, false, false)); + + assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, true, false, true, true)); + + assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, false, false, true, false)); + + assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, false, false, false, true)); + + assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, false, false, false, false)); + + assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, false, true, true, true)); + + assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, false, true, true, false)); + + assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, false, true, false, true)); + + assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, false, true, false, false)); + + assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, false, false, true, true)); + + assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, false, false, true, false)); + + assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, false, false, false, true)); + + assertThrows(IllegalArgumentException.class, () -> typeElementFinder(NULL_TYPE_ELEMENT, false, false, false, false)); + } + + private void assertIsSameType(Element typeElement, Type type) { + assertTrue(isSameType(typeElement, type)); + assertTrue(isSameType(typeElement, type.getTypeName())); + assertTrue(isSameType(typeElement.asType(), type)); + assertTrue(isSameType(typeElement.asType(), type.getTypeName())); + } + + private void assertOfTypeMirrors(Class... types) { + Element[] elements = getElements(types); + assertEquals(getTypeMirrors(types), ofTypeMirrors(elements)); + } + + private void assertOfTypeElements(Class... types) { + List typesList = getTypeMirrors(types); + List typeElements = ofTypeElements(typesList); + for (TypeMirror typeMirror : typesList) { + assertTrue(typeElements.contains(ofTypeElement(typeMirror))); + } + } + + private void assertOfDeclaredTypes(Class... types) { + Element[] elements = getElements(types); + List declaredTypes = ofDeclaredTypes(elements); + assertDeclaredTypes(declaredTypes, types); + } + + private void assertIsArrayType(Type type) { + assertTrue(isArrayType(getFieldType(type, "integers"))); + assertTrue(isArrayType(getFieldType(type, "strings"))); + assertTrue(isArrayType(getFieldType(type, "primitiveTypeModels"))); + assertTrue(isArrayType(getFieldType(type, "models"))); + assertTrue(isArrayType(getFieldType(type, "colors"))); + } + + private void assertIsArrayType(Element element) { + assertTrue(isArrayType(findField(element, "integers"))); + assertTrue(isArrayType(findField(element, "strings"))); + assertTrue(isArrayType(findField(element, "primitiveTypeModels"))); + assertTrue(isArrayType(findField(element, "models"))); + assertTrue(isArrayType(findField(element, "colors"))); + } + + private void assertTypeMirrors(List typeMirrors, Type... types) { + int length = length(types); + for (int i = 0; i < length; i++) { + if (types[i] == null) { + length--; + } + } + assertEquals(length, typeMirrors.size()); + for (int i = 0; i < length; i++) { + assertSame(typeMirrors.get(i), getTypeMirror(types[i])); + } + } + + private void assertTypeElements(List typeElements, Type... types) { + int length = length(types); + for (int i = 0; i < length; i++) { + if (types[i] == null) { + length--; + } + } + assertEquals(length, typeElements.size()); + for (int i = 0; i < length; i++) { + assertSame(typeElements.get(i), getTypeElement(types[i])); + } + } + + private void assertDeclaredTypes(List declaredTypes, Type... types) { + int length = length(types); + for (int i = 0; i < length; i++) { + if (types[i] == null) { + length--; + } + } + assertEquals(length, declaredTypes.size()); + for (int i = 0; i < length; i++) { + assertSame(declaredTypes.get(i), getDeclaredType(types[i])); + } + } + + private void assertInterfaceTypeMirror(Element type, Type interfaceType) { + TypeMirror typeMirror = findInterfaceTypeMirror(type, interfaceType); + assertTrue(isSameType(typeMirror, interfaceType)); + + typeMirror = findInterfaceTypeMirror(type.asType(), interfaceType); + assertTrue(isSameType(typeMirror, interfaceType)); + } + + private void assertGetTypeMirrors(Type... types) { + List typeMirrors = TypeUtils.getTypeMirrors(processingEnv, types); + assertEquals(typeMirrors, getTypeMirrors(types)); + assertTypeMirrors(typeMirrors, types); + } + + private void assertGetTypeMirror(Type... types) { + int length = length(types); + for (int i = 0; i < length; i++) { + Type type = types[i]; + TypeMirror typeMirror = TypeUtils.getTypeMirror(processingEnv, type); + assertSame(getTypeMirror(type), typeMirror); + assertTrue(isSameType(typeMirror, type)); + } + } + + private void assertGetTypeMirrorOnNullProcessingEnvironment(Type... types) { + int length = length(types); + for (int i = 0; i < length; i++) { + Type type = types[i]; + TypeMirror typeMirror = TypeUtils.getTypeMirror(NULL_PROCESSING_ENVIRONMENT, type); + assertNull(typeMirror); + } + } + + private void assertGetTypeElementsWithProcessingEnvironment(Type... types) { + List typeElements = TypeUtils.getTypeElements(this.processingEnv, types); + assertEquals(getTypeElements(types), typeElements); + assertTypeElements(typeElements, types); + } + + private void assertGetTypeElementsOnNullProcessingEnvironment(Type... types) { + List typeElements = TypeUtils.getTypeElements(NULL_PROCESSING_ENVIRONMENT, types); + assertEmptyList(typeElements); + } + + private void assertGetDeclaredType(Type... types) { + int length = length(types); + for (int i = 0; i < length; i++) { + Type type = types[i]; + DeclaredType declaredType = TypeUtils.getDeclaredType(processingEnv, type); + assertSame(getDeclaredType(type), declaredType); + assertSame(getDeclaredType(type), TypeUtils.getDeclaredType(processingEnv, declaredType)); + assertTrue(isSameType(declaredType, type)); + } + } + + private void assertGetDeclaredTypeOnNullProcessingEnvironment(Type... types) { + int length = length(types); + for (int i = 0; i < length; i++) { + Type type = types[i]; + TypeMirror typeMirror = TypeUtils.getDeclaredType(NULL_PROCESSING_ENVIRONMENT, type); + assertNull(typeMirror); + } + } + + private void assertToStringOnMapTypes() { + assertToString(getFieldType(MapTypeModel.class, "strings")); + assertToString(getFieldType(MapTypeModel.class, "colors")); + assertToString(getFieldType(MapTypeModel.class, "primitiveTypeModels")); + assertToString(getFieldType(MapTypeModel.class, "models")); + assertToString(getFieldType(MapTypeModel.class, "modelArrays")); + } + + private void assertToStringOnCollectionTypes() { + assertToString(getFieldType(CollectionTypeModel.class, "strings")); + assertToString(getFieldType(CollectionTypeModel.class, "colors")); + assertToString(getFieldType(CollectionTypeModel.class, "primitiveTypeModels")); + assertToString(getFieldType(CollectionTypeModel.class, "models")); + assertToString(getFieldType(CollectionTypeModel.class, "modelArrays")); + } + + private void assertToStringOnArrayTypes() { + assertToString(getFieldType(ArrayTypeModel.class, "integers")); + assertToString(getFieldType(ArrayTypeModel.class, "strings")); + assertToString(getFieldType(ArrayTypeModel.class, "primitiveTypeModels")); + assertToString(getFieldType(ArrayTypeModel.class, "models")); + assertToString(getFieldType(ArrayTypeModel.class, "colors")); + } + + private TypeMirror getFieldType(Type type, String fieldName) { + TypeMirror typeMirror = getTypeMirror(type); + return findField(typeMirror, fieldName).asType(); + } + + private TypeMirror getFieldType(Element element, String fieldName) { + return findField(element, fieldName).asType(); + } + + private void assertToStringOnClasses() { + assertToString(NULL_TYPE); + assertToString(SELF_TYPE); + assertToString(SUPER_CLASS); + assertToString(ALL_TYPES); + assertToString(ALL_SUPER_TYPES); + assertToString(ALL_SUPER_CLASSES); + assertToString(ALL_SUPER_INTERFACES); + assertToString(SUPER_INTERFACES); + assertToString(SUPER_TYPES); + + assertToString(SELF_TYPE_PLUS_ALL_SUPER_TYPES); + assertToString(SELF_TYPE_PLUS_ALL_SUPER_CLASSES); + assertToString(SELF_TYPE_PLUS_ALL_SUPER_INTERFACES); + assertToString(SELF_TYPE_PLUS_SUPER_CLASS); + assertToString(SELF_TYPE_PLUS_SUPER_INTERFACES); + assertToString(SELF_TYPE_PLUS_SUPER_CLASS_PLUS_SUPER_INTERFACES); + } + + private void assertToString(Type... types) { + int length = length(types); + for (int i = 0; i < length; i++) { + if (types[i] == null) { + length--; + } + } + for (int i = 0; i < length; i++) { + TypeMirror typeMirror = getTypeMirror(types[i]); + assertEquals(types[i].getTypeName(), TypeUtils.toString(typeMirror)); + } + } + + private void assertToString(TypeMirror type) { + assertEquals(type.toString(), TypeUtils.toString(type)); + } +} \ No newline at end of file diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/UtilTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/UtilTest.java new file mode 100644 index 000000000..9cad309cf --- /dev/null +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/UtilTest.java @@ -0,0 +1,88 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.lang.model.util; + +import io.microsphere.test.annotation.processing.AbstractAnnotationProcessingTest; + +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.TypeElement; +import javax.lang.model.element.VariableElement; +import javax.lang.model.type.DeclaredType; +import javax.lang.model.type.TypeMirror; +import java.lang.reflect.Type; +import java.util.List; + +import static io.microsphere.lang.model.util.ConstructorUtils.findConstructor; +import static io.microsphere.lang.model.util.FieldUtils.findField; +import static io.microsphere.lang.model.util.MethodUtils.findMethod; +import static java.util.Collections.emptyList; +import static org.junit.jupiter.api.Assertions.assertSame; + +/** + * The utilies class for testing + * + * @author Mercy + * @see AbstractAnnotationProcessingTest + * @since 1.0.0 + */ +public abstract class UtilTest extends AbstractAnnotationProcessingTest { + + protected List getTypeMirrors(Type... types) { + return TypeUtils.getTypeMirrors(processingEnv, types); + } + + protected TypeMirror getTypeMirror(Type type) { + return TypeUtils.getTypeMirror(processingEnv, type); + } + + protected List getTypeElements(Type... types) { + return TypeUtils.getTypeElements(processingEnv, types); + } + + protected TypeElement getTypeElement(Type type) { + return TypeUtils.getTypeElement(processingEnv, type); + } + + protected VariableElement getField(Type type, String fieldName) { + TypeElement typeElement = getTypeElement(type); + return findField(typeElement, fieldName); + } + + protected ExecutableElement getMethod(Type type, String methodName, Type... parameterTypes) { + TypeElement typeElement = getTypeElement(type); + return findMethod(typeElement, methodName, parameterTypes); + } + + protected ExecutableElement getConstructor(Type type, Type... parameterTypes) { + TypeElement typeElement = getTypeElement(type); + return findConstructor(typeElement, parameterTypes); + } + + protected Element[] getElements(Type... types) { + return getTypeMirrors(types).stream().map(TypeUtils::ofTypeElement).toArray(Element[]::new); + } + + protected DeclaredType getDeclaredType(Type type) { + return TypeUtils.getDeclaredType(processingEnv, type); + } + + protected void assertEmptyList(List list) { + assertSame(emptyList(), list); + } +} From 94feebdde850e30ba42a4cde9f176fea1b8eb1ff Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 19:04:40 +0800 Subject: [PATCH 13/79] Use lang-model utilities; update deps Replace references to io.microsphere.annotation.processor.util.* with the new io.microsphere.lang.model.util.* equivalents across the annotation processor (MessagerUtils, AnnotationUtils, ElementUtils, TypeUtils, ClassUtils, JSONElementVisitor). Update Javadoc and fully-qualified references where needed. Simplify ConfigurationPropertyAnnotationProcessorTest by using AbstractAnnotationProcessingTest and removing an unused lifecycle override. Update pom dependency management and dependencies to add microsphere-java-core and microsphere-lang-model, replace microsphere-java-core dependency usage with microsphere-jdk-tools, and add microsphere-java-test to reflect module relocations. --- ...figurationPropertyAnnotationProcessor.java | 2 +- .../annotation/processor/FilerProcessor.java | 2 +- .../processor/ResourceProcessor.java | 4 ++-- .../AnnotatedElementJSONElementVisitor.java | 11 +++++----- ...nfigurationPropertyJSONElementVisitor.java | 16 +++++++-------- ...rationPropertyAnnotationProcessorTest.java | 9 ++------- microsphere-java-dependencies/pom.xml | 20 ++++++++++++++++++- 7 files changed, 39 insertions(+), 25 deletions(-) diff --git a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/ConfigurationPropertyAnnotationProcessor.java b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/ConfigurationPropertyAnnotationProcessor.java index 547c702a2..6060855d6 100644 --- a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/ConfigurationPropertyAnnotationProcessor.java +++ b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/ConfigurationPropertyAnnotationProcessor.java @@ -36,11 +36,11 @@ import java.util.Set; import static io.microsphere.annotation.processor.model.util.ConfigurationPropertyJSONElementVisitor.CONFIGURATION_PROPERTY_ANNOTATION_CLASS_NAME; -import static io.microsphere.annotation.processor.util.MessagerUtils.printNote; import static io.microsphere.constants.ResourceConstants.CONFIGURATION_PROPERTY_METADATA_RESOURCE; import static io.microsphere.constants.SymbolConstants.COMMA_CHAR; import static io.microsphere.constants.SymbolConstants.LEFT_SQUARE_BRACKET_CHAR; import static io.microsphere.constants.SymbolConstants.RIGHT_SQUARE_BRACKET_CHAR; +import static io.microsphere.lang.model.util.MessagerUtils.printNote; import static io.microsphere.metadata.ConfigurationPropertyLoader.loadAll; import static javax.lang.model.SourceVersion.latestSupported; import static javax.tools.StandardLocation.CLASS_OUTPUT; diff --git a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/FilerProcessor.java b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/FilerProcessor.java index 36d1416b4..5a34c0fa5 100644 --- a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/FilerProcessor.java +++ b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/FilerProcessor.java @@ -24,7 +24,7 @@ import javax.tools.JavaFileManager; import java.util.function.BiFunction; -import static io.microsphere.annotation.processor.util.MessagerUtils.printMandatoryWarning; +import static io.microsphere.lang.model.util.MessagerUtils.printMandatoryWarning; import static io.microsphere.reflect.FieldUtils.getFieldValue; /** diff --git a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/ResourceProcessor.java b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/ResourceProcessor.java index ab7b0c883..71852e810 100644 --- a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/ResourceProcessor.java +++ b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/ResourceProcessor.java @@ -34,8 +34,8 @@ import java.util.function.BiFunction; import java.util.function.Function; -import static io.microsphere.annotation.processor.util.MessagerUtils.printNote; -import static io.microsphere.annotation.processor.util.MessagerUtils.printWarning; +import static io.microsphere.lang.model.util.MessagerUtils.printNote; +import static io.microsphere.lang.model.util.MessagerUtils.printWarning; import static io.microsphere.util.ExceptionUtils.wrap; import static java.util.Optional.empty; import static java.util.Optional.of; diff --git a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/AnnotatedElementJSONElementVisitor.java b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/AnnotatedElementJSONElementVisitor.java index b5c76b0b1..cbb1d6418 100644 --- a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/AnnotatedElementJSONElementVisitor.java +++ b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/AnnotatedElementJSONElementVisitor.java @@ -18,6 +18,7 @@ package io.microsphere.annotation.processor.model.util; import io.microsphere.annotation.Nonnull; +import io.microsphere.lang.model.util.JSONElementVisitor; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; @@ -29,16 +30,16 @@ import java.lang.annotation.ElementType; import java.lang.reflect.AnnotatedElement; -import static io.microsphere.annotation.processor.util.AnnotationUtils.getElementTypes; -import static io.microsphere.annotation.processor.util.ElementUtils.matchesElementType; -import static io.microsphere.annotation.processor.util.TypeUtils.getDeclaredType; +import static io.microsphere.lang.model.util.AnnotationUtils.getElementTypes; +import static io.microsphere.lang.model.util.ElementUtils.matchesElementType; +import static io.microsphere.lang.model.util.TypeUtils.getDeclaredType; import static io.microsphere.util.Assert.assertNotNull; /** * An abstract implementation of {@link ElementVisitor} that generates JSON content for elements * annotated with a specific annotation. * - *

This class extends {@link JSONElementVisitor}, providing functionality to filter and process + *

This class extends {@link io.microsphere.lang.model.util.JSONElementVisitor}, providing functionality to filter and process * only those elements that are annotated with the specified annotation. It leverages the annotation * processing environment to gather information about the annotated elements and constructs JSON * representations accordingly.

@@ -79,7 +80,7 @@ * type elements annotated with a custom annotation and generates JSON output for them.

* * @author Mercy - * @see JSONElementVisitor + * @see io.microsphere.lang.model.util.JSONElementVisitor * @see AnnotatedElement * @see Annotation * @see ElementType diff --git a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/ConfigurationPropertyJSONElementVisitor.java b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/ConfigurationPropertyJSONElementVisitor.java index 963392408..278575b9f 100644 --- a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/ConfigurationPropertyJSONElementVisitor.java +++ b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/ConfigurationPropertyJSONElementVisitor.java @@ -31,22 +31,22 @@ import java.util.List; import java.util.Map; -import static io.microsphere.annotation.processor.util.AnnotationUtils.getAnnotation; -import static io.microsphere.annotation.processor.util.AnnotationUtils.getAttributeName; -import static io.microsphere.annotation.processor.util.AnnotationUtils.getElementValues; -import static io.microsphere.annotation.processor.util.AnnotationUtils.matchesDefaultAttributeValue; -import static io.microsphere.annotation.processor.util.ClassUtils.getClassName; -import static io.microsphere.annotation.processor.util.TypeUtils.getTypeName; +import static io.microsphere.lang.model.util.AnnotationUtils.getAnnotation; +import static io.microsphere.lang.model.util.AnnotationUtils.getAttributeName; +import static io.microsphere.lang.model.util.AnnotationUtils.getElementValues; +import static io.microsphere.lang.model.util.AnnotationUtils.matchesDefaultAttributeValue; +import static io.microsphere.lang.model.util.ClassUtils.getClassName; +import static io.microsphere.lang.model.util.TypeUtils.getTypeName; import static io.microsphere.constants.SymbolConstants.COMMA_CHAR; import static io.microsphere.util.ServiceLoaderUtils.loadFirstService; import static io.microsphere.util.StringUtils.isBlank; /** - * {@link ConfigurationProperty @ConfigurationProperty}'s {@link AnnotatedElementJSONElementVisitor} based on + * {@link ConfigurationProperty @ConfigurationProperty}'s {@link io.microsphere.lang.model.util.AnnotatedElementJSONElementVisitor} based on * {@link ConfigurationPropertyGenerator} generating the JSON representation of the configuration property metadata. * * @author Mercy - * @see AnnotatedElementJSONElementVisitor + * @see io.microsphere.lang.model.util.AnnotatedElementJSONElementVisitor * @see ConfigurationProperty * @see io.microsphere.beans.ConfigurationProperty * @since 1.0.0 diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/ConfigurationPropertyAnnotationProcessorTest.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/ConfigurationPropertyAnnotationProcessorTest.java index 82693aa0f..2fd190bc9 100644 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/ConfigurationPropertyAnnotationProcessorTest.java +++ b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/ConfigurationPropertyAnnotationProcessorTest.java @@ -23,6 +23,7 @@ import io.microsphere.io.StandardFileWatchService; import io.microsphere.reflect.MethodUtils; import io.microsphere.reflect.TypeUtils; +import io.microsphere.test.annotation.processing.AbstractAnnotationProcessingTest; import io.microsphere.util.ServiceLoaderUtils; import org.junit.jupiter.api.Test; @@ -39,12 +40,6 @@ * @since 1.0.0 */ class ConfigurationPropertyAnnotationProcessorTest extends AbstractAnnotationProcessingTest { - - @Override - protected void beforeTest() { - super.beforeTest(); - } - @Override protected void addCompiledClasses(Set> compiledClasses) { compiledClasses.add(ManifestArtifactResourceResolver.class); @@ -60,4 +55,4 @@ protected void addCompiledClasses(Set> compiledClasses) { void testConstants() { assertEquals("io.microsphere.annotation.ConfigurationProperty", CONFIGURATION_PROPERTY_ANNOTATION_CLASS_NAME); } -} +} \ No newline at end of file diff --git a/microsphere-java-dependencies/pom.xml b/microsphere-java-dependencies/pom.xml index 1f36e1c37..c1fd80661 100644 --- a/microsphere-java-dependencies/pom.xml +++ b/microsphere-java-dependencies/pom.xml @@ -21,6 +21,18 @@ + + io.github.microsphere-projects + microsphere-java-core + ${revision} + + + + io.github.microsphere-projects + microsphere-lang-model + ${revision} + + io.github.microsphere-projects microsphere-annotation-processor @@ -29,7 +41,13 @@ io.github.microsphere-projects - microsphere-java-core + microsphere-jdk-tools + ${revision} + + + + io.github.microsphere-projects + microsphere-java-test ${revision} From 9cfeefbd771d525227f89a04f9b6f183bdaa68eb Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 19:04:46 +0800 Subject: [PATCH 14/79] Update modules list in parent POM Add new modules to the parent POM and reorder existing entries. This commit introduces microsphere-jdk-tools, microsphere-java-test, and microsphere-lang-model to the section and moves microsphere-annotation-processor to the end of the list so the module ordering reflects the updated project structure. --- pom.xml | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index 3f1676d72..1b85ffa97 100644 --- a/pom.xml +++ b/pom.xml @@ -57,8 +57,11 @@ microsphere-java-parent microsphere-java-dependencies - microsphere-annotation-processor microsphere-java-core + microsphere-jdk-tools + microsphere-java-test + microsphere-lang-model + microsphere-annotation-processor \ No newline at end of file From 89ac266b313dc7b0020fb3a983f8bc4b6c99fe97 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 19:08:48 +0800 Subject: [PATCH 15/79] Remove compiler and shade plugins from module POMs Remove the sections from microsphere-java-test, microsphere-jdk-tools, and microsphere-lang-model POMs. This deletes the maven-compiler-plugin configuration (compilerArgument -proc:none) and the maven-shade-plugin execution that shaded io.github.microsphere-projects:microsphere-java-core, consolidating/cleaning up module-level build configuration. --- microsphere-java-test/pom.xml | 31 ------------------------------- microsphere-jdk-tools/pom.xml | 32 -------------------------------- microsphere-lang-model/pom.xml | 31 ------------------------------- 3 files changed, 94 deletions(-) diff --git a/microsphere-java-test/pom.xml b/microsphere-java-test/pom.xml index 9d94d023b..e59a339d2 100644 --- a/microsphere-java-test/pom.xml +++ b/microsphere-java-test/pom.xml @@ -99,35 +99,4 @@ - - - - org.apache.maven.plugins - maven-compiler-plugin - - -proc:none - - - - org.apache.maven.plugins - maven-shade-plugin - - - package - - shade - - - - - io.github.microsphere-projects:microsphere-java-core - - - - - - - - - \ No newline at end of file diff --git a/microsphere-jdk-tools/pom.xml b/microsphere-jdk-tools/pom.xml index d16b92c62..b0822a8de 100644 --- a/microsphere-jdk-tools/pom.xml +++ b/microsphere-jdk-tools/pom.xml @@ -55,36 +55,4 @@ - - - - - org.apache.maven.plugins - maven-compiler-plugin - - -proc:none - - - - org.apache.maven.plugins - maven-shade-plugin - - - package - - shade - - - - - io.github.microsphere-projects:microsphere-java-core - - - - - - - - - \ No newline at end of file diff --git a/microsphere-lang-model/pom.xml b/microsphere-lang-model/pom.xml index 2c674b268..83947daa6 100644 --- a/microsphere-lang-model/pom.xml +++ b/microsphere-lang-model/pom.xml @@ -99,35 +99,4 @@ - - - - org.apache.maven.plugins - maven-compiler-plugin - - -proc:none - - - - org.apache.maven.plugins - maven-shade-plugin - - - package - - shade - - - - - io.github.microsphere-projects:microsphere-java-core - - - - - - - - - \ No newline at end of file From 7956a2041190200c5643416cd4cbe99b2b263bd2 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 19:17:50 +0800 Subject: [PATCH 16/79] Centralize JAX API versions; remove test processor Move javax.ws.rs and jaxws-api version properties into the parent pom and add dependencyManagement entries for javax.ws.rs-api and jaxws-api. Remove duplicate properties and explicit version elements from module poms (annotation-processor, lang-model, java-test) so they inherit the parent-managed versions. Adjust microsphere-java-dependencies to reorder artifactIds (swap mappings between microsphere-lang-model, microsphere-jdk-tools, microsphere-annotation-processor, and microsphere-java-test). Delete the TestProcessor test class and its service registration (META-INF/services) from the java-test module. --- microsphere-annotation-processor/pom.xml | 7 --- microsphere-java-dependencies/pom.xml | 8 ++-- microsphere-java-parent/pom.xml | 19 +++++++- microsphere-java-test/pom.xml | 7 --- .../annotation/processing/TestProcessor.java | 48 ------------------- .../javax.annotation.processing.Processor | 1 - microsphere-lang-model/pom.xml | 7 --- 7 files changed, 22 insertions(+), 75 deletions(-) delete mode 100644 microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/TestProcessor.java delete mode 100644 microsphere-java-test/src/test/resources/META-INF/services/javax.annotation.processing.Processor diff --git a/microsphere-annotation-processor/pom.xml b/microsphere-annotation-processor/pom.xml index e5558b6fe..26473f3d3 100644 --- a/microsphere-annotation-processor/pom.xml +++ b/microsphere-annotation-processor/pom.xml @@ -18,11 +18,6 @@ Microsphere :: Java :: Annotation Processor Microsphere Annotation Processor - - 2.1 - 2.3.1 - - @@ -79,7 +74,6 @@ javax.ws.rs javax.ws.rs-api - ${javax.ws.rs.version} test @@ -87,7 +81,6 @@ javax.xml.ws jaxws-api - ${jaxws-api.version} test diff --git a/microsphere-java-dependencies/pom.xml b/microsphere-java-dependencies/pom.xml index c1fd80661..2be116cb7 100644 --- a/microsphere-java-dependencies/pom.xml +++ b/microsphere-java-dependencies/pom.xml @@ -29,25 +29,25 @@ io.github.microsphere-projects - microsphere-lang-model + microsphere-jdk-tools ${revision} io.github.microsphere-projects - microsphere-annotation-processor + microsphere-java-test ${revision} io.github.microsphere-projects - microsphere-jdk-tools + microsphere-lang-model ${revision} io.github.microsphere-projects - microsphere-java-test + microsphere-annotation-processor ${revision} diff --git a/microsphere-java-parent/pom.xml b/microsphere-java-parent/pom.xml index 4d1d66ae9..ee94b7b74 100644 --- a/microsphere-java-parent/pom.xml +++ b/microsphere-java-parent/pom.xml @@ -20,6 +20,8 @@ 1.3.2 + 2.1 + 2.3.1 3.0.2 1.3.2 7.0.2 @@ -31,7 +33,6 @@ 1.37 - @@ -43,6 +44,22 @@ ${javax.annotation-api.version} + + + javax.ws.rs + javax.ws.rs-api + ${javax.ws.rs.version} + true + + + + + javax.xml.ws + jaxws-api + ${jaxws-api.version} + true + + com.google.code.findbugs diff --git a/microsphere-java-test/pom.xml b/microsphere-java-test/pom.xml index e59a339d2..568f1add5 100644 --- a/microsphere-java-test/pom.xml +++ b/microsphere-java-test/pom.xml @@ -18,11 +18,6 @@ Microsphere :: Java :: Test Microsphere Java Test - - 2.1 - 2.3.1 - - @@ -72,7 +67,6 @@ javax.ws.rs javax.ws.rs-api - ${javax.ws.rs.version} true @@ -80,7 +74,6 @@ javax.xml.ws jaxws-api - ${jaxws-api.version} true diff --git a/microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/TestProcessor.java b/microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/TestProcessor.java deleted file mode 100644 index e1ad024a5..000000000 --- a/microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/TestProcessor.java +++ /dev/null @@ -1,48 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package io.microsphere.test.annotation.processing; - -import javax.annotation.processing.AbstractProcessor; -import javax.annotation.processing.Processor; -import javax.annotation.processing.RoundEnvironment; -import javax.annotation.processing.SupportedAnnotationTypes; -import javax.lang.model.SourceVersion; -import javax.lang.model.element.TypeElement; -import java.util.Set; - -import static javax.lang.model.SourceVersion.latestSupported; - -/** - * Test {@link Processor} - * - * @author Mercy - * @see Processor - * @since 1.0.0 - */ -@SupportedAnnotationTypes("*") -public class TestProcessor extends AbstractProcessor { - @Override - public boolean process(Set annotations, RoundEnvironment roundEnv) { - return true; - } - - @Override - public SourceVersion getSupportedSourceVersion() { - return latestSupported(); - } -} \ No newline at end of file diff --git a/microsphere-java-test/src/test/resources/META-INF/services/javax.annotation.processing.Processor b/microsphere-java-test/src/test/resources/META-INF/services/javax.annotation.processing.Processor deleted file mode 100644 index 6b85e96b8..000000000 --- a/microsphere-java-test/src/test/resources/META-INF/services/javax.annotation.processing.Processor +++ /dev/null @@ -1 +0,0 @@ -io.microsphere.test.annotation.processing.TestProcessor \ No newline at end of file diff --git a/microsphere-lang-model/pom.xml b/microsphere-lang-model/pom.xml index 83947daa6..101084931 100644 --- a/microsphere-lang-model/pom.xml +++ b/microsphere-lang-model/pom.xml @@ -18,11 +18,6 @@ Microsphere :: Java :: Language Model Microsphere Language Model - - 2.1 - 2.3.1 - - @@ -72,7 +67,6 @@ javax.ws.rs javax.ws.rs-api - ${javax.ws.rs.version} test @@ -80,7 +74,6 @@ javax.xml.ws jaxws-api - ${jaxws-api.version} test From a7185d67075f2eaf8f43028627833dc83874777b Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 19:18:10 +0800 Subject: [PATCH 17/79] Clean up imports in FieldUtils and tests Reorder and group static imports in FieldUtils for consistency and readability. Remove an unused import (AbstractAnnotationProcessingTest) from JSONElementVisitorTest to eliminate a compiler/IDE warning. No behavior changes. --- .../java/io/microsphere/lang/model/util/FieldUtils.java | 6 +++--- .../microsphere/lang/model/util/JSONElementVisitorTest.java | 1 - 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/FieldUtils.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/FieldUtils.java index 3ded2017e..b14dd47a1 100644 --- a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/FieldUtils.java +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/FieldUtils.java @@ -29,14 +29,14 @@ import java.util.List; import java.util.function.Predicate; +import static io.microsphere.collection.CollectionUtils.isEmpty; +import static io.microsphere.lang.function.Predicates.EMPTY_PREDICATE_ARRAY; +import static io.microsphere.lang.function.Streams.filterFirst; import static io.microsphere.lang.model.util.ElementUtils.filterElements; import static io.microsphere.lang.model.util.ElementUtils.hasModifiers; import static io.microsphere.lang.model.util.ElementUtils.matchesElementKind; import static io.microsphere.lang.model.util.MemberUtils.getDeclaredMembers; import static io.microsphere.lang.model.util.TypeUtils.isEnumType; -import static io.microsphere.collection.CollectionUtils.isEmpty; -import static io.microsphere.lang.function.Predicates.EMPTY_PREDICATE_ARRAY; -import static io.microsphere.lang.function.Streams.filterFirst; import static java.util.Collections.emptyList; import static javax.lang.model.element.ElementKind.ENUM_CONSTANT; import static javax.lang.model.element.ElementKind.FIELD; diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONElementVisitorTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONElementVisitorTest.java index 4cc8234f9..c18e83147 100644 --- a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONElementVisitorTest.java +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONElementVisitorTest.java @@ -19,7 +19,6 @@ import io.microsphere.test.annotation.TestAnnotation; -import io.microsphere.test.annotation.processing.AbstractAnnotationProcessingTest; import io.microsphere.test.model.Color; import io.microsphere.test.model.StringArrayList; import org.junit.jupiter.api.BeforeEach; From 91949bd290cad022ca0139ccb8229623f16ebbd7 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 19:18:26 +0800 Subject: [PATCH 18/79] Reorder and clean up imports across modules Normalize and tidy imports across multiple modules: reorder static imports for consistency, remove unused imports (including AbstractAnnotationProcessingTest in tests), and fix minor formatting. Replace Mockito wildcard import with explicit mock import in TestServiceImplTest. These are code-cleanup changes to reduce warnings and improve import organization. --- .../ConfigurationPropertyJSONElementVisitor.java | 2 +- .../annotation/processor/FilerProcessorTest.java | 1 - .../test/service/TestServiceImplTest.java | 2 +- .../lang/model/util/AnnotationUtils.java | 14 +++++++------- .../io/microsphere/lang/model/util/ClassUtils.java | 2 +- .../lang/model/util/ConstructorUtils.java | 6 +++--- .../microsphere/lang/model/util/ElementUtils.java | 2 +- .../microsphere/lang/model/util/MemberUtils.java | 2 +- .../microsphere/lang/model/util/MethodUtils.java | 8 ++++---- .../util/ResolvableAnnotationValueVisitor.java | 2 +- .../lang/model/util/ConstructorUtilsTest.java | 1 - .../util/ExecutableElementComparatorTest.java | 1 - 12 files changed, 20 insertions(+), 23 deletions(-) diff --git a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/ConfigurationPropertyJSONElementVisitor.java b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/ConfigurationPropertyJSONElementVisitor.java index 278575b9f..5f5b9f2f7 100644 --- a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/ConfigurationPropertyJSONElementVisitor.java +++ b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/ConfigurationPropertyJSONElementVisitor.java @@ -31,13 +31,13 @@ import java.util.List; import java.util.Map; +import static io.microsphere.constants.SymbolConstants.COMMA_CHAR; import static io.microsphere.lang.model.util.AnnotationUtils.getAnnotation; import static io.microsphere.lang.model.util.AnnotationUtils.getAttributeName; import static io.microsphere.lang.model.util.AnnotationUtils.getElementValues; import static io.microsphere.lang.model.util.AnnotationUtils.matchesDefaultAttributeValue; import static io.microsphere.lang.model.util.ClassUtils.getClassName; import static io.microsphere.lang.model.util.TypeUtils.getTypeName; -import static io.microsphere.constants.SymbolConstants.COMMA_CHAR; import static io.microsphere.util.ServiceLoaderUtils.loadFirstService; import static io.microsphere.util.StringUtils.isBlank; diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/FilerProcessorTest.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/FilerProcessorTest.java index 132685903..8f715df0f 100644 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/FilerProcessorTest.java +++ b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/FilerProcessorTest.java @@ -25,7 +25,6 @@ import javax.tools.JavaFileManager; import javax.tools.JavaFileObject; - import java.lang.reflect.Method; import static io.microsphere.annotation.processor.ResourceProcessor.exists; diff --git a/microsphere-java-test/src/test/java/io/microsphere/test/service/TestServiceImplTest.java b/microsphere-java-test/src/test/java/io/microsphere/test/service/TestServiceImplTest.java index 272aba056..b7fc3ecf8 100644 --- a/microsphere-java-test/src/test/java/io/microsphere/test/service/TestServiceImplTest.java +++ b/microsphere-java-test/src/test/java/io/microsphere/test/service/TestServiceImplTest.java @@ -10,7 +10,7 @@ import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertSame; -import static org.mockito.Mockito.*; +import static org.mockito.Mockito.mock; /** * Unit tests for the TestServiceImpl class. diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/AnnotationUtils.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/AnnotationUtils.java index bbfce4988..53462b44f 100644 --- a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/AnnotationUtils.java +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/AnnotationUtils.java @@ -42,13 +42,6 @@ import java.util.Objects; import java.util.function.Predicate; -import static io.microsphere.lang.model.util.MethodUtils.findDeclaredMethods; -import static io.microsphere.lang.model.util.MethodUtils.getDeclaredMethods; -import static io.microsphere.lang.model.util.MethodUtils.getMethodName; -import static io.microsphere.lang.model.util.TypeUtils.getAllTypeElements; -import static io.microsphere.lang.model.util.TypeUtils.getTypeElement; -import static io.microsphere.lang.model.util.TypeUtils.isSameType; -import static io.microsphere.lang.model.util.TypeUtils.ofTypeElement; import static io.microsphere.collection.CollectionUtils.isEmpty; import static io.microsphere.collection.CollectionUtils.size; import static io.microsphere.collection.MapUtils.immutableEntry; @@ -56,6 +49,13 @@ import static io.microsphere.collection.MapUtils.newFixedLinkedHashMap; import static io.microsphere.lang.function.Predicates.EMPTY_PREDICATE_ARRAY; import static io.microsphere.lang.function.Streams.filterAll; +import static io.microsphere.lang.model.util.MethodUtils.findDeclaredMethods; +import static io.microsphere.lang.model.util.MethodUtils.getDeclaredMethods; +import static io.microsphere.lang.model.util.MethodUtils.getMethodName; +import static io.microsphere.lang.model.util.TypeUtils.getAllTypeElements; +import static io.microsphere.lang.model.util.TypeUtils.getTypeElement; +import static io.microsphere.lang.model.util.TypeUtils.isSameType; +import static io.microsphere.lang.model.util.TypeUtils.ofTypeElement; import static io.microsphere.util.ArrayUtils.isNotEmpty; import static io.microsphere.util.StringUtils.isBlank; import static java.util.Collections.emptyList; diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ClassUtils.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ClassUtils.java index 1c2239399..7b83b0c99 100644 --- a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ClassUtils.java +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ClassUtils.java @@ -21,9 +21,9 @@ import javax.lang.model.type.TypeMirror; -import static io.microsphere.lang.model.util.TypeUtils.ofTypeElement; import static io.microsphere.constants.SymbolConstants.DOLLAR_CHAR; import static io.microsphere.constants.SymbolConstants.DOT_CHAR; +import static io.microsphere.lang.model.util.TypeUtils.ofTypeElement; import static io.microsphere.util.ClassLoaderUtils.getClassLoader; import static io.microsphere.util.ClassLoaderUtils.resolveClass; diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ConstructorUtils.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ConstructorUtils.java index eb878ed96..c864c1c7d 100644 --- a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ConstructorUtils.java +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ConstructorUtils.java @@ -32,12 +32,12 @@ import java.util.List; import java.util.function.Predicate; -import static io.microsphere.lang.model.util.ElementUtils.filterElements; -import static io.microsphere.lang.model.util.ElementUtils.matchParameterTypes; -import static io.microsphere.lang.model.util.MemberUtils.getDeclaredMembers; import static io.microsphere.collection.CollectionUtils.isEmpty; import static io.microsphere.collection.ListUtils.first; import static io.microsphere.lang.function.Predicates.EMPTY_PREDICATE_ARRAY; +import static io.microsphere.lang.model.util.ElementUtils.filterElements; +import static io.microsphere.lang.model.util.ElementUtils.matchParameterTypes; +import static io.microsphere.lang.model.util.MemberUtils.getDeclaredMembers; import static java.util.Collections.emptyList; import static javax.lang.model.util.ElementFilter.constructorsIn; diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ElementUtils.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ElementUtils.java index f3d708d8a..f24373a19 100644 --- a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ElementUtils.java +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ElementUtils.java @@ -32,9 +32,9 @@ import java.util.Set; import java.util.function.Predicate; -import static io.microsphere.lang.model.util.TypeUtils.isSameType; import static io.microsphere.collection.CollectionUtils.isEmpty; import static io.microsphere.lang.function.Predicates.and; +import static io.microsphere.lang.model.util.TypeUtils.isSameType; import static io.microsphere.reflect.TypeUtils.getTypeNames; import static io.microsphere.util.ArrayUtils.isNotEmpty; import static io.microsphere.util.ArrayUtils.length; diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/MemberUtils.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/MemberUtils.java index addc57158..77f027a4f 100644 --- a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/MemberUtils.java +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/MemberUtils.java @@ -27,10 +27,10 @@ import java.util.List; import java.util.function.Predicate; +import static io.microsphere.lang.function.Predicates.EMPTY_PREDICATE_ARRAY; import static io.microsphere.lang.model.util.ElementUtils.filterElements; import static io.microsphere.lang.model.util.TypeUtils.getAllDeclaredTypes; import static io.microsphere.lang.model.util.TypeUtils.ofTypeElement; -import static io.microsphere.lang.function.Predicates.EMPTY_PREDICATE_ARRAY; import static java.util.Collections.emptyList; import static java.util.stream.Collectors.toList; diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/MethodUtils.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/MethodUtils.java index 925d3ee37..f4e741343 100644 --- a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/MethodUtils.java +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/MethodUtils.java @@ -34,6 +34,10 @@ import java.util.Objects; import java.util.function.Predicate; +import static io.microsphere.collection.CollectionUtils.isEmpty; +import static io.microsphere.lang.function.Predicates.EMPTY_PREDICATE_ARRAY; +import static io.microsphere.lang.function.Predicates.and; +import static io.microsphere.lang.function.Streams.filterFirst; import static io.microsphere.lang.model.util.ElementUtils.filterElements; import static io.microsphere.lang.model.util.ElementUtils.isPublicNonStatic; import static io.microsphere.lang.model.util.ElementUtils.matchParameterTypeNames; @@ -41,10 +45,6 @@ import static io.microsphere.lang.model.util.MemberUtils.getDeclaredMembers; import static io.microsphere.lang.model.util.TypeUtils.isSameType; import static io.microsphere.lang.model.util.TypeUtils.ofDeclaredType; -import static io.microsphere.collection.CollectionUtils.isEmpty; -import static io.microsphere.lang.function.Predicates.EMPTY_PREDICATE_ARRAY; -import static io.microsphere.lang.function.Predicates.and; -import static io.microsphere.lang.function.Streams.filterFirst; import static io.microsphere.util.ArrayUtils.EMPTY_STRING_ARRAY; import static io.microsphere.util.ArrayUtils.EMPTY_TYPE_ARRAY; import static io.microsphere.util.ArrayUtils.isNotEmpty; diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ResolvableAnnotationValueVisitor.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ResolvableAnnotationValueVisitor.java index 7a4653fe8..86bce41b5 100644 --- a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ResolvableAnnotationValueVisitor.java +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/ResolvableAnnotationValueVisitor.java @@ -30,10 +30,10 @@ import java.util.Map; import java.util.Map.Entry; +import static io.microsphere.collection.MapUtils.newFixedLinkedHashMap; import static io.microsphere.lang.model.util.AnnotationUtils.getAttributeName; import static io.microsphere.lang.model.util.AnnotationUtils.getElementValues; import static io.microsphere.lang.model.util.ClassUtils.loadClass; -import static io.microsphere.collection.MapUtils.newFixedLinkedHashMap; import static io.microsphere.reflect.MethodUtils.findMethod; import static io.microsphere.reflect.MethodUtils.invokeStaticMethod; import static io.microsphere.util.ArrayUtils.newArray; diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ConstructorUtilsTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ConstructorUtilsTest.java index 8fd8e5eb5..a4b513650 100644 --- a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ConstructorUtilsTest.java +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ConstructorUtilsTest.java @@ -18,7 +18,6 @@ package io.microsphere.lang.model.util; -import io.microsphere.test.annotation.processing.AbstractAnnotationProcessingTest; import org.junit.jupiter.api.Test; import org.springframework.core.env.Environment; diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ExecutableElementComparatorTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ExecutableElementComparatorTest.java index de416226f..9043220bb 100644 --- a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ExecutableElementComparatorTest.java +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ExecutableElementComparatorTest.java @@ -1,6 +1,5 @@ package io.microsphere.lang.model.util; -import io.microsphere.test.annotation.processing.AbstractAnnotationProcessingTest; import io.microsphere.test.service.TestService; import org.junit.jupiter.api.Test; From ccfd34451d86d20760edfb6fb75a160e5fe832ec Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 19:35:02 +0800 Subject: [PATCH 19/79] Move annotations to dedicated module Create a new microsphere-java-annotations module and move annotation sources and tests from microsphere-java-core into it. Added a module POM (including jsr305 and JUnit test deps), new NonnullTest and NullableTest classes, and updated test Javadocs. Updated microsphere-java-core POM to depend on the new annotations artifact (replacing the previous direct jsr305 dependency), added the annotations artifact to dependencyManagement, and registered the new module in the root POM. Also removed an unused import in Since.java. --- microsphere-java-annotations/pom.xml | 44 +++++++++++++++++++ .../annotation/ConfigurationProperty.java | 2 +- .../microsphere/annotation/Experimental.java | 2 +- .../io/microsphere/annotation/Immutable.java | 2 +- .../io/microsphere/annotation/Nonnull.java | 2 +- .../io/microsphere/annotation/Nullable.java | 2 +- .../java/io/microsphere/annotation/Since.java | 7 +-- .../annotation/ConfigurationPropertyTest.java | 2 +- .../annotation/ExperimentalTest.java | 2 +- .../microsphere/annotation/ImmutableTest.java | 2 +- .../microsphere/annotation/NonnullTest.java | 38 ++++++++++++++++ .../microsphere/annotation/NullableTest.java | 38 ++++++++++++++++ .../io/microsphere/annotation/SinceTest.java | 2 +- microsphere-java-core/pom.xml | 8 ++-- microsphere-java-dependencies/pom.xml | 6 +++ pom.xml | 1 + 16 files changed, 142 insertions(+), 18 deletions(-) create mode 100644 microsphere-java-annotations/pom.xml rename {microsphere-java-core => microsphere-java-annotations}/src/main/java/io/microsphere/annotation/ConfigurationProperty.java (99%) rename {microsphere-java-core => microsphere-java-annotations}/src/main/java/io/microsphere/annotation/Experimental.java (99%) rename {microsphere-java-core => microsphere-java-annotations}/src/main/java/io/microsphere/annotation/Immutable.java (99%) rename {microsphere-java-core => microsphere-java-annotations}/src/main/java/io/microsphere/annotation/Nonnull.java (99%) rename {microsphere-java-core => microsphere-java-annotations}/src/main/java/io/microsphere/annotation/Nullable.java (99%) rename {microsphere-java-core => microsphere-java-annotations}/src/main/java/io/microsphere/annotation/Since.java (96%) rename {microsphere-java-core => microsphere-java-annotations}/src/test/java/io/microsphere/annotation/ConfigurationPropertyTest.java (96%) rename {microsphere-java-core => microsphere-java-annotations}/src/test/java/io/microsphere/annotation/ExperimentalTest.java (96%) rename {microsphere-java-core => microsphere-java-annotations}/src/test/java/io/microsphere/annotation/ImmutableTest.java (96%) create mode 100644 microsphere-java-annotations/src/test/java/io/microsphere/annotation/NonnullTest.java create mode 100644 microsphere-java-annotations/src/test/java/io/microsphere/annotation/NullableTest.java rename {microsphere-java-core => microsphere-java-annotations}/src/test/java/io/microsphere/annotation/SinceTest.java (99%) diff --git a/microsphere-java-annotations/pom.xml b/microsphere-java-annotations/pom.xml new file mode 100644 index 000000000..e80e54ea5 --- /dev/null +++ b/microsphere-java-annotations/pom.xml @@ -0,0 +1,44 @@ + + + + io.github.microsphere-projects + microsphere-java-parent + ${revision} + ../microsphere-java-parent/pom.xml + + 4.0.0 + + io.github.microsphere-projects + microsphere-java-annotations + ${revision} + jar + + Microsphere :: Java :: Annotations + Microsphere Java Annotations + + + + + + com.google.code.findbugs + jsr305 + true + + + + + org.junit.jupiter + junit-jupiter + test + + + + org.junit.jupiter + junit-jupiter-engine + test + + + + \ No newline at end of file diff --git a/microsphere-java-core/src/main/java/io/microsphere/annotation/ConfigurationProperty.java b/microsphere-java-annotations/src/main/java/io/microsphere/annotation/ConfigurationProperty.java similarity index 99% rename from microsphere-java-core/src/main/java/io/microsphere/annotation/ConfigurationProperty.java rename to microsphere-java-annotations/src/main/java/io/microsphere/annotation/ConfigurationProperty.java index dd6272f95..10203087e 100644 --- a/microsphere-java-core/src/main/java/io/microsphere/annotation/ConfigurationProperty.java +++ b/microsphere-java-annotations/src/main/java/io/microsphere/annotation/ConfigurationProperty.java @@ -94,4 +94,4 @@ */ String[] source() default {}; -} +} \ No newline at end of file diff --git a/microsphere-java-core/src/main/java/io/microsphere/annotation/Experimental.java b/microsphere-java-annotations/src/main/java/io/microsphere/annotation/Experimental.java similarity index 99% rename from microsphere-java-core/src/main/java/io/microsphere/annotation/Experimental.java rename to microsphere-java-annotations/src/main/java/io/microsphere/annotation/Experimental.java index 498df0028..e3780f909 100644 --- a/microsphere-java-core/src/main/java/io/microsphere/annotation/Experimental.java +++ b/microsphere-java-annotations/src/main/java/io/microsphere/annotation/Experimental.java @@ -49,4 +49,4 @@ */ String description() default ""; -} +} \ No newline at end of file diff --git a/microsphere-java-core/src/main/java/io/microsphere/annotation/Immutable.java b/microsphere-java-annotations/src/main/java/io/microsphere/annotation/Immutable.java similarity index 99% rename from microsphere-java-core/src/main/java/io/microsphere/annotation/Immutable.java rename to microsphere-java-annotations/src/main/java/io/microsphere/annotation/Immutable.java index 593118b5e..0ae81044f 100644 --- a/microsphere-java-core/src/main/java/io/microsphere/annotation/Immutable.java +++ b/microsphere-java-annotations/src/main/java/io/microsphere/annotation/Immutable.java @@ -31,4 +31,4 @@ @Documented @Retention(RUNTIME) public @interface Immutable { -} +} \ No newline at end of file diff --git a/microsphere-java-core/src/main/java/io/microsphere/annotation/Nonnull.java b/microsphere-java-annotations/src/main/java/io/microsphere/annotation/Nonnull.java similarity index 99% rename from microsphere-java-core/src/main/java/io/microsphere/annotation/Nonnull.java rename to microsphere-java-annotations/src/main/java/io/microsphere/annotation/Nonnull.java index 859ec90a4..0a36bb87a 100644 --- a/microsphere-java-core/src/main/java/io/microsphere/annotation/Nonnull.java +++ b/microsphere-java-annotations/src/main/java/io/microsphere/annotation/Nonnull.java @@ -35,4 +35,4 @@ @javax.annotation.Nonnull @TypeQualifierNickname public @interface Nonnull { -} +} \ No newline at end of file diff --git a/microsphere-java-core/src/main/java/io/microsphere/annotation/Nullable.java b/microsphere-java-annotations/src/main/java/io/microsphere/annotation/Nullable.java similarity index 99% rename from microsphere-java-core/src/main/java/io/microsphere/annotation/Nullable.java rename to microsphere-java-annotations/src/main/java/io/microsphere/annotation/Nullable.java index c3a3a49e0..9b708f889 100644 --- a/microsphere-java-core/src/main/java/io/microsphere/annotation/Nullable.java +++ b/microsphere-java-annotations/src/main/java/io/microsphere/annotation/Nullable.java @@ -36,4 +36,4 @@ @javax.annotation.Nonnull(when = MAYBE) @TypeQualifierNickname public @interface Nullable { -} +} \ No newline at end of file diff --git a/microsphere-java-core/src/main/java/io/microsphere/annotation/Since.java b/microsphere-java-annotations/src/main/java/io/microsphere/annotation/Since.java similarity index 96% rename from microsphere-java-core/src/main/java/io/microsphere/annotation/Since.java rename to microsphere-java-annotations/src/main/java/io/microsphere/annotation/Since.java index bb840ccbc..c2ec0c22d 100644 --- a/microsphere-java-core/src/main/java/io/microsphere/annotation/Since.java +++ b/microsphere-java-annotations/src/main/java/io/microsphere/annotation/Since.java @@ -16,8 +16,6 @@ */ package io.microsphere.annotation; -import io.microsphere.util.Version; - import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.Target; @@ -38,7 +36,6 @@ * The annotation that indicates the API is introduced in the first time. * * @author Mercy - * @see Version * @see Experimental * @since 1.0.0 */ @@ -65,7 +62,7 @@ /** * @return The version value of the API, e.g. 1.0.0 - * @see Version */ String value(); -} + +} \ No newline at end of file diff --git a/microsphere-java-core/src/test/java/io/microsphere/annotation/ConfigurationPropertyTest.java b/microsphere-java-annotations/src/test/java/io/microsphere/annotation/ConfigurationPropertyTest.java similarity index 96% rename from microsphere-java-core/src/test/java/io/microsphere/annotation/ConfigurationPropertyTest.java rename to microsphere-java-annotations/src/test/java/io/microsphere/annotation/ConfigurationPropertyTest.java index 54c7d50c6..c31732d3a 100644 --- a/microsphere-java-core/src/test/java/io/microsphere/annotation/ConfigurationPropertyTest.java +++ b/microsphere-java-annotations/src/test/java/io/microsphere/annotation/ConfigurationPropertyTest.java @@ -25,7 +25,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals; /** - * {@link ConfigurationProperty} Test + * {@link ConfigurationProperty @ConfigurationProperty} Test * * @author Mercy * @see ConfigurationProperty diff --git a/microsphere-java-core/src/test/java/io/microsphere/annotation/ExperimentalTest.java b/microsphere-java-annotations/src/test/java/io/microsphere/annotation/ExperimentalTest.java similarity index 96% rename from microsphere-java-core/src/test/java/io/microsphere/annotation/ExperimentalTest.java rename to microsphere-java-annotations/src/test/java/io/microsphere/annotation/ExperimentalTest.java index 9014ea8a9..d4db9a409 100644 --- a/microsphere-java-core/src/test/java/io/microsphere/annotation/ExperimentalTest.java +++ b/microsphere-java-annotations/src/test/java/io/microsphere/annotation/ExperimentalTest.java @@ -21,7 +21,7 @@ import static org.junit.jupiter.api.Assertions.assertNull; /** - * {@link Experimental} Test + * {@link Experimental @Experimental} Test * * @author Mercy * @see Experimental diff --git a/microsphere-java-core/src/test/java/io/microsphere/annotation/ImmutableTest.java b/microsphere-java-annotations/src/test/java/io/microsphere/annotation/ImmutableTest.java similarity index 96% rename from microsphere-java-core/src/test/java/io/microsphere/annotation/ImmutableTest.java rename to microsphere-java-annotations/src/test/java/io/microsphere/annotation/ImmutableTest.java index 5d871cf1d..6ae1ffb79 100644 --- a/microsphere-java-core/src/test/java/io/microsphere/annotation/ImmutableTest.java +++ b/microsphere-java-annotations/src/test/java/io/microsphere/annotation/ImmutableTest.java @@ -22,7 +22,7 @@ import static org.junit.jupiter.api.Assertions.assertNotNull; /** - * {@link Immutable} Test + * {@link Immutable @Immutable} Test * * @author Mercy * @see Immutable diff --git a/microsphere-java-annotations/src/test/java/io/microsphere/annotation/NonnullTest.java b/microsphere-java-annotations/src/test/java/io/microsphere/annotation/NonnullTest.java new file mode 100644 index 000000000..cea51bd42 --- /dev/null +++ b/microsphere-java-annotations/src/test/java/io/microsphere/annotation/NonnullTest.java @@ -0,0 +1,38 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.annotation; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertNotNull; + +/** + * {@link Nonnull @Nonnull} Test + * + * @author Mercy + * @see Nonnull + * @since 1.0.0 + */ +@Nonnull +class NonnullTest { + + @Test + void test() { + assertNotNull(NonnullTest.class.getAnnotation(Nonnull.class)); + } +} \ No newline at end of file diff --git a/microsphere-java-annotations/src/test/java/io/microsphere/annotation/NullableTest.java b/microsphere-java-annotations/src/test/java/io/microsphere/annotation/NullableTest.java new file mode 100644 index 000000000..25a6625fe --- /dev/null +++ b/microsphere-java-annotations/src/test/java/io/microsphere/annotation/NullableTest.java @@ -0,0 +1,38 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.annotation; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertNotNull; + +/** + * {@link Nullable @Nullable} Test + * + * @author Mercy + * @see Nullable + * @since 1.0.0 + */ +@Nullable +class NullableTest { + + @Test + void test() { + assertNotNull(NullableTest.class.getAnnotation(Nullable.class)); + } +} \ No newline at end of file diff --git a/microsphere-java-core/src/test/java/io/microsphere/annotation/SinceTest.java b/microsphere-java-annotations/src/test/java/io/microsphere/annotation/SinceTest.java similarity index 99% rename from microsphere-java-core/src/test/java/io/microsphere/annotation/SinceTest.java rename to microsphere-java-annotations/src/test/java/io/microsphere/annotation/SinceTest.java index 1ecca38c8..1e6314b95 100644 --- a/microsphere-java-core/src/test/java/io/microsphere/annotation/SinceTest.java +++ b/microsphere-java-annotations/src/test/java/io/microsphere/annotation/SinceTest.java @@ -36,4 +36,4 @@ void test() { assertEquals("microsphere-java-core", since.module()); assertEquals("1.0.0", since.value()); } -} +} \ No newline at end of file diff --git a/microsphere-java-core/pom.xml b/microsphere-java-core/pom.xml index c6063daa5..ed6e35fdb 100644 --- a/microsphere-java-core/pom.xml +++ b/microsphere-java-core/pom.xml @@ -20,11 +20,11 @@ - + - com.google.code.findbugs - jsr305 - true + io.github.microsphere-projects + microsphere-java-annotations + ${revision} diff --git a/microsphere-java-dependencies/pom.xml b/microsphere-java-dependencies/pom.xml index 2be116cb7..aba268cdb 100644 --- a/microsphere-java-dependencies/pom.xml +++ b/microsphere-java-dependencies/pom.xml @@ -21,6 +21,12 @@ + + io.github.microsphere-projects + microsphere-java-annotations + ${revision} + + io.github.microsphere-projects microsphere-java-core diff --git a/pom.xml b/pom.xml index 1b85ffa97..33ed4932f 100644 --- a/pom.xml +++ b/pom.xml @@ -57,6 +57,7 @@ microsphere-java-parent microsphere-java-dependencies + microsphere-java-annotations microsphere-java-core microsphere-jdk-tools microsphere-java-test From b7f1af5bec7b777929e0864aeeab02f40e003e68 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 19:36:05 +0800 Subject: [PATCH 20/79] Bump parent POM version to 0.2.3 Update the project's parent POM from io.github.microsphere-projects:microsphere-build:0.2.2 to 0.2.3 to incorporate upstream build configuration changes and fixes. --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index 33ed4932f..dc5c6a270 100644 --- a/pom.xml +++ b/pom.xml @@ -6,7 +6,7 @@ io.github.microsphere-projects microsphere-build - 0.2.2 + 0.2.3 io.github.microsphere-projects From f4300ecbf81cb6386fbb66f8b844c153581090b6 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 19:40:14 +0800 Subject: [PATCH 21/79] Add jsr305 test dependency Add JSR-305 (com.google.code.findbugs:jsr305) as a test-scoped dependency in microsphere-java-core/pom.xml. This brings in standard nullability annotations for use in tests and static analysis during the test phase. --- microsphere-java-core/pom.xml | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/microsphere-java-core/pom.xml b/microsphere-java-core/pom.xml index ed6e35fdb..c31c60b8c 100644 --- a/microsphere-java-core/pom.xml +++ b/microsphere-java-core/pom.xml @@ -62,6 +62,13 @@ test + + + com.google.code.findbugs + jsr305 + test + + ch.qos.logback From 51162497bbc9917844ba7ecf3ce538e4e15f2f68 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 19:43:33 +0800 Subject: [PATCH 22/79] Update Maven Wrapper to 3.3.4 Replace checked-in maven-wrapper binary with the newer wrapper scripts and properties. Removes .mvn/wrapper/maven-wrapper.jar, updates .mvn/wrapper/maven-wrapper.properties to wrapperVersion=3.3.4 and points distributionUrl to an aliyun mirror (apache-maven-3.9.9) using distributionType=only-script. Replaces mvnw and mvnw.cmd with revamped wrapper implementations that download/install Maven on demand, add support for MVNW_REPOURL/MVNW_USERNAME/MVNW_PASSWORD/MVNW_VERBOSE, improve Java detection and error handling, support checksum validation, and add mvnd handling. --- .mvn/wrapper/maven-wrapper.jar | Bin 59925 -> 0 bytes .mvn/wrapper/maven-wrapper.properties | 19 +- mvnw | 483 ++++++++++++-------------- mvnw.cmd | 377 ++++++++++---------- 4 files changed, 423 insertions(+), 456 deletions(-) delete mode 100755 .mvn/wrapper/maven-wrapper.jar diff --git a/.mvn/wrapper/maven-wrapper.jar b/.mvn/wrapper/maven-wrapper.jar deleted file mode 100755 index bf82ff01c6cdae4a1bb754a6e062954d77ac5c11..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 59925 zcmb5U1CS=sk~ZA7ZQHhc+Mc%Ywrx+_*0gQgw(Xv_ZBOg(y}RG;-uU;sUu;#Jh>EHw zGfrmZsXF;&D$0O@!2kh40RbILm8t;!w*&h7T24$wm|jX=oKf)`hV~7E`UmXw?e4Pt z`>_l#5YYGC|ANU0%S(xiDXTEZiATrw!Spl1gyQYxsqjrZO`%3Yq?k$Dr=tVr?HIeHlsmnE9=ZU6I2QoCjlLn85rrn7M!RO}+ z%|6^Q>sv`K3j6Ux>as6NoB}L8q#ghm_b)r{V+Pf3xj>b^+M8ZFY`k|FHgl zM!^0D!qDCjU~cj+fXM$0v@vuwvHcft?EeYw=4fbdZ{qkb#PI)>7{J=%Ux*@pi~i^9 z{(nu6>i-Y^_7lUudx7B}(hUFa*>e0ZwEROS{eRc_U*VV`F$C=Jtqb-$9MS)~&L3im zV)8%4)^9W3c4IT94|h)3k zdAT_~?$Z0{&MK=M0K)Y#_0R;gEjTs0uy4JHvr6q{RKur)D^%t>W+U;a*TZ;VL{kcnJJT z3mD=m7($$%?Y#>-Edcet`uWDH(@wIl+|_f#5l8odHg_|+)4AAYP9)~B^10nU306iE zaS4Y#5&gTL4eHH6&zd(VGyR0Qccx;>0R~Y5#29OkJpSAyr4&h1CYY|I}o)z ze}OiPf5V~(ABejc1pN%8rJQHwPn_`O*q7Dm)p}3K(mm1({hFmfY{yYbM)&Y`2R=h? zTtYwx?$W-*1LqsUrUY&~BwJjr)rO{qI$a`=(6Uplsti7Su#&_03es*Yp0{U{(nQCr z?5M{cLyHT_XALxWu5fU>DPVo99l3FAB<3mtIS<_+71o0jR1A8rd30@j;B75Z!uH;< z{shmnFK@pl080=?j0O8KnkE;zsuxzZx z4X2?!Dk7}SxCereOJK4-FkOq3i{GD#xtAE(tzLUiN~R2WN*RMuA3uYv-3vr9N8;p- z0ovH_gnvKnB5M{_^d`mUsVPvYv`38c2_qP$*@)N(ZmZosbxiRG=Cbm`0ZOx23Zzgs zLJPF;&V~ZV;Nb8ELEf73;P5ciI7|wZBtDl}on%WwtCh8Lf$Yfq`;Hb1D!-KYz&Kd< z+WE+o-gPb6S%ah2^mF80rK=H*+8mQdyrR+)Ar5krl4S!TAAG+sv8o+Teg)`9b22%4 zI7vnPTq&h=o=Z|$;>tEj(i@KN^8N@nk}}6SBhDIGCE4TrmVvM^PlBVZsbZcmR$P7v3{Pw88(jhhI?28MZ>uB%H z&+HAqu-MDFVk5|LYqUXBMR74n1nJ|qLNe#G7UaE>J{uX(rz6McAWj)Ui2R!4y&B01 z`}LOF7k|z0$I+psk+U^Z3YiAH-{>k*@z|0?L4MPNdtsPB+(F791LsRX$Dm(Gycm1k}n z#a2T#*)k-v{}p@^L5PC^@bH+-YO4v`l7Gq)9pgSns??ISG!M6>7&GySTZkVhykqk* zijh9sE`ky?DQPo+7}Vu@?}15_zTovL$r%h~*)=6*vTz?G#h|~>p(ukh%MKOCV^Jxa zi~lMP5+^-OW%Te@b#UoL6T1%9h-W}*hUtdu!>odxuT`kTg6U3+a@6QTiwM0I zqXcEI2x-gOS74?=&<18fYRv&Ms)R>e;Qz&0N20K9%CM_Iq#3V8%pwU>rAGbaXoGVS z-r5a$;fZ>75!`u@7=vV?y@7J;S;E#lvQ?Ar>%ao zOX)rc794W?X64tUEk>y|m_aCxU#N>o!Xw7##(7dIZDuYn0+9DoafcrK_(IUSl$m`A zZF1;0D&2KMWxq{!JlB#Yo*~RCRR~RBkfBb1)-;J`)fjK%LQgUfj-6(iNb3|)(r4fB z-3-I@OH8NV#Rr1`+c=9-0s3A3&EDUg1gC3 zVVb)^B@WE;ePBj#Rg2m!twC+Fe#io0Tzv)b#xh64;e}usgfxu(SfDvcONCs$<@#J@ zQrOhaWLG+)32UCO&4%us+o5#=hq*l-RUMAc6kp~sY%|01#<|RDV=-c0(~U2iF;^~Z zEGyIGa;#2iBbNLww#a{)mO^_H26>4DzS zW3Ln9#3bY?&5y|}CNM1c33!u1X@E`O+UCM*7`0CQ9bK1=r%PTO%S(Xhn0jV&cY5!; zknWK#W@!pMK$6<7w)+&nQZwlnxpxV_loGvL47cDabBUjf{BtT=5h1f2O&`n<$C%+3 zm$_pHm|BCm`G@w&Db)?4fM_YHa%}k|QMMl^&R}^}qj!z-hSy7npCB+A1jrr|1}lLs zw#c+UwVNwxP{=c;rL2BGdx*7zEe1Bcd{@%1-n8y7D4tiWqfpUVh-lHmLXM^KZShOH z*xFp)8|Y+bM`|>mg}p~MOHeh4Ev0_oE?T1n|HMCuuhyf*JDmFP(@8+hi#f-8(!7>g zH}lOHg#Nw(x(LkB`Q;g)oVAM{fXLqlew~t2GU);6V}=6Hx<4O5T!!-c93s;NqxUDm zofsXe!Q%wAD~BBUQ3dIiCtR4WMh-t>ISH?ZMus*wja+&<^&&Gm-nBlDvNS4vFnsl^ ztNpIbyMcWMPfKMe=YnWeIVj|?e>nZbwm$=sV@Qj@A@PE#Gnjlk{CGPDsqFS_)9LEa zuKx7=Sa>|^MiSKB?)pG()OoM}_%lx|mMlX&!?+`^^4bT=yz=ZoxWH_ngA*jX*IZcHOjb62dT(qTvBPn`2AFuL0q` zG+T@693;<++Z2>R2bD`qi0y2-Zf>Ao)K0f&d2P zfP78gpA6dVzjNaH?(M_mDL)R0U=lEaBZvDI4%DXB?8uw7yMJ~gE#%4F`v`Nr+^}vY zNk!D`{o4;L#H`(&_&69MXgCe`BzoU+!tF?72v9Ywy}vJ>QpqhIh5d@V>0xHtnyvuH zkllrfsI^;%I{@6lUi{~rA_w0mAm940-d++CcVAe<%1_RMLrby@&kK~cJQDXKIiybT z-kqt-K3rNz|3HT@un%{nW0OI{_DTXa-Gt@ONBB`7yPzA#K+GBJn@t@$=}KtxV871R zdlK|BI%we#j)k%=s3KJX%`+e4L~_qWz2@P z#)_IbEn(N_Ea!@g!rjt?kw;wph2ziGM|CPAOSzd(_Cp~tpAPO_7R!r5msJ4J@6?@W zb7r0)y);{W17k3}ls4DaNKdRpv@#b#oh4zlV3U@E2TCET9y3LQs1&)-c6+olCeAYp zOdn^BGxjbJIUL0yuFK_Dqpq%@KGOvu(ZgtKw;O*bxSb1Yp#>D?c~ir9P;<3wS2!-P zMc%jlfyqGiZiTjBA(FcUQ9mq#D-cvB9?$ctRZ;8+0s}_I8~6!fM~(jD=psem4Ee>J zWw&CJ7z{P9{Q7Ubye9)gwd`}~OSe#Rf$+;U1GvliVlhuHCK9yJZ2>_y@94OzD`#Ze z9)jO->@7)Bx~CeDJqQK|0%Pfmg&-w7mHdq3hENhQ;IKK;+>|iFp;c?M^kE!kGY&!y zk0I0Fk*!r6F59pwb<6v2ioT*86d(Tee%E1tmlfVjA#rHqA%a~cH`ct#9wX$-o9erW zXJEEOOJ&dezJO$TrCEB2LVOPr4a1H9%k<&lGZo1LDHNDa_xlUqto!CGM^Y}cxJn@x ziOYwn=mHBj_FAw|vMAK^Oqb(dg4Q?7Umqwc#pL?^vpIVNpINMEiP4Ml+xGo3f$#n$ zSTA3aJ)pM~4OPF>OOXOH&EW^(@T%5hknDw^bLpH%?4DjNr1s9Q9(3+8zy87a{1<&7 zQ@0A|_nnege~*7+LF5%wzLWD`lXWotLU4Y&{0i|(kn5hdwj^9o@)((-j86#TKNN|Got?9j^EYE8XJ}!o>}=@hY~siOur_pZ`mJW+ zg}Q?7Q_~bhh6s%uqEU!cv`B=jEp1K|eld>}I`pHtYzif`aZCe88}u$J6??5!TjY7Z zi_PXV!PdeegMrv48ein(j_-BWXDa73W&U|uQY2%u#HZ5hI@4>q?YPsd?K$Vm;~XD| za8S@laz_>}&|R%BD&V-i4%Q6dPCyvF3vd@kU>rvB!x*5ubENu_D>JSGcAwBe1xXs> z#6>7f9RU7nBW^%VMe9x%V$+)28`I~HD=gM$1Sivq)mNV>xD~CileqbUCO{vWg4Rh# zor2~~5hCEN)_0u$!q<(|hY5H=>Bbu%&{4ZV_rD1<#JLjo7b^d16tZ8WIRSY-f>X{Z zrJFo^lCo+3AagC{EW4g= z#o?8?8vCfRVy)U15jF^~4Gl{&Ybt92qe)hZ^_X>`+9vgWKwyZiaxznCo|TfVh3jIi zcEf?H`U;iFaJh=3Gy2JXApN`o zE=O1Gg$YQt6|76IiMNF?q#SA1bPB@dw#H+-V@9gL>;1mg+Cb#k1ey8`dvR+(4ebj= zUV1Z)tKRo}YEh@TN=$v(;aR{{n8vk`w|nNuHuckt$h27 z8*aBefUxw1*r#xB#9egcpXEi_*UAJYXXk!L7j@ zEHre9TeA?cA^qC?JqR^Tr%MObx)3(nztwV-kCeU-pv~$-T<>1;$_fqD%D@B13@6nJvk$Tb z%oMcxY|wp&wv8pf7?>V>*_$XB&mflZG#J;cO4(H9<>)V(X0~FRrD50GSAr_n^}6UI=}MTD3{q9rAHBj;!)G9GGx;~wMc8S8e@_! z_A@g2tE?_kGw#r}Y07^+v*DjB7v08O#kihqtSjT)2uwHG1UbSIKEAO<7Nt3T;R`YCSSj z!e)qa4Y~g>{F>ed`oWGW>((#s$zQGbsS&sg}^pBd?yeAN05Roe8> zT5^XsnI??pY-edI9fQNz3&cr}&YORzr4;sw1u{|Ne1V}nxSb|%Xa_Xy5#TrcTBpS@ z368Ly!a8oDB$mv21-kqD9t&0#7+@mt50oW4*qGcwbx}EyQ=zv+>?xQUL*ja2`WGq` z)sWi!%{f{lG)P(lu6{68R~smEp!Jy9!#~65DQ1AHIc%r7doy*L!1L>x7gLJdR;hH_ zP$2dAdV+VY*^|&oN=|}3-FdyGooDOM-vAGCT@@JyuF4C(otz>?^9!lR%m-tde}ePe z)Jp)zydtP%C02mCPddGz5R9NYvrS6)Bv$~r@W&cP5lLp7-4NrEQDN3%6AmXH@Tdfj zZ+k^}6%>L=d8BK-pxgvV`ix>w6F;U0C zlZ#lnOYYDhj4r)_+s){%-OP5Z{)Xy~)T{p`w1d-Z`uhiyaHX5R=prRWzg^tr8b$NI z3YKgTUvnV)o{xug^1=F=B;=5i^p6ZQ3ES<#>@?2!i0763S{RDit@XiOrjHyVHS*O` z`z@(K2K8gwhd0$u@upveU3ryuDP~by=Xy(MYd_#3r)*XC z^9+R*>njXE-TIP1lci2Q!U>qTn(dh*x7Zxv8r{aX7H$;tD?d1a-PrZ_=K*c8e050Z zQPw-n`us6g%-5T&A%0G0Pakpyp2}L*esj#H#HB!%;_(n z?@GhGHsn-TmjhdE&(mGUnQ3irA0sJtKpZ!N{aFsHtyTb#dkl=dRF+oo-dwy<#wYi=wik;LC6p#Fm zMTEA@?rBOmn>eCuHR%C{!jx>b|+<6B-)Z%(=lG{@y_@8s2x4Hym6ckPdCB$7NZFp_|El()ANXTORs zO@b$@1`3tXjEm>;bX)%xTUC>T)r6eTFtq*Rp*_?%C+fEzT##kVNH` zV}-lw6&hY;cyl5#RR-w!&K4e)Nf4noLFyjiAbKvP7Y!=2lRiRjc$&d?P~!zM@4!?3-vyqs zhm*63jiRI7cfruv!o=zO%H2cQ#o64%*4YAJ=xp~No53pO?eEA$`fR4x=^|*#{u3bx z1YB3OT97ZU3=ol)l`K!lB?~Dj(p_i0)NN=fdgz(QBu>8xV*FGZUb7m4NEbrA+BJ1O z%CPI+T>JPq9zpg~<>QR+je>?{g)rSuWpyCDcc2@rE8T>oNWPiP*u zLZc3LaQVEsC6emsi7DCL0;U0BP!SwAkXuetI25TYuCwD8~Z|M@2_ z0FaBG|x zW)FZvkPsN^5(Q}whYFk-E8)zC(+hZMRe5VA6GZM!beBdDBqq#Rye$I~h@Kf8ae!Ay z*>8BsT)dYB${E3A^j5m_ks3*1_a^uA+^E{Gxcgw2`f7jw8=^DG391okclzQA zwB6_C;;k_7OnwT<<5RjXf#XxTO9}jrCP+Ina|?UA%gFvNJy7HFEx9r{(c&yDZ9e2aovtJL$um8u>s&1k@G6# z-s55RDvTcFYZji6x+UMyCu{&*d4N<{6;H^PEF!?X@SqMfGFR}LYImL1;U}{iT!qnA zgqLCyvSp>>nS}|sv56Dnwxdo&HrZG1WQL_EkC!D6j)JW4Tv1yyqe&aM- zHXlKm;srQVctoDYl&e}E-P8h#PCQNW{Dg*Te>(zP#h*8faKJ!x-}2Rd)+>ssE`OS? zH{q>EEfl3rrD`3e_VOu!qFXm7TC9*Ni&^{$S76?jtB;*1+&lyEq_j{|Nhg&s;W6R9 zB#r9L#a7UU(Vnq#7asUx%ZyVz{CiVL5!CBl-7p|Kl&=g>)8e?z&u?Q^r>L@P zcB6n=#5Wz+@-j`qSB=wD1p_n<(NhAp8wa!IxDP?M&_ zKNcJonwpOS>a3-OBC9jGV@*WND}F8~E_QS7+H3ZK6w&kq>B}kc123ypkAfx`&en&T z+?U=!q?N5DDkt(2$KU;t^dR}IVC|M)pn@S)m{saxD4V?TZZWh@hK|C|n(P&eXLAq1 zZ#v0gPhHJYiyjEkJT~&%u@zLE`Lm!p!&-VAfk?eF{HN%PeV5S87-u3n;g}^R(OZqI zA|##x9SAAKAb!FSr9+E^(}_HX+lb+XLQiWF2UmH*7tM?y7R{u3(Vr<5h8V>Y-c`SgYgD9RvV*ZP{xBLuk-5sAcGP5G zDdk)Ua8PaYS-R*C(V(}4>%>{X%~yk{l3&El7iOz}m0Y8MAl_Qc`-2(z2T3kJ4L1Ek zW&^0C5lA$XL5oFZ0#iRevGn2ZyiotWRIag?#IT-E$gv92YXfp3P1BJxO zShcix4$;b#UM2o=3x#3;cA8Q#>eO8bAQ6o|-tw;9#7`gGIFVll^%!T5&!M|F|99EZ z?=t(Tag~g}`Wep_VX!|sgf_=8n|trl((YTM-kWDQ1U@WIg!~YjGqsZNOrayhav_lrw< zgSle+;b;p^Ff)tDt~?&TweI#6(}<3?Uw1@|4MvG2w}sQgX*N;Q=eD+(bJ%jKJ9L2o z3%MlC9=i-DKzXOun`;&7ZI$Iw?Y|j!RhIn*O`mRl2_vUnE*Rf6$?{IC&#;ZS4_)ww zZ${m6i^cVHNiw5#0MSjEF!NaQfSr&DbTX&tHM{Ke)6Pt9^4_Jf%G&51@IH0aA7QRc zPHND$ytZTZ7-07AEv8Rn%5+<=Bx1tWJSG_?CqXuJ99Zwp=hP2?0a{F)A8HLWkv z)nWbhcgRVdtQ4DpZiw6*)QeCWDXGN6@7m@}SN?Ai*4{l!jL`wrp_lL`bJF6HVAOnj zNa*fTj+{niV5~*O zN5NwHHcEed1knV2GNSZ~H6A+13`U_yY?Dlr@mtyq*Eutin@fLqITcw+{ zgfCsGo5WmpCuv^;uTtgub$oSUezlUgy1KkqBTfdC=XJ}^QYY+iHNnhYEU)j7Oq^M^ zVSeY5OiE#eElD6|4Haq&dOHw4)&QX=k_Ut{?Uvr21pd&diJ zB2+roNX!_7mJ$9n7GNdG8v{=K#ifQnT&%`l82sR{h&TKf?oxK%8RlG}Ia$WP=oQ3C z8x#$S3Rrheyw7recyTpSGf`^->QMX@9dPE# z?9u`K#Vk!hl`$zv<^Wl(#=J4ewGvm4>kxbr*k(>JDRyr_k#52zWRbBBxSsQfy=+DkvQ40v`jh_1C>g+G@4HuqNae&XeekQeAwk+&jN88l@etjc2U0(3m{pQ8vycb^=k>?R~DSv8<0tRfmLp27RlxR~V8j?ClC z)_B-Ne*s0#m}G~_QwykU<`~vMvpTlr7=W&w=#4eEKq!$muL_QJblmEh6*MUg!$z4fC{DBd*3h=N|lf1X7dTfqL1v6~_al z%J+WD;fSJ>TKV*mid$G+8eIjdfK%pu!#kkan;Qi>LK<0bn$?ecFn-b|@+^+OT=0nl zZzN%OUn9w14s`D45>E^)F8?Z?;l!%DF^oL|Yt!@m^V@3twFD@^D5$*5^c%)sM*sbi zk(RQq-d<^O7T8RfFwEK9_us2+S$&W1-Z3OR+XF6$eJl7IgHM~N8sHzWeuzxpB% zE9h3~^*;?_y)7i>a4#z6(ZQ%RaIo)|BtphTOyY@sM+vd#MYN11?ZV(xUvXb&MFg6g z=p`JrH(5;XsW4xVbiJ?|`nutpC1h*K1p~zS%9GcwUz0UWv0GXKX{69Mbhpcsxie0^ zGqgqzpqFAefIt5 zbjNv;*RSO}%{l!Z)c-Qw`A_=i-}4-?=swGSMI^E7)y37u+#O1^yiI2ehK4F|VMVkK z!hIFgJ+Ixg^6jI3#G8UbMwE1a!y~wFx@T(|6G*f($Q=e5na9eDt?f6v;SI;w0g-j% z!J#+aN|M&6l+$5a()!Cs22!+qIEIPkl)zxaaqx#rxQ_>N-kau^^0U$_bj`Aj28>km zI4^hUZb4$c;z)GTY)9y!5eJ{HNqSO{kJDcTYt-+y5;5RiVE9 z-rfg@X78JdxPkxzqWM?WOW8U(8(Lfc7xz`AqOH6jg!Y-7TpXRJ!mtM~T)9C^L}gSL z;YSLGDG_JZayritQkYm6_9cy96BXEf5-2!+OGf|OA7sdZg?o)Z<$B#|?fq|82c!WU zA|T92NDMBJCWHwuFa{aCfTqmu)kwClHDDbMnUQhx07}$x&ef5J(Vmp?fxerb?&J3W zEcoupee$`(0-Aipdr2XA7n`Vp9X;@`bGTh>URo?1%p&sSNNw!h%G)TZ^kT8~og*H% z!X8H2flq&|Mvn=U>8LSX_1WeQi24JnteP@|j;(g*B2HR-L-*$Ubi+J1heSK4&4lJ| zV!1rQLp=f2`FKko6Wb9aaD_i=<=1h?02JU2)?Ey_SS%6EQ>I20QL=(nW-P4=5mvTJ z&kgssLD)l`rHDCI`%vQMOV-yUxHQyhojHdYC*$H1=nrJKqFo93>xvB=M`$}Roksx# zRgV+d8#sk=v+tN#P-n?dx%RC(iv;9-YS-7PrZu#xJ5%k4i*8joRv1J`M_tOQR`{eV zE~<8%VC63sx|_U&{Bpy&?!~^Ce+CNv^T)?diyKrA zu^d&el}PFVWKFz9wkriy~eruRakPmmS0ZsKRiEMGj!_V`HL0FT$ zQU#r2x}sc&kxyY}K}1C{S`{Vdq_TYD4*4zgkU_ShWmQwGl2*ks*=_2Y*s%9QE)5EL zjq8+CA~jxHywIXd=tyIho1XBio%O)2-sMmqnmR&ZQWWD*!GB&UKv6%Ta=zRBv&eyf z{;f~`|5~B_&z17;pNS$3XoIA~G@mWw1YgrTRH95$f&qLKq5wY@A`UX)0I9GbBoHcu zF+!}=i8N>_J}axHrlmb)A1>vwib%T;N(z z!qkz-mizPTt^2F1``LZ#Is;SC`!6@p@t72+xBF5s!+V#&XJ54bJ|~2p(;ngG3+4NA zG?$Orjti%b`%<{?^7HlMZ3wR29z7?;KBDbAvK`kgqx4(N-xp5MuWJ1**FC|9j~trE zo`+jX&aFP*4hP;(>mA>X7yZujK`$QP9w?a`f9cQJaAA2cdE{Tm@v?W3gT&w=XzhbY zCDpADyRHQ?5fOuf*DrAnVn6BjADR2&!sV&wX1+TC*Qk}9xt8KA7}6LBN-_;c;r`H= zwL1uGsU0;W?OEez?W5HYvu>6SR+O8l#ZM+X@T3>y9G^L76W?!YFcytB^-`NyTDB=; zw421!sr`Wwopu>VDWNN>IN&RxE08d0JJZigpK%)p|Ep&aHWO`AFP)}VkqQg1S#TY> z(W)bm7duX(Nvry|l%sGs+Eudz3=_A0i@M47VtBp1RTz_zxlmqgi53tT!_i)(bad*R zt<1n~oT!|>QLmYf?YL$n8QEJ2A6liMI!hRY#mB@?9sWAUW8! z3#M&1`ZQmRP*o`jtHjbA78}!&iq6v&rlp|5&!}O}NT>|10NoWbiq5@7lhquTSHBCO z2a!-M+(e10feoq(nVw~!ZC;y+4M=F0%n)oHB7{BRYdVpeTN zryeS3Ecv^OC_2HcYbRWnOSY2McCa2PfRXH~!iu|fA^#y<&eJkS1^d|DM3)QKAnMe1 zp%9s~@jq$zOV8LQ$SoOZGMPYE@s<@m$#S(N##mh{yFb!URLo?VmR4c2D<_vio;v$u zEJivu^J$RML#dZFhO#!?D8s-JTIP{sV5EqzlSRH3SEW;p+f8?qW%}bdYNyDgxQcQg z)s4r6KHcPGxO_ErHr?P}mfM;FZE)8_I3? zDjMJvQui}|DLHJ=GXcz4%f~W;nZtC{WKitP66ONo4K<7TO!t?TYs_icsROOjf=!bP z#iDYw8Xa2L$P!_IMS+YdG$s?Gh(pybF}++ekEr=v(g97IC8z28gdGEK?6QPNA@g_H znGEeNG!5O#5gfi{IY+V>Q!Z=}bTeH|H2IGYcgh~!jjG`b~gGo!$<2(Kis_p5;(P-s_l8JWL!*jOOFW7(UIXj)5^C~7r z>g7M$hT|sIVBpur@M~;gi~j(BNMp8UkYv?y&{`-sK=@)-@S(2kqobO@Wt_pSnMh|eW*8azy%8exS@DAQxn9~G zE=4(L_gg-jHh5LtdXPgG=|7Xcq4E&x?X2G2ma(6{%4i1k?yUE4(M*Qk6_ z1vv$_*9q$Ow(QAvO;Y5T^gBQ8XX5ULw$iW6S>Q`+1H*Qj+COZ<4PxD-Fwh71j0cBx zz1pnDR}STs5k`ekB^)M`Iu39H@BwM@^8_X7VVp@epjNMqRjF($LBH!#dnEe)By}7T z7*XbIUY>#irgB@|lb)RRvHN^cPT%6slXqX1FW;4YMtNurd;?3g>rm zCSyAc0+aO+x0NojMi`4bp59%=g=zuk4R4o~hTUxxaj-YA z@UtFr6OY{A=_+?qZnrqBO49}q~-hZ!+0QZzD)8F6c7AMQ8Edl-y|d#R;NOh4ukOeId((#ChBKo`M=8Z@5!BZsX7A3n)%+;0Dy*bI-#fNe6_VV1{v%_*=I&54mqAWAg z3XmVyRkbAG&>7rIx23lx*caz7vL$Tha&FcrqTEUNZXhFsibRbc*L@H$q*&{Bx?^60 zRY;2!ODe~pKwKFrQ{(`51;0#9$tKAkXx7c-OI>j-bmJb*`eqq_;q-_i>B=}Mn^h`z za=K-$4B2-GE(-X{u|gHZ+)8*(@CW35iUra3LHje(qEJao_&fXoo%kNF}#{ zYeCndcH;)cUYsmcLrAwQySyF2t+dUrBDL;uWF|wuX8S|lr+Kg8>%G?Kuzxf;L!gZoxAqhd;`!i$5wZfphJ-c zd|uR@Q=cF4N1HXz1y}KjQJ8{7#aqNM_|j!oz6@&wEfq)8)wG4ngiGocMk=1Ft54#R zLyJe(u>P{fm>k_wUn20W9BZ#%fN9ZePCU*5DGK$uQ{GP3{oE1Qd^}1uSrdHw<-AM% znk>YZOU^R94BahzlbdB994?8{%lZ*NSZ4J+IKP3;K9;B))u#S>TRHMqa-y}{@z#V5wvOmV6zw~pafq=5ncOsU z`b-zkO|3C@lwd3SiQZeinzVP4uu+V>2-LKKA)WQXBXPb#G9E8UQ%5@sBgZtYwKzkq zNI6FloMR!lx7fV|WjJ*b`&y_UK9mPl*` z;XO8P%7{H*K=GrNF#+K3At?5`_oXT|Vz!Rh_05t2S&yd`A2 zjcyVJB|#czi?o<&biP<}0alxnpPLzJ9d#_R9(c$2IPXg7=4mL{7WoN>JTCCZ%zV{) zm691r%m?d5yR3l=Qxn7|f0?e7@ zk^9ia@dNTbyi6%GO;kec5sHCjtyr*i1QSY;G}gTsivUQRTG(i)y`O_~K{I*S+x=>M z;}<><>$k8!-=R}>b#)kmSE&~qf+xi@lJazu^F@~pV>MQ3ISq0)qH;F^;_yT@vc-Pr z390Cb$Zq{edB^7W@Mz_+gQ$>@*@>hJIjn4*`B@N%Lt_t1J1wT!aN`jpEBE5;Z|_X| zT^67k%@CVrtYeC}n;uLV%ZSClL-hu4Q5t8ke5a8BZ`=p#4yh?Xa^Q~OrJm_6aD?yj z!Od*^0L5!;q95XIh28eUbyJRpma5tq`0ds9GcX^qcBuCk#1-M-PcC@xgaV`dTbrNS$rEmz&;`STTF>1pK8< z7ykUcQ^6tZ?Yk3DVGovmRU?@pWL#e2L7cLSeBrZc$+IyWiBmoex!W#F#PlFAMT00niUZfkGz z0o{&eGEc{wC^aE3-eC$<2|Ini!y;&5zPE>9MO-I7kOD#cLp<3a%Juu2?88km=iL=? zg)Nm=ku7YEsu57C#BvklPYQ>o_{4C>a9C*0Px#k2ZkQ)j3FI#lIW3mT#f*2!gL4$_ zZDI76!tIw5o=j7Opkr~D0loH62&g?CHDg;Lp^HZ;W7)N+=s>^NuhmsYC?}lxS;sOE z69`R?BLA*%2m_L7BSZ^X5BKaWF-Y?b-HqGLcTd9NU7vY8k|j{O`cOrwxB2WW@tmhU zt`FA4?YCJwFISu42CLh~%e8Qg093rgqDa!ASGd!qoQ1e+yhXD=@Q7u0*^ddk+;D{) zKG0?!-U>8p8=*&(bw!x;E{EjWUUQyY3zVB2V}@t$lg*Bn3FId6V_Ez&aJ%8kzKZg$ zVwL+>zsp;_`X|m4RRvc|Wtejy* z?bG~}+B%y$b6zBRba$P?mX#UbwE{i{@jbuL@tZ6Rn;SCu#2M*$dpQIn$Hqv`MgjBn zURSnq5+1ReLXsI#*A8G1&h5`YFo^I17Y=&&1eQDtwY8HI3#DdGWslPJSP1` z1D()O()qzD6U~BYRUPw6gfc4Wx!am$yM#i~5MCmF8=7(q7;n3?L@7uuvn$;8B8wk8 z3>T-EJ5X9Z3@yH;L=9QFtWmzdE_;Kw^v+te+u`pF zN4&*o>iRKeC&l_{U^a`eymoog3(GY&2h;5vMyRyld37+7bW+&7tvIfrL9TpA@{Z

dy!05UMhSKsK zV1FiJ5SlAhkpcl_H0wRzql?0Qp5wz72o2cMC@utM(|&o0ZO_JpXr+N7l~F?Ef_02md^m|Ly|(EN; z%;)3t6SWt{5hgzszZWS1v^AU?`~Rctor7%qx@EySW!tuG+qP}nwr$(CZQHi1PTA*F z*Vo_ezW4q*-hHnl_8%)^$Bx*s=9+Vi%$1qr5fK%c+Hm4kiE$B;kgV)wam25w$Y7#k5$> zyB^6k3i~L_6~PX554`c3Lxx;&_sT;I^U92G@fS6#(Xv!B%;H3+{e)1R6lyU)8AK1_ z?@>F5H=sXG=ep;kDRZO_ofS}`Jus*Qp3`_V4v~&b-RQ=t8AN5H5{@!_Il~0 zZd!-aH=h)(7CJ&tL%%{P{6d_g=5tsj%S3Z!QxjrLdjoKmNP-zSjdJ!?qL(UMq38ps zjKSz5gzwhDFA;5md5yYb>QN)U_@8Xpjl4yw5065)+#MSGp;yQ*{%mt>12;$~R{eVV>o|juO{Z^ z^o^m@DOBrE2mm1nLgBfA(Wi=X9R%(1UYZcZJ!3;*bR^smI~6lyn`O4BOwo-STsQcyodVA~leg9`{=l(qDl@DCM>s+w`%S_q*PIjYP ziuHHuj0VVW1%+TH*lx9#-$^q&l)G_ojju-w{# zVs{oOc>_fcS51xY+19tN`;V~R0wVyuxdkS|t zC}~Gtu-UyA{H5~6*ocUWM)RfQ076mL1r zFVWV%zx!_*zk`5&dFbdq4nbWxIwAu=`+$V-`m<*-Z*mE2X|>OCAJVV;wlq0E$hVe@&x7V(!xg1*;%`} zxxBu5;jmZEH*e!Rj=Mz|udBR8BR6LiGoLWb<1=<14it;Fuk$6=7YCR&;F+%r`{S6M zP92W>ECy`pZR$Q<6n8Zw1|uh*M=zK=QP0b38_aX#$gB^y>EahIiUzy^MP1ct%UhZX z>FFLVJ=H`FRSq!<_DtWyjLZ6t^Nf|?<69Aj$U0*lrAJG0{t;t8Y^SKLacoR%3EXw+ zDi5T^PkjmJp7@B|$lkEwHHaQ7BGc$})@qNRqk4JH!(bgPM!{Mb&Kz|UGk?QskODW5-NCJ3`Fbks<}%TsOB+e{Hn1i7BP z(XsKkfl`r0N)u1VqaPYGlDxR3>%y{&vYaQCnX8AAv8h8>a^4<#jAhtfa;TdoFlN=?Ac{@Cdxj{YI z!kxobbr?~GU8JKwH2Ywa(#i=Rzof$nu?4-zlN#QJflTO^QkyarxNI<~MY1}jy~Jz` zBRwV&0+G01D9biQ4PR*1NiSqTXZB~NdI6yVEU|AiWJYA>k9G=*`R^VFjr{jhqZ$&G za0#huq)Mhb&8oR!jrv%;xRe@b&PWBXh7ATurhUY7yobngzP;($8b5g z9U{5JMt%fMp(N6ZVGsYa2p(#ry;Y&;GG(DG((_GrS%r&waWuX94*RX8>&x|Lzv8WCaXaWo(3FK=U@G#S$8kCX_R6q|VO;WbeXk~x zmq?NS+S2WfO|{j{dKy5``SRA!r+%)`DCW{s?8uZJW{-4%x}KJzAtiyY6b#)!fe0kA z)=W5C>X6ZLRFH_-$)Z(B8Hr}FD#FLGum2gRluDsrJHf$do$r!ORQqrI6~=-H0vPiG zC2V88MIp?Xhc&UnIS(c)naRXTu-r!%x0J;3uWjp5K%!b_v$;;T0*{_2txs!*+BgP} z%eY2;N7AFz(g@fFy&(hWk`R9#fRZ&X598A7xjHyoDJ4!3CK{Grr4>0bTBw3ps{tN7KqVY^)~B5St2NQS9wH_Lc=s8$1H5J?52_$nh z+rnm{F~bVIsiCZ^Gy&eV*X9JTJZB^`|6F$9|Fq@ekZKP~h_BWGsow^hUpo~MCTrdk^1B;= zNXiYAZnUPm>}{vX*&Yb&{0FNvW!V)h-<{na1yT-|kAkG7xU7QA-NAc|e4Nf2`OWnV zxbr6@^wO^6xW+Xdu=Z{sdK+Qw3Dii+X&Y(VdCv>CFEIOt?MCM?9@CDUKm7+N>%!q z$WI;(L@2YJ&Qfwr7k@<77r}%_q3O8c#><<+(JFdeT2?e+nsP4h+`n(HuX8^8qLN88 zv^9`|ICnNwS^PYDf7ebCGG~QNosD6-%$5;6Yx$`PGlZVnxs6ntftJW^L?iy3KIBDW&1q;{OspV)`a4w`+K45XmW5g6HLPL(lu zM^>HAPux}=ZJ?|;f=zDh!2|)WLyu7pHcc)9vAr(R_-sI`3GRfExjVpYMgql~xox)Q z)W3=WFT93oMdC)bluYO{cphI8Hjl&)W$TKN(PAk2r&mB9-)@%@xbewYx!c z{}phewJ939{qT;q&KR_!>>XnVYPC^kRaX%+G_v;*kg4g0jdi&G2G5$4#bk+*0mK8` zie_>y1oDA_0hGE(n`I(s0k(P&;*KDaX278vofbbNMZ-&1MCmPD*6d6oN$VjMzpTd@C8e zg81s83_+Y#T;duYQ%tXE$RWVk=@P5Z1VY<1C?mU)7?G9IHYx#rHCx1Mhb!ajXBoJ-rANULXqSAu0Mn9s%@_;uy-AOG|5#jDZ3j5dR7|< zR_{f>x5E@uRa$=rDD-yel$t(bf5=#v9ZWObAu%fou?4KkV-kvjmRiGX7iDe(Q)_^=>m}`2$#Xi#5CpJTi#5EF1T1mmPB}c@A6ou~a`>sHSeM4gF(ksh|DObX#Ao1r$Jp3I3 z-#zhd+d&)DO54E0K@@kKgxRB5%x&3BZ$OrawIi6~b_kN~$5G(kH6b5BD&%g70UWu6 z-ub`EccvhA2YleM%U@;V)N{Ixrkd0bjN}m=kn%!g%wE&P@WcBs>5NJ~t}y$Ar7F1n_=iC*<|&`C=qG#+ z0|)?s_kRK(@&?Z40!~gQHirKa2ua%+8CVNj{J7LD3|*Wp?EV9bZ1_j%PH`5U;9>aTZzwPD=a zXur{4zSk&)HrOFOmSK8ZKMHdg*HQk|a($OZ(0puje1K8EZNjPavWjhh64i-B(p7Zf z2g`IQ_W)I`lGa!LCabrDUSVPmGZbVX*#xhnAH|koEn~hs`=w;zVM^IEU${9oXf4C9 zk#|zrR`2_TI+u08MszOoi%H;viD}|x@Ax-{F_aW3ZIQHw-pT;hgNi%weuhcB7xt*kubK4fep+r)eaJIl%p9|sqv{M(E4lgwXe=HL2nYvO$$HX>QpPxqUn}WG zs*l{rztHOO@k5#cP%_alezmlZW9HCcT_;auQpbtV(Kh6e(9wF`C;OM(L&uqUaFglN zk@mRfKGV716J9j|zU-6W(m9pmEF&sbiZMv*M3~8lC~<@%sH8mKCL5zS4h--)TNbi$ zGT~m~}sa$tL(& zG_GBAe(+OZUY}-iY-rcb4f^fNZt_IXS52F^MC6>C?-IuOUttpxwVQBy0~D@|I1g*pQ^8D9@mu?5(kge3_GjbOm2G+7-z zkx`X#L5jF0+(b=RSgOE*XGFk$mF562Yft^UFH0micC5KNH~tfuDq*ce5Q~fKPyieC z9su^F5Df-F2X&FrZ1?<8uQ5h`uh~m z=&m+g_sL;h^%^JcRk%COiklbyo`Co8z9C%hj$&e+^pKMm>7Jt({+@)$DJbC`QjMHZ zi%3X-hLW4Gca)8|Pf3A1t4Ud8Gcj`ZNDE=lz<+3#C9z0jMR_q934+6jFXzJ$uCq~+ za-#O3p1hSU;tiKizC8=Mh@y(Ne3L{f0B?%ewopC*gCiXqueXVpGg9HaGK>hK#}F8++%^d7M6b=5@V(e#PAgrUnD^4)b1JPZ-PGNWqckW?kadj9w8b7f zp6l)!4JIwHtcBOekEW-B`yJ(E6n$+g06FFIjgZzz&+`UpKdgY-=lxNe1BI|=Cg;T; z?FYQs{*)^&tV>xbx0m~jf7l5>`+q#>!*0u^UJNZmE(3w>j|yNHB$#6zkjE;_0pL0S ze2gb)=zGHVUt5ge;3k7XmZcc5;mh=#z-ZobkM!xX0De$bw@9s|&m~zN9 z!K5tX5=4qA2sK|$bdVMz5etUdXN!`}2PL8R7qLr)Si} z!IONdCg$e~UlJ3u{n50K+;kj7SP&tC(^xDUbl{fdvL#ilA93{7Vm|&0)1p+nx=!XmT2qv6B?FjPHZV*SamC-ro9lXMAbWtsPx?Xq1Kcc_^$@r-YuI4|#Q?})HOyhMfBUVTIsc4Su?*`>kGqVs(0tbI_r0@mbv4tR&NZCQd@%?W!R_Br)qtk^~)!$ zd{bZ$2k_tV&)c$dz%vTer6*=naysJcAnpE2vboBzhwzL3ZZg^xE_1)_2eUw2B&FcL zW(!+zg@=0oy{=sCi##j;)Rn!Ty7I5A;QytP@}FjBaRXc9p9bUK6(&VZ!%ayA`L8Y0 zHgiu1Y%~0(WC8`wPF)OYDg?-xhpK#kN37I*3t$V> zeFT`E`_n>;_dQuVYN1PBmZ_}9TfEcl#^=`Abh1!Ek&ykSp^2 zUtg|J2l-(Fu4-@Z^fZW1~i@QYwP9Q9$d-lN6U6i%K#778wN;pE7`?CIfN* z4j%4F^H^LF6Q70%gi@GEB7#Kar{F)1=Hjc!yt?q2&-sWb^&Mo@Ali3 zYsI8ugwjs$rA3@sca{d2=a5mZ6PM=U7R~l1{udpZzpk<&^i)W$IV*$FUzyJ>#@G4l zunDZP3O}4G8=e2)DEXo;q|ooRSY*pQ@?dPnSA%LBmzMuh zj6iCX{hWsksbMQPykb&WEA^2^)4$ly11z>xG12rAj}?8Ft!(tswaOoNlpt=|kqrTJ z&?vxxBG>4bNn(%_w*|gVh^|*LD_=TzvKLX^EG3#)_JHhIOGSwPo4|0o#`B(-!+g_f zebxHKe=60kQz4i3=g8Q=o!~GyJjpp(m|JFSl$~J?ocx92m&&RUW=F?w)i?X8sjbbg z0+7xvpM&&Mvk2s6TEQh%-l$+wW+-wwx(yPsAW>CS<4@5r)9$_e^l&p0?yxh8t`Ni| zvkg20%R$9KD0hWHDff&(!UL3EXA@7RAORZg2_v!tmF`q!lSi%o$>srm>6H|S)B^2X ztV|vT66Q&WzEYv3LCrtL@fFVn_1u!3AIwvi9c5g^-LY)$kEOwFcdT%;T!@=Lh3b{K zJ5DKC5TfipAQ;Xelrj5>A z=_T7N`9+b0vmdY_zM3SwtpmRY?wNX&N^VG?5}z__+A;qz)l|ZX+QaujvNXdiXZ(V? z{OmPo1P@Yd;$G3ic^NHAm|1j%cIXFahDM~236V%gF?}nu9!H?ApHB?XA?IZs*m$xN z6e^ufgCQ0+_=81#=-f_IGbvy4Xizg)_Q^<)baO)G5(DO zgxn}JpKET9(UqMupTD8jB3cp z4G`IGH%ByG7iZ-QD?Esze`e049rA`qU8-l!$qPyeHl#z_q%CNdv(L)XI;?Ng4p}qk zjkLr}p4PA1I;7{Kc1WJp_Y!Q55JqK#sB5nY)=dehb&d)~g=roafxSw>Sbm)`xVXcf zG#`10jAW<8I#Nd!Q<)M`*0YE;dZ$(eKex&V5$dNnGAi-clRskp_SX#aKy?8;Y^RA; z@xEcdlr!iVGK@89*}AMBb@T}NL#V3*a00ErFr0GKMbDa2oQ-DkTV{N0Y_X9!nY1oWN1B)$PK)1Hfas5LPvtlH8ZL@g6sQ;=~> z=vTK;Y5TAt=ya36;hG?pES_n__RRVv!qlpCcy$N%vN$cm%p@=41Lzl*;2C>KsLXaT zT7L{$DZI@k7u*!SE|y2=Df|?99>gyrLB^ur~Y)vi9TpSJl6Z57d+o)lQAdh`R5kMGB7)eE`*Q;2G zQEcRN!Q?$b+o zUoag8iRTMmKuJ)5s&zS~S*B1~zU7tUT|q&h!EInBeZf#vwR|05>zpU0zRe0VWg5C; z+*3eGa6)oAS)jk-xN&bD5&{yx=Oh{=T<=akX4F4Yue*V0VM zkH4;7TLKmx%@)s6c5z_Q&5qaRX;$2vIP-ud)H84PAd0uJX*ee_AkeYKVtI6CW@W(9 z8KHRBux28|zpfOJu7mRVm*s z%?_&|3rLG%MZsk-XuimeAl!(zkxHX`$uQhJ=7%bztEXtmw!ImA{G>b$_T&F%g zFsQ^s?i59_UX8n_!c>ZltM6ABcMHOtRyrRBB3#Yo+AYyiYjPIXgd#0RF$%&xX*?+- zsPtBuy)cPjVkYkf31o50Tp3zUe-dekc|5FYz`%%l5L^>Pje2fT{!AGEHxWG_Yi|{!_@x>cc6%5SD z$ZvA==C5j@X;L3MCV!XA?SG9M0(T#83W28(9aS(t{d&siNAR`PZa(ke>q+Bbo82ut zvU5xmnR~F1ffCpw7|Fg1Gx@$)QGYDzf$|nfH3sKP3=Huhz#4)dH-ay~7cR-ML4hxY zJC3AyNh<#3hBqDyFFY{D#*eE*cnh{slzoT{|2On)ATR!sO#t-^ABA9?$(s~V<1UDq zyo>|Hc*Nrxk#`IYFkXaDTnoHWAP3E#`a^&-`SJ1RcPRHkeTbBZ&q3G_0==kIKNsi8 zPK+SND@w;5@(Jm9!|;LDkth-G0@RZYW&YJ3k={qg)_?xtrkih&RnY!V zo$Y^|7$WW_MlSzvW>1PbggdqghA-L1jCJc$kjxUIfuHEPj zLAS_=)=>DNjluF!EIspf<>8IN^gzw?ak~<)+k{ykeXo%GE=68f$Z;ZaxUAiN%zGF_5d-JZ0I9JZ*6=&gi*5l3i_WA7VrU|K{v|a zF=S?&Yw?$7*XrNDug-5bH}qO#ji37gcoNsG74BAO>OHL zJ+$W5wVs^^UjrNk2QiwyJ(aXP&FiHZNvXoDgPCs;lE0r3q^E zb1QZFSr@``4tbojlnOSCOUjP5QW*?2!?w1>p3YwB&Mp*GO3M*qgz>{jv{ak$b7(E?tkY*+R+^&>> z2dO%o%W=L!QGyw(WuAnw#oO{!I(8KwC|wq_y)<9lMxDiZwL#OlUU_DnD8&!tX&a7f zewQGgB8{dwkjR8EC%AP&bY^iirN#jA47*}#6?~g6@a?%^7(){yv(mgF=P`2yXr$Ab zuYEY=Rw^DeYTFZ^Ywa=6!`PU?q?O*FI=gFl`bbPev2k8T+=C;_X>sLJQt7BpOATpg zrpfyxa?;Uc`KUT2B@@q5dI0rCDDr{Q8d~En$h%e_rtAvjTEMd-OH%Qc7)o~}(R!O` z(i0MG6N^6LsC174qc^gK-0ayYDy1n5!q9mg_|@<( zH^wGhrdBV;Qzf}LA3=l3S|l{2(ylqgc3&K7pj~tzGSA`-wO86b&05pv_SO)Zw_hfmjx}wah`^|Qo(J(X2h!rc zPxx05-j4zshLMr@l7%0`IwPtjmgCwA{Sxj^m0H$vopZOcn-(l18gE{v?!K>bbY!=G2sL;OsI!wlS zl`om0y?Z#6@8vtXFRh`e5wNSy>T)H41%)Nt*jt9t?c#B>nBknI{Kbhq*5+Q8Lxe_H!J*!N? zH;Gr-bx%ExZEmt^9#)xcGN#!|?Xz6|l^~v7U7wM4&5cAIxbMj53pOBXW2LxqE#=+s zUC(EG;8)Odp&Rd)Qg_wrCnDExg_o7dmilm!?}lv0f5NK>w#Db7WRQa5Z94pw011GV zyHnjESKowJ&H%GT#al{iWgq|S`7S)99~4MXM?gl`=`rD9WWj$*)*NbWq$x&Jdq^ z(Q<+*Sx9NqE8$^Fqc(bfoIHwRM8##C@jW61>q;vG-*gk8G>_$;P+4b&%lQGl^XQpt z@48~+y!wp4mqN@Q?HOZ!Yr_;kT-E1R!Dz4OldNG)t;&2^&}q?~dMa&r60E7E)}#>< zrV*SWbim~#un~*J_!+nsWF_-x*9gTk>Hl>g2f7!ZQCMExX9omA0+-Fd%?Ek`^u5Av zTse2a$3`W_+4p=xIbdWKo>d*OlH=zIocE<>kNpS;Lx`OQ&-Q1P$CASxn1-0~RGYd=l#b>XT!xg+7u%F$Q7jSakj)eTa>Ty2qji4Eb4HFzvHy#qP|SXp zeb#Lbt?Nt*I~QuZr{s3Gk%GGcNPV5a16K0EjBCtb^pLdk4E5uLHP+1tY@v3z5hntx9$Vv0Tj2xkovNOuQz_TE%+7VTio)we=x|p6Zw6woNPx zcG_Z2O%BbGxfe9ld2ol=fLGR4aFV*%y*3D#mSjOJI|7z5B4+&ACSoxT&RK_fuBkxk z1Z{D-MxPSpq+f$DN!oyle^-|TkMi;fqFJ1UGd5NFA{AM^B_NurnPV??jj4yDq`QF! zXQ%rlV=SedtGKM5GccN+LZ_zY*nRh^QhVnOGA2jgF~DjqY%>eUXu}5pt)p9N9V|0Q zXC@$-8kj_9y)dSR&f2Q-S$t*V60-4m5IfeHAp)(*?%V*RU3YRI+fVm;XbrN;Znfre zHV>~Kt<08qOPU*d|3s=CmW8uaSX^bMnclwZa0*-JYD_xdlH-9QSVqCTFRD6%n}VS4 zy>uY+r9H8?BwSa;PMf%#`x7lDq2Ra&?)MJ=q&X-Vdw3kLg=AF;bh`Ngu`{SU0AP{2FA1bXzI)&Qc+N zQe2V^EkBDVUja~}gLyF(bfSN%OWm}6u4HUH3r`v7TIiEzS4!DYc1O$+O(bDf_b(zmfoP2*iYBPA-5lKMee z{!TLNugW*re`hye;8u`de34Z~ks!!LT7(P~?WfwY)j%M(rRlsVfY75wv`_j8-f<~Zh@@_No5u3lgB08$gw3J7t6YYm|-P>#mI z?Ihgih8w9<&jhN0?+L@xpaZf^v}|(+(B!Te$gx^{k_-y^@xZ8pvz4Teo8$&XcRy}gCz)E#b#7b-MxVm-OaCXYoKRhcAIJfQDELSMoUPZ2A zGJT9WYcGs3O6S~oE52|3o?hBGjTo}Z^#p~Y8HA5Pg?)uzq1dK9(?}wqZwRa130=%H zYf~z=E0yYqfTG0fyWBEMhY>h2^w4T@H3nLOIgGoExay2GP9=7H+(sF!>QtGs1-g&W z_gbac+_K^zlCn7G0blgrvHCKoOxX2B-RbMlZrJ;wg{CYdkQ}uH=vCz{^XL9b5MT@I1LRLBCN2G_*J_s4ZGh zWx7MbR#kfA8X5^2SsOa1ssX$FKr+_smpYMtr_8IC^|BTXp$X~a|@aOR`r7XM(DK=Ni-`62A>;$AvH z9_f{d2&YCRYk$@WOzak*c~OoAFfe6f@DJQ(UOb0(1s-V6+8}t zM%Y6TDbM(n0`0~e(Z=fVgsQi^OTtAv{cQHYLACfn!I5^C`4kt?8a_m$6 zbcTozSL$v*0uQgb2#l)xk-#q3kt{M?g;oWD0s&KKtKIf|mIluc_x>!Nn=F(UZhmoC@MLVWfWf8%A{!LJ-a9ibm(5(&roPX(GX)q zd@M1x1j~Z)riLkJ6l^njEwFgGs7mySZY8C9vkvltS$4KH+PxmEb7GD8$Z)quJ$36>!5YC6H4?tWLx3jX zL_~2klDHUK>j@1}T+ZgC#@^9#==euU-lRuP-UC^5Cc+L8jCGOV7-{#UL(6{hSs1p> z-8|04uLdI$1?;BBEEg_BTk#KN4^e`X!u!4==E(^tnRt1KV|!i-9k}i*QR9@it-?e5<6jq(E{}G5amY*n+H0gn_Y9 z-8;^pTZ~?CK_9>Yi%5S(q=#!=vps#u3bpC*N25|FGH$TQ9Pd_4r2%$YW!S{i=_C!G zD_fX}hHLaDE%xg_fp|i?KbzndD++)5bCZZKr8}JL`2AxVDM>tTh|-T>%j~EB_}}&( z|K(H^a5QtVF|l}x|sSOHm@dqAK_|9T*4ARfIiVq!E1 z{?^1IHFL*xX$M4a3Mm5YU!EpeD1oBkARcKhJu}}&7N2i-A0U4zc4~oNFEZ@*1*d{J z{!TQ-;$6U&WxGgOjF^lV^S+fK(41yMfFZe${01$COSKm>OdY0Ko`nRwC?nIcv5sS48^fobUN+7gD3h<@?TK=U zsq2}1JqYJDkDjs^)6H3!Y^(ni&NTu{w6vfAOZuc(I-NvUIA5QH9(Sk7D2hx zNiT)h!1lkZYyV}v{?Q|*B<@K93LuZprFU9Oj(?x*`7jTy!&B9yOv zBC(n=8x!WoL6TsFoU<~Hlq~@JoFJC(_I;+4<3?2gkpWZU!T~EWMF7v*q|26`QcQ^K zyY7tY=WEzh-Beb}LTZdzTqsr?>f%%?W^OSKq2qcG1lkqAukEF_zkk$u>XCWe4? z#Ea%vy>ICg-GEoSljel7W)-xQqU;Q+>#pyscZDYnsvo{+1MT9<8T4`~uVdxf?M~|B zynet59NiL z!rIjSxz;b%7{vy1l_G16WSgRE^<nid77&vHB`Hc!j_1F`ZD`0gi18)_8?o51 zU@6a|ci)iO?`1pg1#z@MGaRt#+VAApkLK*L@84Osn8n1p&wayu_RhR=UwwK_{XRd- z@_u3Wn-N%#fS{lWoezfKS`U=q7T4pO{SIjeFQMNZYxLGubs&kZYA-$P^!^hNiAC_F z(&Wq`HKids+xS2b*p4AAYkL|*f4oYA(x!rpT&_C7K;2ZG?{}K&D<-FkT@)`3VJ0Xb zH#wfssnie>s1svHRy7r9dzwfw#yY({tYB*1nNx)vazVXK$6z6(v#cyYmxjT(-pz)Q zmT^!`Ze~41QiQ(6|xf}+@C5ZNKgKywZ9F6&s&=xLzP2GjAv3Y0oF|N9sQ z)#f|e$7y6jIc&Qc}%ut}8+Yq?|zk-iAB&`7zddtXt^a zODQ(DgQqHOTe)pS1jRV(Z4SSYxFFm9bj`YffOXR_nrFrf=Pmfr^F8?NXDAH)RY_IJ zia@*!T}8>IHGTVN@d71~NRP5^{UuSEQBA;iP@E>vHBrii=Mt#3LM<}6v(uCW8I>pj z)iuPfGO41XkYTVm86?P+ZI7a!bu#F#q8E#ld66=_3qe5(7rwYzkyP1Cj<^O27m+O1 zqSOMa#3!)|Oi}&%<#TTC!j#90$`EUJWnuAw(DgEXbdGZ}D3-~lWKfV3CT06jARCpc zgW3?!cGxC<4bPFx>G2K|pQw6%H=mDNJ9f0i7Z9 zM9Op2T#uZC_CRl%l}%9a`x8xq0TEG6nyJmw%8@N+>W!pE-tgq@Th2AO(m( z5h}V(JEs-EqPp`)cKevppHePn%`Qoa-TTm}v83nfYu{=X)eka!5~;S>wiZ9KJjMq6 z>Fgx8lpK|M8rEmK1%a_jTLUsb8vpPoSY+$7N+_;3vCrkzy8E~s*E6qfhheM@ zrP!Wm9FgoRV70zMFupOPdouaMx%rka;9iusBffkukbq&Oa!Av$T*C5wgjUDJqJ6aB z(?h;NzQ4!^wA4Jl_hYZYcSg~3H}db;N0wk864a3n*J6lB-nb)I+5y2n+93^b!`=_} zy?b!&O*YX7-^{Ztu`4-1**M4EM4h_wU2-D?C}Aqy5ML7Yl@D#`Ppq--or&5LPqq_} zTx|N&G1%{D- z63FD%(!Xv4BFxTlU%s)bFl{J%a)l zqbCh9*g7WHB#?5O@r&ddY*myj&i_IQQSRbI!%jx#TIh8Iq)wt}a5M>>xO${;MLFTF zQ_O(@DdX&)d|+07Gko>hSrJy|%;=1|&mC?0hPHtn%4a35agZa4ED#_egj-4`fBqo0R#9mQ#BIn&i-6N6{L`Zvuc zhVM*t=AS0*G3(^>#-9WE*H7jAAN6DZVp#r5)s#1Ibo$Ty%9LoC$U%Pi5WROaGDy=C zPt+z^E_YxBba`ZMfei{n!7?uADyKFLcYluL^~1#!m1QqvZ}0E6J}Q3>QHVrfykO_w zv$|82jDqR3+Dr8`t0^fspZL6W?}Nb;in4>0ln_bv#S{!mP!7LHENN-l=~@%6ujbu+43{~BuZ zw^SLl6$KJ<_cuxbNb7Q!O0hDnWC6M4;8A_GNy9bkmdF>;M}Dt+#2h+{u6VQ^>0eSK z?k25<;(Ths!zu0AKiM3QGv1%~7fk+3?IroYB0MoYk(mh#@FSK8vIjI`ov_bH&I$oz zrLZYtsUQX0EBOWR#C}5l3RW{%Bo}~%2(30eRFFehtEwIkdu=PDTFFsev{oQPGaF9N zLO7CGqMw|o4 zXEdacLL>~Z9Q8;+O$?#CmfUc5aG9?YnHuPISSR3nZ8JM_D8dyb$SQv2-HWX?N}@nm z^pSjPE?!b&xN4pT6Iqj~IYUn!w~x*r*YJ!DJC8qDd%4PPqge{1d$*@GPtr)Wz z>kkUX_B@U^7XN4)%$HV&YAuDsY&6oUGVU~47&0HNr6)8$M29v4AHrT6Y7amNwe@2$ zMSs9J#(B)Opvkmq-rs#zH^A-}z<5I6p~|}zU3FOP#3gE}fPLjmm(O>k5}KVb$R=n4 zvES$OqRV_LtbbnFs2e-~T>F$+Tee&KFz1vD>C`sQ)TI=mBR(H3_R%|oh4VtiF3Lw_ z7tdE0!H=H2f)&ytAwMlWbDnuG(ULf9m*DTI1h-oaT(SX8kWAje29U8iM_5m`S?wCh z|2)fTcQ|>_y8p(TEt&BeR`_UPS^SO_Aw+z!Pzmz)2I2q4*o0Z?4L!A|{tFwR-u=j9 zsk_AMkBW&!9LF;X`vOexf?OkPMS?qF1or}T8%dvO4jne0W%dkm317^C;}z8p2F%50 zC&$arDGBdTWteETu7-Ej;`Eo6}jy1~TUaAs~m zhhS2-ZEu)clw!Zg9(sfvs-2Us;-4ssADLua7E|t`zlU(bj*`I2HTml-oa)BD4e;6x z#Il6qrF;-Y&tW8D@woFayo)8iO4hl9<<`}vd|k|mufrz)`$@MDyYyXLUZ9H^p@Jxe zn3mtSIH_Iw3x1|2Uhj^WaR8u^ISw=>@4vIf@UM=kjX!9O{)a6V`2W#l{>NGNfA8Xd zH=IuY-n}iVHvby@n;Z4Nh6Epb#M;g4i74tF_sb-Rd>-;(kwu z!RK#BjQOW9?`I~}#+8PwCNmj9+V$-8Ece{>&Gqh|xAzMwe+X%;d4~ahM4=pFn5%J& z@T0^41a(ePmuQCKNZXc45sKg7Sq99%CmTnsy4$U_RC+C;tYjWEXHr!g4%MNwS8o=t zU5BBC4m*jkf0GUk%P;RA01A1p(jYj9Vw|c~O0{}Vr%@Vn#JfdxEAB5UcKs;NtiXs5`3}FZBK{*S)g3 z$55~%jX_?tZ2!@XL*pbtJ0W!BhNlhcAlYmd__dLYu$LT3VyZdB7?{G*%+mk){+zJ4 zs;d!SlV0vINdFQ8yIDmbS|~){ZQ+Xl-0nVjY{WBZH5Ok(qD#50@k&HaWJ=SGQjG>sw?0g%xYX zo)I%5ZHB10EwcdHota@yKcn98pHZ*azYhpLLnCWD!~gxero1VS zp@{gsIoVg3UI+zeB3s%p_gfSf;DeNK@ONMnGm*)fS&4SKAx4v=6GM980?4Bv)-VW8 z#%=F+UKG0m8qZe7ZTAh#?Cr)Tq8}KQ_&S>Q)0X>H>+#1=Ija73_V>pJg^y?j*~!oY z-dh3EgHGCh#cwnQaC#T22>X=76ohcssCz$4SzkX0OcV~A(0xas~l-q|+(dlYU+po{VjMHA~h+?A9sV>Gg8pemGtgwQ5AD<1!^m1fsM?$4U=Pdx_dA z1Vdd^{^<QaRq{WW`$q8N+3kYCzjK`3k>V=-aI z24Nj-l1^-9@jCMfs_jjagNd?f30jHf$A9_`|w#Lm3Kw0)GM{<}zxR z>)9>F0>Hl3fVi{#9s@Nu0wh9jAuXw^`{pc}oS@tT^KC?^x}q(lC%Kz#g8xDh&VExs zNwY#ntAS8{_V% z>+5d(Cat43U!n=EJ35}M^%!aT7r^byL#@M=>I%4i#Ns}GAERjzpA-XOl0L$U&V?$O zU5Et*b(n1e(Qj=l+Kt#miKG*{HUE^I6ZIRiZkqVvq{2)w$2r|dfN{q6-d5PiP=H>y zFfj3n#fJ%9Wti#CMh3gPv`;=Zu!_H}OdwcEN1rtFVw`_} z_Z7iZ!2v$7Z1VH$Qo_SQ#Tns=?5 z`x!jNy9?0?NhcNi)A88qo3M6Dd#sE$?1>im5Hw1V3NN-b%$fzwzRli)mN1NdKEb(pdIM^yv_VSLm-8J|0?3wwKx390yng>H+3*|GL-*W zhqW^PVcIsjKMvvlr>9Td{6EOHk^L&Om4yV2S>uv;W9x#II$Ugm-=BcL6@dv|(oORY zX7m_FEQ`+Ch_@gwICp#EKsW=&-ti&EPRU}DiodxpG8l}z?0>$@*Qfn^lwUA4vHp>T zn8Xuty_)qK^|cm#L>NdIiWn4-tCFP#ErT)SiO;BWj^5g|5=@2g>;78mCz@MVas?|7 zTw9y_YH6PE62ZarIw}?Se;E~U6>#}oDb;e5%H*HjJ*!+#%z=w@6J{Q%VSe+1aY$-A zYiu2F<=VJ^sE|Gv9({JrR4pe`8$PwHv2b13V1af%!1$s2UkY;kRS;<6g!xUC8O*#Q-fj;-J7t=$q+gn)jXnj( z1wxL)j~-PE{e9s9bfni~T8*~RgP&P!!_c?gcR8}vTUg>9en5>d&RK=wqPzDm#gp4$ zj01f?E#o{t{#5aQ|3r&h{ZwH5!#4lnpFjQM4u=2m&Px?_6-;NO@5vh4aaz$4;+Vfo zXzFr0t(35F%ut&_KV4xqqT+;eWs@}=fuc#Njz-9FE@W#<@0CnSrHbWCOXB6BNkoY5 zx5$>A@1ET6XYn+j+&CX^rNsROBZnuWN+;2(HE>lR0 zdt+vO8Q`bJK=B4C;yF_|RX7V=U2w9SiCA@8{v$N4F98y0ULq4>-vfwx=hNc^ke)jP z=JtUX3@51;5GL@pCPIo6e?R{P_1Z&Yh~!3;`{l=LI!TdT+GBjnhRsd0E4$?t(cF!z z4~#=v5NNe=^9uQHzBg*}*h}OJs4&Oz+O9l{@=ma&6>15fDnS3Lu zhNjlUH_tu4aG8~G#M(x%^W-&-9c^k#MVC8F+(@<=A-S%`Ub$W?Fc$Kt5+9$Idch*` z8DPZGrrDga&I@4J#R*`!JUMdw*O>xdJluM;2O(QyC6bm(|7=LXtOMpeK2{Oc%&@VGgIM}n=xPTsHZu*o|%=ydsHI*DGc2AD4b$rWMYr_F+cj(?lYu$Y(d0;`Gym zsVB+o4{0WaVAxWNLo&g-2maMO*qGgJH^Fz&7= z2fEolQG2QIcl}C3QYX&n7uJjBQw?>=S+N}$3TvDBB4GzLg zRLYKx^=)OTX4DgErJ$67t1~NTT)b{xDBJpm-PJp6oYIFy>k5yf4es3Dl0RBGlcl=6 zkeqZGj7n2lOVEiD7>~>izlNL*I0?~Dk3B&I=?k3@VF&JxNNflsY7~FfIS1h??ud;d z(DEysJz}!|k{hFP%wR_V1vv6eo}VD6bZprUiHm6Oc!Z({ZoD1T7?|r-)XyP$bG-Kk zs+K#Tcp+0iFn)Ojr~N=xynz_nO>QaMQGRLk!77)=oI))vu#!h&Wy>uG*Xlp#{1EDy z%3$r6jdxpHLNJIgSmO)!3NMHED&BdX_<))Ch(?8pE>b8Lyn%w;OM+3lR+y?QTQooRsb|E)Y+ibYPpR&p z6s+)b!X(VTwzS7+!HF5!N~m_e9HxfjR~m1(1NVhmD`i`y54ph*TuOHuB+7D#w|bn^rs6qM}j4>u88m-909 z8Qn378h$ehryt=81-d2(punML3ZG(*KwecJa-AGkfNPyvMS%^{9mNgCm4!IL&HC@J z^l77MMF&_St=`G-5)v585Jn?7Ln~EA!8Fe_82Ch>P0PpQ+VT)sB9MB@HR@Z3(I;CA zJo(00bBCDqE0P=Q-p@S%iEzyp(jhvEEnkvBeitFmh~)w7kJK)2IQLuSThcG;t;19m zA}y3r+ik(BUg}RFoeS0@+Aw!O=T#}{7vd=KmTSobahGQvS@-iPF`2(zEWZ|rcL;+h z*A_P95X#6hgKb=iO8R&>Lx(@?U7Hnbcz{}VWQ+Y_<#T}WigYMJ>43m!22#ZMp5gld zvjS`{o;AuM{G5Q_d%Q8HaIyEgX^dy2Nw)g^$op4#@1uRb@iKc^`0oDIN}!Mz`O)-4 zeusYO!vEkuT+-Cu{)g`VLl%DQ1^)|Es7&0Jo|i!!?smr5TtY%458>ez*n}wn6hK@k z`Jf#NB}A3*Xpcyjt>2`!1o+JMh!McM?KR%_f7^?f=04Td*%F0@2j|n!kd%~Ws5j%c1tuc1<14SI~GT{=5FRz6U0JD0S?LmuiOd&*a4Hl2GA3j*mk~0 zHG{zh;!{+DZUTEyhhE~-I~nx~s|gCSu*A?HC1m3($CYe+6H9wDyGls11or9(nytJ| zd*-n%2D@K`5fS*rJ)?+*sq?mMo6t0*6fGywY7RRNIp4Ub#|f4Kahsq^&@5tt_sEw0 z6$tBs!r=*u#H5mic33oSM;v_oggvkemK}+&k^{?7?z2fqgf*5IzCiS_fY*Gr3UPfh4gBdXY(XjrTV_9xzp6snGzFWJz6*U5Ae z>b#^$8`}Oa>Yx%)Z5Ua^{d@1j`9<3&2(qX3VKiS|pK-r78?u0jI73d-73h_vE*v9^nb#_S=Y|+zY*z1#s8FFs5YJ2SHfgyTzIL#sp<+tP{L67dQd6i78rY* zPo1dBFRd8bfj;rLUm!egc@bm@LV0>{3_0s5RelFi_9kbtHD7z!KV_t9cYA;Qp^bbc zltWd_-A&ujR6b=W(!+E`0+JwY$>sB{$|=DQjq@`FVnLG&nzyoVm#wvk&sDJ%kUz$< zsz`N9uTKBzKyxY92j4VNeFI0ST2*<$kTnW%H&05Zz(!w3IP3>SMCedaI4A zV!|4#j{auL*KY|)(UQMQZG@D-G_i}_&nIGbPs1fosoM8gw&|v0gvu#GWiJny6dkAA z-tutWs3nWft)s%3*w5>H2Uz2q{mj;TB{`%`((Z0bgJ@|&bigU0=wieD!l+jHeA2opi z+<@NBOcX&dBF*y`WU)wDjBvt|L{|-1lJPd|sI&$C8(Rp_U|c3sZXHuWY9QX6;iwQ@ zLl)3S<^&wxggq*BjIn5v)~&}bg&vOc?VbThy}Qj`JF9KRFi;(X#(;=Vy)XB6dBV3J zDevR#SQo(;_9_)=xm+BwUe=4x19DusZ;98PG=+T`ysxWBjg|D)oYj_G%rpHZl7LV) zX$v2yquc{&c9dXA4Uk6IXmP8L=$*(MyP&AihZ^D6zu3_R{e=R?eo&(G zgA&1i|9A5rl>F<&q)_1>d>FMGiksGIAa&&UH3jzB36t8@&K8KuOPGl~Sdzxq8MLok zG>?S8p?u(Vy!;k|@2}?>b17=?6)Ue>Yv6hw&-f2<^6QYo2k0O#M4vuP>vh?m3~FAs zWF|jlFeAtn3PM((0JAqP$ndl)Z#OhZ5y~7=^E}9~1p_iy!7Z70a`oMBSE#o}pjLJh zVTz*5IIgH$C%LtC9E*RfOV079G@4(p_z1lzvA&$?%4XRKRqv;AP-^Pnu?;u+((h8i zL2LgIFjx6Cw&tN3x_U7nKUtE$c!a$9$#6D#qZGn;&uoa&U&%^Lp(&%yiJeB8xx|}Y z`tgF8XP6d)@q^wa%SeIAAnL0Rk7uuKv@%S~4y(V+fD5CQP@ZZivy)%ess1v}K?`t@ zQuF)fi}JY6u72#6vftxICFm+nwzg$GCg1zMT?(U0_l)Pc5!=B4LxEJS4ns<{gO;!< zXgw`8Hc(F_hbG98bMbG9=a+QL9r8@r^6nI{s-;H15v2MGagO#T9zUH9Ae$D7YdLjA z+b+6rUT1u5x61&npD`pu?-5155E}FMJ^B~@Z|iSJ|IA;1n~6ymKz||ax)GgDo`@H! z=P1HkG53^qWlx#xF?6NhQERNoVoC3Pkt;yj{nM9isXV40D1&?jp+)C!d0N7Z~W~jmsBwN~D`fatRBJZO#*%k>!yjFS^0uKVbnUJd2Ryq$#3wPIxJfZVqJ{k&L&9 zXGCBQb4AEn#6de{voh66ZgSnUtK&f&3VPU`{pLb@%fxrO3nm!q)B}6PdXBGvSNwRb znYu@N!ldSa(*GSjg59@YnmN^50&QLU~Q;g};bg&FW1uN-D6+(tiSj13|*jaU7szS?JO%dg{la; zsYTbJ>S51)l`=Ja293O0qU*grE{>~Vl~KEju8(CD)=RK6c8wXv=Ry{0eQY>gXHbMs zf(9?Q^CXoZo16h3k5t4ol0WgU@(59J#$rXL#!T$oiR2;)m5l~P=ou9rBG zKW3L*?Z8_lpgc$u*MB}N{M3p2H4S>dtnu8Y?ig969?)uZXiMBkgy{rwyvHX{IwQ*1 zAaq*bEdCiNur{67aksM~O|G6rDQ9Zva~!a|*~U!cX7%1NuGu&KR{sIq?_r_$D%$FK zxv_K6f~%Io%g_V7`)TPMKhqWVq~k!XKec!HEiArL`92$v=|=Fy{>{a`u^4b%_X}@F zaX=)3VSRhobHA_OLU51xa|m;}5)1(E>KAu5Af;kUL_1Q|j#ePnvNgw%f9VT`kTto~ zH}bUvD8g--TZr)D%6`~)z-4bH@U}GFb+C$o1;du}!_&pT=wTNZRcmcOcPPeBVAB6U zApYkL{b%<4&!DbQ;Zh1g7M80S$3itpF5HI{9ABip!2*Jmd?dIe6pq(l?`GSuohd_}1NBcI-LaLWPNMI*u862C=;tK_$ z(n&p`Ly#LKfE1kWXOo8=oF9Zma{O61Y#!*hdweURwIrF`@}}l=L)N;UYbO*a0={5B zQUPPZEY(0o5Osk`nMW4tB5m+6q$f&l_QhIa+@Wd8uwM`_ByCMc5C*DD%?Pb~C@-qq zcUh(7rHYZwlq0;NNurHgAibV_8IBFj&GvdPGrx4aFyXuJ79qf40_xr5Z*&bu?vUHi zrL{iT&VA80Zh;VY{H%tC6_8BZ({o_1Zv)FXq{4b}9w7xB9s!AIEI+J~1?*I0z!gqC z3xG=tIMJp6tvi@N)02M3zh-%m@oA)pc$rU1H2dNhDf8U~Nl`etmlVKWe5;&7d?}X) z#txXgpFv;o;ZgP|?+G}GT#aCqPZCeLfh~{RR&(0C1`nBj>JD@+Yd*Zipb_W7Gf&dR z5V2ZWykWs2WOT2WZg=R5kzfX%oX!y=y@3yCsa3&v#Q~(KRS0=IQG@~}1gL_Hi9MPT zOb$ZvS{D{a8pi$b?0yjmst@Cz0w#;kwov4k0bZp8{{js0aEg`EA7HHgs5Ad#3jY5h z$|y+wcqmZ4jM^{z+5*F5kf?I-8xU8MX!ONG3S{RC{6wKbw}R+RQPww&oWsAMXvhap zt+d>3e}@taRsYzaJdD+4Db3PcR$O_GT)VSUS82Aly#Lhr7-D^DHL6>UFAa!(Z`tDH2S}%#z)&5j#_v zI%kw=H*yBO2=zB(wjZ=7X^wI{0z0=}w?GQ@HU*|v+fE|{v@1JogpFc!`~(7k&3Q|dsgmZW#r!!e8PcYLjUy34;4uRDf z9#U%h>|eU(4V1H2NwYq^1oLj0j2<77JiF#IyodH-sB`399Jg_m`T>J$i9NBqF_T2| zyC&(TTyrJmb{i;KT(J-dQ+S^>oT@Y3lhjgdc2vlbcOEcq*0q?A*6wQ_9vQ>{0LuDb zZRZ6M1wCSOOxa5#T1c;C9jdqIy%R@%1LB=aqoVR=;61$~LOOqq4|2q|NfP$om`cza zxN$MGnK9`qf0*4Mo_0+=CIO(it+Jy|&3OL}#D@u}0H~9Qi!g9G0v+R!Lxh||kCi%P z(<{KR{57SQLKrXLIm6Z6l& zc$4!0Kzl;r(d}r&AQ6n@8xKsH{QdVC#Q%mnNLtVTh4tKLwY8B;`=gfQktp{QX3*lp z`jUi_(Lx+oeZBQoN2=!c z*Zn<;PjN}Bi2kG?u(|4nb8Qp|G&Vaa0zF69U4C+aLaW{18t48hLP};2qUR{TriE(( z_nufef{Tz|-WBOp)YCQ zAo-a9Tr1n4nZc&V?(4X#(kb*jw}?4Yd6IXU`Uo~-tv&3WlZt7X=AE&j>pXna8_WF7 zu%l%hY6M+wzY%r-KGIFb{7Rh~U65B(_(#e9GL)8hnJqlywnCmU+XCwELaE~6}7dR^0< zmG6o(Pe~FJK>Sp-LmmQ_Y{Ny|<%<-BV3k!?K4k7SP4Ui}8v#G&m)pT5%^uHxV*AOf5Z3mFX_%v@} zNJoU0h@y`^L0CQPfmGf{+kDXi6rb#B zHBK+?u?~L}H9l@Q&SWpRuHhg?M142jRAWZ!52aHNiFbvJ8aIyf!pst`fjGf5-6-f= zwb!bz9W=``d@FkoH4BPMZw#@XZv2wK9l1@uAviWs!4QCw$(cAyCaF|bC^_yq$P%7Z zu{nCX$L?(D3Z0;9JzjM5)QOA}SWlpp#I+9B9jRNo7%=6RC*+7oc@0!e*%D|r3Xd&G zl(~xANHEg(s8pe8%^PLPo!Pq5z$A2(dTpf|bb^>)2{CN|a^v@|NwKqqt4y zZJw|xD>_7omTcgs+u=xRHk>B!XurguZl!#dFd1?Y8D;e#LZ6?H0EVS0ayB!QtN-g$ zcH%6hKcDnOkn3A`eE6n7uz(m=Q__Lq7zgQdsbNhgsPy3#m~(CooW9}SsSp8C3pFuJO|^k466PtsDJwZU4jVD^=Zf6c$sz zJx3=tMkj&d{`&C7jN}vI;f;uc?!x`X7yFG4w_mUx-5YG#Gg~Rqd!M6RXb^Pvi z%t2y}>Hezt%l@$N_n%u|v#*jgp3)OuAYCVJJ)n-Lh+21Y{5( z{EQ?{{yV5!#4u$K;;=zlSwb&nd8J2pr6J!ak^wTk~#7Pug_Ji~W zzIeweDy5|82Dy0Q5*14Ejdd$Dj$?r03lnnPl=5km%95RA6a~DGO6YZEuqdOgUaFQO zu4U~)q1@XvD5O}+Z-ug-R`dp$p%jSwk9xHvD07!%0Tc#7cqp%hs;f4&p-QVcZpkl( z`ElaX+Gb+m8b%|Bzs)6CF9b07oG6b5{^&0|4*JL1*mI&oIx`Bew_lWCMGHW+^3k^T zMzNXq(UD+64Ee8TSm5)lC^r`p9Ug|pAbz()b%^tO2IYYLF!PBtzZWsd% zvISKmColu+(}g)1pXXz_g*7c$hjGX{Ga7|Zq2>!uK?&*K9$hJ&Et&?ekLm>0lfgUI z4MCYovgLTSV>!|vG=YIL0FMldJtyfX3?Oyt8JihgBD<$+&SSv@nW0}+4f^>V=?Jex zISZFs+aFnEzB3pEbC_uWhcEv`H8VLSZ#J!#o;EbI?WSGIwwI5GE;R)DF@be11NTRj zkL(pD$XEpP#a>4CVoAC8AxU(M|H*%J8Pc*TD%d;?W4CO2VlbT3e26X=rIpJMW)||t zBtD;=S4a_foJ;IY*+jQH0n*l_#f+dqI!IR5z`tP>Si>@8Uo<S{B0)7%2v-7I!k$kBpHTmCx3?f$ z-V45|wQlS}4y_x{$ax0I*8%XXm3rf9hzemc%s^*5MWkUflo)UxE7I_{PCY`gk8D7? zq}n;5q%8X6nvMkAp|ztEy>0Vq?p3_-m<;NH90_JLIdb`iwJGs})O^2~OaVug9$s;( z1TZ#2rV}R?B2&11e18F2sxI5*ZBPkV_iN@8bnk)$Oa^XTk>TskAA@lF)Y$Wlk=8bD z^~8Br&7r7Oww1+Qove3QT|**)gcG2hqNcwNmx zdKav4mfpGzC$czs#!CmON)5DFpNkY2Zp|nDF;s7?)6KX+izo--brmr3100TkLCV3NKFgNP zzRDHL-TM{8UGWvFl$e9gDvqs1tm7e8r(%k}m`Y@=_?SSB!g#1F`AJPqV30|!=_t#h z(Fz>96BCh@xDW?bmtWDKMo`x_sQAIHQw8-0=%M6^dS$u~RhUPwsr4pG9c@snMx#!v zz4g;^nRb;#+41L~7pu1BqmOog{Kai+aTtfhd#kjHA~ZLN2kB_bi;KzHjR#|?NgMbq zDtE4{hNCD4;Yl8%E#gLcPNNlK;#P_4h`pCd8+gw2kPiuIy;x?#P+wJDc1lF@JeRB@ z$Q|W*vmy&|?Fno9LHPW%3srylO;$JUqKUMV+^Jr}>;^sS*5lp}0mQKrIH+7jfcj1_ zg+s$)`O(~+Z5M1?oCRX%$?t%xb;lIl73z~;%t!lwX8%D0z6e`q4aN9(@%@&dO|W@V z;++@g`9#rU`e;?9(L$G*XN(8Bx}*DJ_pXYD$X;RIbq8Rr%D=?B$lobn(>RSrmZ>`M z-l<&a!zIsh8VZC13ys|@+*k?NH}m`AtVbM^IEkd?ryM$Cw+$2q#>N(Yi)YDlurNR8 z>WtKfeX;c>G{i;QZ0iQAs5v{=VT)>lsdThblcv*gG3QgFQq=PcL_cL3UQ$N(Nxf4R z4mK|YaaoT7B+@rRIk94fCa+#z8pbv>GA{?k6IfD9Qd$Y`8?O7`P8u?l8Bd@O1+~5F zk3b}KkS^EVpdSt0anCSL5RrJwt8hsKk+@l)dZiqBrNB~tHz-%_@?V2tbD~Rua0hn; zWoW$_b;r;ONq=)Qf5hY79~#b-t;BQ{x$wsnqi}_51Z!v z?L4$6bsRH{)NG@|>9RUTPPU;ONhxDMcV4ew6>^FOq?dPAiRxB-ce;+K97R*jDvO87 z%8ORzfSUXc=Fjj9(@u|Z<>=g^{8`_qMa2JjSc)TIdA9;7Ovs|WIF^2?5?@bHmEE9n z?$-A4c@Mu-|KO#O;O7Z`a9q zxJ`0HDXm>7us3bPC>`CLNegu8cx_I)SX5V?5VP5TcLnIIvESG{2TtKQ!ND(1UekCl zc7Z~|Rf=E8iPbjA*?%a-$`REL@!^e6s)e9S6@+6`78Q&|uy3@IdM-hfL5b}12!>@7 zfi4+{dXzwG`c-9RA($`Q=dT2GyitLcY8XS@vZwkO3Ci+XqErPHx&*hRQ>k!PAe-D( zKu_wUU(Mob>8;nnjzNB<#*tzzfAQ<1dwkKY{0Grhe`2(zv-PHPL9cVv!zUYJW6qGB=2E|tUuu!j*P^h z6A5wz`(>$mvRL93>J%R=#xIxH;;J2358v*)8^Nzz=BoGRGwaZ{3P8dA#muN~;kYDc z>n7*>Wq6krKp{owp7p!m9-g#sJ3KjP8~sZMC@ntYOMBxNs?=;(gUT<86<6XlZGIJq zmjh$mh%uR~bHRQ7BgV^SsjIB;v!HL`s&hF=eEGq3m?O6obVrt*UTHzU@Z4X z-?+ybh4+k#yoVF~sH@?!)5R-q4Q|Rswd5kTiVN*bX#f!fWUUvZ%G_8Wh_-8~Krz1T{UZn5L6|icUfS5@Q;jk& zVuJ-%WbUU5U_BeB_uF?JDo7x^y#3+W2V|U%!@mnHH_HruYy(upytxuSII3PphBQALx?9`yvjWq z!{rDyhWNr%9n&I}DeE;wT&`j5^IrP1xa2A;y)KY>>7rzO`p2Zq`2~9mCr27&C9Y}$ zfx-Fm65aMd-EO3PxIP63dL05*oaG(80iFDGhV@zm4jY1XbsMVt3-+Lk$CYS|8+hS& z8-%Yo2Jc~sPn4sx_K6vo)bL^3@`#>GdT8enLM_X2n`ng{EjEy6QHHDJ@!K4W-u}5j z;R82L;^tjjS9s~0wa*aDf%rR1PNM34(^t5xCC6U85Qv z#9;JkXR1$G`yyCjQMyIG)@UwUJ-!4f);oc9t_(w1yln2mwLz7>DA6+c{VHy#uD;PW zN?W=wE0W_bC`8(N-?(lFJxtjI;7k!>)4VR^AiV>FUDtB2%X2l;BD&j^t*Qr5y0^;) zw?b0Lo~#FTBRnG3aNY;OfGPz$bxA(;DSs7~`8HJMf(s=V$pp@Z>o_eid+dOnJS&Ua za40~9C)`k?Zi>!KS8xnaf9n^g-+oHVESv4eYS(du>_~|A515P|J4yDM=;2 zM0UyQN$}xOR(jHhN`2J1+j$tsogdDId=a1G34kCCB(G4k&=$@;>O>I|B>>^{_48Sc zF7goM;qdlV<~?UOte=}I&Ji_tE;=J>U=Zsh&qu-Rdjs0a+UHRgr^ak6plCe6KMeF@ zJU>)>K~p3`ao6e%LWVNsOi6dIjRmGE6I-(kifp$A3{Sw{=m9-@#~)7C{Vyvh&i?kDsRp06ZX^m-c+W=jeJ^p~r` z&+tq(N2?f3FuG>)h|bl(t=@I?$kxS)Nd|=ilsIL(qm|b|;aqq@BJM+w07*Q$e{p1b zO-~@UruWqZ<2gtf-?x_M^b)WpXI+Vm9hQZ_$sO<6#&`h%{5IL4!UqK9F4uw1q`lGK z{0=2%_apif(a-9CV}ppmK!6k0&h0_%`)R_3$Lf)y<^B~YGbDr6N0;I?p&eL8ihQ+5`uJtvS zwQtSfbOCxj}B3QIBrNu;DxC)>e6{U)~!hCzoqNp zny3{~n|&&G;_;E;K01dODI8 zgce24dlcM~M_7Q@}Ut2iC8q15dzD=iGf1Qb}_RWK_mU~xGb!Gi?!VX_-6|Lq=cFf7%4eVe=NU9K=Wtel9tQbDhyk7@)G zaj0%HnuKM}X@kYq@wq8P8UR1P)|Y09o!s#I`tXB|@NbghgAV!lkM0-Gs6jjMIJD5~ zLTaM>2S^zW_=`bgY{)EZmpg5NLtngzEc@%fOLn^h?{04}l=FyNQF^+-l}ln;N$hmK zs2B#P%)WyHu$muQ{niPwIQuM9iJKo*_bCE-xZ`Z`Ay@{x264);+4~-3-OIP`T-_`# zcPeW@wg{)zN6*M}nuJ;(iPbyb|6*;C%?G9x{IRt_{!DECkKr)?_lU;ef7!wRXIhh~ z{OXLMjPxZGE}TT-R6%H#QB;~Xm}EFe9!XYu$?iDUVr#}hM9pkPMw>)@R}d$J6`8?0 zlQf6iR@+cvy2>IC8e=EIH=_Fr1?>&keJd>^B{lK96=5)r-aH_DJkfsL)$Vn@#gXs5 z^)|2l3$yQ#bdR)*R1ofOEmCKVLP9=hd%Cg0imbqfWFZuEnWf4A+bwIgp6Fm8DZ5NW z9#*z_|FNv%tp!F_|2^DKvo?fmnI~PCrHkyKxU54iYVWw-r`#WH1%;I6#AaySpFu+JAajI9B6z9S6suF{--a*iU!GEB`hCyV+7663v!t`g(2DAf^( zvqL8QNtR_6sWrH?nM7C`d^aC+_^@#|yt$va@g@GW)5eal`&80|=ud zy3H!oR{ftWnPfWzqfu6(PngIVY4=rTa-mUM)x;s0BB)^ecXT%Ht3tf}4*m0dr!KVu zHuSYNA8)lLcAv_i3|cY6Gmlf87vpW zgQK60L2h^GY9g%N=dM-xTG!K_Ac~xyX35Q)Ff>57LNZBXOgcjz2f@}X4z`BsMOa+#jN$U=Mv3JwNnzIQSVcM;*Z3^E zA{w3pwPu#}T&w5q>C*~S!>Ck;QfkE4_@~-}UTIWF({*R?NVbKF#Tt%?4oqa2m1%() zy5ShK6#7M)xe0fFu-=Hz<HZzOA9QOVm*w#3~(}3Db$((Bg$sXXoT3D=1ov zkfK!s{bCbgA!eie60>QMBl$du2R;Ll3Orz#P0szlxIga=FiAe;RxOO3j-ZZT+Q5*? z6Q|eE7B>era5Jggs7a`%P6Eqn0q!c6Z}Qx?#9q-qP&^E*n=zQ71Rd7O)>QQ;5D{>< z2$yN_=V^VeVH*_*rA`uoo|=OY-_oF8)MjR)Bm6AOLGqg_X~2FldHi{{#Wi`MrnVzD zalyDY`H#%&obRVPCEA+Q3Z{==JPNl2U5QKkReQteUVho+E$bNh{-J=04tckZ#4b={ z#YfY19!wIu2|?Mr#~!MdwAhG$=D?u3d+3Y#ql3UC%v@ma(Y->Q6+guK5nSZ@t8GPl zx0v*OK4X_58bPD7r_r&0b8Ke7bAga^g~lBc+6|!@rJbWB4|#ay?>4(A_g~*E1n;i@ zK}pYZg7p5CMF#s2%bg+NMygbkP)>)A8rmWDUoh6^L%h% zUUA?NX=0>Bf2xpSkG+4hsathn7-sQHVo1_lFx>~p=JvevkF4kt|1(jzakgQep^wom zfv;MAa8fkl6)X+?yXVr&KOyuO2y@d*%*(WiWs2?0ULdr`zIB!l;Q2S1<20 z7k5(g7f7pd_44zx-869ZHB4^e`7ds-q;y|P;N;>sldO2o=P!Jawe8~XL`#|I-*kidTo?f;>AJ5z^yPW zL_Yy?tCFf_94%n=(yi!hm6D8JwG0Jd^AsX>tTdbR>88;CQdLJ z+Iljw44H!snRV~hZ+`*L@|C{R2I#7>_C4}O(DEM*Z}R&T2-zmMU=mc?Isr*%;l2Z6E@GdQXQ zE6yFGUdVB+48dw^#eF9P@tRto9xXw7caarv>W81sy`xkBCuxLSS zJYB2+XzL$#8wSySDztc86VU-1jzEqUjNycoV#A3LHku%J`m6DjMA&sBA%70|xj?F> z$%deE3^iWo4K}dQJT1D^^_tdz*`(?FuPq%TL5j8}E2Sgk6A=q77Ds1ZK30w{YP>p& z#8Vq#UY6HzAXjm1xJI4Cl-el^%?p2>fy%Q1LhYK1u%WXGg+sMSOM7{D<9fHu zb+yr%#^ebn7uVIY#S~TK9&<jqK}aJc*IBTk3GesKj0%hEbwuH<+{l)@|rc5 z-GAQ-{>shxYk_GNTO?bgUxJQ-v*(hd_CtaB7b_}5`75XJCbf7RdWO2IB<%VdjUhYJ z7abavE%-q)IMZ(_rXmIk8F0$b2D^fJ^0L!SFQ5mNFGF1!vnRa4I-tx|iXn0K<@piu zn!I_Zc>>#8+J`5P%s$me=Di=Bw0FgqGs=|<>MNzw1bHV!z{tO=ts#3LXvR1i7b-bB z(+XTuNJdAmk#H8ahCAUo5Qv$Z{fbN`t@EL+^l`ZQC3gjy8wnWDjeoZ~-X)RmQva6+ zAGHTbjm(R?DsQ^~dbshIIZMyjaTi`&a1+4*v%>4I+w4}F5KMetKAu0j2ezypAqt?~ zIT!PzHOjTgtiStX=)^XLORSQ-T8qwJbKZV^5`a2_Gx?9e%J=f;XO4t{e|#d~(b1GJ z^$Gx@Zl~deLFp61-Us0Gwc!6HhMq<4J6Dn~itURCUOqntcF|)BJI97<8wc2{_enZy zpQYA?u{$78y*U+Vo3?EV&0iyA3X^e@^)cYW-}n9(1BqMq&0Wxs1(oS1R!Zdmh#os@ zGedoc|34|qg>mCjeSZ;yrfpDU|J?f7%CZ25%mj+lgz{;?5%t#KjMYM#a!k_dxKL=O zw%h=CknWQy=-0?1w6l62Uw>z^%}<=K-$VSu?AJn;lNsw#0&Zfci4WRjOh7A;3M6@8 z^LHs+(~mJ31E3#i4h&vKXpTNhdd9K~voy6W9!>;Z%1xc&r!$%{6E{rXI9`I4OqQNy zxJG*RRQSJ2I}>;)w>OSYhR9M~LZos{lo*6aQd!12G`6~;m}DQuPLfa|WlLRKT+1|B zveXroREliLTFIIgd*oJ1uD}18D_+jkpnH6Ltk3UzmiN5pJ?FgVd8qGL{!Dwzg4I zc39+X9C0Lx{^I$>^PQTBw{Rf3>3_1Om{>t(y9z0b^~)7bDnHXYu{`Eble#U_&d!&& zqO0muWxsKCv7awPsWYwfe3b6hW)i9BW@9*n&ud8*nVdYs9=}KKc5lSZ*Y`aF(3%ap zE0P%VUey^Lu(i4%-Ej2%ie^l4si4mG?ef)m+S?0RB6Dg+JSu{nl}^7YYktIO@2mXg zk6v{~eslFzn0gh)_}|ncga~)ueQfGhocpp+;sA$J2xw~&(AF9YwKW`wbJkP_az%>tbe^WB+J|Mg2}58P`%3hV|#z$|=ikYS{X?2i_aoWVRqrw4GpRmSYS!x-AdZqF1dN@&?yW(6tB{}(slgRUw^dojogkv5-xylMbrrR#(P?LBG6U_1d zQ-8r#_esbnGGsqz-4h|7i~gBpB{xT3sAEf?O&#b5@0H&NPIZ((W9#CKl(AZR>XME` zPb()$5P(&J=uEVS-MZpoOfkqk;1$&rj&6sb^2G1b7ka?Ij}Axx}kXn%#&Ka~=( zBEvbvGPh3#IS#_E#a-6As2n2Z8TwkqN*zO|#2W&)1eLqCc(ck-Ndj;4+eDMHIV!@E z2`}z$+Q+u8`;uvWxbY`D(P8UE-9Rw>pa4WEPe**>A*Ffc}-k zi2sj41}83Yj_aGWadB=UoS))DMxUQ;iFq7o#;?R<_pkho;(Z-2L8j8P^u^D%f+dPG;UpB}sTa&=$IoCtP3saye==&j8<*KzwMwDHF+b<+pKzqR{Y_P<(F0mwn zrcl;zL6KVauEe4gHDhPT>Z@l>wLeSVa>1q*r+G8fesLU+(e^7VMd_Za%hk|*$~GF3 zn(%p#^~OgrCASlWg73E2-_vMibv(SI?cLZI?rTqZtAZ%clOC0It!$JlW0yQ1n#S!g z*z@YiP5%vnB#(n^Cz#oLcZFs+q^eM3S-;B$08#&rD;RZ<<^bHMtZmD^iqw zuBB65e^pB8LmvG%aninJoT`EGDyKd=Wa&3AYvQlr4>f1xEy1lR(5T+zoBBF2uU+0g zDv*2a$^5ln%`9J`F_)uF_lEA&znh=2`?0e2I!uhX68b>eF0xOMaUf^1X~ue9sF|S;^NedDo+GnDO%C+Gy1zg=|O+5EmS8KfwBxOGp^YhWZl9LB+ zoWXCn6}9=cTl!D|ka`B=OG1C=u5GOp{kS!4e_KL!?fWQ3@Ge#H@5XwH z8|@}}^H&;Lh*`Eq-rHN*GBln$7*!&cCq~X4tGQ10-EhUmc2~V$442}#p4}EhN{}hO zt)h1`@j%<93zx6DSiUeHVsA)enh?3KU(twm7ct2hzoFi8Fhz4PBbR4oFYZ&Q$;dT> z!C3D0%&p~^eRAO~HLXDdSN+63B{Q}9X>L4NT6^*ZUtz>@ANBO)j_s3mRYP4t;v;y1 z1J$k76io@2(v=)lQ}ui_yf*ydMmBj?=0@)9wY8RMTQft)j}b1B_xu07p-@NTt1O1- zrP&glb2U2-`-Q`(;a+19I#@FcwNEcG3AfmuF+c=pxVoPID8#uB=m8}g~n(O(fV>{k-yrT z%?ghWQ)IKh$vXwJZ@YAD40G=ap`+1KK4p)Br_1Woavo@T^m<>PC&B#hU!|J&ey|k_ z4nD3pDDgS3(P11-Y$uQNhZVz5N6F>F!h6BZllEk!_MdK|&aPx|cXhY3a?=stT8Y=e zON`*J*XWAt)HGrxwZ*q+Vqa@ZR!L$}q20V!284MwiP%v31Gsxj)?B>8!)?>u^OApn zubibAoVP(51dG%rOn3B)1%o>rsY(~gcHxBV%zHNcGJAG5LXzusqp zf6xIB1mL$bi4w3Gd_OZ<=ql@JspAZdBy`p3fx$rYJ<-5uph=7HP0s?jFr8%~{M}+| zNTO>9R$pfs>diHr8rccBgeCIxUk5pYDmyHW0xgInO29$zSUV$u*HXpl8RB4To$Jl) z{=g^)d?NLZLQw)fbI!8X+h+vqVdLNM)J_c802p356&!dPP6 zCE7UwrwB-(Cm67|{rYWDP!Y8AfYQ_I;43A7XB{1Ynw2%tgXFFTJT;NX#G{D6V^}|d zVDJD7^jm?x;T-)4a6Qv{?DzgRb=^((gMaJ8lLIg#^ggES;cg28O4wNB&wi4wpM0>1vR)_@;4cOr@Ob#+|3e&Q7EJv(^^|?+hTO*&u!_h2Ss`y zx5A)}f$&VC1c<8AQN@#OY^LLn!S!0&Q*9~*T1_5YgpxCYw2a=t(UH`pO*9TnO)F@Z z{`~n3`;;u525tv@p!e>cBQ9@1N1Q-(w^ep?vvNE_t6@CZl1Ngs1HH`dhzAnP1TKgR z&x+=ipcT78VZ`UK6Yo4@10Zu1dFQ^1lLKX#%I7Y+9FjbP)?{2X?wBENh6hH0t!iov~!_g0%`C9z|%z*OpA9f0PuiVfdgO zf~Mpy6+QnL1HT-G5DZEdApC1jdVT`D&y5iJDway1HzLD3f(U2xlZ7~o-yeiq2;Q4Q zs9aAMpu!K)v!10Ec)Wr4NDwHhZq{nR)NJ^N3n_D#JihOkz~zHi5)l;c*?&PH>xu*& VCNKd3JGtOvEm(5t0lFyE{{i--k}m)N diff --git a/.mvn/wrapper/maven-wrapper.properties b/.mvn/wrapper/maven-wrapper.properties index d83cf1363..423c23e5e 100644 --- a/.mvn/wrapper/maven-wrapper.properties +++ b/.mvn/wrapper/maven-wrapper.properties @@ -1,16 +1,3 @@ -# Copyright 2013-2023 the original author or authors. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# https://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.0/apache-maven-3.9.0-bin.zip -wrapperUrl=https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.1.1/maven-wrapper-3.1.1.jar \ No newline at end of file +wrapperVersion=3.3.4 +distributionType=only-script +distributionUrl=https://maven.aliyun.com/repository/public/org/apache/maven/apache-maven/3.9.9/apache-maven-3.9.9-bin.zip diff --git a/mvnw b/mvnw index 8a8fb2282..bd8896bf2 100755 --- a/mvnw +++ b/mvnw @@ -8,7 +8,7 @@ # "License"); you may not use this file except in compliance # with the License. You may obtain a copy of the License at # -# https://www.apache.org/licenses/LICENSE-2.0 +# http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, # software distributed under the License is distributed on an @@ -19,298 +19,277 @@ # ---------------------------------------------------------------------------- # ---------------------------------------------------------------------------- -# Maven Start Up Batch script -# -# Required ENV vars: -# ------------------ -# JAVA_HOME - location of a JDK home dir +# Apache Maven Wrapper startup batch script, version 3.3.4 # # Optional ENV vars # ----------------- -# M2_HOME - location of maven2's installed home dir -# MAVEN_OPTS - parameters passed to the Java VM when running Maven -# e.g. to debug Maven itself, use -# set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000 -# MAVEN_SKIP_RC - flag to disable loading of mavenrc files +# JAVA_HOME - location of a JDK home dir, required when download maven via java source +# MVNW_REPOURL - repo url base for downloading maven distribution +# MVNW_USERNAME/MVNW_PASSWORD - user and password for downloading maven +# MVNW_VERBOSE - true: enable verbose log; debug: trace the mvnw script; others: silence the output # ---------------------------------------------------------------------------- -if [ -z "$MAVEN_SKIP_RC" ] ; then - - if [ -f /usr/local/etc/mavenrc ] ; then - . /usr/local/etc/mavenrc - fi - - if [ -f /etc/mavenrc ] ; then - . /etc/mavenrc - fi +set -euf +[ "${MVNW_VERBOSE-}" != debug ] || set -x - if [ -f "$HOME/.mavenrc" ] ; then - . "$HOME/.mavenrc" - fi +# OS specific support. +native_path() { printf %s\\n "$1"; } +case "$(uname)" in +CYGWIN* | MINGW*) + [ -z "${JAVA_HOME-}" ] || JAVA_HOME="$(cygpath --unix "$JAVA_HOME")" + native_path() { cygpath --path --windows "$1"; } + ;; +esac -fi +# set JAVACMD and JAVACCMD +set_java_home() { + # For Cygwin and MinGW, ensure paths are in Unix format before anything is touched + if [ -n "${JAVA_HOME-}" ]; then + if [ -x "$JAVA_HOME/jre/sh/java" ]; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD="$JAVA_HOME/jre/sh/java" + JAVACCMD="$JAVA_HOME/jre/sh/javac" + else + JAVACMD="$JAVA_HOME/bin/java" + JAVACCMD="$JAVA_HOME/bin/javac" -# OS specific support. $var _must_ be set to either true or false. -cygwin=false; -darwin=false; -mingw=false -case "`uname`" in - CYGWIN*) cygwin=true ;; - MINGW*) mingw=true;; - Darwin*) darwin=true - # Use /usr/libexec/java_home if available, otherwise fall back to /Library/Java/Home - # See https://developer.apple.com/library/mac/qa/qa1170/_index.html - if [ -z "$JAVA_HOME" ]; then - if [ -x "/usr/libexec/java_home" ]; then - export JAVA_HOME="`/usr/libexec/java_home`" - else - export JAVA_HOME="/Library/Java/Home" + if [ ! -x "$JAVACMD" ] || [ ! -x "$JAVACCMD" ]; then + echo "The JAVA_HOME environment variable is not defined correctly, so mvnw cannot run." >&2 + echo "JAVA_HOME is set to \"$JAVA_HOME\", but \"\$JAVA_HOME/bin/java\" or \"\$JAVA_HOME/bin/javac\" does not exist." >&2 + return 1 fi fi - ;; -esac - -if [ -z "$JAVA_HOME" ] ; then - if [ -r /etc/gentoo-release ] ; then - JAVA_HOME=`java-config --jre-home` + else + JAVACMD="$( + 'set' +e + 'unset' -f command 2>/dev/null + 'command' -v java + )" || : + JAVACCMD="$( + 'set' +e + 'unset' -f command 2>/dev/null + 'command' -v javac + )" || : + + if [ ! -x "${JAVACMD-}" ] || [ ! -x "${JAVACCMD-}" ]; then + echo "The java/javac command does not exist in PATH nor is JAVA_HOME set, so mvnw cannot run." >&2 + return 1 + fi fi -fi - -if [ -z "$M2_HOME" ] ; then - ## resolve links - $0 may be a link to maven's home - PRG="$0" +} - # need this for relative symlinks - while [ -h "$PRG" ] ; do - ls=`ls -ld "$PRG"` - link=`expr "$ls" : '.*-> \(.*\)$'` - if expr "$link" : '/.*' > /dev/null; then - PRG="$link" - else - PRG="`dirname "$PRG"`/$link" - fi +# hash string like Java String::hashCode +hash_string() { + str="${1:-}" h=0 + while [ -n "$str" ]; do + char="${str%"${str#?}"}" + h=$(((h * 31 + $(LC_CTYPE=C printf %d "'$char")) % 4294967296)) + str="${str#?}" done + printf %x\\n $h +} - saveddir=`pwd` +verbose() { :; } +[ "${MVNW_VERBOSE-}" != true ] || verbose() { printf %s\\n "${1-}"; } - M2_HOME=`dirname "$PRG"`/.. +die() { + printf %s\\n "$1" >&2 + exit 1 +} - # make it fully qualified - M2_HOME=`cd "$M2_HOME" && pwd` +trim() { + # MWRAPPER-139: + # Trims trailing and leading whitespace, carriage returns, tabs, and linefeeds. + # Needed for removing poorly interpreted newline sequences when running in more + # exotic environments such as mingw bash on Windows. + printf "%s" "${1}" | tr -d '[:space:]' +} - cd "$saveddir" - # echo Using m2 at $M2_HOME -fi +scriptDir="$(dirname "$0")" +scriptName="$(basename "$0")" + +# parse distributionUrl and optional distributionSha256Sum, requires .mvn/wrapper/maven-wrapper.properties +while IFS="=" read -r key value; do + case "${key-}" in + distributionUrl) distributionUrl=$(trim "${value-}") ;; + distributionSha256Sum) distributionSha256Sum=$(trim "${value-}") ;; + esac +done <"$scriptDir/.mvn/wrapper/maven-wrapper.properties" +[ -n "${distributionUrl-}" ] || die "cannot read distributionUrl property in $scriptDir/.mvn/wrapper/maven-wrapper.properties" + +case "${distributionUrl##*/}" in +maven-mvnd-*bin.*) + MVN_CMD=mvnd.sh _MVNW_REPO_PATTERN=/maven/mvnd/ + case "${PROCESSOR_ARCHITECTURE-}${PROCESSOR_ARCHITEW6432-}:$(uname -a)" in + *AMD64:CYGWIN* | *AMD64:MINGW*) distributionPlatform=windows-amd64 ;; + :Darwin*x86_64) distributionPlatform=darwin-amd64 ;; + :Darwin*arm64) distributionPlatform=darwin-aarch64 ;; + :Linux*x86_64*) distributionPlatform=linux-amd64 ;; + *) + echo "Cannot detect native platform for mvnd on $(uname)-$(uname -m), use pure java version" >&2 + distributionPlatform=linux-amd64 + ;; + esac + distributionUrl="${distributionUrl%-bin.*}-$distributionPlatform.zip" + ;; +maven-mvnd-*) MVN_CMD=mvnd.sh _MVNW_REPO_PATTERN=/maven/mvnd/ ;; +*) MVN_CMD="mvn${scriptName#mvnw}" _MVNW_REPO_PATTERN=/org/apache/maven/ ;; +esac -# For Cygwin, ensure paths are in UNIX format before anything is touched -if $cygwin ; then - [ -n "$M2_HOME" ] && - M2_HOME=`cygpath --unix "$M2_HOME"` - [ -n "$JAVA_HOME" ] && - JAVA_HOME=`cygpath --unix "$JAVA_HOME"` - [ -n "$CLASSPATH" ] && - CLASSPATH=`cygpath --path --unix "$CLASSPATH"` -fi +# apply MVNW_REPOURL and calculate MAVEN_HOME +# maven home pattern: ~/.m2/wrapper/dists/{apache-maven-,maven-mvnd--}/ +[ -z "${MVNW_REPOURL-}" ] || distributionUrl="$MVNW_REPOURL$_MVNW_REPO_PATTERN${distributionUrl#*"$_MVNW_REPO_PATTERN"}" +distributionUrlName="${distributionUrl##*/}" +distributionUrlNameMain="${distributionUrlName%.*}" +distributionUrlNameMain="${distributionUrlNameMain%-bin}" +MAVEN_USER_HOME="${MAVEN_USER_HOME:-${HOME}/.m2}" +MAVEN_HOME="${MAVEN_USER_HOME}/wrapper/dists/${distributionUrlNameMain-}/$(hash_string "$distributionUrl")" + +exec_maven() { + unset MVNW_VERBOSE MVNW_USERNAME MVNW_PASSWORD MVNW_REPOURL || : + exec "$MAVEN_HOME/bin/$MVN_CMD" "$@" || die "cannot exec $MAVEN_HOME/bin/$MVN_CMD" +} -# For Mingw, ensure paths are in UNIX format before anything is touched -if $mingw ; then - [ -n "$M2_HOME" ] && - M2_HOME="`(cd "$M2_HOME"; pwd)`" - [ -n "$JAVA_HOME" ] && - JAVA_HOME="`(cd "$JAVA_HOME"; pwd)`" +if [ -d "$MAVEN_HOME" ]; then + verbose "found existing MAVEN_HOME at $MAVEN_HOME" + exec_maven "$@" fi -if [ -z "$JAVA_HOME" ]; then - javaExecutable="`which javac`" - if [ -n "$javaExecutable" ] && ! [ "`expr \"$javaExecutable\" : '\([^ ]*\)'`" = "no" ]; then - # readlink(1) is not available as standard on Solaris 10. - readLink=`which readlink` - if [ ! `expr "$readLink" : '\([^ ]*\)'` = "no" ]; then - if $darwin ; then - javaHome="`dirname \"$javaExecutable\"`" - javaExecutable="`cd \"$javaHome\" && pwd -P`/javac" - else - javaExecutable="`readlink -f \"$javaExecutable\"`" - fi - javaHome="`dirname \"$javaExecutable\"`" - javaHome=`expr "$javaHome" : '\(.*\)/bin'` - JAVA_HOME="$javaHome" - export JAVA_HOME - fi - fi -fi +case "${distributionUrl-}" in +*?-bin.zip | *?maven-mvnd-?*-?*.zip) ;; +*) die "distributionUrl is not valid, must match *-bin.zip or maven-mvnd-*.zip, but found '${distributionUrl-}'" ;; +esac -if [ -z "$JAVACMD" ] ; then - if [ -n "$JAVA_HOME" ] ; then - if [ -x "$JAVA_HOME/jre/sh/java" ] ; then - # IBM's JDK on AIX uses strange locations for the executables - JAVACMD="$JAVA_HOME/jre/sh/java" - else - JAVACMD="$JAVA_HOME/bin/java" - fi - else - JAVACMD="`\\unset -f command; \\command -v java`" - fi +# prepare tmp dir +if TMP_DOWNLOAD_DIR="$(mktemp -d)" && [ -d "$TMP_DOWNLOAD_DIR" ]; then + clean() { rm -rf -- "$TMP_DOWNLOAD_DIR"; } + trap clean HUP INT TERM EXIT +else + die "cannot create temp dir" fi -if [ ! -x "$JAVACMD" ] ; then - echo "Error: JAVA_HOME is not defined correctly." >&2 - echo " We cannot execute $JAVACMD" >&2 - exit 1 -fi +mkdir -p -- "${MAVEN_HOME%/*}" + +# Download and Install Apache Maven +verbose "Couldn't find MAVEN_HOME, downloading and installing it ..." +verbose "Downloading from: $distributionUrl" +verbose "Downloading to: $TMP_DOWNLOAD_DIR/$distributionUrlName" -if [ -z "$JAVA_HOME" ] ; then - echo "Warning: JAVA_HOME environment variable is not set." +# select .zip or .tar.gz +if ! command -v unzip >/dev/null; then + distributionUrl="${distributionUrl%.zip}.tar.gz" + distributionUrlName="${distributionUrl##*/}" fi -CLASSWORLDS_LAUNCHER=org.codehaus.plexus.classworlds.launcher.Launcher +# verbose opt +__MVNW_QUIET_WGET=--quiet __MVNW_QUIET_CURL=--silent __MVNW_QUIET_UNZIP=-q __MVNW_QUIET_TAR='' +[ "${MVNW_VERBOSE-}" != true ] || __MVNW_QUIET_WGET='' __MVNW_QUIET_CURL='' __MVNW_QUIET_UNZIP='' __MVNW_QUIET_TAR=v -# traverses directory structure from process work directory to filesystem root -# first directory with .mvn subdirectory is considered project base directory -find_maven_basedir() { +# normalize http auth +case "${MVNW_PASSWORD:+has-password}" in +'') MVNW_USERNAME='' MVNW_PASSWORD='' ;; +has-password) [ -n "${MVNW_USERNAME-}" ] || MVNW_USERNAME='' MVNW_PASSWORD='' ;; +esac - if [ -z "$1" ] - then - echo "Path not specified to find_maven_basedir" - return 1 - fi +if [ -z "${MVNW_USERNAME-}" ] && command -v wget >/dev/null; then + verbose "Found wget ... using wget" + wget ${__MVNW_QUIET_WGET:+"$__MVNW_QUIET_WGET"} "$distributionUrl" -O "$TMP_DOWNLOAD_DIR/$distributionUrlName" || die "wget: Failed to fetch $distributionUrl" +elif [ -z "${MVNW_USERNAME-}" ] && command -v curl >/dev/null; then + verbose "Found curl ... using curl" + curl ${__MVNW_QUIET_CURL:+"$__MVNW_QUIET_CURL"} -f -L -o "$TMP_DOWNLOAD_DIR/$distributionUrlName" "$distributionUrl" || die "curl: Failed to fetch $distributionUrl" +elif set_java_home; then + verbose "Falling back to use Java to download" + javaSource="$TMP_DOWNLOAD_DIR/Downloader.java" + targetZip="$TMP_DOWNLOAD_DIR/$distributionUrlName" + cat >"$javaSource" <<-END + public class Downloader extends java.net.Authenticator + { + protected java.net.PasswordAuthentication getPasswordAuthentication() + { + return new java.net.PasswordAuthentication( System.getenv( "MVNW_USERNAME" ), System.getenv( "MVNW_PASSWORD" ).toCharArray() ); + } + public static void main( String[] args ) throws Exception + { + setDefault( new Downloader() ); + java.nio.file.Files.copy( java.net.URI.create( args[0] ).toURL().openStream(), java.nio.file.Paths.get( args[1] ).toAbsolutePath().normalize() ); + } + } + END + # For Cygwin/MinGW, switch paths to Windows format before running javac and java + verbose " - Compiling Downloader.java ..." + "$(native_path "$JAVACCMD")" "$(native_path "$javaSource")" || die "Failed to compile Downloader.java" + verbose " - Running Downloader.java ..." + "$(native_path "$JAVACMD")" -cp "$(native_path "$TMP_DOWNLOAD_DIR")" Downloader "$distributionUrl" "$(native_path "$targetZip")" +fi - basedir="$1" - wdir="$1" - while [ "$wdir" != '/' ] ; do - if [ -d "$wdir"/.mvn ] ; then - basedir=$wdir - break +# If specified, validate the SHA-256 sum of the Maven distribution zip file +if [ -n "${distributionSha256Sum-}" ]; then + distributionSha256Result=false + if [ "$MVN_CMD" = mvnd.sh ]; then + echo "Checksum validation is not supported for maven-mvnd." >&2 + echo "Please disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties." >&2 + exit 1 + elif command -v sha256sum >/dev/null; then + if echo "$distributionSha256Sum $TMP_DOWNLOAD_DIR/$distributionUrlName" | sha256sum -c - >/dev/null 2>&1; then + distributionSha256Result=true fi - # workaround for JBEAP-8937 (on Solaris 10/Sparc) - if [ -d "${wdir}" ]; then - wdir=`cd "$wdir/.."; pwd` + elif command -v shasum >/dev/null; then + if echo "$distributionSha256Sum $TMP_DOWNLOAD_DIR/$distributionUrlName" | shasum -a 256 -c >/dev/null 2>&1; then + distributionSha256Result=true fi - # end of workaround - done - echo "${basedir}" -} - -# concatenates all lines of a file -concat_lines() { - if [ -f "$1" ]; then - echo "$(tr -s '\n' ' ' < "$1")" + else + echo "Checksum validation was requested but neither 'sha256sum' or 'shasum' are available." >&2 + echo "Please install either command, or disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties." >&2 + exit 1 + fi + if [ $distributionSha256Result = false ]; then + echo "Error: Failed to validate Maven distribution SHA-256, your Maven distribution might be compromised." >&2 + echo "If you updated your Maven version, you need to update the specified distributionSha256Sum property." >&2 + exit 1 fi -} - -BASE_DIR=`find_maven_basedir "$(pwd)"` -if [ -z "$BASE_DIR" ]; then - exit 1; fi -########################################################################################## -# Extension to allow automatically downloading the maven-wrapper.jar from Maven-central -# This allows using the maven wrapper in projects that prohibit checking in binary data. -########################################################################################## -if [ -r "$BASE_DIR/.mvn/wrapper/maven-wrapper.jar" ]; then - if [ "$MVNW_VERBOSE" = true ]; then - echo "Found .mvn/wrapper/maven-wrapper.jar" - fi +# unzip and move +if command -v unzip >/dev/null; then + unzip ${__MVNW_QUIET_UNZIP:+"$__MVNW_QUIET_UNZIP"} "$TMP_DOWNLOAD_DIR/$distributionUrlName" -d "$TMP_DOWNLOAD_DIR" || die "failed to unzip" else - if [ "$MVNW_VERBOSE" = true ]; then - echo "Couldn't find .mvn/wrapper/maven-wrapper.jar, downloading it ..." - fi - if [ -n "$MVNW_REPOURL" ]; then - jarUrl="$MVNW_REPOURL/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar" - else - jarUrl="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar" - fi - while IFS="=" read key value; do - case "$key" in (wrapperUrl) jarUrl="$value"; break ;; - esac - done < "$BASE_DIR/.mvn/wrapper/maven-wrapper.properties" - if [ "$MVNW_VERBOSE" = true ]; then - echo "Downloading from: $jarUrl" - fi - wrapperJarPath="$BASE_DIR/.mvn/wrapper/maven-wrapper.jar" - if $cygwin; then - wrapperJarPath=`cygpath --path --windows "$wrapperJarPath"` - fi + tar xzf${__MVNW_QUIET_TAR:+"$__MVNW_QUIET_TAR"} "$TMP_DOWNLOAD_DIR/$distributionUrlName" -C "$TMP_DOWNLOAD_DIR" || die "failed to untar" +fi - if command -v wget > /dev/null; then - if [ "$MVNW_VERBOSE" = true ]; then - echo "Found wget ... using wget" - fi - if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then - wget "$jarUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath" - else - wget --http-user=$MVNW_USERNAME --http-password=$MVNW_PASSWORD "$jarUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath" - fi - elif command -v curl > /dev/null; then - if [ "$MVNW_VERBOSE" = true ]; then - echo "Found curl ... using curl" - fi - if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then - curl -o "$wrapperJarPath" "$jarUrl" -f - else - curl --user $MVNW_USERNAME:$MVNW_PASSWORD -o "$wrapperJarPath" "$jarUrl" -f - fi +# Find the actual extracted directory name (handles snapshots where filename != directory name) +actualDistributionDir="" - else - if [ "$MVNW_VERBOSE" = true ]; then - echo "Falling back to using Java to download" - fi - javaClass="$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.java" - # For Cygwin, switch paths to Windows format before running javac - if $cygwin; then - javaClass=`cygpath --path --windows "$javaClass"` - fi - if [ -e "$javaClass" ]; then - if [ ! -e "$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.class" ]; then - if [ "$MVNW_VERBOSE" = true ]; then - echo " - Compiling MavenWrapperDownloader.java ..." - fi - # Compiling the Java class - ("$JAVA_HOME/bin/javac" "$javaClass") - fi - if [ -e "$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.class" ]; then - # Running the downloader - if [ "$MVNW_VERBOSE" = true ]; then - echo " - Running MavenWrapperDownloader.java ..." - fi - ("$JAVA_HOME/bin/java" -cp .mvn/wrapper MavenWrapperDownloader "$MAVEN_PROJECTBASEDIR") - fi - fi - fi +# First try the expected directory name (for regular distributions) +if [ -d "$TMP_DOWNLOAD_DIR/$distributionUrlNameMain" ]; then + if [ -f "$TMP_DOWNLOAD_DIR/$distributionUrlNameMain/bin/$MVN_CMD" ]; then + actualDistributionDir="$distributionUrlNameMain" + fi fi -########################################################################################## -# End of extension -########################################################################################## -export MAVEN_PROJECTBASEDIR=${MAVEN_BASEDIR:-"$BASE_DIR"} -if [ "$MVNW_VERBOSE" = true ]; then - echo $MAVEN_PROJECTBASEDIR -fi -MAVEN_OPTS="$(concat_lines "$MAVEN_PROJECTBASEDIR/.mvn/jvm.config") $MAVEN_OPTS" - -# For Cygwin, switch paths to Windows format before running java -if $cygwin; then - [ -n "$M2_HOME" ] && - M2_HOME=`cygpath --path --windows "$M2_HOME"` - [ -n "$JAVA_HOME" ] && - JAVA_HOME=`cygpath --path --windows "$JAVA_HOME"` - [ -n "$CLASSPATH" ] && - CLASSPATH=`cygpath --path --windows "$CLASSPATH"` - [ -n "$MAVEN_PROJECTBASEDIR" ] && - MAVEN_PROJECTBASEDIR=`cygpath --path --windows "$MAVEN_PROJECTBASEDIR"` +# If not found, search for any directory with the Maven executable (for snapshots) +if [ -z "$actualDistributionDir" ]; then + # enable globbing to iterate over items + set +f + for dir in "$TMP_DOWNLOAD_DIR"/*; do + if [ -d "$dir" ]; then + if [ -f "$dir/bin/$MVN_CMD" ]; then + actualDistributionDir="$(basename "$dir")" + break + fi + fi + done + set -f fi -# Provide a "standardized" way to retrieve the CLI args that will -# work with both Windows and non-Windows executions. -MAVEN_CMD_LINE_ARGS="$MAVEN_CONFIG $@" -export MAVEN_CMD_LINE_ARGS +if [ -z "$actualDistributionDir" ]; then + verbose "Contents of $TMP_DOWNLOAD_DIR:" + verbose "$(ls -la "$TMP_DOWNLOAD_DIR")" + die "Could not find Maven distribution directory in extracted archive" +fi -WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain +verbose "Found extracted Maven distribution directory: $actualDistributionDir" +printf %s\\n "$distributionUrl" >"$TMP_DOWNLOAD_DIR/$actualDistributionDir/mvnw.url" +mv -- "$TMP_DOWNLOAD_DIR/$actualDistributionDir" "$MAVEN_HOME" || [ -d "$MAVEN_HOME" ] || die "fail to move MAVEN_HOME" -exec "$JAVACMD" \ - $MAVEN_OPTS \ - $MAVEN_DEBUG_OPTS \ - -classpath "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar" \ - "-Dmaven.home=${M2_HOME}" \ - "-Dmaven.multiModuleProjectDirectory=${MAVEN_PROJECTBASEDIR}" \ - ${WRAPPER_LAUNCHER} $MAVEN_CONFIG "$@" +clean || : +exec_maven "$@" diff --git a/mvnw.cmd b/mvnw.cmd index 1d8ab018e..5761d9489 100644 --- a/mvnw.cmd +++ b/mvnw.cmd @@ -1,188 +1,189 @@ -@REM ---------------------------------------------------------------------------- -@REM Licensed to the Apache Software Foundation (ASF) under one -@REM or more contributor license agreements. See the NOTICE file -@REM distributed with this work for additional information -@REM regarding copyright ownership. The ASF licenses this file -@REM to you under the Apache License, Version 2.0 (the -@REM "License"); you may not use this file except in compliance -@REM with the License. You may obtain a copy of the License at -@REM -@REM https://www.apache.org/licenses/LICENSE-2.0 -@REM -@REM Unless required by applicable law or agreed to in writing, -@REM software distributed under the License is distributed on an -@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -@REM KIND, either express or implied. See the License for the -@REM specific language governing permissions and limitations -@REM under the License. -@REM ---------------------------------------------------------------------------- - -@REM ---------------------------------------------------------------------------- -@REM Maven Start Up Batch script -@REM -@REM Required ENV vars: -@REM JAVA_HOME - location of a JDK home dir -@REM -@REM Optional ENV vars -@REM M2_HOME - location of maven2's installed home dir -@REM MAVEN_BATCH_ECHO - set to 'on' to enable the echoing of the batch commands -@REM MAVEN_BATCH_PAUSE - set to 'on' to wait for a keystroke before ending -@REM MAVEN_OPTS - parameters passed to the Java VM when running Maven -@REM e.g. to debug Maven itself, use -@REM set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000 -@REM MAVEN_SKIP_RC - flag to disable loading of mavenrc files -@REM ---------------------------------------------------------------------------- - -@REM Begin all REM lines with '@' in case MAVEN_BATCH_ECHO is 'on' -@echo off -@REM set title of command window -title %0 -@REM enable echoing by setting MAVEN_BATCH_ECHO to 'on' -@if "%MAVEN_BATCH_ECHO%" == "on" echo %MAVEN_BATCH_ECHO% - -@REM set %HOME% to equivalent of $HOME -if "%HOME%" == "" (set "HOME=%HOMEDRIVE%%HOMEPATH%") - -@REM Execute a user defined script before this one -if not "%MAVEN_SKIP_RC%" == "" goto skipRcPre -@REM check for pre script, once with legacy .bat ending and once with .cmd ending -if exist "%USERPROFILE%\mavenrc_pre.bat" call "%USERPROFILE%\mavenrc_pre.bat" %* -if exist "%USERPROFILE%\mavenrc_pre.cmd" call "%USERPROFILE%\mavenrc_pre.cmd" %* -:skipRcPre - -@setlocal - -set ERROR_CODE=0 - -@REM To isolate internal variables from possible post scripts, we use another setlocal -@setlocal - -@REM ==== START VALIDATION ==== -if not "%JAVA_HOME%" == "" goto OkJHome - -echo. -echo Error: JAVA_HOME not found in your environment. >&2 -echo Please set the JAVA_HOME variable in your environment to match the >&2 -echo location of your Java installation. >&2 -echo. -goto error - -:OkJHome -if exist "%JAVA_HOME%\bin\java.exe" goto init - -echo. -echo Error: JAVA_HOME is set to an invalid directory. >&2 -echo JAVA_HOME = "%JAVA_HOME%" >&2 -echo Please set the JAVA_HOME variable in your environment to match the >&2 -echo location of your Java installation. >&2 -echo. -goto error - -@REM ==== END VALIDATION ==== - -:init - -@REM Find the project base dir, i.e. the directory that contains the folder ".mvn". -@REM Fallback to current working directory if not found. - -set MAVEN_PROJECTBASEDIR=%MAVEN_BASEDIR% -IF NOT "%MAVEN_PROJECTBASEDIR%"=="" goto endDetectBaseDir - -set EXEC_DIR=%CD% -set WDIR=%EXEC_DIR% -:findBaseDir -IF EXIST "%WDIR%"\.mvn goto baseDirFound -cd .. -IF "%WDIR%"=="%CD%" goto baseDirNotFound -set WDIR=%CD% -goto findBaseDir - -:baseDirFound -set MAVEN_PROJECTBASEDIR=%WDIR% -cd "%EXEC_DIR%" -goto endDetectBaseDir - -:baseDirNotFound -set MAVEN_PROJECTBASEDIR=%EXEC_DIR% -cd "%EXEC_DIR%" - -:endDetectBaseDir - -IF NOT EXIST "%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config" goto endReadAdditionalConfig - -@setlocal EnableExtensions EnableDelayedExpansion -for /F "usebackq delims=" %%a in ("%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config") do set JVM_CONFIG_MAVEN_PROPS=!JVM_CONFIG_MAVEN_PROPS! %%a -@endlocal & set JVM_CONFIG_MAVEN_PROPS=%JVM_CONFIG_MAVEN_PROPS% - -:endReadAdditionalConfig - -SET MAVEN_JAVA_EXE="%JAVA_HOME%\bin\java.exe" -set WRAPPER_JAR="%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.jar" -set WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain - -set DOWNLOAD_URL="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar" - -FOR /F "usebackq tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties") DO ( - IF "%%A"=="wrapperUrl" SET DOWNLOAD_URL=%%B -) - -@REM Extension to allow automatically downloading the maven-wrapper.jar from Maven-central -@REM This allows using the maven wrapper in projects that prohibit checking in binary data. -if exist %WRAPPER_JAR% ( - if "%MVNW_VERBOSE%" == "true" ( - echo Found %WRAPPER_JAR% - ) -) else ( - if not "%MVNW_REPOURL%" == "" ( - SET DOWNLOAD_URL="%MVNW_REPOURL%/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar" - ) - if "%MVNW_VERBOSE%" == "true" ( - echo Couldn't find %WRAPPER_JAR%, downloading it ... - echo Downloading from: %DOWNLOAD_URL% - ) - - powershell -Command "&{"^ - "$webclient = new-object System.Net.WebClient;"^ - "if (-not ([string]::IsNullOrEmpty('%MVNW_USERNAME%') -and [string]::IsNullOrEmpty('%MVNW_PASSWORD%'))) {"^ - "$webclient.Credentials = new-object System.Net.NetworkCredential('%MVNW_USERNAME%', '%MVNW_PASSWORD%');"^ - "}"^ - "[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; $webclient.DownloadFile('%DOWNLOAD_URL%', '%WRAPPER_JAR%')"^ - "}" - if "%MVNW_VERBOSE%" == "true" ( - echo Finished downloading %WRAPPER_JAR% - ) -) -@REM End of extension - -@REM Provide a "standardized" way to retrieve the CLI args that will -@REM work with both Windows and non-Windows executions. -set MAVEN_CMD_LINE_ARGS=%* - -%MAVEN_JAVA_EXE% ^ - %JVM_CONFIG_MAVEN_PROPS% ^ - %MAVEN_OPTS% ^ - %MAVEN_DEBUG_OPTS% ^ - -classpath %WRAPPER_JAR% ^ - "-Dmaven.multiModuleProjectDirectory=%MAVEN_PROJECTBASEDIR%" ^ - %WRAPPER_LAUNCHER% %MAVEN_CONFIG% %* -if ERRORLEVEL 1 goto error -goto end - -:error -set ERROR_CODE=1 - -:end -@endlocal & set ERROR_CODE=%ERROR_CODE% - -if not "%MAVEN_SKIP_RC%"=="" goto skipRcPost -@REM check for post script, once with legacy .bat ending and once with .cmd ending -if exist "%USERPROFILE%\mavenrc_post.bat" call "%USERPROFILE%\mavenrc_post.bat" -if exist "%USERPROFILE%\mavenrc_post.cmd" call "%USERPROFILE%\mavenrc_post.cmd" -:skipRcPost - -@REM pause the script if MAVEN_BATCH_PAUSE is set to 'on' -if "%MAVEN_BATCH_PAUSE%"=="on" pause - -if "%MAVEN_TERMINATE_CMD%"=="on" exit %ERROR_CODE% - -cmd /C exit /B %ERROR_CODE% +<# : batch portion +@REM ---------------------------------------------------------------------------- +@REM Licensed to the Apache Software Foundation (ASF) under one +@REM or more contributor license agreements. See the NOTICE file +@REM distributed with this work for additional information +@REM regarding copyright ownership. The ASF licenses this file +@REM to you under the Apache License, Version 2.0 (the +@REM "License"); you may not use this file except in compliance +@REM with the License. You may obtain a copy of the License at +@REM +@REM http://www.apache.org/licenses/LICENSE-2.0 +@REM +@REM Unless required by applicable law or agreed to in writing, +@REM software distributed under the License is distributed on an +@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +@REM KIND, either express or implied. See the License for the +@REM specific language governing permissions and limitations +@REM under the License. +@REM ---------------------------------------------------------------------------- + +@REM ---------------------------------------------------------------------------- +@REM Apache Maven Wrapper startup batch script, version 3.3.4 +@REM +@REM Optional ENV vars +@REM MVNW_REPOURL - repo url base for downloading maven distribution +@REM MVNW_USERNAME/MVNW_PASSWORD - user and password for downloading maven +@REM MVNW_VERBOSE - true: enable verbose log; others: silence the output +@REM ---------------------------------------------------------------------------- + +@IF "%__MVNW_ARG0_NAME__%"=="" (SET __MVNW_ARG0_NAME__=%~nx0) +@SET __MVNW_CMD__= +@SET __MVNW_ERROR__= +@SET __MVNW_PSMODULEP_SAVE=%PSModulePath% +@SET PSModulePath= +@FOR /F "usebackq tokens=1* delims==" %%A IN (`powershell -noprofile "& {$scriptDir='%~dp0'; $script='%__MVNW_ARG0_NAME__%'; icm -ScriptBlock ([Scriptblock]::Create((Get-Content -Raw '%~f0'))) -NoNewScope}"`) DO @( + IF "%%A"=="MVN_CMD" (set __MVNW_CMD__=%%B) ELSE IF "%%B"=="" (echo %%A) ELSE (echo %%A=%%B) +) +@SET PSModulePath=%__MVNW_PSMODULEP_SAVE% +@SET __MVNW_PSMODULEP_SAVE= +@SET __MVNW_ARG0_NAME__= +@SET MVNW_USERNAME= +@SET MVNW_PASSWORD= +@IF NOT "%__MVNW_CMD__%"=="" ("%__MVNW_CMD__%" %*) +@echo Cannot start maven from wrapper >&2 && exit /b 1 +@GOTO :EOF +: end batch / begin powershell #> + +$ErrorActionPreference = "Stop" +if ($env:MVNW_VERBOSE -eq "true") { + $VerbosePreference = "Continue" +} + +# calculate distributionUrl, requires .mvn/wrapper/maven-wrapper.properties +$distributionUrl = (Get-Content -Raw "$scriptDir/.mvn/wrapper/maven-wrapper.properties" | ConvertFrom-StringData).distributionUrl +if (!$distributionUrl) { + Write-Error "cannot read distributionUrl property in $scriptDir/.mvn/wrapper/maven-wrapper.properties" +} + +switch -wildcard -casesensitive ( $($distributionUrl -replace '^.*/','') ) { + "maven-mvnd-*" { + $USE_MVND = $true + $distributionUrl = $distributionUrl -replace '-bin\.[^.]*$',"-windows-amd64.zip" + $MVN_CMD = "mvnd.cmd" + break + } + default { + $USE_MVND = $false + $MVN_CMD = $script -replace '^mvnw','mvn' + break + } +} + +# apply MVNW_REPOURL and calculate MAVEN_HOME +# maven home pattern: ~/.m2/wrapper/dists/{apache-maven-,maven-mvnd--}/ +if ($env:MVNW_REPOURL) { + $MVNW_REPO_PATTERN = if ($USE_MVND -eq $False) { "/org/apache/maven/" } else { "/maven/mvnd/" } + $distributionUrl = "$env:MVNW_REPOURL$MVNW_REPO_PATTERN$($distributionUrl -replace "^.*$MVNW_REPO_PATTERN",'')" +} +$distributionUrlName = $distributionUrl -replace '^.*/','' +$distributionUrlNameMain = $distributionUrlName -replace '\.[^.]*$','' -replace '-bin$','' + +$MAVEN_M2_PATH = "$HOME/.m2" +if ($env:MAVEN_USER_HOME) { + $MAVEN_M2_PATH = "$env:MAVEN_USER_HOME" +} + +if (-not (Test-Path -Path $MAVEN_M2_PATH)) { + New-Item -Path $MAVEN_M2_PATH -ItemType Directory | Out-Null +} + +$MAVEN_WRAPPER_DISTS = $null +if ((Get-Item $MAVEN_M2_PATH).Target[0] -eq $null) { + $MAVEN_WRAPPER_DISTS = "$MAVEN_M2_PATH/wrapper/dists" +} else { + $MAVEN_WRAPPER_DISTS = (Get-Item $MAVEN_M2_PATH).Target[0] + "/wrapper/dists" +} + +$MAVEN_HOME_PARENT = "$MAVEN_WRAPPER_DISTS/$distributionUrlNameMain" +$MAVEN_HOME_NAME = ([System.Security.Cryptography.SHA256]::Create().ComputeHash([byte[]][char[]]$distributionUrl) | ForEach-Object {$_.ToString("x2")}) -join '' +$MAVEN_HOME = "$MAVEN_HOME_PARENT/$MAVEN_HOME_NAME" + +if (Test-Path -Path "$MAVEN_HOME" -PathType Container) { + Write-Verbose "found existing MAVEN_HOME at $MAVEN_HOME" + Write-Output "MVN_CMD=$MAVEN_HOME/bin/$MVN_CMD" + exit $? +} + +if (! $distributionUrlNameMain -or ($distributionUrlName -eq $distributionUrlNameMain)) { + Write-Error "distributionUrl is not valid, must end with *-bin.zip, but found $distributionUrl" +} + +# prepare tmp dir +$TMP_DOWNLOAD_DIR_HOLDER = New-TemporaryFile +$TMP_DOWNLOAD_DIR = New-Item -Itemtype Directory -Path "$TMP_DOWNLOAD_DIR_HOLDER.dir" +$TMP_DOWNLOAD_DIR_HOLDER.Delete() | Out-Null +trap { + if ($TMP_DOWNLOAD_DIR.Exists) { + try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null } + catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" } + } +} + +New-Item -Itemtype Directory -Path "$MAVEN_HOME_PARENT" -Force | Out-Null + +# Download and Install Apache Maven +Write-Verbose "Couldn't find MAVEN_HOME, downloading and installing it ..." +Write-Verbose "Downloading from: $distributionUrl" +Write-Verbose "Downloading to: $TMP_DOWNLOAD_DIR/$distributionUrlName" + +$webclient = New-Object System.Net.WebClient +if ($env:MVNW_USERNAME -and $env:MVNW_PASSWORD) { + $webclient.Credentials = New-Object System.Net.NetworkCredential($env:MVNW_USERNAME, $env:MVNW_PASSWORD) +} +[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12 +$webclient.DownloadFile($distributionUrl, "$TMP_DOWNLOAD_DIR/$distributionUrlName") | Out-Null + +# If specified, validate the SHA-256 sum of the Maven distribution zip file +$distributionSha256Sum = (Get-Content -Raw "$scriptDir/.mvn/wrapper/maven-wrapper.properties" | ConvertFrom-StringData).distributionSha256Sum +if ($distributionSha256Sum) { + if ($USE_MVND) { + Write-Error "Checksum validation is not supported for maven-mvnd. `nPlease disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties." + } + Import-Module $PSHOME\Modules\Microsoft.PowerShell.Utility -Function Get-FileHash + if ((Get-FileHash "$TMP_DOWNLOAD_DIR/$distributionUrlName" -Algorithm SHA256).Hash.ToLower() -ne $distributionSha256Sum) { + Write-Error "Error: Failed to validate Maven distribution SHA-256, your Maven distribution might be compromised. If you updated your Maven version, you need to update the specified distributionSha256Sum property." + } +} + +# unzip and move +Expand-Archive "$TMP_DOWNLOAD_DIR/$distributionUrlName" -DestinationPath "$TMP_DOWNLOAD_DIR" | Out-Null + +# Find the actual extracted directory name (handles snapshots where filename != directory name) +$actualDistributionDir = "" + +# First try the expected directory name (for regular distributions) +$expectedPath = Join-Path "$TMP_DOWNLOAD_DIR" "$distributionUrlNameMain" +$expectedMvnPath = Join-Path "$expectedPath" "bin/$MVN_CMD" +if ((Test-Path -Path $expectedPath -PathType Container) -and (Test-Path -Path $expectedMvnPath -PathType Leaf)) { + $actualDistributionDir = $distributionUrlNameMain +} + +# If not found, search for any directory with the Maven executable (for snapshots) +if (!$actualDistributionDir) { + Get-ChildItem -Path "$TMP_DOWNLOAD_DIR" -Directory | ForEach-Object { + $testPath = Join-Path $_.FullName "bin/$MVN_CMD" + if (Test-Path -Path $testPath -PathType Leaf) { + $actualDistributionDir = $_.Name + } + } +} + +if (!$actualDistributionDir) { + Write-Error "Could not find Maven distribution directory in extracted archive" +} + +Write-Verbose "Found extracted Maven distribution directory: $actualDistributionDir" +Rename-Item -Path "$TMP_DOWNLOAD_DIR/$actualDistributionDir" -NewName $MAVEN_HOME_NAME | Out-Null +try { + Move-Item -Path "$TMP_DOWNLOAD_DIR/$MAVEN_HOME_NAME" -Destination $MAVEN_HOME_PARENT | Out-Null +} catch { + if (! (Test-Path -Path "$MAVEN_HOME" -PathType Container)) { + Write-Error "fail to move MAVEN_HOME" + } +} finally { + try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null } + catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" } +} + +Write-Output "MVN_CMD=$MAVEN_HOME/bin/$MVN_CMD" From f4fca6900821f7c222f0fd6c649bae077c26e67d Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 19:43:49 +0800 Subject: [PATCH 23/79] Update GH Actions to v5 and use Maven wrapper Bump GitHub Actions steps to v5 (actions/checkout and actions/setup-java) and switch the build command to use the project Maven wrapper (./mvnw) instead of system mvn. Removed the setup-java cache configuration; this ensures the workflow uses the updated action versions and a consistent, project-provided Maven runtime for builds. --- .github/workflows/maven-build.yml | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/.github/workflows/maven-build.yml b/.github/workflows/maven-build.yml index e6edb1a1f..b2267b040 100644 --- a/.github/workflows/maven-build.yml +++ b/.github/workflows/maven-build.yml @@ -22,17 +22,16 @@ jobs: java: [ '8', '11' , '17' , '21' , '25' ] steps: - name: Checkout Source - uses: actions/checkout@v4 + uses: actions/checkout@v5 - name: Setup JDK ${{ matrix.Java }} - uses: actions/setup-java@v4 + uses: actions/setup-java@v5 with: distribution: 'temurin' java-version: ${{ matrix.java }} - cache: maven - name: Build with Maven - run: mvn + run: ./mvnw --batch-mode --update-snapshots --file pom.xml From 7cba8eb2a51a1a61768ddad78de1a66874971933 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 19:43:57 +0800 Subject: [PATCH 24/79] Upgrade GitHub Actions to v5 in Maven workflow Bump actions/checkout and actions/setup-java from v4 to v5 in .github/workflows/maven-publish.yml. Java 11 (Temurin) configuration remains unchanged. Update brings the workflow to the latest major action releases for improvements, fixes, and security updates. --- .github/workflows/maven-publish.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/maven-publish.yml b/.github/workflows/maven-publish.yml index 6d40bcd43..61db0dc6d 100644 --- a/.github/workflows/maven-publish.yml +++ b/.github/workflows/maven-publish.yml @@ -24,10 +24,10 @@ jobs: if: ${{ inputs.revision }} steps: - name: Checkout Source - uses: actions/checkout@v4 + uses: actions/checkout@v5 - name: Setup Maven Central Repository - uses: actions/setup-java@v4 + uses: actions/setup-java@v5 with: java-version: '11' distribution: 'temurin' From 6d4df332b95e76b29f554807e8607a5df60e3eed Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 20:36:25 +0800 Subject: [PATCH 25/79] Add UtilTest.beforeTest and super calls Provide a base beforeTest implementation in UtilTest that initializes testTypeElement from TestServiceImpl and add required imports (TestServiceImpl, ReflectiveInvocationContext, ExtensionContext, Method). Update several test classes (ElementUtilsTest, JSONAnnotationValueVisitorTest, MessagerUtilsTest, MethodUtilsTest, ResolvableAnnotationValueVisitorTest) to call super.beforeTest(invocationContext, extensionContext) at the start of their overridden beforeTest methods so the shared setup runs correctly. --- .../io/microsphere/lang/model/util/ElementUtilsTest.java | 1 + .../lang/model/util/JSONAnnotationValueVisitorTest.java | 1 + .../microsphere/lang/model/util/MessagerUtilsTest.java | 1 + .../io/microsphere/lang/model/util/MethodUtilsTest.java | 1 + .../model/util/ResolvableAnnotationValueVisitorTest.java | 1 + .../java/io/microsphere/lang/model/util/UtilTest.java | 9 +++++++++ 6 files changed, 14 insertions(+) diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ElementUtilsTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ElementUtilsTest.java index 6fa9d8130..e13704df3 100644 --- a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ElementUtilsTest.java +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ElementUtilsTest.java @@ -94,6 +94,7 @@ class ElementUtilsTest extends UtilTest { @Override protected void beforeTest(ReflectiveInvocationContext invocationContext, ExtensionContext extensionContext) { + super.beforeTest(invocationContext,extensionContext); this.echoMethod = findMethod(testTypeElement, "echo", "java.lang.String"); } diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONAnnotationValueVisitorTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONAnnotationValueVisitorTest.java index 6e4246323..cf1e85c0f 100644 --- a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONAnnotationValueVisitorTest.java +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONAnnotationValueVisitorTest.java @@ -50,6 +50,7 @@ class JSONAnnotationValueVisitorTest extends UtilTest { @Override protected void beforeTest(ReflectiveInvocationContext invocationContext, ExtensionContext extensionContext) { + super.beforeTest(invocationContext,extensionContext); this.jsonBuilder = new StringBuilder(); this.visitor = new JSONAnnotationValueVisitor(jsonBuilder); this.testAnnotationAttributes = getElementValues(testTypeElement, TestAnnotation.class); diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/MessagerUtilsTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/MessagerUtilsTest.java index f91edab56..554d4b4d2 100644 --- a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/MessagerUtilsTest.java +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/MessagerUtilsTest.java @@ -46,6 +46,7 @@ class MessagerUtilsTest extends UtilTest { @Override protected void beforeTest(ReflectiveInvocationContext invocationContext, ExtensionContext extensionContext) { + super.beforeTest(invocationContext,extensionContext); this.messager = this.processingEnv.getMessager(); } diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/MethodUtilsTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/MethodUtilsTest.java index 931c71b18..67a87679d 100644 --- a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/MethodUtilsTest.java +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/MethodUtilsTest.java @@ -86,6 +86,7 @@ protected void addCompiledClasses(Set> compiledClasses) { @Override protected void beforeTest(ReflectiveInvocationContext invocationContext, ExtensionContext extensionContext) { + super.beforeTest(invocationContext,extensionContext); TypeElement type = getTypeElement(Object.class); List methods = getDeclaredMethods(type); this.objectMethods = methods; diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ResolvableAnnotationValueVisitorTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ResolvableAnnotationValueVisitorTest.java index a177dad1f..225fcc3bd 100644 --- a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ResolvableAnnotationValueVisitorTest.java +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ResolvableAnnotationValueVisitorTest.java @@ -83,6 +83,7 @@ class ResolvableAnnotationValueVisitorTest extends UtilTest { @Override protected void beforeTest(ReflectiveInvocationContext invocationContext, ExtensionContext extensionContext) { + super.beforeTest(invocationContext, extensionContext); this.visitor = new ResolvableAnnotationValueVisitor(); this.visitor1 = new ResolvableAnnotationValueVisitor(true); this.visitor2 = new ResolvableAnnotationValueVisitor(true, true); diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/UtilTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/UtilTest.java index 9cad309cf..57ecefce1 100644 --- a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/UtilTest.java +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/UtilTest.java @@ -18,6 +18,9 @@ package io.microsphere.lang.model.util; import io.microsphere.test.annotation.processing.AbstractAnnotationProcessingTest; +import io.microsphere.test.service.TestServiceImpl; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.ReflectiveInvocationContext; import javax.lang.model.element.Element; import javax.lang.model.element.ExecutableElement; @@ -25,6 +28,7 @@ import javax.lang.model.element.VariableElement; import javax.lang.model.type.DeclaredType; import javax.lang.model.type.TypeMirror; +import java.lang.reflect.Method; import java.lang.reflect.Type; import java.util.List; @@ -43,6 +47,11 @@ */ public abstract class UtilTest extends AbstractAnnotationProcessingTest { + @Override + protected void beforeTest(ReflectiveInvocationContext invocationContext, ExtensionContext extensionContext) { + this.testTypeElement = getTypeElement(TestServiceImpl.class); + } + protected List getTypeMirrors(Type... types) { return TypeUtils.getTypeMirrors(processingEnv, types); } From 2514e17c397c34f485d5280d37c5a4ab956595f2 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 20:55:20 +0800 Subject: [PATCH 26/79] Add initTestClass to initialize test type Introduce initTestClass(Class) to centralize initialization of test class metadata for annotation-processing tests. The new method sets testClass, testClassName, resolves testTypeElement via Elements, assigns testTypeMirror and casts it to testDeclaredType (DeclaredType). This consolidates repeated setup logic and prepares type information for subsequent processing. --- .../processing/AbstractAnnotationProcessingTest.java | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AbstractAnnotationProcessingTest.java b/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AbstractAnnotationProcessingTest.java index 0979eab68..57f4a8daf 100644 --- a/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AbstractAnnotationProcessingTest.java +++ b/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AbstractAnnotationProcessingTest.java @@ -132,6 +132,14 @@ public abstract class AbstractAnnotationProcessingTest { protected void addCompiledClasses(Set> compiledClasses) { } + protected void initTestClass(Class testClass) { + this.testClass = testClass; + this.testClassName = testClass.getName(); + this.testTypeElement = this.elements.getTypeElement(this.testClassName); + this.testTypeMirror = this.testTypeElement.asType(); + this.testDeclaredType = (DeclaredType) this.testTypeMirror; + } + /** * Before Test * From 914e36a6b0079cfebb5f71a18d4fb1aecf8d58dd Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 20:55:30 +0800 Subject: [PATCH 27/79] Use initTestClass to initialize test class Replace manual resolution of TypeElement/TypeMirror and multiple direct field assignments with a single call to abstractAnnotationProcessingTest.initTestClass(testClass). Remove now-unused imports (DeclaredType, TypeMirror) and simplify the processor's initialization logic to centralize test class setup. --- .../processing/AnnotationProcessingTestProcessor.java | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-) diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AnnotationProcessingTestProcessor.java b/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AnnotationProcessingTestProcessor.java index abc23576e..7162d5e69 100644 --- a/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AnnotationProcessingTestProcessor.java +++ b/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AnnotationProcessingTestProcessor.java @@ -26,8 +26,6 @@ import javax.annotation.processing.SupportedAnnotationTypes; import javax.lang.model.SourceVersion; import javax.lang.model.element.TypeElement; -import javax.lang.model.type.DeclaredType; -import javax.lang.model.type.TypeMirror; import javax.lang.model.util.Elements; import javax.lang.model.util.Types; import java.lang.reflect.Method; @@ -87,19 +85,12 @@ void prepare(RoundEnvironment roundEnv) { Elements elements = processingEnv.getElementUtils(); Types types = processingEnv.getTypeUtils(); Class testClass = this.invocationContext.getTargetClass(); - String testClassName = testClass.getName(); - TypeElement testTypeElement = elements.getTypeElement(testClassName); - TypeMirror testType = testTypeElement.asType(); abstractAnnotationProcessingTest.roundEnv = roundEnv; abstractAnnotationProcessingTest.processingEnv = processingEnv; abstractAnnotationProcessingTest.elements = elements; abstractAnnotationProcessingTest.types = types; - abstractAnnotationProcessingTest.testClass = testClass; - abstractAnnotationProcessingTest.testClassName = testClassName; - abstractAnnotationProcessingTest.testTypeElement = testTypeElement; - abstractAnnotationProcessingTest.testTypeMirror = testType; - abstractAnnotationProcessingTest.testDeclaredType = (DeclaredType) testType; + abstractAnnotationProcessingTest.initTestClass(testClass); } @Override From 344794c01f5338e8a0bac351f1b9f2c770678ab6 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 20:55:48 +0800 Subject: [PATCH 28/79] Use initTestClass in UtilTest.beforeTest Replace direct assignment of testTypeElement with a call to initTestClass(TestServiceImpl.class) in beforeTest. This centralizes test setup and ensures any additional initialization performed by initTestClass is applied for the test class. --- .../src/test/java/io/microsphere/lang/model/util/UtilTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/UtilTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/UtilTest.java index 57ecefce1..2730dab41 100644 --- a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/UtilTest.java +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/UtilTest.java @@ -49,7 +49,7 @@ public abstract class UtilTest extends AbstractAnnotationProcessingTest { @Override protected void beforeTest(ReflectiveInvocationContext invocationContext, ExtensionContext extensionContext) { - this.testTypeElement = getTypeElement(TestServiceImpl.class); + initTestClass(TestServiceImpl.class); } protected List getTypeMirrors(Type... types) { From d2dca1afb94cffde88d526e36866d0f923295f57 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 20:55:55 +0800 Subject: [PATCH 29/79] Qualify test fields with 'this.' Update ResolvableAnnotationValueVisitorTest to explicitly reference instance fields by prefixing with 'this.' (visitor, visitor1, visitor2, testTypeElement) to avoid ambiguity and improve clarity. Also fix a duplicated assertion in testVisitString to use visitor2 for the third check. --- .../ResolvableAnnotationValueVisitorTest.java | 26 +++++++++---------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ResolvableAnnotationValueVisitorTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ResolvableAnnotationValueVisitorTest.java index 225fcc3bd..3189ce3f9 100644 --- a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ResolvableAnnotationValueVisitorTest.java +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ResolvableAnnotationValueVisitorTest.java @@ -87,12 +87,12 @@ protected void beforeTest(ReflectiveInvocationContext invocationContext, this.visitor = new ResolvableAnnotationValueVisitor(); this.visitor1 = new ResolvableAnnotationValueVisitor(true); this.visitor2 = new ResolvableAnnotationValueVisitor(true, true); - this.testAnnotationAttributes = getElementValues(testTypeElement, TestAnnotation.class); + this.testAnnotationAttributes = getElementValues(this.testTypeElement, TestAnnotation.class); } @Test void testVisitBoolean() { - assertEquals(BOOLEAN_VALUE, visitor.visitBoolean(BOOLEAN_VALUE, null)); + assertEquals(BOOLEAN_VALUE, this.visitor.visitBoolean(BOOLEAN_VALUE, null)); assertVisit(this.visitor, "z", BOOLEAN_VALUE); assertVisit(this.visitor1, "z", BOOLEAN_VALUE); assertVisit(this.visitor2, "z", BOOLEAN_VALUE); @@ -100,7 +100,7 @@ void testVisitBoolean() { @Test void testVisitByte() { - assertEquals(BYTE_VALUE, visitor.visitByte(BYTE_VALUE, null)); + assertEquals(BYTE_VALUE, this.visitor.visitByte(BYTE_VALUE, null)); assertVisit(this.visitor, "b", BYTE_VALUE); assertVisit(this.visitor1, "b", BYTE_VALUE); assertVisit(this.visitor2, "b", BYTE_VALUE); @@ -108,7 +108,7 @@ void testVisitByte() { @Test void testVisitChar() { - assertEquals(CHAR_VALUE, visitor.visitChar(CHAR_VALUE, null)); + assertEquals(CHAR_VALUE, this.visitor.visitChar(CHAR_VALUE, null)); assertVisit(this.visitor, "c", CHAR_VALUE); assertVisit(this.visitor1, "c", CHAR_VALUE); assertVisit(this.visitor2, "c", CHAR_VALUE); @@ -116,7 +116,7 @@ void testVisitChar() { @Test void testVisitDouble() { - assertEquals(DOUBLE_VALUE, visitor.visitDouble(DOUBLE_VALUE, null)); + assertEquals(DOUBLE_VALUE, this.visitor.visitDouble(DOUBLE_VALUE, null)); assertVisit(this.visitor, "d", DOUBLE_VALUE); assertVisit(this.visitor1, "d", DOUBLE_VALUE); assertVisit(this.visitor2, "d", DOUBLE_VALUE); @@ -124,7 +124,7 @@ void testVisitDouble() { @Test void testVisitFloat() { - assertEquals(FLOAT_VALUE, visitor.visitFloat(FLOAT_VALUE, null)); + assertEquals(FLOAT_VALUE, this.visitor.visitFloat(FLOAT_VALUE, null)); assertVisit(this.visitor, "f", FLOAT_VALUE); assertVisit(this.visitor1, "f", FLOAT_VALUE); assertVisit(this.visitor2, "f", FLOAT_VALUE); @@ -132,7 +132,7 @@ void testVisitFloat() { @Test void testVisitInt() { - assertEquals(INT_VALUE, visitor.visitInt(INT_VALUE, null)); + assertEquals(INT_VALUE, this.visitor.visitInt(INT_VALUE, null)); assertVisit(this.visitor, "i", INT_VALUE); assertVisit(this.visitor1, "i", INT_VALUE); assertVisit(this.visitor2, "i", INT_VALUE); @@ -140,7 +140,7 @@ void testVisitInt() { @Test void testVisitLong() { - assertEquals(LONG_VALUE, visitor.visitLong(LONG_VALUE, null)); + assertEquals(LONG_VALUE, this.visitor.visitLong(LONG_VALUE, null)); assertVisit(this.visitor, "l", LONG_VALUE); assertVisit(this.visitor1, "l", LONG_VALUE); assertVisit(this.visitor2, "l", LONG_VALUE); @@ -148,7 +148,7 @@ void testVisitLong() { @Test void testVisitShort() { - assertEquals(SHORT_VALUE, visitor.visitShort(SHORT_VALUE, null)); + assertEquals(SHORT_VALUE, this.visitor.visitShort(SHORT_VALUE, null)); assertVisit(this.visitor, "s", SHORT_VALUE); assertVisit(this.visitor1, "s", SHORT_VALUE); assertVisit(this.visitor2, "s", SHORT_VALUE); @@ -156,15 +156,15 @@ void testVisitShort() { @Test void testVisitString() { - assertEquals(STRING_VALUE, visitor.visitString(STRING_VALUE, null)); + assertEquals(STRING_VALUE, this.visitor.visitString(STRING_VALUE, null)); assertVisit(this.visitor, "string", STRING_VALUE); assertVisit(this.visitor1, "string", STRING_VALUE); - assertVisit(this.visitor1, "string", STRING_VALUE); + assertVisit(this.visitor2, "string", STRING_VALUE); } @Test void testVisitType() { - assertEquals(TYPE_VALUE, visitor.visitType(getTypeMirror(TYPE_VALUE), null)); + assertEquals(TYPE_VALUE, this.visitor.visitType(getTypeMirror(TYPE_VALUE), null)); assertVisit(this.visitor, "type", TYPE_VALUE); assertVisit(this.visitor1, "type", TYPE_VALUE.getName()); assertVisit(this.visitor2, "type", TYPE_VALUE.getName()); @@ -204,7 +204,7 @@ void testVisitUnknown() { for (Entry elementValue : this.testAnnotationAttributes.entrySet()) { ExecutableElement attributeMethod = elementValue.getKey(); AnnotationValue annotationValue = elementValue.getValue(); - assertSame(annotationValue, visitor.visitUnknown(annotationValue, attributeMethod)); + assertSame(annotationValue, this.visitor.visitUnknown(annotationValue, attributeMethod)); } } From 1532f508d011b67e7aa0c83da709b5f146f09ae6 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 21:16:25 +0800 Subject: [PATCH 30/79] Refactor JSONElementVisitor unsupported tests Rename and reorganize tests in JSONElementVisitorTest to match the visited element types and assertions. Test method names were corrected (package, variable, executable, type, type-parameter) and assertions updated to call the appropriate visitor methods and element getters; a missing test for visitTypeParameter when unsupported was added. Minor formatting cleanup included. --- .../model/util/JSONElementVisitorTest.java | 25 +++++++++++-------- 1 file changed, 15 insertions(+), 10 deletions(-) diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONElementVisitorTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONElementVisitorTest.java index c18e83147..ade0ce967 100644 --- a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONElementVisitorTest.java +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONElementVisitorTest.java @@ -145,9 +145,9 @@ void testVisitPackage() { } @Test - void testVisitVariableOnUnsupported() { + void testVisitPackageOnUnsupported() { supported = false; - assertFalse(visitor.visitVariable(null, jsonBuilder)); + assertFalse(visitor.visitPackage(this.elements.getPackageElement("io.microsphere.annotation.processor.model.util"), jsonBuilder)); } @Test @@ -155,7 +155,6 @@ void testVisitVariableAsEnumConstant() { VariableElement element = getField(Color.class, "RED"); assertTrue(visitor.visitVariable(element, jsonBuilder)); assertJson("visitVariableAsEnumConstant"); - } @Test @@ -175,9 +174,9 @@ void testVisitVariableAsParameter() { } @Test - void testVisitExecutableOnUnsupported() { + void testVisitVariableOnUnsupported() { supported = false; - assertFalse(visitor.visitExecutable(null, jsonBuilder)); + assertFalse(visitor.visitVariable(null, jsonBuilder)); } @Test @@ -195,10 +194,9 @@ void testVisitExecutableAsMethod() { } @Test - void testVisitTypeOnUnsupported() { + void testVisitExecutableOnUnsupported() { supported = false; - TypeElement typeElement = getTypeElement(Serializable.class); - assertFalse(visitor.visitType(typeElement, jsonBuilder)); + assertFalse(visitor.visitExecutable(null, jsonBuilder)); } @Test @@ -230,9 +228,10 @@ void testVisitTypeAsAnnotationType() { } @Test - void testVisitTypeParameterOnUnsupported() { + void testVisitTypeOnUnsupported() { supported = false; - assertFalse(visitor.visitTypeParameter(null, jsonBuilder)); + TypeElement typeElement = getTypeElement(Serializable.class); + assertFalse(visitor.visitType(typeElement, jsonBuilder)); } @Test @@ -247,6 +246,12 @@ void testVisitTypeParameter() { } } + @Test + void testVisitTypeParameterOnUnsupported() { + supported = false; + assertFalse(visitor.visitTypeParameter(null, jsonBuilder)); + } + void assertJson(String expected) { assertEquals(expected, jsonBuilder.toString()); } From ef24c72e056e58c53e1b3b4dabbf28f214703ab5 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 21:43:00 +0800 Subject: [PATCH 31/79] Return early when type not supported If supportsType(e) is false, visitType now returns immediately to avoid processing unsupported types. Also initialize 'appended' from super.visitType(e, jsonBuilder) and keep existing member-visit logic, simplifying control flow and making behavior more explicit. --- .../lang/model/util/JSONElementVisitor.java | 23 ++++--------------- 1 file changed, 5 insertions(+), 18 deletions(-) diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/JSONElementVisitor.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/JSONElementVisitor.java index 36a20126c..46cf974e0 100644 --- a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/JSONElementVisitor.java +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/JSONElementVisitor.java @@ -77,11 +77,12 @@ public final Boolean visitExecutable(ExecutableElement e, StringBuilder jsonBuil @Override public final Boolean visitType(TypeElement e, StringBuilder jsonBuilder) { - boolean appended = false; - if (supportsType(e) && super.visitType(e, jsonBuilder)) { - appended = true; + if (!supportsType(e)) { + return false; } + boolean appended = super.visitType(e, jsonBuilder); + // The declared members of the type element if (visitMembers(e.getEnclosedElements(), jsonBuilder)) { appended = true; @@ -92,21 +93,7 @@ public final Boolean visitType(TypeElement e, StringBuilder jsonBuilder) { @Override public final Boolean visitTypeParameter(TypeParameterElement e, StringBuilder jsonBuilder) { - if (!supports(e)) { - return FALSE; - } - - boolean appended = false; - if (supportsTypeParameter(e) && doVisitTypeParameter(e, jsonBuilder)) { - appended = true; - } - - // The declared members of the type element - if (visitMembers(e.getEnclosedElements(), jsonBuilder)) { - appended = true; - } - - return appended; + return supportsTypeParameter(e) && doVisitTypeParameter(e, jsonBuilder); } protected boolean visitMembers(List members, StringBuilder jsonBuilder) { From 3442b9f1fc95bf05b0801d0201b1705cd703c710 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 22:05:42 +0800 Subject: [PATCH 32/79] Use ListUtils.first for annotation retrieval Replace manual .get(0) checks with ListUtils.first by adding a static import and using first(annotations) in AnnotationUtils. Simplifies code for obtaining the first annotation and centralizes handling of empty lists. --- .../java/io/microsphere/lang/model/util/AnnotationUtils.java | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/AnnotationUtils.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/AnnotationUtils.java index 53462b44f..5d33af6fb 100644 --- a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/AnnotationUtils.java +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/AnnotationUtils.java @@ -44,6 +44,7 @@ import static io.microsphere.collection.CollectionUtils.isEmpty; import static io.microsphere.collection.CollectionUtils.size; +import static io.microsphere.collection.ListUtils.first; import static io.microsphere.collection.MapUtils.immutableEntry; import static io.microsphere.collection.MapUtils.isEmpty; import static io.microsphere.collection.MapUtils.newFixedLinkedHashMap; @@ -169,7 +170,7 @@ static AnnotationMirror getAnnotation(AnnotatedConstruct annotatedConstruct, Cha return null; } List annotations = getAnnotations(annotatedConstruct, annotationClassName); - return annotations.isEmpty() ? null : annotations.get(0); + return first(annotations); } /** @@ -606,7 +607,7 @@ static AnnotationMirror findAnnotation(Element element, CharSequence annotationC return null; } List annotations = findAllAnnotations(element, annotation -> matchesAnnotationTypeName(annotation, annotationClassName)); - return isEmpty(annotations) ? null : annotations.get(0); + return first(annotations); } /** From d63ffdfcd12d73f975e490e4336721350a2dbba4 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 22:08:23 +0800 Subject: [PATCH 33/79] Use ListUtils.first in MethodUtils Replace manual empty-check and get(0) pattern with a static import of ListUtils.first when returning the first declared method. Adds import io.microsphere.collection.ListUtils.first and uses first(allDeclaredMethods) to keep the previous null-on-empty behavior while simplifying the code. --- .../java/io/microsphere/lang/model/util/MethodUtils.java | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/MethodUtils.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/MethodUtils.java index f4e741343..de250a897 100644 --- a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/MethodUtils.java +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/MethodUtils.java @@ -35,6 +35,7 @@ import java.util.function.Predicate; import static io.microsphere.collection.CollectionUtils.isEmpty; +import static io.microsphere.collection.ListUtils.first; import static io.microsphere.lang.function.Predicates.EMPTY_PREDICATE_ARRAY; import static io.microsphere.lang.function.Predicates.and; import static io.microsphere.lang.function.Streams.filterFirst; @@ -666,7 +667,7 @@ static ExecutableElement findMethod(TypeMirror type, String methodName, Type... return null; } List allDeclaredMethods = findAllDeclaredMethods(type, method -> matches(method, methodName, parameterTypes)); - return allDeclaredMethods.isEmpty() ? null : allDeclaredMethods.get(0); + return first(allDeclaredMethods); } /** @@ -730,7 +731,7 @@ static ExecutableElement findMethod(TypeMirror type, String methodName, CharSequ return null; } List allDeclaredMethods = findAllDeclaredMethods(type, method -> matches(method, methodName, parameterTypeNames)); - return allDeclaredMethods.isEmpty() ? null : allDeclaredMethods.get(0); + return first(allDeclaredMethods); } /** From 3daabb99bff947d1d62b772ac1bbda2ecc0af0c0 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 22:08:37 +0800 Subject: [PATCH 34/79] Remove optional flag from core dependency Deleted the true element from the microsphere-java-core dependency in microsphere-java-test/pom.xml so the core artifact is no longer optional and will be included on the test module's classpath (ensuring tests have access to core). --- microsphere-java-test/pom.xml | 1 - 1 file changed, 1 deletion(-) diff --git a/microsphere-java-test/pom.xml b/microsphere-java-test/pom.xml index 568f1add5..40504c98e 100644 --- a/microsphere-java-test/pom.xml +++ b/microsphere-java-test/pom.xml @@ -25,7 +25,6 @@ io.github.microsphere-projects microsphere-java-core ${revision} - true From 0714652b0d5a84249e3a43624b892caba9966cb5 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Wed, 4 Feb 2026 22:16:46 +0800 Subject: [PATCH 35/79] Qualify echoMethod references in tests Update ElementUtilsTest to consistently reference the instance field by qualifying echoMethod with this. Also add additional null-case assertions for matchParameterTypes (NULL_METHOD and NULL_CLASS_ARRAY) and normalize spacing in super.beforeTest. These changes improve clarity and null-safety in the test code. --- .../lang/model/util/ElementUtilsTest.java | 20 ++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ElementUtilsTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ElementUtilsTest.java index e13704df3..df59a4162 100644 --- a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ElementUtilsTest.java +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ElementUtilsTest.java @@ -94,20 +94,20 @@ class ElementUtilsTest extends UtilTest { @Override protected void beforeTest(ReflectiveInvocationContext invocationContext, ExtensionContext extensionContext) { - super.beforeTest(invocationContext,extensionContext); + super.beforeTest(invocationContext, extensionContext); this.echoMethod = findMethod(testTypeElement, "echo", "java.lang.String"); } @Test void testMatchesElementTypeElementKind() { assertTrue(matchesElementKind(echoMethod, METHOD)); - assertFalse(matchesElementKind(echoMethod, FIELD)); + assertFalse(matchesElementKind(this.echoMethod, FIELD)); } @Test void testMatchesElementTypeElementKindOnNull() { assertFalse(matchesElementKind(NULL_ELEMENT, FIELD)); - assertFalse(matchesElementKind(echoMethod, NULL_ELEMENT_KIND)); + assertFalse(matchesElementKind(this.echoMethod, NULL_ELEMENT_KIND)); } @Test @@ -306,33 +306,35 @@ void testFilterElements() { @Test void testFilterElementsOnNull() { assertEmptyList(filterElements(NULL_LIST, alwaysTrue())); - List methods = ofList(echoMethod); + List methods = ofList(this.echoMethod); assertSame(emptyList(), filterElements(methods, NULL_PREDICATE_ARRAY)); } @Test void testFilterElementsOnEmpty() { assertEmptyList(filterElements(emptyList(), alwaysTrue())); - List methods = ofList(echoMethod); + List methods = ofList(this.echoMethod); assertEquals(methods, filterElements(methods)); } @Test void testMatchParameterTypes() { - assertTrue(matchParameterTypes(echoMethod.getParameters(), String.class)); - assertFalse(matchParameterTypes(echoMethod.getParameters(), Object.class)); + assertTrue(matchParameterTypes(this.echoMethod.getParameters(), String.class)); + assertFalse(matchParameterTypes(this.echoMethod.getParameters(), Object.class)); } @Test void testMatchParameterTypesOnNull() { assertFalse(matchParameterTypes(NULL_LIST, String.class)); assertFalse(matchParameterTypes(emptyList(), NULL_CLASS_ARRAY)); + assertFalse(matchParameterTypes(NULL_METHOD, String.class)); + assertFalse(matchParameterTypes(this.echoMethod, NULL_CLASS_ARRAY)); } @Test void testMatchParameterTypeNames() { - assertTrue(matchParameterTypeNames(echoMethod.getParameters(), "java.lang.String")); - assertFalse(matchParameterTypeNames(echoMethod.getParameters(), "java.lang.Object")); + assertTrue(matchParameterTypeNames(this.echoMethod.getParameters(), "java.lang.String")); + assertFalse(matchParameterTypeNames(this.echoMethod.getParameters(), "java.lang.Object")); } @Test From 1424da904a4c577670ec219080c8b06dd34a4bfe Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Thu, 5 Feb 2026 13:52:59 +0800 Subject: [PATCH 36/79] Test loadClass returns null for missing class Add a null-case assertion to ClassUtilsTest: import assertNull and assert that loadClass("not-found-class") returns null. This verifies that loadClass handles unknown class names gracefully. --- .../java/io/microsphere/lang/model/util/ClassUtilsTest.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ClassUtilsTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ClassUtilsTest.java index 5f6708723..c6857d5ed 100644 --- a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ClassUtilsTest.java +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ClassUtilsTest.java @@ -23,6 +23,7 @@ import static io.microsphere.lang.model.util.ClassUtils.getClassName; import static io.microsphere.lang.model.util.ClassUtils.loadClass; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertSame; /** @@ -47,5 +48,6 @@ void testLoadClassOnTypeMirror() { @Test void testLoadClass() { assertSame(ComponentScan.Filter.class, loadClass("org.springframework.context.annotation.ComponentScan.Filter")); + assertNull(loadClass("not-found-class")); } } From 632bc1bda1c172b8ac5a3a256c2505b0b91f1e93 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Thu, 5 Feb 2026 14:13:25 +0800 Subject: [PATCH 37/79] Re-throw test failure root cause as Error After invoking afterTest, if a test produced a failure, extract its root cause and rethrow it wrapped as an Error to preserve the original cause and halt processing. Adds static imports for ExceptionUtils.wrap and ThrowableUtils.getRootCause. --- .../processing/AnnotationProcessingTestProcessor.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AnnotationProcessingTestProcessor.java b/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AnnotationProcessingTestProcessor.java index 7162d5e69..3192d0140 100644 --- a/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AnnotationProcessingTestProcessor.java +++ b/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/AnnotationProcessingTestProcessor.java @@ -32,6 +32,8 @@ import java.util.Set; import static io.microsphere.constants.SymbolConstants.WILDCARD; +import static io.microsphere.util.ExceptionUtils.wrap; +import static io.microsphere.util.ThrowableUtils.getRootCause; import static javax.lang.model.SourceVersion.latestSupported; /** @@ -76,6 +78,10 @@ public boolean process(Set annotations, RoundEnvironment } finally { abstractAnnotationProcessingTest.afterTest(invocationContext, extensionContext, result, failure); } + if (failure != null) { + Throwable cause = getRootCause(failure); + throw wrap(cause, Error.class); + } } return false; } From a2d6b6a8d23c4bcadce285cd19a3cf5fc5f05607 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Thu, 5 Feb 2026 14:15:08 +0800 Subject: [PATCH 38/79] Improve matchesElementType test assertions Replace a bare matchesElementType call with explicit assertions in ElementUtilsTest: assertTrue for the expected TYPE match and assertFalse for a non-matching PACKAGE. This makes the test verify both positive and negative outcomes rather than relying on a no-op call. --- .../java/io/microsphere/lang/model/util/ElementUtilsTest.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ElementUtilsTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ElementUtilsTest.java index df59a4162..46c2e03cb 100644 --- a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ElementUtilsTest.java +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ElementUtilsTest.java @@ -281,7 +281,8 @@ void testMatchesElementTypeWithArray() { @Test void testMatchesElementTypeWithElement() { - matchesElementType(this.testTypeElement, TYPE); + assertTrue(matchesElementType(this.testTypeElement, TYPE)); + assertFalse(matchesElementType(this.testTypeElement, PACKAGE)); } @Test From 31c7f9fae0968312b5d304556093cc11bd8fff64 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Thu, 5 Feb 2026 15:04:24 +0800 Subject: [PATCH 39/79] Make context and environment protected Change ApplicationContext and Environment field visibility from package-private to protected so subclasses can access them directly. @Autowired on the ApplicationContext is retained; Environment remains unannotated. --- .../java/io/microsphere/test/service/TestServiceImpl.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/service/TestServiceImpl.java b/microsphere-java-test/src/main/java/io/microsphere/test/service/TestServiceImpl.java index a97658884..27a53b2d3 100644 --- a/microsphere-java-test/src/main/java/io/microsphere/test/service/TestServiceImpl.java +++ b/microsphere-java-test/src/main/java/io/microsphere/test/service/TestServiceImpl.java @@ -77,9 +77,9 @@ public class TestServiceImpl extends GenericTestService implements TestService, AutoCloseable, Serializable { @Autowired - ApplicationContext context; + protected ApplicationContext context; - Environment environment; + protected Environment environment; public TestServiceImpl() { this(null); From 1be84f729fb408d9806613372764ec0216a3ff58 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Thu, 5 Feb 2026 15:04:36 +0800 Subject: [PATCH 40/79] Use PROTECTED modifier in ElementUtilsTest Replace PRIVATE with PROTECTED in the import and the assertion so the test verifies the protected modifier on the field. This aligns the test expectation with the field's actual visibility. --- .../java/io/microsphere/lang/model/util/ElementUtilsTest.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ElementUtilsTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ElementUtilsTest.java index 46c2e03cb..b65ea7b2c 100644 --- a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ElementUtilsTest.java +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/ElementUtilsTest.java @@ -72,7 +72,7 @@ import static javax.lang.model.element.ElementKind.PARAMETER; import static javax.lang.model.element.ElementKind.RESOURCE_VARIABLE; import static javax.lang.model.element.ElementKind.STATIC_INIT; -import static javax.lang.model.element.Modifier.PRIVATE; +import static javax.lang.model.element.Modifier.PROTECTED; import static javax.lang.model.util.ElementFilter.fieldsIn; import static javax.lang.model.util.ElementFilter.methodsIn; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -127,7 +127,7 @@ void testIsPublicNonStaticOnNull() { void testHasModifiers() { List members = getAllDeclaredMembers(testTypeElement.asType()); List fields = fieldsIn(members); - assertTrue(hasModifiers(fields.get(0), PRIVATE)); + assertTrue(hasModifiers(fields.get(0), PROTECTED)); } @Test From 3d65ddf6ec6fc0751ace0a74ba6382fdfc2229b8 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Thu, 5 Feb 2026 15:04:49 +0800 Subject: [PATCH 41/79] Fix expected type in JSONAnnotationValueVisitorTest Update the expected JSON fragment in testVisit from "io.microsphere.annotation.processor.GenericTestService" to "io.microsphere.test.service.GenericTestService" to match the class/package change. This keeps the test assertion in microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONAnnotationValueVisitorTest.java in sync with the refactored/relocated test service class. --- .../lang/model/util/JSONAnnotationValueVisitorTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONAnnotationValueVisitorTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONAnnotationValueVisitorTest.java index cf1e85c0f..d89d3c732 100644 --- a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONAnnotationValueVisitorTest.java +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONAnnotationValueVisitorTest.java @@ -103,7 +103,7 @@ void testVisitString() { @Test void testVisitType() { - testVisit("type", "\"type\":\"io.microsphere.annotation.processor.GenericTestService\""); + testVisit("type", "\"type\":\"io.microsphere.test.service.GenericTestService\""); } @Test From 24cbc8852ef5f0e8928dc3bf0e5ea0a46487fcec Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Thu, 5 Feb 2026 15:05:08 +0800 Subject: [PATCH 42/79] Update package refs in JSONElementVisitorTest Replace outdated package references in JSONElementVisitorTest: change io.microsphere.annotation.processor.model.util to io.microsphere.lang.model.util in testVisitPackage and testVisitPackageOnUnsupported. Keeps tests aligned with the current package structure after refactor. --- .../microsphere/lang/model/util/JSONElementVisitorTest.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONElementVisitorTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONElementVisitorTest.java index ade0ce967..f9c20e905 100644 --- a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONElementVisitorTest.java +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/JSONElementVisitorTest.java @@ -140,14 +140,14 @@ public Boolean visitTypeAsAnnotationType(TypeElement e, StringBuilder stringBuil @Test void testVisitPackage() { - assertTrue(visitor.visitPackage(this.elements.getPackageElement("io.microsphere.annotation.processor.model.util"), jsonBuilder)); + assertTrue(visitor.visitPackage(this.elements.getPackageElement("io.microsphere.lang.model.util"), jsonBuilder)); assertJson("visitPackage"); } @Test void testVisitPackageOnUnsupported() { supported = false; - assertFalse(visitor.visitPackage(this.elements.getPackageElement("io.microsphere.annotation.processor.model.util"), jsonBuilder)); + assertFalse(visitor.visitPackage(this.elements.getPackageElement("io.microsphere.lang.model.util"), jsonBuilder)); } @Test From f16d29471e0f0c231a01e581634f35023faf1766 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Thu, 5 Feb 2026 15:13:20 +0800 Subject: [PATCH 43/79] Ignore testOnFailure exceptions via extension Make AnnotationProcessingTest a JUnit 5 exception handler and use it as an extension for testOnFailure. The class now implements TestExecutionExceptionHandler and is applied to the failing test with @ExtendWith(AnnotationProcessingTest.class). handleTestExecutionException suppresses the RuntimeException thrown by testOnFailure so the test can exercise failure behavior without failing the whole test run. Added the required JUnit imports. --- .../processing/AnnotationProcessingTest.java | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/AnnotationProcessingTest.java b/microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/AnnotationProcessingTest.java index 287fb77f9..568cf0d3d 100644 --- a/microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/AnnotationProcessingTest.java +++ b/microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/AnnotationProcessingTest.java @@ -18,8 +18,10 @@ package io.microsphere.test.annotation.processing; import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.api.extension.ExtensionContext; import org.junit.jupiter.api.extension.ReflectiveInvocationContext; +import org.junit.jupiter.api.extension.TestExecutionExceptionHandler; import javax.lang.model.element.Element; import javax.lang.model.type.TypeMirror; @@ -38,7 +40,7 @@ * @see AbstractAnnotationProcessingTest * @since 1.0.0 */ -public class AnnotationProcessingTest extends AbstractAnnotationProcessingTest { +public class AnnotationProcessingTest extends AbstractAnnotationProcessingTest implements TestExecutionExceptionHandler { @Test void test() { @@ -72,6 +74,7 @@ void test() { } @Test + @ExtendWith(AnnotationProcessingTest.class) void testOnFailure() { throw new RuntimeException("For testing"); } @@ -83,4 +86,14 @@ protected void afterTest(ReflectiveInvocationContext invocationContext, assertEquals("For testing", failure.getMessage()); } } + + @Override + public void handleTestExecutionException(ExtensionContext context, Throwable throwable) throws Throwable { + if (throwable != null) { + Method method = context.getTestMethod().get(); + if ("testOnFailure".equals(method.getName())) { + // ingnore + } + } + } } From 418d96ec02b96d58683a535e7968fc1d28207930 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Thu, 5 Feb 2026 15:20:42 +0800 Subject: [PATCH 44/79] Remove final newline from AnnotationProcessingTest Remove the trailing newline at end-of-file for microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/AnnotationProcessingTest.java. No other code changes were made. --- .../test/annotation/processing/AnnotationProcessingTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/AnnotationProcessingTest.java b/microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/AnnotationProcessingTest.java index 568cf0d3d..9b40f9b77 100644 --- a/microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/AnnotationProcessingTest.java +++ b/microsphere-java-test/src/test/java/io/microsphere/test/annotation/processing/AnnotationProcessingTest.java @@ -96,4 +96,4 @@ public void handleTestExecutionException(ExtensionContext context, Throwable thr } } } -} +} \ No newline at end of file From 380521c3987d6808ce317842bb4caef13ea2ef33 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Thu, 5 Feb 2026 15:53:39 +0800 Subject: [PATCH 45/79] Enable JUnit Jupiter extensions & parallelism Add junit-platform.properties to enable JUnit Jupiter extension autodetection and parallel test execution. Sets junit.jupiter.extensions.autodetection.enabled=true and configures parallel execution mode to concurrent for both default and classes, improving test discovery and runtime performance. File added at microsphere-java-test/src/main/resources. --- .../src/main/resources/junit-platform.properties | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 microsphere-java-test/src/main/resources/junit-platform.properties diff --git a/microsphere-java-test/src/main/resources/junit-platform.properties b/microsphere-java-test/src/main/resources/junit-platform.properties new file mode 100644 index 000000000..1e4594242 --- /dev/null +++ b/microsphere-java-test/src/main/resources/junit-platform.properties @@ -0,0 +1,5 @@ +junit.jupiter.extensions.autodetection.enabled = true + +junit.jupiter.execution.parallel.enabled = true +junit.jupiter.execution.parallel.mode.default = concurrent +junit.jupiter.execution.parallel.mode.classes.default = concurrent \ No newline at end of file From 8b003226ea0eca03ad8fe76e2d3f40715f05fb33 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Thu, 5 Feb 2026 18:20:33 +0800 Subject: [PATCH 46/79] Refactor getElementValue and update tests Simplify AnnotationUtils.getElementValue: narrow attribute method search by combining the missing-value and name match into the predicate, use first(...) to pick the attribute method, and return null early if no value is found. Update unit tests to reference super.testTypeElement/testTypeMirror consistently, add missing imports (PAYLOAD, assertNotNull), and introduce new tests for default-attribute-null and element-not-found cases. Also strengthen assertAttributeEntry (null checks and clearer expected-value comparison) and adjust related helper methods to match the new behaviors. --- .../lang/model/util/AnnotationUtils.java | 17 +- .../lang/model/util/AnnotationUtilsTest.java | 224 ++++++++++-------- 2 files changed, 139 insertions(+), 102 deletions(-) diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/AnnotationUtils.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/AnnotationUtils.java index 5d33af6fb..816854717 100644 --- a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/AnnotationUtils.java +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/AnnotationUtils.java @@ -1582,17 +1582,18 @@ static Entry getElementValue(AnnotationMirro if (withDefault && annotationValue == null) { // not found if the default value is required DeclaredType annotationType = annotation.getAnnotationType(); - List attributeMethods = findDeclaredMethods(annotationType, method -> !elementValues.containsKey(method)); - int size = attributeMethods.size(); - for (int i = 0; i < size; i++) { - attributeMethod = attributeMethods.get(i); - if (matchesAttributeMethod(attributeMethod, attributeName)) { - annotationValue = attributeMethod.getDefaultValue(); - break; - } + List attributeMethods = findDeclaredMethods(annotationType, method -> + !elementValues.containsKey(method) && matchesAttributeMethod(method, attributeName)); + attributeMethod = first(attributeMethods); + if (attributeMethod != null) { + annotationValue = attributeMethod.getDefaultValue(); } } + if (annotationValue == null) { + return null; + } + return immutableEntry(attributeMethod, annotationValue); } diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/AnnotationUtilsTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/AnnotationUtilsTest.java index 4dec272bb..bb9a48f9b 100644 --- a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/AnnotationUtilsTest.java +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/AnnotationUtilsTest.java @@ -82,9 +82,11 @@ import static java.lang.annotation.ElementType.METHOD; import static java.lang.annotation.ElementType.TYPE; import static java.util.Collections.emptyMap; +import static javax.xml.ws.Service.Mode.PAYLOAD; import static org.junit.jupiter.api.Assertions.assertArrayEquals; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertSame; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -109,21 +111,21 @@ void testGetAnnotationWithClassName() { @Test void testGetAnnotationOnNull() { - assertNull(getAnnotation(testTypeElement, NULL_CLASS)); - assertNull(getAnnotation(testTypeElement.asType(), NULL_CLASS)); + assertNull(getAnnotation(super.testTypeElement, NULL_CLASS)); + assertNull(getAnnotation(super.testTypeElement.asType(), NULL_CLASS)); assertNull(getAnnotation(NULL_ANNOTATED_CONSTRUCT, NULL_CLASS)); } @Test void testGetAnnotationWithClassNameOnNull() { - assertNull(getAnnotation(testTypeElement, NULL_STRING)); - assertNull(getAnnotation(testTypeElement.asType(), NULL_STRING)); + assertNull(getAnnotation(super.testTypeElement, NULL_STRING)); + assertNull(getAnnotation(super.testTypeElement.asType(), NULL_STRING)); assertNull(getAnnotation(NULL_ANNOTATED_CONSTRUCT, NULL_STRING)); } @Test void testGetAnnotations() { - List annotations = getAnnotations(testTypeElement); + List annotations = getAnnotations(super.testTypeElement); assertEquals(4, annotations.size()); assertAnnotation(annotations.get(0), Service.class); assertAnnotation(annotations.get(1), ServiceMode.class); @@ -146,13 +148,13 @@ void testGetAnnotationsWithAnnotationClass() { @Test void testGetAnnotationsWithAnnotationClassOnNull() { assertTrue(getAnnotations(NULL_ANNOTATED_CONSTRUCT, NULL_CLASS).isEmpty()); - assertTrue(getAnnotations(testTypeElement, NULL_CLASS).isEmpty()); + assertTrue(getAnnotations(super.testTypeElement, NULL_CLASS).isEmpty()); assertTrue(getAnnotations(NULL_ANNOTATED_CONSTRUCT, Service.class).isEmpty()); } @Test void testGetAnnotationsWithAnnotationClassOnNotFound() { - List annotations = getAnnotations(testTypeElement, Override.class); + List annotations = getAnnotations(super.testTypeElement, Override.class); assertEquals(0, annotations.size()); } @@ -165,16 +167,16 @@ void testGetAnnotationsWithAnnotationClassName() { @Test void testGetAnnotationsWithAnnotationClassNameOnNull() { assertTrue(getAnnotations(NULL_ANNOTATED_CONSTRUCT, NULL_STRING).isEmpty()); - assertTrue(getAnnotations(testTypeElement, NULL_STRING).isEmpty()); + assertTrue(getAnnotations(super.testTypeElement, NULL_STRING).isEmpty()); assertTrue(getAnnotations(NULL_ANNOTATED_CONSTRUCT, "org.springframework.stereotype.Service").isEmpty()); } @Test void testGetAllAnnotations() { - List annotations = getAllAnnotations(testTypeElement); + List annotations = getAllAnnotations(super.testTypeElement); assertEquals(5, annotations.size()); - annotations = getAllAnnotations(testTypeMirror); + annotations = getAllAnnotations(super.testTypeMirror); assertEquals(5, annotations.size()); } @@ -186,16 +188,16 @@ void testGetAllAnnotationsOnNull() { @Test void testGetAllAnnotationsWithAnnotationClass() { - List annotations = getAllAnnotations(testTypeElement, Override.class); + List annotations = getAllAnnotations(super.testTypeElement, Override.class); assertEquals(0, annotations.size()); - annotations = getAllAnnotations(testTypeMirror, Override.class); + annotations = getAllAnnotations(super.testTypeMirror, Override.class); assertEquals(0, annotations.size()); - annotations = getAllAnnotations(testTypeElement, Service.class); + annotations = getAllAnnotations(super.testTypeElement, Service.class); assertEquals(1, annotations.size()); - annotations = getAllAnnotations(testTypeMirror, Service.class); + annotations = getAllAnnotations(super.testTypeMirror, Service.class); assertEquals(1, annotations.size()); annotations = getAllAnnotations(processingEnv, TestServiceImpl.class); @@ -212,17 +214,17 @@ void testGetAllAnnotationsWithAnnotationClassOnNull() { assertEmptyList(getAllAnnotations(NULL_TYPE_MIRROR, Service.class)); assertEmptyList(getAllAnnotations(NULL_PROCESSING_ENVIRONMENT, Service.class)); - assertEmptyList(getAllAnnotations(testTypeElement, NULL_CLASS)); - assertEmptyList(getAllAnnotations(testTypeMirror, NULL_CLASS)); + assertEmptyList(getAllAnnotations(super.testTypeElement, NULL_CLASS)); + assertEmptyList(getAllAnnotations(super.testTypeMirror, NULL_CLASS)); assertEmptyList(getAllAnnotations(processingEnv, NULL_CLASS)); } @Test void testGetAllAnnotationsWithAnnotationClassName() { - List annotations = getAllAnnotations(testTypeElement, "java.lang.Override"); + List annotations = getAllAnnotations(super.testTypeElement, "java.lang.Override"); assertEquals(0, annotations.size()); - annotations = getAllAnnotations(testTypeMirror, "org.springframework.stereotype.Service"); + annotations = getAllAnnotations(super.testTypeMirror, "org.springframework.stereotype.Service"); assertEquals(1, annotations.size()); } @@ -234,8 +236,8 @@ void testGetAllAnnotationsWithAnnotationClassNameOnNull() { assertTrue(getAllAnnotations(NULL_ELEMENT, "org.springframework.stereotype.Service").isEmpty()); assertTrue(getAllAnnotations(NULL_TYPE_MIRROR, "org.springframework.stereotype.Service").isEmpty()); - assertEmptyList(getAllAnnotations(testTypeElement, NULL_STRING)); - assertEmptyList(getAllAnnotations(testTypeMirror, NULL_STRING)); + assertEmptyList(getAllAnnotations(super.testTypeElement, NULL_STRING)); + assertEmptyList(getAllAnnotations(super.testTypeMirror, NULL_STRING)); } @Test @@ -246,23 +248,23 @@ void testFindAnnotation() { @Test void testFindAnnotationOnNotFound() { - assertNull(findAnnotation(testTypeMirror, Target.class)); - assertNull(findAnnotation(testTypeElement, Target.class)); - assertNull(findAnnotation(testTypeMirror, Override.class)); - assertNull(findAnnotation(testTypeElement, Override.class)); + assertNull(findAnnotation(super.testTypeMirror, Target.class)); + assertNull(findAnnotation(super.testTypeElement, Target.class)); + assertNull(findAnnotation(super.testTypeMirror, Override.class)); + assertNull(findAnnotation(super.testTypeElement, Override.class)); } @Test void testFindAnnotationOnNull() { assertNull(findAnnotation(NULL_ELEMENT, NULL_CLASS)); assertNull(findAnnotation(NULL_TYPE_MIRROR, NULL_CLASS)); - assertNull(findAnnotation(testTypeMirror, NULL_CLASS)); - assertNull(findAnnotation(testTypeElement, NULL_CLASS)); + assertNull(findAnnotation(super.testTypeMirror, NULL_CLASS)); + assertNull(findAnnotation(super.testTypeElement, NULL_CLASS)); assertNull(findAnnotation(NULL_ELEMENT, NULL_STRING)); assertNull(findAnnotation(NULL_TYPE_MIRROR, NULL_STRING)); - assertNull(findAnnotation(testTypeMirror, NULL_STRING)); - assertNull(findAnnotation(testTypeElement, NULL_STRING)); + assertNull(findAnnotation(super.testTypeMirror, NULL_STRING)); + assertNull(findAnnotation(super.testTypeElement, NULL_STRING)); } @Test @@ -274,19 +276,19 @@ void testFindMetaAnnotationWithAnnotationClass() { @Test void testFindMetaAnnotationWithAnnotationClassOnNotFound() { - assertNull(findMetaAnnotation(testTypeElement, Service.class)); + assertNull(findMetaAnnotation(super.testTypeElement, Service.class)); } @Test void testFindMetaAnnotationWithAnnotationClassNameOnNotFound() { - assertNull(findMetaAnnotation(testTypeElement, "org.springframework.stereotype.Service")); + assertNull(findMetaAnnotation(super.testTypeElement, "org.springframework.stereotype.Service")); } @Test void testFindMetaAnnotationWithAnnotationClassOnNull() { assertNull(findMetaAnnotation(NULL_ELEMENT, NULL_CLASS)); assertNull(findMetaAnnotation(NULL_ELEMENT, Service.class)); - assertNull(findMetaAnnotation(testTypeElement, NULL_CLASS)); + assertNull(findMetaAnnotation(super.testTypeElement, NULL_CLASS)); } @Test @@ -300,30 +302,30 @@ void testFindMetaAnnotationWithAnnotationClassName() { void testFindMetaAnnotationWithAnnotationClassNameOnNull() { assertNull(findMetaAnnotation(NULL_ELEMENT, NULL_STRING)); assertNull(findMetaAnnotation(NULL_ELEMENT, "test")); - assertNull(findMetaAnnotation(testTypeElement, NULL_STRING)); + assertNull(findMetaAnnotation(super.testTypeElement, NULL_STRING)); } @Test void testFindAllAnnotationsWithTypeMirror() { - List annotations = findAllAnnotations(testTypeMirror, alwaysTrue()); + List annotations = findAllAnnotations(super.testTypeMirror, alwaysTrue()); assertEquals(5, annotations.size()); - annotations = findAllAnnotations(testTypeMirror, alwaysFalse()); + annotations = findAllAnnotations(super.testTypeMirror, alwaysFalse()); assertEmptyList(annotations); } @Test void testFindAllAnnotationsWithTypeElement() { - List annotations = findAllAnnotations(testTypeElement, alwaysTrue()); + List annotations = findAllAnnotations(super.testTypeElement, alwaysTrue()); assertEquals(5, annotations.size()); - annotations = findAllAnnotations(testTypeElement, alwaysFalse()); + annotations = findAllAnnotations(super.testTypeElement, alwaysFalse()); assertEmptyList(annotations); } @Test void testFindAllAnnotationsWithMethod() { - ExecutableElement method = findMethod(testTypeElement, "echo", String.class); + ExecutableElement method = findMethod(super.testTypeElement, "echo", String.class); List annotations = findAllAnnotations(method, alwaysTrue()); assertEquals(1, annotations.size()); @@ -358,13 +360,13 @@ void testFindAllAnnotationsWithMethodParameters() { @Test void testFindAllAnnotationsWithField() { - VariableElement field = findField(testTypeElement, "context"); + VariableElement field = findField(super.testTypeElement, "context"); List annotations = findAllAnnotations(field, alwaysTrue()); assertEquals(1, annotations.size()); assertAnnotation(annotations.get(0), Autowired.class); - field = findField(testTypeElement, "environment"); + field = findField(super.testTypeElement, "environment"); annotations = findAllAnnotations(field, alwaysTrue()); assertEmptyList(annotations); } @@ -401,38 +403,38 @@ void testFindAllAnnotationsOnNull() { @Test void testMatchesAnnotationClass() { - AnnotationMirror annotation = findAnnotation(testTypeElement, Service.class); + AnnotationMirror annotation = findAnnotation(super.testTypeElement, Service.class); assertTrue(AnnotationUtils.matchesAnnotationType(annotation, Service.class)); } @Test void testMatchesAnnotationClassOnNull() { assertFalse(AnnotationUtils.matchesAnnotationType(NULL_ANNOTATION_MIRROR, Service.class)); - assertFalse(AnnotationUtils.matchesAnnotationType(findAnnotation(testTypeElement, Service.class), NULL_CLASS)); + assertFalse(AnnotationUtils.matchesAnnotationType(findAnnotation(super.testTypeElement, Service.class), NULL_CLASS)); } @Test void testMatchesAnnotationTypeName() { - AnnotationMirror annotation = findAnnotation(testTypeElement, "org.springframework.stereotype.Service"); + AnnotationMirror annotation = findAnnotation(super.testTypeElement, "org.springframework.stereotype.Service"); assertTrue(matchesAnnotationTypeName(annotation, "org.springframework.stereotype.Service")); } @Test void testMatchesAnnotationTypeNameOnNull() { assertFalse(matchesAnnotationTypeName(NULL_ANNOTATION_MIRROR, "org.springframework.stereotype.Service")); - assertFalse(matchesAnnotationTypeName(findAnnotation(testTypeElement, "org.springframework.stereotype.Service"), NULL_STRING)); + assertFalse(matchesAnnotationTypeName(findAnnotation(super.testTypeElement, "org.springframework.stereotype.Service"), NULL_STRING)); } @Test void testGetAttribute() { - assertEquals("testService", getAttribute(findAnnotation(testTypeElement, Service.class), "value")); - assertEquals("testService", getAttribute(findAnnotation(testTypeElement, Service.class), "value", false)); - assertEquals("/echo", getAttribute(findAnnotation(testTypeElement, Path.class), "value")); + assertEquals("testService", getAttribute(findAnnotation(super.testTypeElement, Service.class), "value")); + assertEquals("testService", getAttribute(findAnnotation(super.testTypeElement, Service.class), "value", false)); + assertEquals("/echo", getAttribute(findAnnotation(super.testTypeElement, Path.class), "value")); - assertNull(getAttribute(findAnnotation(testTypeElement, Path.class), NULL_STRING)); - assertNull(getAttribute(findAnnotation(testTypeElement, NULL_CLASS), NULL_STRING)); + assertNull(getAttribute(findAnnotation(super.testTypeElement, Path.class), NULL_STRING)); + assertNull(getAttribute(findAnnotation(super.testTypeElement, NULL_CLASS), NULL_STRING)); - ExecutableElement echoMethod = findMethod(testTypeElement, "echo", String.class); + ExecutableElement echoMethod = findMethod(super.testTypeElement, "echo", String.class); AnnotationMirror cacheableAnnotation = findAnnotation(echoMethod, Cacheable.class); String[] cacheNames = getAttribute(cacheableAnnotation, "cacheNames"); assertArrayEquals(ofArray("cache-1", "cache-2"), cacheNames); @@ -455,54 +457,54 @@ void testGetValue() { @Test void testIsAnnotationPresentOnAnnotationClass() { - assertTrue(isAnnotationPresent(testTypeElement, Service.class)); - assertTrue(isAnnotationPresent(testTypeElement, Component.class)); - assertTrue(isAnnotationPresent(testTypeElement, ServiceMode.class)); - assertTrue(isAnnotationPresent(testTypeElement, Inherited.class)); - assertTrue(isAnnotationPresent(testTypeElement, Documented.class)); + assertTrue(isAnnotationPresent(super.testTypeElement, Service.class)); + assertTrue(isAnnotationPresent(super.testTypeElement, Component.class)); + assertTrue(isAnnotationPresent(super.testTypeElement, ServiceMode.class)); + assertTrue(isAnnotationPresent(super.testTypeElement, Inherited.class)); + assertTrue(isAnnotationPresent(super.testTypeElement, Documented.class)); } @Test void testIsAnnotationPresentOnAnnotationClassOnNull() { assertFalse(isAnnotationPresent(NULL_ELEMENT, Service.class)); - assertFalse(isAnnotationPresent(testTypeElement, NULL_CLASS)); - assertFalse(isAnnotationPresent(testTypeElement, Override.class)); + assertFalse(isAnnotationPresent(super.testTypeElement, NULL_CLASS)); + assertFalse(isAnnotationPresent(super.testTypeElement, Override.class)); } @Test void testIsAnnotationPresentOnAnnotationClassName() { - assertTrue(isAnnotationPresent(testTypeElement, "org.springframework.stereotype.Service")); - assertTrue(isAnnotationPresent(testTypeElement, "org.springframework.stereotype.Component")); - assertTrue(isAnnotationPresent(testTypeElement, "javax.xml.ws.ServiceMode")); - assertTrue(isAnnotationPresent(testTypeElement, "java.lang.annotation.Inherited")); - assertTrue(isAnnotationPresent(testTypeElement, "java.lang.annotation.Documented")); + assertTrue(isAnnotationPresent(super.testTypeElement, "org.springframework.stereotype.Service")); + assertTrue(isAnnotationPresent(super.testTypeElement, "org.springframework.stereotype.Component")); + assertTrue(isAnnotationPresent(super.testTypeElement, "javax.xml.ws.ServiceMode")); + assertTrue(isAnnotationPresent(super.testTypeElement, "java.lang.annotation.Inherited")); + assertTrue(isAnnotationPresent(super.testTypeElement, "java.lang.annotation.Documented")); } @Test void testIsAnnotationPresentOnAnnotationClassNameOnNull() { assertFalse(isAnnotationPresent(NULL_ELEMENT, "org.springframework.stereotype.Service")); - assertFalse(isAnnotationPresent(testTypeElement, NULL_STRING)); - assertFalse(isAnnotationPresent(testTypeElement, "java.lang.Override")); + assertFalse(isAnnotationPresent(super.testTypeElement, NULL_STRING)); + assertFalse(isAnnotationPresent(super.testTypeElement, "java.lang.Override")); } @Test void testFindAnnotations() { - List annotations = findAnnotations(testTypeElement); + List annotations = findAnnotations(super.testTypeElement); assertEquals(4, annotations.size()); assertAnnotation(annotations.get(0), Service.class); assertAnnotation(annotations.get(1), ServiceMode.class); assertAnnotation(annotations.get(2), ComponentScans.class); assertAnnotation(annotations.get(3), TestAnnotation.class); - annotations = findAnnotations(testTypeElement, alwaysTrue()); + annotations = findAnnotations(super.testTypeElement, alwaysTrue()); assertEquals(4, annotations.size()); assertAnnotation(annotations.get(0), Service.class); assertAnnotation(annotations.get(1), ServiceMode.class); assertAnnotation(annotations.get(2), ComponentScans.class); assertAnnotation(annotations.get(3), TestAnnotation.class); - annotations = findAnnotations(testTypeElement, alwaysFalse()); + annotations = findAnnotations(super.testTypeElement, alwaysFalse()); assertEmptyList(annotations); } @@ -518,7 +520,7 @@ void testFindAnnotationsOnNull() { @Test void testGetAttributeName() { - Map elementValues = getElementValues(testTypeElement, TestAnnotation.class); + Map elementValues = getElementValues(super.testTypeElement, TestAnnotation.class); for (Entry entry : elementValues.entrySet()) { ExecutableElement attributeMethod = entry.getKey(); assertEquals(attributeMethod.getSimpleName().toString(), getAttributeName(attributeMethod)); @@ -527,7 +529,7 @@ void testGetAttributeName() { @Test void testMatchesAttributeMethod() { - Map elementValues = getElementValues(testTypeElement, TestAnnotation.class); + Map elementValues = getElementValues(super.testTypeElement, TestAnnotation.class); for (Entry entry : elementValues.entrySet()) { ExecutableElement attributeMethod = entry.getKey(); assertTrue(matchesAttributeMethod(attributeMethod, getAttributeName(attributeMethod))); @@ -538,7 +540,7 @@ void testMatchesAttributeMethod() { void testMatchesAttributeMethodOnNull() { assertFalse(matchesAttributeMethod(null, null)); - Map elementValues = getElementValues(testTypeElement, TestAnnotation.class); + Map elementValues = getElementValues(super.testTypeElement, TestAnnotation.class); for (Entry entry : elementValues.entrySet()) { ExecutableElement attributeMethod = entry.getKey(); assertFalse(matchesAttributeMethod(attributeMethod, null)); @@ -547,7 +549,7 @@ void testMatchesAttributeMethodOnNull() { @Test void testMatchesAttributeValue() { - Map elementValues = getElementValues(testTypeElement, TestAnnotation.class); + Map elementValues = getElementValues(super.testTypeElement, TestAnnotation.class); for (Entry entry : elementValues.entrySet()) { AnnotationValue annotationValue = entry.getValue(); assertTrue(matchesAttributeValue(annotationValue, annotationValue)); @@ -562,7 +564,7 @@ void testMatchesAttributeValueOnNull() { assertTrue(matchesAttributeValue(null, null)); assertFalse(matchesAttributeValue(null, (Object) null)); - Map elementValues = getElementValues(testTypeElement, TestAnnotation.class); + Map elementValues = getElementValues(super.testTypeElement, TestAnnotation.class); for (Entry entry : elementValues.entrySet()) { AnnotationValue annotationValue = entry.getValue(); assertFalse(matchesAttributeValue(annotationValue, null)); @@ -572,16 +574,25 @@ void testMatchesAttributeValueOnNull() { @Test void testMatchesDefaultAttributeValue() { - Map elementValues = getElementValues(testTypeElement, ServiceMode.class); + Map elementValues = getElementValues(super.testTypeElement, ServiceMode.class); for (Entry entry : elementValues.entrySet()) { ExecutableElement attributeMethod = entry.getKey(); assertTrue(matchesDefaultAttributeValue(attributeMethod, attributeMethod.getDefaultValue())); } } + @Test + void testMatchesDefaultAttributeValueOnNull() { + Map elementValues = getElementValues(super.testTypeElement, ServiceMode.class); + for (Entry entry : elementValues.entrySet()) { + ExecutableElement attributeMethod = entry.getKey(); + assertFalse(matchesDefaultAttributeValue(NULL_METHOD, attributeMethod.getDefaultValue())); + } + } + @Test void testGetElementValue() { - Map elementValues = getElementValues(testTypeElement, TestAnnotation.class); + Map elementValues = getElementValues(super.testTypeElement, TestAnnotation.class); for (Entry entry : elementValues.entrySet()) { ExecutableElement attributeMethod = entry.getKey(); String attributeName = getAttributeName(attributeMethod); @@ -589,11 +600,29 @@ void testGetElementValue() { } assertNull(getElementValue(elementValues, "unknown")); + + AnnotationMirror annotation = findAnnotation(super.testTypeElement, ServiceMode.class); + Entry elementValue = getElementValue(annotation, "value", true); + + assertAttributeEntry(elementValue, "value", PAYLOAD); + + elementValue = getElementValue(annotation, "value", false); + assertNull(elementValue); + } + + @Test + void testGetElementValueOnNotFound() { + AnnotationMirror annotation = findAnnotation(super.testTypeElement, ServiceMode.class); + Entry elementValue = getElementValue(annotation, "z", true); + assertNull(elementValue); + + elementValue = getElementValue(annotation, "z", false); + assertNull(elementValue); } @Test void testGetElementValueOnEmptyElementValues() { - AnnotationMirror annotation = findAnnotation(testTypeElement, ServiceMode.class); + AnnotationMirror annotation = findAnnotation(super.testTypeElement, ServiceMode.class); Map elementValues = annotation.getElementValues(); assertNull(getElementValue(elementValues, "value")); } @@ -605,14 +634,14 @@ void testGetElementValueOnNull() { @Test void testGetElementValuesMapOnAnnotatedClass() { - Map attributesMap = getAttributesMap(testTypeElement, Service.class); + Map attributesMap = getAttributesMap(super.testTypeElement, Service.class); assertEquals(1, attributesMap.size()); assertEquals("testService", attributesMap.get("value")); } @Test void testGetElementValuesMapOnAnnotatedMethod() { - ExecutableElement method = findMethod(testTypeElement, "echo", String.class); + ExecutableElement method = findMethod(super.testTypeElement, "echo", String.class); Map attributesMap = getAttributesMap(method, Cacheable.class); assertEquals(9, attributesMap.size()); assertArrayEquals(ofArray("cache-1", "cache-2"), (String[]) attributesMap.get("cacheNames")); @@ -620,7 +649,7 @@ void testGetElementValuesMapOnAnnotatedMethod() { @Test void testGetElementValuesMapOnRepeatableAnnotation() { - Map attributesMap = getAttributesMap(testTypeElement, ComponentScans.class); + Map attributesMap = getAttributesMap(super.testTypeElement, ComponentScans.class); assertEquals(1, attributesMap.size()); ComponentScans componentScans = testClass.getAnnotation(ComponentScans.class); @@ -634,7 +663,7 @@ void testGetElementValuesMapOnNull() { Map attributesMap = getAttributesMap(null, null); assertSame(emptyMap(), attributesMap); - attributesMap = getAttributesMap(testTypeElement, null); + attributesMap = getAttributesMap(super.testTypeElement, null); assertSame(emptyMap(), attributesMap); attributesMap = getAttributesMap(null); @@ -643,16 +672,16 @@ void testGetElementValuesMapOnNull() { @Test void testGetElementValuesOnAnnotatedClass() { - Map elementValues = getElementValues(testTypeElement, Service.class); + Map elementValues = getElementValues(super.testTypeElement, Service.class); assertServiceAttributes(elementValues); - elementValues = getElementValues(testTypeElement, Service.class, false); + elementValues = getElementValues(super.testTypeElement, Service.class, false); assertServiceAttributes(elementValues); } @Test void testGetElementValuesOnAnnotatedMethod() { - ExecutableElement method = findMethod(testTypeElement, "echo", String.class); + ExecutableElement method = findMethod(super.testTypeElement, "echo", String.class); Map elementValues = getElementValues(method, Cacheable.class, false); assertEquals(1, elementValues.size()); assertAttributeEntry(elementValues, "cacheNames", ofArray("cache-1", "cache-2")); @@ -686,7 +715,7 @@ void testGetElementTypes() { } void assertElementTypes(Class annotationClass, ElementType... expectedElementTypes) { - AnnotationMirror annotationMirror = findAnnotation(this.testTypeElement, annotationClass); + AnnotationMirror annotationMirror = findAnnotation(super.testTypeElement, annotationClass); assertArrayEquals(expectedElementTypes, getElementTypes(annotationMirror)); } @@ -711,19 +740,26 @@ void assertAttributeEntry(Map attributes, St } } - void assertAttributeEntry(Entry attributeEntry, String attributeName, Object attributeValue) { + void assertAttributeEntry(Entry attributeEntry, String attributeName, Object expectedAttributeValue) { + assertNotNull(attributeEntry); + ExecutableElement attributeMethod = attributeEntry.getKey(); - AnnotationValue annotationValue = attributeEntry.getValue(); + AnnotationValue attributeValue = attributeEntry.getValue(); + assertNotNull(attributeMethod); + assertNotNull(attributeValue); + assertEquals(attributeName, getAttributeName(attributeMethod)); + assertTrue(matchesAttributeMethod(attributeMethod, getAttributeName(attributeMethod))); + Object value = getAttribute(attributeEntry); Class attributeValueClass = value.getClass(); if (attributeValueClass.isArray()) { Class componentType = attributeValueClass.getComponentType(); if (String.class.equals(componentType)) { - assertArrayEquals((String[]) attributeValue, (String[]) value); + assertArrayEquals((String[]) expectedAttributeValue, (String[]) value); } } else { - assertEquals(attributeValue, value); + assertEquals(expectedAttributeValue, value); } } @@ -736,30 +772,30 @@ private void assertFindMetaAnnotation(Element element, String annotationClassNam } private void assertFindAnnotation(Class annotationClass) { - assertAnnotation(findAnnotation(testTypeMirror, annotationClass), annotationClass); - assertAnnotation(findAnnotation(testTypeElement, annotationClass), annotationClass); - assertAnnotation(findAnnotation(testTypeMirror, annotationClass.getName()), annotationClass); - assertAnnotation(findAnnotation(testTypeElement, annotationClass.getName()), annotationClass); + assertAnnotation(findAnnotation(super.testTypeMirror, annotationClass), annotationClass); + assertAnnotation(findAnnotation(super.testTypeElement, annotationClass), annotationClass); + assertAnnotation(findAnnotation(super.testTypeMirror, annotationClass.getName()), annotationClass); + assertAnnotation(findAnnotation(super.testTypeElement, annotationClass.getName()), annotationClass); } private void asserGetAnnotation(Class annotationClass) { - AnnotationMirror annotation = getAnnotation(testTypeElement, annotationClass); + AnnotationMirror annotation = getAnnotation(super.testTypeElement, annotationClass); assertAnnotation(annotation, annotationClass); } private void asserGetAnnotation(String annotationClassName) { - AnnotationMirror annotation = getAnnotation(testTypeElement, annotationClassName); + AnnotationMirror annotation = getAnnotation(super.testTypeElement, annotationClassName); assertAnnotation(annotation, annotationClassName); } private void assertGetAnnotations(Class annotationClass) { - List annotations = getAnnotations(testTypeElement, annotationClass); + List annotations = getAnnotations(super.testTypeElement, annotationClass); assertEquals(1, annotations.size()); assertAnnotation(annotations.get(0), annotationClass); } private void assertGetAnnotations(String annotationClassName) { - List annotations = getAnnotations(testTypeElement, annotationClassName); + List annotations = getAnnotations(super.testTypeElement, annotationClassName); assertEquals(1, annotations.size()); assertAnnotation(annotations.get(0), annotationClassName); } From 5dfc61daa90c054330bf6eedb51e983595966e10 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Thu, 5 Feb 2026 18:28:30 +0800 Subject: [PATCH 47/79] Add null-arg assertion to AnnotationUtilsTest Add an assertion to verify matchesAttributeValue returns false when the first argument is null and the second is a non-null AnnotationValue. Strengthens null-safety coverage in AnnotationUtils tests. --- .../java/io/microsphere/lang/model/util/AnnotationUtilsTest.java | 1 + 1 file changed, 1 insertion(+) diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/AnnotationUtilsTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/AnnotationUtilsTest.java index bb9a48f9b..5b01b35da 100644 --- a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/AnnotationUtilsTest.java +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/AnnotationUtilsTest.java @@ -569,6 +569,7 @@ void testMatchesAttributeValueOnNull() { AnnotationValue annotationValue = entry.getValue(); assertFalse(matchesAttributeValue(annotationValue, null)); assertFalse(matchesAttributeValue(annotationValue, (Object) null)); + assertFalse(matchesAttributeValue(null, annotationValue)); } } From 55628e2c39d69cfe9a889df8bf731c42e5c5558e Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Thu, 5 Feb 2026 18:39:02 +0800 Subject: [PATCH 48/79] Null-check declaredType in isTypeElement Add an explicit null check and early return in TypeUtils.isTypeElement to avoid calling declaredType.asElement() when declaredType is null. This prevents a potential NPE and improves readability of the method. --- .../main/java/io/microsphere/lang/model/util/TypeUtils.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/TypeUtils.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/TypeUtils.java index 06692f441..1da76f704 100644 --- a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/TypeUtils.java +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/TypeUtils.java @@ -579,7 +579,10 @@ static boolean isTypeElement(Element element) { */ static boolean isTypeElement(TypeMirror type) { DeclaredType declaredType = ofDeclaredType(type); - return declaredType != null && isTypeElement(declaredType.asElement()); + if (declaredType == null) { + return false; + } + return isTypeElement(declaredType.asElement()); } /** From 6b9a35e514229611a22422249fe47770460b73e5 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Thu, 5 Feb 2026 18:41:53 +0800 Subject: [PATCH 49/79] Make support checks explicit in JSONElementVisitor Replace inline logical-and guard returns with explicit if-checks in visitPackage, visitVariable, visitExecutable and visitTypeParameter. Behavior is unchanged; this refactor improves readability and makes it easier to set breakpoints during debugging. --- .../lang/model/util/JSONElementVisitor.java | 22 ++++++++++++++----- 1 file changed, 17 insertions(+), 5 deletions(-) diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/JSONElementVisitor.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/JSONElementVisitor.java index 46cf974e0..416eafce3 100644 --- a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/JSONElementVisitor.java +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/JSONElementVisitor.java @@ -62,17 +62,26 @@ public JSONElementVisitor() { @Override public final Boolean visitPackage(PackageElement e, StringBuilder jsonBuilder) { - return supportsPackage(e) && doVisitPackage(e, jsonBuilder); + if (!supportsPackage(e)) { + return false; + } + return doVisitPackage(e, jsonBuilder); } @Override public final Boolean visitVariable(VariableElement e, StringBuilder stringBuilder) { - return supportsVariable(e) && super.visitVariable(e, stringBuilder); + if (!supportsVariable(e)) { + return false; + } + return super.visitVariable(e, stringBuilder); } @Override public final Boolean visitExecutable(ExecutableElement e, StringBuilder jsonBuilder) { - return supportsExecutable(e) && super.visitExecutable(e, jsonBuilder); + if (!supportsExecutable(e)) { + return false; + } + return super.visitExecutable(e, jsonBuilder); } @Override @@ -93,7 +102,10 @@ public final Boolean visitType(TypeElement e, StringBuilder jsonBuilder) { @Override public final Boolean visitTypeParameter(TypeParameterElement e, StringBuilder jsonBuilder) { - return supportsTypeParameter(e) && doVisitTypeParameter(e, jsonBuilder); + if (!supportsTypeParameter(e)) { + return false; + } + return doVisitTypeParameter(e, jsonBuilder); } protected boolean visitMembers(List members, StringBuilder jsonBuilder) { @@ -205,4 +217,4 @@ protected boolean doVisitPackage(PackageElement e, StringBuilder jsonBuilder) { protected boolean doVisitTypeParameter(TypeParameterElement e, StringBuilder jsonBuilder) { return super.visitTypeParameter(e, jsonBuilder); } -} +} \ No newline at end of file From 86af0347591458a1408395454f65ad6186277566 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Thu, 5 Feb 2026 18:47:22 +0800 Subject: [PATCH 50/79] Explicit null check in matchesDefaultAttributeValue Replace the inline null-check return with an explicit if-block in AnnotationUtils.matchesDefaultAttributeValue to improve readability. The method now returns false immediately if attributeMethod is null, then delegates to matchesAttributeValue for the default value; no behavioral change intended. --- .../java/io/microsphere/lang/model/util/AnnotationUtils.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/AnnotationUtils.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/AnnotationUtils.java index 816854717..ea4859b76 100644 --- a/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/AnnotationUtils.java +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/AnnotationUtils.java @@ -1142,7 +1142,10 @@ static boolean matchesAttributeValue(AnnotationValue annotationValue, Object att * {@code false} otherwise */ static boolean matchesDefaultAttributeValue(ExecutableElement attributeMethod, AnnotationValue annotationValue) { - return attributeMethod != null && matchesAttributeValue(attributeMethod.getDefaultValue(), annotationValue); + if (attributeMethod == null) { + return false; + } + return matchesAttributeValue(attributeMethod.getDefaultValue(), annotationValue); } /** From b52a110f6940121fbf531ff8021af4c5b2cc8f44 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Thu, 5 Feb 2026 19:02:56 +0800 Subject: [PATCH 51/79] Use EMPTY_CLASS_ARRAY and pass class array Refactor CompilerInvocationInterceptor to build a Class[] from the collected Set and pass that array to Compiler APIs. Added a static import of EMPTY_CLASS_ARRAY and renamed the Set to compiledClassesSet to avoid naming confusion. This ensures typed empty-array usage with toArray(EMPTY_CLASS_ARRAY) and uses the resulting Class[] for sourcePaths(...) and compile(...), removing ad-hoc toArray(new Class[0]) calls. --- .../processing/CompilerInvocationInterceptor.java | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/CompilerInvocationInterceptor.java b/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/CompilerInvocationInterceptor.java index a0d113350..c45776142 100644 --- a/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/CompilerInvocationInterceptor.java +++ b/microsphere-java-test/src/main/java/io/microsphere/test/annotation/processing/CompilerInvocationInterceptor.java @@ -29,6 +29,7 @@ import java.util.ServiceLoader; import java.util.Set; +import static io.microsphere.util.ArrayUtils.EMPTY_CLASS_ARRAY; import static java.util.ServiceLoader.load; @@ -43,14 +44,17 @@ class CompilerInvocationInterceptor implements InvocationInterceptor { @Override public void interceptTestMethod(Invocation invocation, ReflectiveInvocationContext invocationContext, ExtensionContext extensionContext) throws Throwable { - Set> compiledClasses = new LinkedHashSet<>(); + Set> compiledClassesSet = new LinkedHashSet<>(); AbstractAnnotationProcessingTest test = (AbstractAnnotationProcessingTest) invocationContext.getTarget().get(); Class testClass = extensionContext.getTestClass().get(); ClassLoader classLoader = testClass.getClassLoader(); - compiledClasses.add(testClass); - test.addCompiledClasses(compiledClasses); + compiledClassesSet.add(testClass); + test.addCompiledClasses(compiledClassesSet); + + Class[] compiledClasses = compiledClassesSet.toArray(EMPTY_CLASS_ARRAY); + Compiler compiler = new Compiler(); - compiler.sourcePaths(testClass); + compiler.sourcePaths(compiledClasses); List processors = new LinkedList<>(); processors.add(new AnnotationProcessingTestProcessor(test, invocation, invocationContext, extensionContext)); @@ -58,6 +62,6 @@ public void interceptTestMethod(Invocation invocation, ReflectiveInvocatio ServiceLoader loadedProcessors = load(Processor.class, classLoader); loadedProcessors.forEach(processors::add); compiler.processors(processors.toArray(new Processor[0])); - compiler.compile(compiledClasses.toArray(new Class[0])); + compiler.compile(compiledClasses); } } \ No newline at end of file From 5fada1fff1b987a241d0ccfe21f6fa214e7ac759 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Thu, 5 Feb 2026 20:10:54 +0800 Subject: [PATCH 52/79] Refactor JSON visitors and processor, add tests Move AnnotatedElementJSONElementVisitor to microsphere-lang-model and update packages/usages; make ConfigurationPropertyJSONElementVisitor package-private, change its CONFIGURATION_PROPERTY_ANNOTATION_CLASS_NAME and constructor visibility, and override supportsType to always return true. Update ConfigurationPropertyAnnotationProcessor to import ResourceConstants, adjust static import path, refactor resolveMetadata into an overload that accepts a Set (prepend '[' before resolving, append generated SPI JSON, and ensure proper trailing bracket handling), and add a toJSON() helper. Update and add unit tests to match the refactor: adapt ConfigurationPropertyAnnotationProcessorTest, add ConfigurationPropertyJSONElementVisitorTest, and add AnnotatedElementJSONElementVisitorTest under the lang-model tests. Miscellaneous import and formatting adjustments applied to affected files. --- ...figurationPropertyAnnotationProcessor.java | 33 +++++---- ...nfigurationPropertyJSONElementVisitor.java | 22 +++--- ...rationPropertyAnnotationProcessorTest.java | 31 +++------ ...urationPropertyJSONElementVisitorTest.java | 68 +++++++++++++++++++ .../AnnotatedElementJSONElementVisitor.java | 4 +- ...nnotatedElementJSONElementVisitorTest.java | 52 ++++++++++++++ 6 files changed, 163 insertions(+), 47 deletions(-) rename microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/{model/util => }/ConfigurationPropertyJSONElementVisitor.java (92%) create mode 100644 microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/ConfigurationPropertyJSONElementVisitorTest.java rename {microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor => microsphere-lang-model/src/main/java/io/microsphere/lang}/model/util/AnnotatedElementJSONElementVisitor.java (97%) create mode 100644 microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/AnnotatedElementJSONElementVisitorTest.java diff --git a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/ConfigurationPropertyAnnotationProcessor.java b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/ConfigurationPropertyAnnotationProcessor.java index 6060855d6..4523a1e42 100644 --- a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/ConfigurationPropertyAnnotationProcessor.java +++ b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/ConfigurationPropertyAnnotationProcessor.java @@ -18,7 +18,7 @@ package io.microsphere.annotation.processor; import io.microsphere.annotation.ConfigurationProperty; -import io.microsphere.annotation.processor.model.util.ConfigurationPropertyJSONElementVisitor; +import io.microsphere.constants.ResourceConstants; import io.microsphere.json.JSONArray; import io.microsphere.metadata.ConfigurationPropertyGenerator; @@ -35,7 +35,7 @@ import java.util.List; import java.util.Set; -import static io.microsphere.annotation.processor.model.util.ConfigurationPropertyJSONElementVisitor.CONFIGURATION_PROPERTY_ANNOTATION_CLASS_NAME; +import static io.microsphere.annotation.processor.ConfigurationPropertyJSONElementVisitor.CONFIGURATION_PROPERTY_ANNOTATION_CLASS_NAME; import static io.microsphere.constants.ResourceConstants.CONFIGURATION_PROPERTY_METADATA_RESOURCE; import static io.microsphere.constants.SymbolConstants.COMMA_CHAR; import static io.microsphere.constants.SymbolConstants.LEFT_SQUARE_BRACKET_CHAR; @@ -62,7 +62,7 @@ * *

  • {@link #resolveMetadata(RoundEnvironment)} traverses all root elements to extract configuration property metadata.
    • *
  • {@link #writeMetadata()} writes the generated metadata into a JSON file under - * {@value #CONFIGURATION_PROPERTY_METADATA_RESOURCE_NAME} using a writer.
    • + * {@value ResourceConstants#CONFIGURATION_PROPERTY_METADATA_RESOURCE} using a writer. * * * @author Mercy @@ -106,24 +106,28 @@ public boolean process(Set annotations, RoundEnvironment private void resolveMetadata(RoundEnvironment roundEnv) { Set elements = roundEnv.getRootElements(); - if (!elements.isEmpty()) { + resolveMetadata(elements); + } + + void resolveMetadata(Set elements) { + jsonBuilder.append(LEFT_SQUARE_BRACKET_CHAR); + // Resolve the content + if (!elements.isEmpty()) { Iterator iterator = elements.iterator(); - jsonBuilder.append(LEFT_SQUARE_BRACKET_CHAR); while (iterator.hasNext()) { Element element = iterator.next(); element.accept(jsonElementVisitor, jsonBuilder); } - // append the JSON content generated by ConfigurationPropertyGenerator SPI appendGeneratedConfigurationPropertyJSON(jsonBuilder); + } - int lastIndex = jsonBuilder.length() - 1; - if (COMMA_CHAR == jsonBuilder.charAt(lastIndex)) { - jsonBuilder.setCharAt(lastIndex, RIGHT_SQUARE_BRACKET_CHAR); - } else { - jsonBuilder.append(RIGHT_SQUARE_BRACKET_CHAR); - } + int lastIndex = jsonBuilder.length() - 1; + if (COMMA_CHAR == jsonBuilder.charAt(lastIndex)) { + jsonBuilder.setCharAt(lastIndex, RIGHT_SQUARE_BRACKET_CHAR); + } else { + jsonBuilder.append(RIGHT_SQUARE_BRACKET_CHAR); } } @@ -151,9 +155,12 @@ private void writeMetadata() { }); } + String toJSON() { + return jsonBuilder.toString(); + } + @Override public SourceVersion getSupportedSourceVersion() { return latestSupported(); } } - \ No newline at end of file diff --git a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/ConfigurationPropertyJSONElementVisitor.java b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/ConfigurationPropertyJSONElementVisitor.java similarity index 92% rename from microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/ConfigurationPropertyJSONElementVisitor.java rename to microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/ConfigurationPropertyJSONElementVisitor.java index 5f5b9f2f7..bd8a2463c 100644 --- a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/ConfigurationPropertyJSONElementVisitor.java +++ b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/ConfigurationPropertyJSONElementVisitor.java @@ -15,10 +15,11 @@ * limitations under the License. */ -package io.microsphere.annotation.processor.model.util; +package io.microsphere.annotation.processor; import io.microsphere.annotation.ConfigurationProperty; import io.microsphere.beans.ConfigurationProperty.Metadata; +import io.microsphere.lang.model.util.AnnotatedElementJSONElementVisitor; import io.microsphere.metadata.ConfigurationPropertyGenerator; import javax.annotation.processing.ProcessingEnvironment; @@ -26,6 +27,7 @@ import javax.lang.model.element.AnnotationValue; import javax.lang.model.element.Element; import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.TypeElement; import javax.lang.model.element.VariableElement; import javax.lang.model.type.TypeMirror; import java.util.List; @@ -42,22 +44,22 @@ import static io.microsphere.util.StringUtils.isBlank; /** - * {@link ConfigurationProperty @ConfigurationProperty}'s {@link io.microsphere.lang.model.util.AnnotatedElementJSONElementVisitor} based on + * {@link ConfigurationProperty @ConfigurationProperty}'s {@link AnnotatedElementJSONElementVisitor} based on * {@link ConfigurationPropertyGenerator} generating the JSON representation of the configuration property metadata. * * @author Mercy - * @see io.microsphere.lang.model.util.AnnotatedElementJSONElementVisitor + * @see AnnotatedElementJSONElementVisitor * @see ConfigurationProperty * @see io.microsphere.beans.ConfigurationProperty * @since 1.0.0 */ -public class ConfigurationPropertyJSONElementVisitor extends AnnotatedElementJSONElementVisitor { +class ConfigurationPropertyJSONElementVisitor extends AnnotatedElementJSONElementVisitor { - public static final String CONFIGURATION_PROPERTY_ANNOTATION_CLASS_NAME = "io.microsphere.annotation.ConfigurationProperty"; + static final String CONFIGURATION_PROPERTY_ANNOTATION_CLASS_NAME = "io.microsphere.annotation.ConfigurationProperty"; private final ConfigurationPropertyGenerator generator; - public ConfigurationPropertyJSONElementVisitor(ProcessingEnvironment processingEnv) { + ConfigurationPropertyJSONElementVisitor(ProcessingEnvironment processingEnv) { super(processingEnv, CONFIGURATION_PROPERTY_ANNOTATION_CLASS_NAME); this.generator = loadFirstService(ConfigurationPropertyGenerator.class); } @@ -102,6 +104,11 @@ public Boolean visitVariableAsField(VariableElement field, StringBuilder jsonBui return false; } + @Override + protected boolean supportsType(TypeElement e) { + return true; + } + public ConfigurationPropertyGenerator getGenerator() { return generator; } @@ -149,5 +156,4 @@ private void setDeclaredField(io.microsphere.beans.ConfigurationProperty configu String declaredFieldName = field.getSimpleName().toString(); configurationProperty.getMetadata().setDeclaredField(declaredFieldName); } - -} +} \ No newline at end of file diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/ConfigurationPropertyAnnotationProcessorTest.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/ConfigurationPropertyAnnotationProcessorTest.java index 2fd190bc9..2e2806fa0 100644 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/ConfigurationPropertyAnnotationProcessorTest.java +++ b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/ConfigurationPropertyAnnotationProcessorTest.java @@ -17,20 +17,11 @@ package io.microsphere.annotation.processor; -import io.microsphere.annotation.ConfigurationProperty; -import io.microsphere.classloading.ManifestArtifactResourceResolver; -import io.microsphere.io.IOUtils; -import io.microsphere.io.StandardFileWatchService; -import io.microsphere.reflect.MethodUtils; -import io.microsphere.reflect.TypeUtils; import io.microsphere.test.annotation.processing.AbstractAnnotationProcessingTest; -import io.microsphere.util.ServiceLoaderUtils; import org.junit.jupiter.api.Test; -import java.util.Set; - -import static io.microsphere.annotation.processor.model.util.ConfigurationPropertyJSONElementVisitor.CONFIGURATION_PROPERTY_ANNOTATION_CLASS_NAME; -import static org.junit.jupiter.api.Assertions.assertEquals; +import static io.microsphere.util.Assert.assertNotNull; +import static java.util.Collections.emptySet; /** * {@link ConfigurationPropertyAnnotationProcessor} Test @@ -40,19 +31,13 @@ * @since 1.0.0 */ class ConfigurationPropertyAnnotationProcessorTest extends AbstractAnnotationProcessingTest { - @Override - protected void addCompiledClasses(Set> compiledClasses) { - compiledClasses.add(ManifestArtifactResourceResolver.class); - compiledClasses.add(IOUtils.class); - compiledClasses.add(StandardFileWatchService.class); - compiledClasses.add(TypeUtils.class); - compiledClasses.add(ServiceLoaderUtils.class); - compiledClasses.add(MethodUtils.class); - compiledClasses.add(ConfigurationProperty.class); - } @Test - void testConstants() { - assertEquals("io.microsphere.annotation.ConfigurationProperty", CONFIGURATION_PROPERTY_ANNOTATION_CLASS_NAME); + void testResolveMetadataOnEmptySet() { + ConfigurationPropertyAnnotationProcessor processor = new ConfigurationPropertyAnnotationProcessor(); + processor.init(super.processingEnv); + processor.resolveMetadata(emptySet()); + String json = processor.toJSON(); + assertNotNull("[]", json); } } \ No newline at end of file diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/ConfigurationPropertyJSONElementVisitorTest.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/ConfigurationPropertyJSONElementVisitorTest.java new file mode 100644 index 000000000..8f06ccce4 --- /dev/null +++ b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/ConfigurationPropertyJSONElementVisitorTest.java @@ -0,0 +1,68 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.annotation.processor; + + +import io.microsphere.annotation.ConfigurationProperty; +import io.microsphere.classloading.ManifestArtifactResourceResolver; +import io.microsphere.io.IOUtils; +import io.microsphere.io.StandardFileWatchService; +import io.microsphere.reflect.MethodUtils; +import io.microsphere.reflect.TypeUtils; +import io.microsphere.test.annotation.processing.AbstractAnnotationProcessingTest; +import io.microsphere.util.ServiceLoaderUtils; +import org.junit.jupiter.api.Test; + +import java.util.Set; + +import static io.microsphere.annotation.processor.ConfigurationPropertyJSONElementVisitor.CONFIGURATION_PROPERTY_ANNOTATION_CLASS_NAME; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * {@link ConfigurationPropertyJSONElementVisitor} Test + * + * @author Mercy + * @see ConfigurationPropertyJSONElementVisitor + * @since 1.0.0 + */ +class ConfigurationPropertyJSONElementVisitorTest extends AbstractAnnotationProcessingTest { + + @Override + protected void addCompiledClasses(Set> compiledClasses) { + compiledClasses.add(ManifestArtifactResourceResolver.class); + compiledClasses.add(IOUtils.class); + compiledClasses.add(StandardFileWatchService.class); + compiledClasses.add(TypeUtils.class); + compiledClasses.add(ServiceLoaderUtils.class); + compiledClasses.add(MethodUtils.class); + compiledClasses.add(ConfigurationProperty.class); + } + + @Test + void testConstants() { + assertEquals("io.microsphere.annotation.ConfigurationProperty", CONFIGURATION_PROPERTY_ANNOTATION_CLASS_NAME); + } + + @Test + void testSupportsType() { + ConfigurationPropertyJSONElementVisitor visitor = new ConfigurationPropertyJSONElementVisitor(super.processingEnv); + assertTrue(visitor.supportsType(super.testTypeElement)); + assertTrue(visitor.supportsType(NULL_TYPE_ELEMENT)); + } +} \ No newline at end of file diff --git a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/AnnotatedElementJSONElementVisitor.java b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/AnnotatedElementJSONElementVisitor.java similarity index 97% rename from microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/AnnotatedElementJSONElementVisitor.java rename to microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/AnnotatedElementJSONElementVisitor.java index cbb1d6418..e6df266ec 100644 --- a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/model/util/AnnotatedElementJSONElementVisitor.java +++ b/microsphere-lang-model/src/main/java/io/microsphere/lang/model/util/AnnotatedElementJSONElementVisitor.java @@ -15,10 +15,9 @@ * limitations under the License. */ -package io.microsphere.annotation.processor.model.util; +package io.microsphere.lang.model.util; import io.microsphere.annotation.Nonnull; -import io.microsphere.lang.model.util.JSONElementVisitor; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; @@ -125,5 +124,4 @@ public final String getAnnotationClassName() { protected boolean supports(Element e) { return matchesElementType(e, this.elementTypes); } - } diff --git a/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/AnnotatedElementJSONElementVisitorTest.java b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/AnnotatedElementJSONElementVisitorTest.java new file mode 100644 index 000000000..3dd0cc74c --- /dev/null +++ b/microsphere-lang-model/src/test/java/io/microsphere/lang/model/util/AnnotatedElementJSONElementVisitorTest.java @@ -0,0 +1,52 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.lang.model.util; + + +import org.junit.jupiter.api.Test; + +import javax.lang.model.element.ExecutableElement; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * {@link AnnotatedElementJSONElementVisitor} Test + * + * @author Mercy + * @see AnnotatedElementJSONElementVisitor + * @since 1.0.0 + */ +class AnnotatedElementJSONElementVisitorTest extends UtilTest { + + @Test + void test() { + String annotationClassName = Test.class.getName(); + AnnotatedElementJSONElementVisitor visitor = new AnnotatedElementJSONElementVisitor(super.processingEnv, annotationClassName) { + }; + + assertEquals(annotationClassName, visitor.getAnnotationClassName()); + + ExecutableElement testMethod = getMethod(AnnotatedElementJSONElementVisitorTest.class, "test"); + assertTrue(visitor.supports(testMethod)); + assertFalse(visitor.supports(super.testTypeElement)); + assertFalse(visitor.supports(NULL_ELEMENT)); + } + +} \ No newline at end of file From a0f23ddcc40b7ce915d834c0027c7a0778a3db1d Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Thu, 5 Feb 2026 20:39:04 +0800 Subject: [PATCH 53/79] Check attribute name in setSources Pass the attribute name into setSources and make the method process only when attributeName equals "source". This avoids treating non-source annotation attributes as sources when the visitor's default branch invokes setSources. The method visibility was relaxed and a unit test (testSetSourcesOnNoSource) was added to ensure calling setSources with a non-'source' attribute and null values does not throw. --- ...onfigurationPropertyJSONElementVisitor.java | 18 ++++++++++-------- ...gurationPropertyJSONElementVisitorTest.java | 8 ++++++++ 2 files changed, 18 insertions(+), 8 deletions(-) diff --git a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/ConfigurationPropertyJSONElementVisitor.java b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/ConfigurationPropertyJSONElementVisitor.java index bd8a2463c..e30972026 100644 --- a/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/ConfigurationPropertyJSONElementVisitor.java +++ b/microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/ConfigurationPropertyJSONElementVisitor.java @@ -89,8 +89,8 @@ public Boolean visitVariableAsField(VariableElement field, StringBuilder jsonBui } else if ("description".equals(attributeName)) { String description = resolveDescription(field, attributeMethod, annotationValue); configurationProperty.setDescription(description); - } else if ("source".equals(attributeName)) { - setSources(configurationProperty, annotationValue); + } else { + setSources(configurationProperty, attributeName, annotationValue); } } setDeclaredClass(configurationProperty, field); @@ -137,12 +137,14 @@ private String resolveStringValue(ExecutableElement attributeMethod, AnnotationV return (String) value; } - private void setSources(io.microsphere.beans.ConfigurationProperty configurationProperty, AnnotationValue annotationValue) { - List sources = (List) annotationValue.getValue(); - Metadata metadata = configurationProperty.getMetadata(); - for (AnnotationValue source : sources) { - String sourceValue = (String) source.getValue(); - metadata.getSources().add(sourceValue); + void setSources(io.microsphere.beans.ConfigurationProperty configurationProperty, String attributeName, AnnotationValue annotationValue) { + if ("source".equals(attributeName)) { + List sources = (List) annotationValue.getValue(); + Metadata metadata = configurationProperty.getMetadata(); + for (AnnotationValue source : sources) { + String sourceValue = (String) source.getValue(); + metadata.getSources().add(sourceValue); + } } } diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/ConfigurationPropertyJSONElementVisitorTest.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/ConfigurationPropertyJSONElementVisitorTest.java index 8f06ccce4..89e4e5deb 100644 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/ConfigurationPropertyJSONElementVisitorTest.java +++ b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/ConfigurationPropertyJSONElementVisitorTest.java @@ -32,6 +32,7 @@ import static io.microsphere.annotation.processor.ConfigurationPropertyJSONElementVisitor.CONFIGURATION_PROPERTY_ANNOTATION_CLASS_NAME; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertTrue; /** @@ -65,4 +66,11 @@ void testSupportsType() { assertTrue(visitor.supportsType(super.testTypeElement)); assertTrue(visitor.supportsType(NULL_TYPE_ELEMENT)); } + + @Test + void testSetSourcesOnNoSource() { + ConfigurationPropertyJSONElementVisitor visitor = new ConfigurationPropertyJSONElementVisitor(super.processingEnv); + visitor.setSources(null, "noSource", null); + assertNotNull(visitor); + } } \ No newline at end of file From 3ac0646e1cc0255a88aa4bf527cfee3391af6854 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Thu, 5 Feb 2026 20:55:57 +0800 Subject: [PATCH 54/79] Add exception-handler tests for resource processors Extend ResourceProcessorTest to cover fallback/error-handler behavior when resource callbacks throw. Add assertions that: - classOutputProcessor.processInResource with a throwing callback returns null when a handler returning null is provided. - sourcePathProcessor.processInResourceInputStream/Reader/Content with throwing callbacks return Optional.empty() when a handler returning null is provided. - classOutputProcessor.processInResourceOutputStream and processInResourceWriter invoke the error handler and receive a non-null exception. These tests ensure resource processors correctly propagate exceptions to provided handlers and return the expected fallback values. --- .../processor/ResourceProcessorTest.java | 31 +++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/ResourceProcessorTest.java b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/ResourceProcessorTest.java index 868022463..1ed22a16d 100644 --- a/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/ResourceProcessorTest.java +++ b/microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/ResourceProcessorTest.java @@ -34,11 +34,14 @@ import static io.microsphere.nio.charset.CharsetUtils.DEFAULT_CHARSET; import static java.lang.Boolean.FALSE; import static java.lang.System.currentTimeMillis; +import static java.util.Optional.empty; import static javax.tools.StandardLocation.CLASS_OUTPUT; import static javax.tools.StandardLocation.SOURCE_PATH; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -81,6 +84,10 @@ void testProcessInResourceOnFailed() { assertThrows(RuntimeException.class, () -> this.classOutputProcessor.processInResource(this.randomResourceName, FOR_READING, fileObject -> { throw new RuntimeException(); })); + + assertNull(this.classOutputProcessor.processInResource(this.randomResourceName, FOR_READING, fileObject -> { + throw new RuntimeException(); + }, e -> null)); } @Test @@ -101,6 +108,10 @@ void testProcessInResourceInputStreamOnFailed() { assertThrows(RuntimeException.class, () -> this.sourcePathProcessor.processInResourceInputStream(JAVA_SOURCE_RESOURCE_NAME, inputStream -> { throw new RuntimeException(); })); + + assertSame(empty(), this.sourcePathProcessor.processInResourceInputStream(JAVA_SOURCE_RESOURCE_NAME, inputStream -> { + throw new RuntimeException(); + }, (f, e) -> null)); } @Test @@ -115,6 +126,10 @@ void testProcessInResourceReaderOnFailed() { assertThrows(RuntimeException.class, () -> this.sourcePathProcessor.processInResourceReader(JAVA_SOURCE_RESOURCE_NAME, reader -> { throw new RuntimeException(); })); + + assertSame(empty(), this.sourcePathProcessor.processInResourceReader(JAVA_SOURCE_RESOURCE_NAME, reader -> { + throw new RuntimeException(); + }, (f, e) -> null)); } @Test @@ -128,6 +143,10 @@ void testProcessInResourceContentOnFailed() { assertThrows(RuntimeException.class, () -> this.sourcePathProcessor.processInResourceContent(JAVA_SOURCE_RESOURCE_NAME, content -> { throw new RuntimeException(); })); + + assertSame(empty(), this.sourcePathProcessor.processInResourceContent(JAVA_SOURCE_RESOURCE_NAME, content -> { + throw new RuntimeException(); + }, (f, e) -> null)); } @Test @@ -142,6 +161,12 @@ void testProcessInResourceOutputStreamOnFailed() { assertThrows(RuntimeException.class, () -> this.classOutputProcessor.processInResourceOutputStream(this.randomResourceName, outputStream -> { throw new RuntimeException(); })); + + this.classOutputProcessor.processInResourceOutputStream(this.randomResourceName, outputStream -> { + throw new RuntimeException(); + }, (f, e) -> { + assertNotNull(e); + }); } @Test @@ -156,6 +181,12 @@ void testProcessInResourceOnWriterOnFailed() { assertThrows(RuntimeException.class, () -> this.classOutputProcessor.processInResourceWriter(randomResourceName, writer -> { throw new RuntimeException(); })); + + this.classOutputProcessor.processInResourceWriter(this.randomResourceName, writer -> { + throw new RuntimeException(); + }, (f, e) -> { + assertNotNull(e); + }); } @Test From 0ea8bafd1f6bbe4e9dfd4fe40b2c374bbc5d1998 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Thu, 5 Feb 2026 21:15:17 +0800 Subject: [PATCH 55/79] Add TestDeque and simplify AbstractDequeTest Introduce TestDeque (backed by LinkedList) as a reusable test implementation of AbstractDeque with configurable max capacity. Replace the large anonymous deque instance in AbstractDequeTest#setUp with TestDeque<>(1), remove now-unused imports, and update the testRemoveFirstOccurrence assertion to expect false when removing null. These changes improve test clarity and reuse. --- .../collection/AbstractDequeTest.java | 106 +------------ .../io/microsphere/collection/TestDeque.java | 144 ++++++++++++++++++ 2 files changed, 146 insertions(+), 104 deletions(-) create mode 100644 microsphere-java-core/src/test/java/io/microsphere/collection/TestDeque.java diff --git a/microsphere-java-core/src/test/java/io/microsphere/collection/AbstractDequeTest.java b/microsphere-java-core/src/test/java/io/microsphere/collection/AbstractDequeTest.java index eb6aa11fe..df8696b1b 100644 --- a/microsphere-java-core/src/test/java/io/microsphere/collection/AbstractDequeTest.java +++ b/microsphere-java-core/src/test/java/io/microsphere/collection/AbstractDequeTest.java @@ -3,9 +3,7 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import java.util.Iterator; import java.util.NoSuchElementException; -import java.util.Objects; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNull; @@ -28,107 +26,7 @@ class AbstractDequeTest { @BeforeEach void setUp() { - - deque = new AbstractDeque() { - - private String value; - - @Override - public Iterator iterator() { - return new Iterator() { - - private int cursor = 0; - - @Override - public boolean hasNext() { - return cursor == 0; - } - - @Override - public String next() { - if (cursor++ == 0) { - return value; - } else { - throw new NoSuchElementException(); - } - } - - @Override - public void remove() { - if (cursor <= 1) { - value = null; - } else { - throw new NoSuchElementException(); - } - } - }; - } - - @Override - public Iterator descendingIterator() { - return iterator(); - } - - @Override - public boolean offerFirst(String s) { - if (value == null) { - value = s; - return true; - } - return false; - } - - @Override - public boolean offerLast(String s) { - return offerFirst(s); - } - - @Override - public String pollFirst() { - String s = value; - value = null; - return s; - } - - @Override - public String pollLast() { - return pollFirst(); - } - - @Override - public String getFirst() { - return value; - } - - @Override - public String getLast() { - return getFirst(); - } - - @Override - public String peekFirst() { - return value; - } - - @Override - public String peekLast() { - return value; - } - - @Override - public boolean removeLastOccurrence(Object o) { - if (Objects.equals(o, value)) { - value = null; - return true; - } - return false; - } - - @Override - public int size() { - return 1; - } - }; + deque = new TestDeque<>(1); } @Test @@ -189,7 +87,7 @@ void testPeekLast() { @Test void testRemoveFirstOccurrence() { - assertTrue(deque.removeFirstOccurrence(null)); + assertFalse(deque.removeFirstOccurrence(null)); deque.add(TEST_VALUE); assertFalse(deque.removeFirstOccurrence("")); assertTrue(deque.removeFirstOccurrence(TEST_VALUE)); diff --git a/microsphere-java-core/src/test/java/io/microsphere/collection/TestDeque.java b/microsphere-java-core/src/test/java/io/microsphere/collection/TestDeque.java new file mode 100644 index 000000000..fc60e5f90 --- /dev/null +++ b/microsphere-java-core/src/test/java/io/microsphere/collection/TestDeque.java @@ -0,0 +1,144 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.collection; + +import java.util.Iterator; +import java.util.LinkedList; +import java.util.Spliterator; +import java.util.function.Consumer; +import java.util.function.Predicate; +import java.util.stream.Stream; + +import static java.lang.Integer.MAX_VALUE; + +/** + * {@link AbstractDeque} class for testing + * + * @author Mercy + * @see AbstractDeque + * @since 1.0.0 + */ +public class TestDeque extends AbstractDeque { + + private final int maxCapacity; + + private final LinkedList delegate = new LinkedList<>(); + + public TestDeque() { + this(MAX_VALUE); + } + + public TestDeque(int maxCapacity) { + this.maxCapacity = maxCapacity; + } + + @Override + public Iterator iterator() { + return delegate.iterator(); + } + + @Override + public void forEach(Consumer action) { + delegate.forEach(action); + } + + @Override + public boolean removeIf(Predicate filter) { + return delegate.removeIf(filter); + } + + @Override + public Spliterator spliterator() { + return delegate.spliterator(); + } + + @Override + public Stream stream() { + return delegate.stream(); + } + + @Override + public Stream parallelStream() { + return delegate.parallelStream(); + } + + @Override + public Iterator descendingIterator() { + return delegate.descendingIterator(); + } + + @Override + public boolean offerFirst(E e) { + if (isFull()) { + return false; + } + return delegate.offerFirst(e); + } + + @Override + public boolean offerLast(E e) { + if (isFull()) { + return false; + } + return delegate.offerLast(e); + } + + @Override + public E pollFirst() { + return delegate.pollFirst(); + } + + @Override + public E pollLast() { + return delegate.pollLast(); + } + + @Override + public E getFirst() { + return delegate.getFirst(); + } + + @Override + public E getLast() { + return delegate.getLast(); + } + + @Override + public E peekFirst() { + return delegate.peekFirst(); + } + + @Override + public E peekLast() { + return delegate.peekLast(); + } + + @Override + public boolean removeLastOccurrence(Object o) { + return delegate.removeLastOccurrence(o); + } + + @Override + public int size() { + return delegate.size(); + } + + public boolean isFull() { + return this.size() >= this.maxCapacity; + } +} \ No newline at end of file From 841f1dbe9656e8966548904e34563fb8a15fa607 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Thu, 5 Feb 2026 21:18:54 +0800 Subject: [PATCH 56/79] Add explicit Deque method overrides in TestDeque Added explicit overrides for common Deque operations (addFirst, addLast, removeFirst, removeLast, removeFirstOccurrence, push, pop, offer, poll, peek) in TestDeque that simply delegate to the superclass. This clarifies the class API and ensures these methods are available/overridable for testing or further extension without changing behavior. --- .../io/microsphere/collection/TestDeque.java | 50 +++++++++++++++++++ 1 file changed, 50 insertions(+) diff --git a/microsphere-java-core/src/test/java/io/microsphere/collection/TestDeque.java b/microsphere-java-core/src/test/java/io/microsphere/collection/TestDeque.java index fc60e5f90..f14674a7b 100644 --- a/microsphere-java-core/src/test/java/io/microsphere/collection/TestDeque.java +++ b/microsphere-java-core/src/test/java/io/microsphere/collection/TestDeque.java @@ -47,6 +47,56 @@ public TestDeque(int maxCapacity) { this.maxCapacity = maxCapacity; } + @Override + public void addFirst(E e) { + super.addFirst(e); + } + + @Override + public void addLast(E e) { + super.addLast(e); + } + + @Override + public E removeFirst() { + return super.removeFirst(); + } + + @Override + public E removeLast() { + return super.removeLast(); + } + + @Override + public boolean removeFirstOccurrence(Object o) { + return super.removeFirstOccurrence(o); + } + + @Override + public void push(E e) { + super.push(e); + } + + @Override + public E pop() { + return super.pop(); + } + + @Override + public boolean offer(E e) { + return super.offer(e); + } + + @Override + public E poll() { + return super.poll(); + } + + @Override + public E peek() { + return super.peek(); + } + @Override public Iterator iterator() { return delegate.iterator(); From fc44d09cb06d30479b2c4475568b6c960bcdc3ad Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Thu, 5 Feb 2026 21:42:52 +0800 Subject: [PATCH 57/79] Add DelegatingIterator and update EmptyIterator Introduce DelegatingIterator that forwards all Iterator calls to an underlying delegate and implements DelegatingWrapper to expose the delegate. Refactor EmptyIterator to extend DelegatingIterator and use Collections.emptyIterator() as its delegate. Add DelegatingIteratorTest to verify delegation behavior (hasNext, next, remove, forEachRemaining, getDelegate, hashCode, equals, toString). This enables easier iterator wrapping and reuse of common iterator behavior. --- .../collection/DelegatingIterator.java | 88 +++++++++++++++ .../microsphere/collection/EmptyIterator.java | 20 +--- .../collection/DelegatingIteratorTest.java | 100 ++++++++++++++++++ 3 files changed, 190 insertions(+), 18 deletions(-) create mode 100644 microsphere-java-core/src/main/java/io/microsphere/collection/DelegatingIterator.java create mode 100644 microsphere-java-core/src/test/java/io/microsphere/collection/DelegatingIteratorTest.java diff --git a/microsphere-java-core/src/main/java/io/microsphere/collection/DelegatingIterator.java b/microsphere-java-core/src/main/java/io/microsphere/collection/DelegatingIterator.java new file mode 100644 index 000000000..3975f19ab --- /dev/null +++ b/microsphere-java-core/src/main/java/io/microsphere/collection/DelegatingIterator.java @@ -0,0 +1,88 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.microsphere.collection; + +import io.microsphere.lang.DelegatingWrapper; + +import java.util.Iterator; +import java.util.function.Consumer; + +/** + * A delegating implementation of the {@link Iterator} interface that forwards all method calls to a delegate iterator. + * This class is useful when you want to wrap an existing iterator and potentially override some of its behavior. + * + *

    Example Usage

    + * 
    {@code
+ * List list = Arrays.asList("a", "b", "c");
+ * Iterator iterator = new DelegatingIterator<>(list.iterator());
+ * while (iterator.hasNext()) {
+ *     System.out.println(iterator.next());
+ * }
+ * }
    + * + * @param the type of elements returned by this iterator + * @author Mercy + * @see Iterator + */ +public class DelegatingIterator implements Iterator, DelegatingWrapper { + + private final Iterator delegate; + + public DelegatingIterator(Iterator delegate) { + this.delegate = delegate; + } + + @Override + public final boolean hasNext() { + return delegate.hasNext(); + } + + @Override + public final E next() { + return delegate.next(); + } + + @Override + public final void remove() { + delegate.remove(); + } + + @Override + public final void forEachRemaining(Consumer action) { + this.delegate.forEachRemaining(action); + } + + @Override + public final Object getDelegate() { + return this.delegate; + } + + @Override + public final int hashCode() { + return this.delegate.hashCode(); + } + + @Override + public final boolean equals(Object obj) { + return this.delegate.equals(obj); + } + + @Override + public final String toString() { + return this.delegate.toString(); + } +} \ No newline at end of file diff --git a/microsphere-java-core/src/main/java/io/microsphere/collection/EmptyIterator.java b/microsphere-java-core/src/main/java/io/microsphere/collection/EmptyIterator.java index 83f95542d..08514248e 100644 --- a/microsphere-java-core/src/main/java/io/microsphere/collection/EmptyIterator.java +++ b/microsphere-java-core/src/main/java/io/microsphere/collection/EmptyIterator.java @@ -55,31 +55,15 @@ * @see Collections#emptyIterator() */ @Immutable -public class EmptyIterator implements Iterator { +public class EmptyIterator extends DelegatingIterator { /** * The singleton of {@link EmptyIterator} */ public static final EmptyIterator INSTANCE = new EmptyIterator(); - private final Iterator delegate; public EmptyIterator() { - this.delegate = emptyIterator(); - } - - @Override - public boolean hasNext() { - return delegate.hasNext(); - } - - @Override - public E next() { - return delegate.next(); - } - - @Override - public void remove() { - delegate.remove(); + super(emptyIterator()); } } diff --git a/microsphere-java-core/src/test/java/io/microsphere/collection/DelegatingIteratorTest.java b/microsphere-java-core/src/test/java/io/microsphere/collection/DelegatingIteratorTest.java new file mode 100644 index 000000000..f29382d37 --- /dev/null +++ b/microsphere-java-core/src/test/java/io/microsphere/collection/DelegatingIteratorTest.java @@ -0,0 +1,100 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.microsphere.collection; + + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.Iterator; +import java.util.List; +import java.util.NoSuchElementException; + +import static io.microsphere.collection.ListUtils.ofArrayList; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * {@link DelegatingIterator} Test + * + * @author Mercy + * @see DelegatingIterator + * @since 1.0.0 + */ +class DelegatingIteratorTest { + + private Iterator iterator; + + private DelegatingIterator delegatingIterator; + + @BeforeEach + void setUp() { + List list = ofArrayList("1", "2", "3"); + this.iterator = list.iterator(); + this.delegatingIterator = new DelegatingIterator<>(this.iterator); + } + + @Test + void testHasNext() { + assertTrue(delegatingIterator.hasNext()); + } + + @Test + void testNext() { + assertEquals("1", this.delegatingIterator.next()); + assertEquals("2", this.delegatingIterator.next()); + assertEquals("3", this.delegatingIterator.next()); + assertThrows(NoSuchElementException.class, this.delegatingIterator::next); + } + + @Test + void testRemove() { + while (this.delegatingIterator.hasNext()) { + this.delegatingIterator.next(); + this.delegatingIterator.remove(); + } + } + + @Test + void testForEachRemaining() { + this.delegatingIterator.forEachRemaining(Assertions::assertNotNull); + } + + @Test + void testGetDelegate() { + assertSame(this.delegatingIterator.getDelegate(), this.iterator); + } + + @Test + void testHashCode() { + assertEquals(this.delegatingIterator.hashCode(), this.iterator.hashCode()); + } + + @Test + void testEquals() { + assertEquals(this.delegatingIterator, this.iterator); + } + + @Test + void testToString() { + assertEquals(this.delegatingIterator.toString(), this.iterator.toString()); + } +} \ No newline at end of file From 65edb6b582fcc5d0ce62b5798841e78e6dc2eadd Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Fri, 6 Feb 2026 00:48:04 +0800 Subject: [PATCH 58/79] Refactor JSONTokener char/position handling Centralize and simplify character access and position checks in JSONTokener. Replaced repeated this.in.charAt/length checks with helper methods (hasNext, nextChar, currentChar, charAt) and refactored loops to use them. Also added static imports for Double.valueOf, Long.parseLong, Integer.MAX_VALUE and MIN_VALUE and updated numeric parsing to use those imports. Adjusted more() and next() to use the new helpers and cleaned up related parsing methods to improve readability and reduce duplication. --- .../java/io/microsphere/json/JSONTokener.java | 54 +++++++++++++------ 1 file changed, 37 insertions(+), 17 deletions(-) diff --git a/microsphere-java-core/src/main/java/io/microsphere/json/JSONTokener.java b/microsphere-java-core/src/main/java/io/microsphere/json/JSONTokener.java index ac6e4318a..f17066c58 100644 --- a/microsphere-java-core/src/main/java/io/microsphere/json/JSONTokener.java +++ b/microsphere-java-core/src/main/java/io/microsphere/json/JSONTokener.java @@ -19,6 +19,10 @@ import static io.microsphere.json.JSONObject.NULL; import static java.lang.Boolean.FALSE; import static java.lang.Boolean.TRUE; +import static java.lang.Double.valueOf; +import static java.lang.Integer.MAX_VALUE; +import static java.lang.Integer.MIN_VALUE; +import static java.lang.Long.parseLong; /** * Parses a JSON (RFC 4627) encoded @@ -117,8 +121,8 @@ public Object nextValue() throws JSONException { } int nextCleanInternal() throws JSONException { - while (this.pos < this.in.length()) { - int c = this.in.charAt(this.pos++); + while (hasNext()) { + int c = nextChar(); switch (c) { case '\t': case ' ': @@ -131,7 +135,7 @@ int nextCleanInternal() throws JSONException { return c; } - char peek = this.in.charAt(this.pos); + char peek = currentChar(); switch (peek) { case '*': // skip a /* c-style comment */ @@ -175,8 +179,8 @@ int nextCleanInternal() throws JSONException { * terminated by "\r\n", the '\n' must be consumed as whitespace by the caller. */ void skipToEndOfLine() { - for (; this.pos < this.in.length(); this.pos++) { - char c = this.in.charAt(this.pos); + for (; hasNext(); this.pos++) { + char c = currentChar(); if (c == '\r' || c == '\n') { this.pos++; break; @@ -206,8 +210,8 @@ public String nextString(char quote) throws JSONException { /* the index of the first character not yet appended to the builder. */ int start = this.pos; - while (this.pos < this.in.length()) { - int c = this.in.charAt(this.pos++); + while (hasNext()) { + int c = nextChar(); if (c == quote) { if (builder == null) { // a new string avoids leaking memory @@ -244,7 +248,7 @@ public String nextString(char quote) throws JSONException { * @throws JSONException if processing of json failed */ char readEscapeCharacter() throws JSONException { - char escaped = this.in.charAt(this.pos++); + char escaped = nextChar(); switch (escaped) { case 'u': if (this.pos + 4 > this.in.length()) { @@ -309,8 +313,8 @@ public Object readLiteral() throws JSONException { base = 8; } try { - long longValue = Long.parseLong(number, base); - if (longValue <= Integer.MAX_VALUE && longValue >= Integer.MIN_VALUE) { + long longValue = parseLong(number, base); + if (longValue <= MAX_VALUE && longValue >= MIN_VALUE) { return (int) longValue; } else { return longValue; @@ -326,7 +330,7 @@ public Object readLiteral() throws JSONException { /* ...next try to parse as a floating point... */ try { - return Double.valueOf(literal); + return valueOf(literal); } catch (NumberFormatException ignored) { } @@ -343,8 +347,8 @@ public Object readLiteral() throws JSONException { */ String nextToInternal(String excluded) { int start = this.pos; - for (; this.pos < this.in.length(); this.pos++) { - char c = this.in.charAt(this.pos); + for (; hasNext(); this.pos++) { + char c = currentChar(); if (c == '\r' || c == '\n' || excluded.indexOf(c) != -1) { return this.in.substring(start, this.pos); } @@ -389,7 +393,7 @@ public JSONObject readObject() throws JSONException { if (separator != ':' && separator != '=') { throw syntaxError("Expected ':' after " + name); } - if (this.pos < this.in.length() && this.in.charAt(this.pos) == '>') { + if (hasNext() && currentChar() == '>') { this.pos++; } @@ -486,11 +490,15 @@ public String toString() { */ public boolean more() { - return this.pos < this.in.length(); + return hasNext(); } public char next() { - return this.pos < this.in.length() ? this.in.charAt(this.pos++) : '\0'; + return hasNext() ? nextChar() : '\0'; + } + + public boolean hasNext() { + return this.pos < this.in.length(); } public char next(char c) throws JSONException { @@ -547,6 +555,18 @@ public void back() { } } + char currentChar() { + return charAt(this.pos); + } + + char nextChar() { + return charAt(this.pos++); + } + + char charAt(int pos) { + return this.in.charAt(pos); + } + public static int dehexchar(char hex) { if (hex >= '0' && hex <= '9') { return hex - '0'; @@ -559,4 +579,4 @@ public static int dehexchar(char hex) { } } -} +} \ No newline at end of file From 23d34961a52176404ac31c98b9abe53bba5b6058 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Fri, 6 Feb 2026 00:58:59 +0800 Subject: [PATCH 59/79] Use static Scope imports and isEmpty() Refactor JSONStringer to use static imports for Scope enum constants and introduce an isEmpty() helper that wraps stack.isEmpty(). Replace direct Scope.* and stack.isEmpty() usages across methods (array/endArray/object/endObject/open/peek/value/beforeKey/beforeValue) to improve readability and consistency without changing behavior. --- .../io/microsphere/json/JSONStringer.java | 46 +++++++++++-------- 1 file changed, 27 insertions(+), 19 deletions(-) diff --git a/microsphere-java-core/src/main/java/io/microsphere/json/JSONStringer.java b/microsphere-java-core/src/main/java/io/microsphere/json/JSONStringer.java index 832787050..37c6dbd51 100644 --- a/microsphere-java-core/src/main/java/io/microsphere/json/JSONStringer.java +++ b/microsphere-java-core/src/main/java/io/microsphere/json/JSONStringer.java @@ -21,6 +21,11 @@ import static io.microsphere.json.JSONObject.NULL; import static io.microsphere.json.JSONObject.numberToString; +import static io.microsphere.json.JSONStringer.Scope.DANGLING_KEY; +import static io.microsphere.json.JSONStringer.Scope.EMPTY_ARRAY; +import static io.microsphere.json.JSONStringer.Scope.EMPTY_OBJECT; +import static io.microsphere.json.JSONStringer.Scope.NONEMPTY_ARRAY; +import static io.microsphere.json.JSONStringer.Scope.NONEMPTY_OBJECT; import static io.microsphere.util.ClassUtils.getTypeName; import static java.util.Arrays.fill; @@ -145,7 +150,7 @@ public JSONStringer(int indentSpaces) { * @throws JSONException if processing of json failed */ public JSONStringer array() throws JSONException { - return open(Scope.EMPTY_ARRAY, "["); + return open(EMPTY_ARRAY, "["); } /** @@ -155,7 +160,7 @@ public JSONStringer array() throws JSONException { * @throws JSONException if processing of json failed */ public JSONStringer endArray() throws JSONException { - return close(Scope.EMPTY_ARRAY, Scope.NONEMPTY_ARRAY, "]"); + return close(EMPTY_ARRAY, NONEMPTY_ARRAY, "]"); } /** @@ -166,7 +171,7 @@ public JSONStringer endArray() throws JSONException { * @throws JSONException if processing of json failed */ public JSONStringer object() throws JSONException { - return open(Scope.EMPTY_OBJECT, "{"); + return open(EMPTY_OBJECT, "{"); } /** @@ -176,7 +181,7 @@ public JSONStringer object() throws JSONException { * @throws JSONException if processing of json failed */ public JSONStringer endObject() throws JSONException { - return close(Scope.EMPTY_OBJECT, Scope.NONEMPTY_OBJECT, "}"); + return close(EMPTY_OBJECT, NONEMPTY_OBJECT, "}"); } /** @@ -188,7 +193,7 @@ public JSONStringer endObject() throws JSONException { * @throws JSONException if processing of json failed */ JSONStringer open(Scope empty, String openBracket) throws JSONException { - if (this.stack.isEmpty() && this.out.length() > 0) { + if (isEmpty() && this.out.length() > 0) { throw new JSONException("Nesting problem: multiple top-level roots"); } beforeValue(); @@ -228,7 +233,7 @@ JSONStringer close(Scope empty, Scope nonempty, String closeBracket) throws JSON * @throws JSONException if processing of json failed */ private Scope peek() throws JSONException { - if (this.stack.isEmpty()) { + if (isEmpty()) { throw new JSONException("Nesting problem"); } return this.stack.get(this.stack.size() - 1); @@ -253,7 +258,7 @@ private void replaceTop(Scope topOfStack) { * @throws JSONException if processing of json failed */ public JSONStringer value(Object value) throws JSONException { - if (this.stack.isEmpty()) { + if (isEmpty()) { throw new JSONException("Nesting problem"); } @@ -288,7 +293,7 @@ public JSONStringer value(Object value) throws JSONException { * @throws JSONException if processing of json failed */ public JSONStringer value(boolean value) throws JSONException { - if (this.stack.isEmpty()) { + if (isEmpty()) { throw new JSONException("Nesting problem"); } beforeValue(); @@ -305,7 +310,7 @@ public JSONStringer value(boolean value) throws JSONException { * @throws JSONException if processing of json failed */ public JSONStringer value(double value) throws JSONException { - if (this.stack.isEmpty()) { + if (isEmpty()) { throw new JSONException("Nesting problem"); } beforeValue(); @@ -321,7 +326,7 @@ public JSONStringer value(double value) throws JSONException { * @throws JSONException if processing of json failed */ public JSONStringer value(long value) throws JSONException { - if (this.stack.isEmpty()) { + if (isEmpty()) { throw new JSONException("Nesting problem"); } beforeValue(); @@ -414,13 +419,13 @@ public JSONStringer key(String name) throws JSONException { */ void beforeKey() throws JSONException { Scope context = peek(); - if (context == Scope.NONEMPTY_OBJECT) { // first in object + if (context == NONEMPTY_OBJECT) { // first in object this.out.append(','); - } else if (context != Scope.EMPTY_OBJECT) { // not in an object! + } else if (context != EMPTY_OBJECT) { // not in an object! throw new JSONException("Nesting problem"); } newline(); - replaceTop(Scope.DANGLING_KEY); + replaceTop(DANGLING_KEY); } /** @@ -431,20 +436,20 @@ void beforeKey() throws JSONException { * @throws JSONException if processing of json failed */ void beforeValue() throws JSONException { - if (this.stack.isEmpty()) { + if (isEmpty()) { return; } Scope context = peek(); - if (context == Scope.EMPTY_ARRAY) { // first in array - replaceTop(Scope.NONEMPTY_ARRAY); + if (context == EMPTY_ARRAY) { // first in array + replaceTop(NONEMPTY_ARRAY); newline(); - } else if (context == Scope.NONEMPTY_ARRAY) { // another in array + } else if (context == NONEMPTY_ARRAY) { // another in array this.out.append(','); newline(); - } else if (context == Scope.DANGLING_KEY) { // value for key + } else if (context == DANGLING_KEY) { // value for key this.out.append(this.indent == null ? ":" : ": "); - replaceTop(Scope.NONEMPTY_OBJECT); + replaceTop(NONEMPTY_OBJECT); } else if (context != Scope.NULL) { throw new JSONException("Nesting problem"); } @@ -466,4 +471,7 @@ public String toString() { return this.out.length() == 0 ? null : this.out.toString(); } + boolean isEmpty() { + return this.stack.isEmpty(); + } } From c3202f0e9b484ca70e61d78f14b5a4c3aef92094 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Fri, 6 Feb 2026 01:24:06 +0800 Subject: [PATCH 60/79] Use cached length in single-char split loop Replace value.length() with the precomputed 'length' variable when delimiterLength == 0. This ensures the loop boundary is consistent with earlier computations and avoids repeated method calls when splitting the string into single-character substrings. --- .../src/main/java/io/microsphere/util/StringUtils.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/microsphere-java-core/src/main/java/io/microsphere/util/StringUtils.java b/microsphere-java-core/src/main/java/io/microsphere/util/StringUtils.java index b8e92bf57..8ca872b66 100644 --- a/microsphere-java-core/src/main/java/io/microsphere/util/StringUtils.java +++ b/microsphere-java-core/src/main/java/io/microsphere/util/StringUtils.java @@ -173,7 +173,7 @@ public static String[] split(@Nullable String value, @Nullable String delimiter) List result = new ArrayList<>(); if (delimiterLength == 0) { - for (int i = 0; i < value.length(); i++) { + for (int i = 0; i < length; i++) { result.add(value.substring(i, i + 1)); } } else { From 56e5b856c3c6cb7a407e9c5ccdd422f01ad7ae58 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Fri, 6 Feb 2026 01:58:07 +0800 Subject: [PATCH 61/79] Use isObjectType check in TypeUtils loop Replace the manual null and Object.class checks with a call to isObjectType(targetClass) in the loop that collects resolved type arguments. This centralizes the terminal-condition logic for traversing the class hierarchy, improving readability and consistency when resolving type arguments. --- .../src/main/java/io/microsphere/reflect/TypeUtils.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/microsphere-java-core/src/main/java/io/microsphere/reflect/TypeUtils.java b/microsphere-java-core/src/main/java/io/microsphere/reflect/TypeUtils.java index e0b2a6e60..0792648e4 100644 --- a/microsphere-java-core/src/main/java/io/microsphere/reflect/TypeUtils.java +++ b/microsphere-java-core/src/main/java/io/microsphere/reflect/TypeUtils.java @@ -1192,7 +1192,7 @@ public static List resolveTypeArguments(Class targetClass) { return emptyList(); } List typeArguments = newLinkedList(); - while (targetClass != null && targetClass != Object.class) { + while (!isObjectType(targetClass)) { typeArguments.addAll(resolveTypeArguments(targetClass.getGenericSuperclass())); typeArguments.addAll(resolveTypeArguments(targetClass.getGenericInterfaces())); targetClass = targetClass.getSuperclass(); From 804fd25877ad8da5b1e8b92f7430f4889b0c243f Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Fri, 6 Feb 2026 02:14:03 +0800 Subject: [PATCH 62/79] Revert "Use isObjectType check in TypeUtils loop" This reverts commit 56e5b856c3c6cb7a407e9c5ccdd422f01ad7ae58. --- .../src/main/java/io/microsphere/reflect/TypeUtils.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/microsphere-java-core/src/main/java/io/microsphere/reflect/TypeUtils.java b/microsphere-java-core/src/main/java/io/microsphere/reflect/TypeUtils.java index 0792648e4..e0b2a6e60 100644 --- a/microsphere-java-core/src/main/java/io/microsphere/reflect/TypeUtils.java +++ b/microsphere-java-core/src/main/java/io/microsphere/reflect/TypeUtils.java @@ -1192,7 +1192,7 @@ public static List resolveTypeArguments(Class targetClass) { return emptyList(); } List typeArguments = newLinkedList(); - while (!isObjectType(targetClass)) { + while (targetClass != null && targetClass != Object.class) { typeArguments.addAll(resolveTypeArguments(targetClass.getGenericSuperclass())); typeArguments.addAll(resolveTypeArguments(targetClass.getGenericInterfaces())); targetClass = targetClass.getSuperclass(); From 244a8138cb293ee0aaf11a7f3e0864d980a932be Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Fri, 6 Feb 2026 02:17:02 +0800 Subject: [PATCH 63/79] Enable JUnit Jupiter parallel execution Add junit.jupiter.execution.parallel.enabled = true to src/test/resources/junit-platform.properties to enable parallel test execution for JUnit Jupiter. This update allows tests to run concurrently during the test phase. --- .../src/test/resources/junit-platform.properties | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/microsphere-java-core/src/test/resources/junit-platform.properties b/microsphere-java-core/src/test/resources/junit-platform.properties index 1cebb76d5..993f2b029 100644 --- a/microsphere-java-core/src/test/resources/junit-platform.properties +++ b/microsphere-java-core/src/test/resources/junit-platform.properties @@ -1 +1,3 @@ -junit.jupiter.extensions.autodetection.enabled = true \ No newline at end of file +junit.jupiter.extensions.autodetection.enabled = true + +junit.jupiter.execution.parallel.enabled = true \ No newline at end of file From e22218d0ce08bd41382d72395aac5b160a2794f5 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Fri, 6 Feb 2026 08:55:59 +0800 Subject: [PATCH 64/79] Format signatures; remove redundant null check Reformat long method signatures in TypeUtils.resolveTypeArgumentsMap overloads for improved readability by wrapping parameters across lines. Also simplify the loop in resolveTypeArguments by removing a redundant null check (targetClass is validated earlier), leaving behavior unchanged while making the code clearer. --- .../java/io/microsphere/reflect/TypeUtils.java | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/microsphere-java-core/src/main/java/io/microsphere/reflect/TypeUtils.java b/microsphere-java-core/src/main/java/io/microsphere/reflect/TypeUtils.java index e0b2a6e60..d105b4059 100644 --- a/microsphere-java-core/src/main/java/io/microsphere/reflect/TypeUtils.java +++ b/microsphere-java-core/src/main/java/io/microsphere/reflect/TypeUtils.java @@ -646,7 +646,9 @@ static List doResolveActualTypeArgumentsInFastPath(Type type) { } @Nonnull - private static Map resolveTypeArgumentsMap(Type type, List hierarchicalTypes, int hierarchicalTypesSize, Class baseClass, TypeVariable[] baseTypeParameters) { + private static Map resolveTypeArgumentsMap(Type type, List hierarchicalTypes, + int hierarchicalTypesSize, Class baseClass, + TypeVariable[] baseTypeParameters) { int size = hierarchicalTypesSize + 1; @@ -663,14 +665,18 @@ private static Map resolveTypeArgumentsMap(Type type, Lis return typeArgumentsMap; } - private static void resolveTypeArgumentsMap(Type type, List hierarchicalTypes, int index, int hierarchicalTypesSize, Map typeArgumentsMap, Class baseClass, TypeVariable[] baseTypeParameters) { + private static void resolveTypeArgumentsMap(Type type, List hierarchicalTypes, int index, + int hierarchicalTypesSize, Map typeArgumentsMap, + Class baseClass, TypeVariable[] baseTypeParameters) { ParameterizedType pType = asParameterizedType(type); if (pType != null) { resolveTypeArgumentsMap(pType, hierarchicalTypes, index, hierarchicalTypesSize, typeArgumentsMap, baseClass, baseTypeParameters); } } - private static void resolveTypeArgumentsMap(ParameterizedType type, List hierarchicalTypes, int index, int hierarchicalTypesSize, Map typeArgumentsMap, Class baseClass, TypeVariable[] baseTypeParameters) { + private static void resolveTypeArgumentsMap(ParameterizedType type, List hierarchicalTypes, int index, + int hierarchicalTypesSize, Map typeArgumentsMap, + Class baseClass, TypeVariable[] baseTypeParameters) { Class klass = asClass(type); int baseTypeArgumentsLength = baseTypeParameters.length; @@ -1192,7 +1198,7 @@ public static List resolveTypeArguments(Class targetClass) { return emptyList(); } List typeArguments = newLinkedList(); - while (targetClass != null && targetClass != Object.class) { + while (targetClass != Object.class) { typeArguments.addAll(resolveTypeArguments(targetClass.getGenericSuperclass())); typeArguments.addAll(resolveTypeArguments(targetClass.getGenericInterfaces())); targetClass = targetClass.getSuperclass(); From 95cef367eb78c9bb2e01578be7094944bca3d6c1 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Fri, 6 Feb 2026 08:57:13 +0800 Subject: [PATCH 65/79] Add private constructor to Assert utility Prevent instantiation of the Assert utility class by adding a private no-arg constructor. This enforces the class's static-only usage and communicates intent to future maintainers. --- .../src/main/java/io/microsphere/util/Assert.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/microsphere-java-core/src/main/java/io/microsphere/util/Assert.java b/microsphere-java-core/src/main/java/io/microsphere/util/Assert.java index 362d81bad..262f56136 100644 --- a/microsphere-java-core/src/main/java/io/microsphere/util/Assert.java +++ b/microsphere-java-core/src/main/java/io/microsphere/util/Assert.java @@ -502,4 +502,7 @@ public static void assertFieldMatchType(Object object, String fieldName, Class messageSupplier) { return messageSupplier == null ? null : messageSupplier.get(); } -} + + private Assert() { + } +} \ No newline at end of file From 1ab16cc0f3f71231dd30ca011379c3d24ffa32dc Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Fri, 6 Feb 2026 08:57:45 +0800 Subject: [PATCH 66/79] Remove super() from StringUtils constructor Remove the redundant super() call from the private no-arg constructor in StringUtils. This is a clean-up change with no behavioral impact since Object's constructor is invoked implicitly. --- .../src/main/java/io/microsphere/util/StringUtils.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/microsphere-java-core/src/main/java/io/microsphere/util/StringUtils.java b/microsphere-java-core/src/main/java/io/microsphere/util/StringUtils.java index 8ca872b66..f5e8da389 100644 --- a/microsphere-java-core/src/main/java/io/microsphere/util/StringUtils.java +++ b/microsphere-java-core/src/main/java/io/microsphere/util/StringUtils.java @@ -882,6 +882,5 @@ static String trimWhitespace(String str, boolean includeLeading, boolean include } private StringUtils() { - super(); } -} +} \ No newline at end of file From 00bf5ebdeb09147bf65a71d2d0efa203bcebd517 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Fri, 6 Feb 2026 12:04:18 +0800 Subject: [PATCH 67/79] Refactor DelegatingURLConnectionTest to use this. Normalize test code by prefixing urlConnection references with this.urlConnection and consolidating static imports (copyToString, attach, TEST_CONSOLE_URL, System.out, assertSame). Replace IOUtils.toString with copyToString, adjust testGetOutputStream to expect IOException, and add a scenario that attaches the ServiceLoaderURLStreamHandlerFactory, opens TEST_CONSOLE_URL and asserts the returned output stream is System.out. Miscellaneous small assertions and cleanup for clarity. --- .../net/DelegatingURLConnectionTest.java | 110 ++++++++++-------- 1 file changed, 60 insertions(+), 50 deletions(-) diff --git a/microsphere-java-core/src/test/java/io/microsphere/net/DelegatingURLConnectionTest.java b/microsphere-java-core/src/test/java/io/microsphere/net/DelegatingURLConnectionTest.java index 7cfa84144..b2554b3ed 100644 --- a/microsphere-java-core/src/test/java/io/microsphere/net/DelegatingURLConnectionTest.java +++ b/microsphere-java-core/src/test/java/io/microsphere/net/DelegatingURLConnectionTest.java @@ -16,7 +16,6 @@ */ package io.microsphere.net; -import io.microsphere.io.IOUtils; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -27,11 +26,16 @@ import java.util.List; import java.util.Map; +import static io.microsphere.io.IOUtils.copyToString; +import static io.microsphere.net.ServiceLoaderURLStreamHandlerFactory.attach; +import static io.microsphere.net.console.HandlerTest.TEST_CONSOLE_URL; import static java.lang.System.currentTimeMillis; +import static java.lang.System.out; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -96,207 +100,213 @@ void testGetReadTimeout() { @Test void testGetURL() { - assertEquals(url, urlConnection.getURL()); + assertEquals(url, this.urlConnection.getURL()); } @Test void testGetContentLength() { - assertEquals(19, urlConnection.getContentLength()); + assertEquals(19, this.urlConnection.getContentLength()); } @Test void testGetContentLengthLong() { - assertEquals(19, urlConnection.getContentLengthLong()); + assertEquals(19, this.urlConnection.getContentLengthLong()); } @Test void testGetContentType() { - assertEquals("content/unknown", urlConnection.getContentType()); + assertEquals("content/unknown", this.urlConnection.getContentType()); } @Test void testGetContentEncoding() { - assertNull(urlConnection.getContentEncoding()); + assertNull(this.urlConnection.getContentEncoding()); } @Test void testGetExpiration() { - assertEquals(0, urlConnection.getExpiration()); + assertEquals(0, this.urlConnection.getExpiration()); } @Test void testGetDate() { - assertEquals(0, urlConnection.getDate()); + assertEquals(0, this.urlConnection.getDate()); } @Test void testGetLastModified() { - assertFalse(urlConnection.getLastModified() > currentTimeMillis()); + assertFalse(this.urlConnection.getLastModified() > currentTimeMillis()); } @Test void testGetHeaderField() { - assertNull(urlConnection.getHeaderField(NOT_EXISTS_HEADER_NAME)); - assertEquals("19", urlConnection.getHeaderField(CONTENT_LENGTH_HEADER_NAME)); - assertNotNull(urlConnection.getHeaderField(LAST_MODIFIED_HEADER_NAME)); + assertNull(this.urlConnection.getHeaderField(NOT_EXISTS_HEADER_NAME)); + assertEquals("19", this.urlConnection.getHeaderField(CONTENT_LENGTH_HEADER_NAME)); + assertNotNull(this.urlConnection.getHeaderField(LAST_MODIFIED_HEADER_NAME)); } @Test void testGetHeaderFields() { - assertNotNull(urlConnection.getHeaderFields()); + assertNotNull(this.urlConnection.getHeaderFields()); } @Test void testGetHeaderFieldInt() { - assertEquals(19, urlConnection.getHeaderFieldInt(CONTENT_LENGTH_HEADER_NAME, 10)); - assertEquals(1, urlConnection.getHeaderFieldInt(NOT_EXISTS_HEADER_NAME, 1)); + assertEquals(19, this.urlConnection.getHeaderFieldInt(CONTENT_LENGTH_HEADER_NAME, 10)); + assertEquals(1, this.urlConnection.getHeaderFieldInt(NOT_EXISTS_HEADER_NAME, 1)); } @Test void testGetHeaderFieldLong() { - assertEquals(19, urlConnection.getHeaderFieldLong(CONTENT_LENGTH_HEADER_NAME, 10)); - assertEquals(1, urlConnection.getHeaderFieldLong(NOT_EXISTS_HEADER_NAME, 1)); + assertEquals(19, this.urlConnection.getHeaderFieldLong(CONTENT_LENGTH_HEADER_NAME, 10)); + assertEquals(1, this.urlConnection.getHeaderFieldLong(NOT_EXISTS_HEADER_NAME, 1)); } @Test void testGetHeaderFieldDate() { long now = currentTimeMillis(); - assertTrue(now > urlConnection.getHeaderFieldDate(LAST_MODIFIED_HEADER_NAME, now)); - assertEquals(now, urlConnection.getHeaderFieldDate(NOT_EXISTS_HEADER_NAME, now)); + assertTrue(now > this.urlConnection.getHeaderFieldDate(LAST_MODIFIED_HEADER_NAME, now)); + assertEquals(now, this.urlConnection.getHeaderFieldDate(NOT_EXISTS_HEADER_NAME, now)); } @Test void testGetHeaderFieldKey() { - assertEquals(CONTENT_LENGTH_HEADER_NAME, urlConnection.getHeaderFieldKey(0)); - assertEquals(LAST_MODIFIED_HEADER_NAME, urlConnection.getHeaderFieldKey(1)); - assertNull(urlConnection.getHeaderFieldKey(2)); + assertEquals(CONTENT_LENGTH_HEADER_NAME, this.urlConnection.getHeaderFieldKey(0)); + assertEquals(LAST_MODIFIED_HEADER_NAME, this.urlConnection.getHeaderFieldKey(1)); + assertNull(this.urlConnection.getHeaderFieldKey(2)); } @Test void testGetHeaderFieldWithInt() { - assertEquals("19", urlConnection.getHeaderField(0)); - assertNotNull(urlConnection.getHeaderField(1)); - assertNull(urlConnection.getHeaderFieldKey(2)); + assertEquals("19", this.urlConnection.getHeaderField(0)); + assertNotNull(this.urlConnection.getHeaderField(1)); + assertNull(this.urlConnection.getHeaderFieldKey(2)); } @Test void testGetContent() throws IOException { - urlConnection.getContent(); + this.urlConnection.getContent(); } @Test void testGetContentWithClassArray() throws IOException { - urlConnection.getContent(new Class[0]); + this.urlConnection.getContent(new Class[0]); } @Test void testGetPermission() throws IOException { - assertNotNull(urlConnection.getPermission()); + assertNotNull(this.urlConnection.getPermission()); } @Test void testGetInputStream() throws Exception { String encoding = "UTF-8"; String data = "name = 测试名称"; - assertEquals(data, IOUtils.toString(urlConnection.getInputStream(), encoding)); + assertEquals(data, copyToString(this.urlConnection.getInputStream(), encoding)); } @Test - void testGetOutputStream() throws Exception { - assertThrows(Exception.class, urlConnection::getOutputStream); + void testGetOutputStream() throws IOException { + assertThrows(Exception.class, this.urlConnection::getOutputStream); + + attach(); + URL url = new URL(TEST_CONSOLE_URL); + URLConnection delegate = url.openConnection(); + this.urlConnection = new DelegatingURLConnection(delegate); + assertSame(out, this.urlConnection.getOutputStream()); } @Test void testToString() { - assertNotNull(urlConnection.toString()); + assertNotNull(this.urlConnection.toString()); } @Test void testSetDoInput() { - urlConnection.setDoInput(true); + this.urlConnection.setDoInput(true); } @Test void testGetDoInput() { testSetDoInput(); - assertTrue(urlConnection.getDoInput()); + assertTrue(this.urlConnection.getDoInput()); } @Test void testSetDoOutput() { - urlConnection.setDoOutput(true); + this.urlConnection.setDoOutput(true); } @Test void testGetDoOutput() { testSetDoOutput(); - assertTrue(urlConnection.getDoOutput()); + assertTrue(this.urlConnection.getDoOutput()); } @Test void testSetAllowUserInteraction() { - urlConnection.setAllowUserInteraction(true); + this.urlConnection.setAllowUserInteraction(true); } @Test void testGetAllowUserInteraction() { testSetAllowUserInteraction(); - assertTrue(urlConnection.getAllowUserInteraction()); + assertTrue(this.urlConnection.getAllowUserInteraction()); } @Test void testSetUseCaches() { - urlConnection.setUseCaches(true); + this.urlConnection.setUseCaches(true); } @Test void testGetUseCaches() { testSetUseCaches(); - assertTrue(urlConnection.getUseCaches()); + assertTrue(this.urlConnection.getUseCaches()); } @Test void testSetIfModifiedSince() { long now = currentTimeMillis(); - urlConnection.setIfModifiedSince(now); + this.urlConnection.setIfModifiedSince(now); } @Test void testGetIfModifiedSince() { testSetIfModifiedSince(); - assertTrue(currentTimeMillis() >= urlConnection.getIfModifiedSince()); + assertTrue(currentTimeMillis() >= this.urlConnection.getIfModifiedSince()); } @Test void testSetDefaultUseCaches() { - urlConnection.setDefaultUseCaches(true); + this.urlConnection.setDefaultUseCaches(true); } @Test void testGetDefaultUseCaches() { - urlConnection.setDefaultUseCaches(true); - assertTrue(urlConnection.getDefaultUseCaches()); + this.urlConnection.setDefaultUseCaches(true); + assertTrue(this.urlConnection.getDefaultUseCaches()); } @Test void testSetRequestProperty() { - urlConnection.setRequestProperty("key-1", "value-1"); + this.urlConnection.setRequestProperty("key-1", "value-1"); } @Test void testAddRequestProperty() { - urlConnection.addRequestProperty("key-1", "value-1-1"); - urlConnection.addRequestProperty("key-2", "value-2"); + this.urlConnection.addRequestProperty("key-1", "value-1-1"); + this.urlConnection.addRequestProperty("key-2", "value-2"); } @Test void testGetRequestProperty() { - assertNull(urlConnection.getRequestProperty("key-1")); + assertNull(this.urlConnection.getRequestProperty("key-1")); } @Test void testGetRequestProperties() { - Map> requestProperties = urlConnection.getRequestProperties(); + Map> requestProperties = this.urlConnection.getRequestProperties(); assertNotNull(requestProperties); } } From 739be6556555c5a5071a6c2f9bcefe766973870d Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Fri, 6 Feb 2026 12:12:40 +0800 Subject: [PATCH 68/79] Use this.jsonBuilder in tests; add appendName test MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Refactor JSONUtilsTest to use explicit this.jsonBuilder references (replacing bare jsonBuilder) to avoid ambiguity and make the instance usage clear. Add static import for appendName and introduce testAppendName to validate appendName behavior for null, empty, blank and normal names. No production code changed—only test code and imports updated. --- .../io/microsphere/json/JSONUtilsTest.java | 181 ++++++++++-------- 1 file changed, 98 insertions(+), 83 deletions(-) diff --git a/microsphere-java-core/src/test/java/io/microsphere/json/JSONUtilsTest.java b/microsphere-java-core/src/test/java/io/microsphere/json/JSONUtilsTest.java index 76420059c..d50fa6507 100644 --- a/microsphere-java-core/src/test/java/io/microsphere/json/JSONUtilsTest.java +++ b/microsphere-java-core/src/test/java/io/microsphere/json/JSONUtilsTest.java @@ -46,6 +46,7 @@ import static io.microsphere.collection.Sets.ofSet; import static io.microsphere.json.JSONObject.NULL; import static io.microsphere.json.JSONUtils.append; +import static io.microsphere.json.JSONUtils.appendName; import static io.microsphere.json.JSONUtils.convertValue; import static io.microsphere.json.JSONUtils.determineElementClass; import static io.microsphere.json.JSONUtils.escape; @@ -99,219 +100,219 @@ void setUp() { @Test void testAppendOnBoolean() { - append(jsonBuilder, "name", true); - assertEquals("\"name\":true", jsonBuilder.toString()); + append(this.jsonBuilder, "name", true); + assertEquals("\"name\":true", this.jsonBuilder.toString()); } @Test void testAppendOnByte() { - append(jsonBuilder, "name", (byte) 1); - assertEquals("\"name\":1", jsonBuilder.toString()); + append(this.jsonBuilder, "name", (byte) 1); + assertEquals("\"name\":1", this.jsonBuilder.toString()); } @Test void testAppendOnShort() { - append(jsonBuilder, "name", (short) 1); - assertEquals("\"name\":1", jsonBuilder.toString()); + append(this.jsonBuilder, "name", (short) 1); + assertEquals("\"name\":1", this.jsonBuilder.toString()); } @Test void testAppendOnInt() { - append(jsonBuilder, "name", 1); - assertEquals("\"name\":1", jsonBuilder.toString()); + append(this.jsonBuilder, "name", 1); + assertEquals("\"name\":1", this.jsonBuilder.toString()); } @Test void testAppendOnLong() { - append(jsonBuilder, "name", 1L); - assertEquals("\"name\":1", jsonBuilder.toString()); + append(this.jsonBuilder, "name", 1L); + assertEquals("\"name\":1", this.jsonBuilder.toString()); } @Test void testAppendOnFloat() { - append(jsonBuilder, "name", 1.0f); - assertEquals("\"name\":1.0", jsonBuilder.toString()); + append(this.jsonBuilder, "name", 1.0f); + assertEquals("\"name\":1.0", this.jsonBuilder.toString()); } @Test void testAppendOnDouble() { - append(jsonBuilder, "name", 1.0); - assertEquals("\"name\":1.0", jsonBuilder.toString()); + append(this.jsonBuilder, "name", 1.0); + assertEquals("\"name\":1.0", this.jsonBuilder.toString()); } @Test void testAppendOnChar() { - append(jsonBuilder, "name", 'a'); - assertEquals("\"name\":\"a\"", jsonBuilder.toString()); + append(this.jsonBuilder, "name", 'a'); + assertEquals("\"name\":\"a\"", this.jsonBuilder.toString()); } @Test void testAppendOnBooleanObject() { - append(jsonBuilder, "name", TRUE); - assertEquals("\"name\":true", jsonBuilder.toString()); + append(this.jsonBuilder, "name", TRUE); + assertEquals("\"name\":true", this.jsonBuilder.toString()); } @Test void testAppendOnByteObject() { - append(jsonBuilder, "name", valueOf((byte) 1)); - assertEquals("\"name\":1", jsonBuilder.toString()); + append(this.jsonBuilder, "name", valueOf((byte) 1)); + assertEquals("\"name\":1", this.jsonBuilder.toString()); } @Test void testAppendOnShortObject() { - append(jsonBuilder, "name", Short.valueOf((short) 1)); - assertEquals("\"name\":1", jsonBuilder.toString()); + append(this.jsonBuilder, "name", Short.valueOf((short) 1)); + assertEquals("\"name\":1", this.jsonBuilder.toString()); } @Test void testAppendOnIntegerObject() { - append(jsonBuilder, "name", Integer.valueOf(1)); - assertEquals("\"name\":1", jsonBuilder.toString()); + append(this.jsonBuilder, "name", Integer.valueOf(1)); + assertEquals("\"name\":1", this.jsonBuilder.toString()); } @Test void testAppendOnLongObject() { - append(jsonBuilder, "name", Long.valueOf(1L)); - assertEquals("\"name\":1", jsonBuilder.toString()); + append(this.jsonBuilder, "name", Long.valueOf(1L)); + assertEquals("\"name\":1", this.jsonBuilder.toString()); } @Test void testAppendOnFloatObject() { - append(jsonBuilder, "name", Float.valueOf(1.0f)); - assertEquals("\"name\":1.0", jsonBuilder.toString()); + append(this.jsonBuilder, "name", Float.valueOf(1.0f)); + assertEquals("\"name\":1.0", this.jsonBuilder.toString()); } @Test void testAppendOnDoubleObject() { - append(jsonBuilder, "name", Double.valueOf(1.0)); - assertEquals("\"name\":1.0", jsonBuilder.toString()); + append(this.jsonBuilder, "name", Double.valueOf(1.0)); + assertEquals("\"name\":1.0", this.jsonBuilder.toString()); } @Test void testAppendOnCharacterObject() { - append(jsonBuilder, "name", valueOf('a')); - assertEquals("\"name\":\"a\"", jsonBuilder.toString()); + append(this.jsonBuilder, "name", valueOf('a')); + assertEquals("\"name\":\"a\"", this.jsonBuilder.toString()); } @Test void testAppendOnString() { - append(jsonBuilder, "name", "a"); - assertEquals("\"name\":\"a\"", jsonBuilder.toString()); + append(this.jsonBuilder, "name", "a"); + assertEquals("\"name\":\"a\"", this.jsonBuilder.toString()); } @Test void testAppendOnType() { - append(jsonBuilder, "name", String.class); - assertEquals("\"name\":\"java.lang.String\"", jsonBuilder.toString()); + append(this.jsonBuilder, "name", String.class); + assertEquals("\"name\":\"java.lang.String\"", this.jsonBuilder.toString()); } @Test void testAppendOnBooleanObjectArray() { - append(jsonBuilder, "name", new Boolean[]{TRUE, FALSE}); - assertEquals("\"name\":[true,false]", jsonBuilder.toString()); + append(this.jsonBuilder, "name", new Boolean[]{TRUE, FALSE}); + assertEquals("\"name\":[true,false]", this.jsonBuilder.toString()); } @Test void testAppendOnByteObjectArray() { - append(jsonBuilder, "name", new Byte[]{(byte) 1, (byte) 2}); - assertEquals("\"name\":[1,2]", jsonBuilder.toString()); + append(this.jsonBuilder, "name", new Byte[]{(byte) 1, (byte) 2}); + assertEquals("\"name\":[1,2]", this.jsonBuilder.toString()); } @Test void testAppendOnShortObjectArray() { - append(jsonBuilder, "name", new Short[]{(short) 1, (short) 2}); - assertEquals("\"name\":[1,2]", jsonBuilder.toString()); + append(this.jsonBuilder, "name", new Short[]{(short) 1, (short) 2}); + assertEquals("\"name\":[1,2]", this.jsonBuilder.toString()); } @Test void testAppendOnIntegerObjectArray() { - append(jsonBuilder, "name", new Integer[]{1, 2}); - assertEquals("\"name\":[1,2]", jsonBuilder.toString()); + append(this.jsonBuilder, "name", new Integer[]{1, 2}); + assertEquals("\"name\":[1,2]", this.jsonBuilder.toString()); } @Test void testAppendOnLongObjectArray() { - append(jsonBuilder, "name", new Long[]{1L, 2L}); - assertEquals("\"name\":[1,2]", jsonBuilder.toString()); + append(this.jsonBuilder, "name", new Long[]{1L, 2L}); + assertEquals("\"name\":[1,2]", this.jsonBuilder.toString()); } @Test void testAppendOnFloatObjectArray() { - append(jsonBuilder, "name", new Float[]{1.0f, 2.0f}); - assertEquals("\"name\":[1.0,2.0]", jsonBuilder.toString()); + append(this.jsonBuilder, "name", new Float[]{1.0f, 2.0f}); + assertEquals("\"name\":[1.0,2.0]", this.jsonBuilder.toString()); } @Test void testAppendOnDoubleObjectArray() { - append(jsonBuilder, "name", new Double[]{1.0, 2.0}); - assertEquals("\"name\":[1.0,2.0]", jsonBuilder.toString()); + append(this.jsonBuilder, "name", new Double[]{1.0, 2.0}); + assertEquals("\"name\":[1.0,2.0]", this.jsonBuilder.toString()); } @Test void testAppendOnCharacterObjectArray() { - append(jsonBuilder, "name", new Character[]{'a', 'b'}); - assertEquals("\"name\":[\"a\",\"b\"]", jsonBuilder.toString()); + append(this.jsonBuilder, "name", new Character[]{'a', 'b'}); + assertEquals("\"name\":[\"a\",\"b\"]", this.jsonBuilder.toString()); } @Test void testAppendOnBooleanArray() { - append(jsonBuilder, "name", new boolean[]{true, false}); - assertEquals("\"name\":[true,false]", jsonBuilder.toString()); + append(this.jsonBuilder, "name", new boolean[]{true, false}); + assertEquals("\"name\":[true,false]", this.jsonBuilder.toString()); } @Test void testAppendOnByteArray() { - append(jsonBuilder, "name", new byte[]{1, 2}); - assertEquals("\"name\":[1,2]", jsonBuilder.toString()); + append(this.jsonBuilder, "name", new byte[]{1, 2}); + assertEquals("\"name\":[1,2]", this.jsonBuilder.toString()); } @Test void testAppendOnShortArray() { - append(jsonBuilder, "name", new short[]{1, 2}); - assertEquals("\"name\":[1,2]", jsonBuilder.toString()); + append(this.jsonBuilder, "name", new short[]{1, 2}); + assertEquals("\"name\":[1,2]", this.jsonBuilder.toString()); } @Test void testAppendOnIntegerArray() { - append(jsonBuilder, "name", new int[]{1, 2}); - assertEquals("\"name\":[1,2]", jsonBuilder.toString()); + append(this.jsonBuilder, "name", new int[]{1, 2}); + assertEquals("\"name\":[1,2]", this.jsonBuilder.toString()); } @Test void testAppendOnLongArray() { - append(jsonBuilder, "name", new long[]{1, 2}); - assertEquals("\"name\":[1,2]", jsonBuilder.toString()); + append(this.jsonBuilder, "name", new long[]{1, 2}); + assertEquals("\"name\":[1,2]", this.jsonBuilder.toString()); } @Test void testAppendOnFloatArray() { - append(jsonBuilder, "name", new float[]{1.0f, 2.0f}); - assertEquals("\"name\":[1.0,2.0]", jsonBuilder.toString()); + append(this.jsonBuilder, "name", new float[]{1.0f, 2.0f}); + assertEquals("\"name\":[1.0,2.0]", this.jsonBuilder.toString()); } @Test void testAppendOnDoubleArray() { - append(jsonBuilder, "name", new double[]{1.0, 2.0}); - assertEquals("\"name\":[1.0,2.0]", jsonBuilder.toString()); + append(this.jsonBuilder, "name", new double[]{1.0, 2.0}); + assertEquals("\"name\":[1.0,2.0]", this.jsonBuilder.toString()); } @Test void testAppendOnCharArray() { - append(jsonBuilder, "name", new char[]{'a', 'b'}); - assertEquals("\"name\":[\"a\",\"b\"]", jsonBuilder.toString()); + append(this.jsonBuilder, "name", new char[]{'a', 'b'}); + assertEquals("\"name\":[\"a\",\"b\"]", this.jsonBuilder.toString()); } @Test void testAppendOnStringArray() { - append(jsonBuilder, "name", new String[]{"a", "b"}); - assertEquals("\"name\":[\"a\",\"b\"]", jsonBuilder.toString()); + append(this.jsonBuilder, "name", new String[]{"a", "b"}); + assertEquals("\"name\":[\"a\",\"b\"]", this.jsonBuilder.toString()); } @Test void testAppendOnObjectAsArray() { Object value = new boolean[]{TRUE, FALSE}; - append(jsonBuilder, "name", value); - assertEquals("\"name\":[true,false]", jsonBuilder.toString()); + append(this.jsonBuilder, "name", value); + assertEquals("\"name\":[true,false]", this.jsonBuilder.toString()); } @Test @@ -328,44 +329,58 @@ void testAppendOnObjectAsMap() { "string", "8", "strings", new String[]{"9", "10"} ); - append(jsonBuilder, "name", value); + append(this.jsonBuilder, "name", value); } @Test void testAppendOnObjectAsIterable() { Object value = ofList(true, (byte) 1, '2', 3.0, 4.0f, 5L, 6, (short) 7, "8", ofArray("9", "10")); - append(jsonBuilder, "name", value); - assertEquals("\"name\":[true,1,\"2\",3.0,4.0,5,6,7,\"8\",[\"9\",\"10\"]]", jsonBuilder.toString()); + append(this.jsonBuilder, "name", value); + assertEquals("\"name\":[true,1,\"2\",3.0,4.0,5,6,7,\"8\",[\"9\",\"10\"]]", this.jsonBuilder.toString()); } @Test void testAppendOnObjectAsString() { Object value = "s"; - append(jsonBuilder, "name", value); - assertEquals("\"name\":\"s\"", jsonBuilder.toString()); + append(this.jsonBuilder, "name", value); + assertEquals("\"name\":\"s\"", this.jsonBuilder.toString()); } @Test void testAppendOnObjectAsInteger() { Object value = 1; - append(jsonBuilder, "name", value); - assertEquals("\"name\":1", jsonBuilder.toString()); + append(this.jsonBuilder, "name", value); + assertEquals("\"name\":1", this.jsonBuilder.toString()); } @Test void testAppendOnGenericArray() { TimeUnit[] values = ofArray(DAYS, HOURS, MINUTES); - append(jsonBuilder, "name", values); - assertEquals("\"name\":[\"DAYS\",\"HOURS\",\"MINUTES\"]", jsonBuilder.toString()); + append(this.jsonBuilder, "name", values); + assertEquals("\"name\":[\"DAYS\",\"HOURS\",\"MINUTES\"]", this.jsonBuilder.toString()); } @Test void testAppendOnTypeArray() { Class[] classes = ofArray(String.class, Integer.class); - append(jsonBuilder, "name", classes); - assertEquals("\"name\":[\"java.lang.String\",\"java.lang.Integer\"]", jsonBuilder.toString()); + append(this.jsonBuilder, "name", classes); + assertEquals("\"name\":[\"java.lang.String\",\"java.lang.Integer\"]", this.jsonBuilder.toString()); } + @Test + void testAppendName() { + appendName(this.jsonBuilder, null); + assertEquals(EMPTY_STRING, this.jsonBuilder.toString()); + + appendName(this.jsonBuilder, ""); + assertEquals(EMPTY_STRING, this.jsonBuilder.toString()); + + appendName(this.jsonBuilder, " "); + assertEquals(EMPTY_STRING, this.jsonBuilder.toString()); + + appendName(this.jsonBuilder, "name"); + assertEquals("\"name\":", this.jsonBuilder.toString()); + } @Test void testIsUnknownClass() { From 101a86d44fc0907c8d10964a1be7ebce7f90b8f6 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Fri, 6 Feb 2026 15:26:39 +0800 Subject: [PATCH 69/79] Simplify process id resolution with streams Replace the manual loop for resolving current process id with a Stream-based pipeline that filters supported ProcessIdResolvers, maps to their current id, and picks the first non-null value or UNKNOWN_PROCESS_ID. Remove the Logger, the log(...) helper and related imports since trace logging was eliminated. Update tests to reflect the change: remove the logging-centric test and unused imports, and add an assertion that the static currentProcessId equals the value returned by getCurrentProcessId(). Miscellaneous: add Objects import and tidy up unused imports. --- .../management/ManagementUtils.java | 33 +++++-------------- .../management/ManagementUtilsTest.java | 22 ++++--------- 2 files changed, 15 insertions(+), 40 deletions(-) diff --git a/microsphere-java-core/src/main/java/io/microsphere/management/ManagementUtils.java b/microsphere-java-core/src/main/java/io/microsphere/management/ManagementUtils.java index b14fa3f49..e96d8e662 100644 --- a/microsphere-java-core/src/main/java/io/microsphere/management/ManagementUtils.java +++ b/microsphere-java-core/src/main/java/io/microsphere/management/ManagementUtils.java @@ -1,14 +1,12 @@ package io.microsphere.management; -import io.microsphere.logging.Logger; import io.microsphere.process.ProcessIdResolver; import io.microsphere.util.ServiceLoaderUtils; import io.microsphere.util.Utils; -import java.util.List; +import java.util.Objects; -import static io.microsphere.logging.LoggerFactory.getLogger; import static io.microsphere.process.ProcessIdResolver.UNKNOWN_PROCESS_ID; import static io.microsphere.util.ServiceLoaderUtils.loadServicesList; @@ -22,29 +20,16 @@ */ public abstract class ManagementUtils implements Utils { - private static final Logger logger = getLogger(ManagementUtils.class); - static final long currentProcessId = resolveCurrentProcessId(); private static long resolveCurrentProcessId() { - List resolvers = loadServicesList(ProcessIdResolver.class); - Long processId = null; - for (ProcessIdResolver resolver : resolvers) { - if (resolver.supports()) { - if ((processId = resolver.current()) != null) { - log(resolver, processId); - break; - } - } - } - return processId == null ? UNKNOWN_PROCESS_ID : processId; - } - - static void log(ProcessIdResolver resolver, Long processId) { - if (logger.isTraceEnabled()) { - logger.trace("The process id was resolved by ProcessIdResolver[class : '{}' , priority : {}] successfully : {}", - resolver.getClass().getName(), resolver.getPriority(), processId); - } + return loadServicesList(ProcessIdResolver.class) + .stream() + .filter(ProcessIdResolver::supports) + .map(ProcessIdResolver::current) + .filter(Objects::nonNull) + .findFirst() + .orElse(UNKNOWN_PROCESS_ID); } /** @@ -75,4 +60,4 @@ public static long getCurrentProcessId() { private ManagementUtils() { } -} +} \ No newline at end of file diff --git a/microsphere-java-core/src/test/java/io/microsphere/management/ManagementUtilsTest.java b/microsphere-java-core/src/test/java/io/microsphere/management/ManagementUtilsTest.java index 7f682bc44..bb40748ba 100644 --- a/microsphere-java-core/src/test/java/io/microsphere/management/ManagementUtilsTest.java +++ b/microsphere-java-core/src/test/java/io/microsphere/management/ManagementUtilsTest.java @@ -1,14 +1,11 @@ package io.microsphere.management; import io.microsphere.AbstractTestCase; -import io.microsphere.process.ProcessIdResolver; import org.junit.jupiter.api.Test; -import java.util.List; - +import static io.microsphere.management.ManagementUtils.currentProcessId; import static io.microsphere.management.ManagementUtils.getCurrentProcessId; -import static io.microsphere.process.ProcessIdResolver.UNKNOWN_PROCESS_ID; -import static io.microsphere.util.ServiceLoaderUtils.loadServicesList; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertTrue; /** @@ -22,16 +19,9 @@ class ManagementUtilsTest extends AbstractTestCase { @Test void testGetCurrentProcessId() { - long currentProcessId = getCurrentProcessId(); - assertTrue(currentProcessId > 0); - } - - @Test - void testLog() { - List resolvers = loadServicesList(ProcessIdResolver.class); - for (ProcessIdResolver resolver : resolvers) { - ManagementUtils.log(resolver, UNKNOWN_PROCESS_ID); - } + long processId = getCurrentProcessId(); + assertTrue(processId > 0); + assertEquals(currentProcessId, getCurrentProcessId()); } -} +} \ No newline at end of file From f7235b1317776484c85b108fecbc143caa993c1f Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Fri, 6 Feb 2026 16:25:27 +0800 Subject: [PATCH 70/79] Make load methods static and add tests Refactor BannedArtifactClassLoadingExecutor to make config-loading helpers static and accept a ClassLoader (loadBannedArtifactConfigs(ClassLoader), loadBannedArtifactConfigs(URL), loadBannedArtifactConfig(String)). execute() now passes this.classLoader and uses a stream forEach for artifact processing. loadBannedArtifactConfig now throws IllegalArgumentException for invalid definitions. Tests added to cover execution and error cases (failed resource lookup and invalid definition). Also removed an unused test field as part of cleanup. --- .../BannedArtifactClassLoadingExecutor.java | 31 ++++++++----------- ...annedArtifactClassLoadingExecutorTest.java | 30 ++++++++++++++++-- 2 files changed, 40 insertions(+), 21 deletions(-) diff --git a/microsphere-java-core/src/main/java/io/microsphere/classloading/BannedArtifactClassLoadingExecutor.java b/microsphere-java-core/src/main/java/io/microsphere/classloading/BannedArtifactClassLoadingExecutor.java index 98749c614..9c2375975 100644 --- a/microsphere-java-core/src/main/java/io/microsphere/classloading/BannedArtifactClassLoadingExecutor.java +++ b/microsphere-java-core/src/main/java/io/microsphere/classloading/BannedArtifactClassLoadingExecutor.java @@ -81,21 +81,20 @@ public BannedArtifactClassLoadingExecutor(@Nullable ClassLoader classLoader) { } public void execute() { - List bannedArtifactConfigs = loadBannedArtifactConfigs(); + List bannedArtifactConfigs = loadBannedArtifactConfigs(this.classLoader); List artifacts = artifactDetector.detect(false); - for (Artifact artifact : artifacts) { - URL classPathURL = artifact.getLocation(); - if (classPathURL != null) { - for (MavenArtifact bannedArtifactConfig : bannedArtifactConfigs) { - if (bannedArtifactConfig.matches(artifact)) { - removeClassPathURL(classLoader, classPathURL); + artifacts.stream() + .forEach(artifact -> { + URL classPathURL = artifact.getLocation(); + for (MavenArtifact bannedArtifactConfig : bannedArtifactConfigs) { + if (bannedArtifactConfig.matches(artifact)) { + removeClassPathURL(classLoader, classPathURL); + } } - } - } - } + }); } - private List loadBannedArtifactConfigs() { + static List loadBannedArtifactConfigs(ClassLoader classLoader) { List bannedArtifactConfigs = new LinkedList<>(); try { Enumeration configResources = classLoader.getResources(CONFIG_LOCATION); @@ -110,7 +109,7 @@ private List loadBannedArtifactConfigs() { return bannedArtifactConfigs; } - private List loadBannedArtifactConfigs(URL configResource) throws IOException { + static List loadBannedArtifactConfigs(URL configResource) throws IOException { List bannedArtifactConfigs = new LinkedList<>(); try (InputStream inputStream = configResource.openStream(); BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, ENCODING)) @@ -127,14 +126,10 @@ private List loadBannedArtifactConfigs(URL configResource) throws return bannedArtifactConfigs; } - /** - * @param definition - * @return - */ - private MavenArtifact loadBannedArtifactConfig(String definition) { + static MavenArtifact loadBannedArtifactConfig(String definition) throws IllegalArgumentException { String[] gav = split(definition.trim(), COLON); if (gav.length != 3) { - throw new RuntimeException("The definition of the banned artifact must contain groupId, artifactId and version : " + definition); + throw new IllegalArgumentException("The definition of the banned artifact must contain groupId, artifactId and version : " + definition); } String groupId = gav[0]; String artifactId = gav[1]; diff --git a/microsphere-java-core/src/test/java/io/microsphere/classloading/BannedArtifactClassLoadingExecutorTest.java b/microsphere-java-core/src/test/java/io/microsphere/classloading/BannedArtifactClassLoadingExecutorTest.java index f5e15dff7..f94a96960 100644 --- a/microsphere-java-core/src/test/java/io/microsphere/classloading/BannedArtifactClassLoadingExecutorTest.java +++ b/microsphere-java-core/src/test/java/io/microsphere/classloading/BannedArtifactClassLoadingExecutorTest.java @@ -18,6 +18,15 @@ import org.junit.jupiter.api.Test; +import java.io.IOException; +import java.net.URL; +import java.util.Enumeration; + +import static io.microsphere.classloading.BannedArtifactClassLoadingExecutor.loadBannedArtifactConfig; +import static io.microsphere.classloading.BannedArtifactClassLoadingExecutor.loadBannedArtifactConfigs; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + /** * {@link BannedArtifactClassLoadingExecutor} Test * @@ -26,10 +35,25 @@ */ class BannedArtifactClassLoadingExecutorTest { - private BannedArtifactClassLoadingExecutor detector = new BannedArtifactClassLoadingExecutor(); - @Test void testDetect() { + BannedArtifactClassLoadingExecutor detector = new BannedArtifactClassLoadingExecutor(); detector.execute(); } -} + + @Test + void testLoadBannedArtifactConfigsOnFailed() { + ClassLoader classLoader = new ClassLoader() { + @Override + public Enumeration getResources(String name) throws IOException { + throw new IOException("For testing"); + } + }; + assertTrue(loadBannedArtifactConfigs(classLoader).isEmpty()); + } + + @Test + void testLoadBannedArtifactConfigOnFailed() { + assertThrows(IllegalArgumentException.class, () -> loadBannedArtifactConfig("invalid-definition")); + } +} \ No newline at end of file From 5465a7628bbd5f2f872642e60f6dcaf5308fdf01 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Fri, 6 Feb 2026 16:36:55 +0800 Subject: [PATCH 71/79] Disable Surefire system classloader in CI Add -Dsurefire.useSystemClassLoader=false to the Maven test invocation in the GitHub Actions workflow (.github/workflows/maven-build.yml) to avoid Surefire classloader-related issues during test execution and improve test reliability in CI. --- .github/workflows/maven-build.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/maven-build.yml b/.github/workflows/maven-build.yml index b2267b040..0bbaba8d5 100644 --- a/.github/workflows/maven-build.yml +++ b/.github/workflows/maven-build.yml @@ -36,6 +36,7 @@ jobs: --update-snapshots --file pom.xml -Drevision=0.0.1-SNAPSHOT + -Dsurefire.useSystemClassLoader=false test --activate-profiles test,coverage From 973f253f76009ec72303c38b6fc03617647401d4 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Fri, 6 Feb 2026 16:46:47 +0800 Subject: [PATCH 72/79] Use collection forEach instead of stream().forEach Replace artifacts.stream().forEach(...) with artifacts.forEach(...) to avoid unnecessary stream creation and simplify the iteration. This is a small stylistic cleanup with no functional change. --- .../BannedArtifactClassLoadingExecutor.java | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/microsphere-java-core/src/main/java/io/microsphere/classloading/BannedArtifactClassLoadingExecutor.java b/microsphere-java-core/src/main/java/io/microsphere/classloading/BannedArtifactClassLoadingExecutor.java index 9c2375975..4d5f8325a 100644 --- a/microsphere-java-core/src/main/java/io/microsphere/classloading/BannedArtifactClassLoadingExecutor.java +++ b/microsphere-java-core/src/main/java/io/microsphere/classloading/BannedArtifactClassLoadingExecutor.java @@ -83,15 +83,14 @@ public BannedArtifactClassLoadingExecutor(@Nullable ClassLoader classLoader) { public void execute() { List bannedArtifactConfigs = loadBannedArtifactConfigs(this.classLoader); List artifacts = artifactDetector.detect(false); - artifacts.stream() - .forEach(artifact -> { - URL classPathURL = artifact.getLocation(); - for (MavenArtifact bannedArtifactConfig : bannedArtifactConfigs) { - if (bannedArtifactConfig.matches(artifact)) { - removeClassPathURL(classLoader, classPathURL); - } - } - }); + artifacts.forEach(artifact -> { + URL classPathURL = artifact.getLocation(); + for (MavenArtifact bannedArtifactConfig : bannedArtifactConfigs) { + if (bannedArtifactConfig.matches(artifact)) { + removeClassPathURL(classLoader, classPathURL); + } + } + }); } static List loadBannedArtifactConfigs(ClassLoader classLoader) { From b573b7fef330b05db9a84e3faad70555662a7629 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Fri, 6 Feb 2026 20:16:36 +0800 Subject: [PATCH 73/79] Refactor ReflectionUtils and update tests Refactor reflection utilities to use common helpers and improve null/edge-case handling. Replaced direct Thread.currentThread() calls with a static import, unified field access via FieldUtils.getFieldValue, and switched static checks to MemberUtils.isStatic. Simplified toObject() and readFieldsAsMap() to handle nulls, recursive structures and return empty/unmodifiable maps; use newLinkedHashMap for initial sizing. Introduced overloads for isInaccessibleObjectException to accept Class and String types and added Javadoc. Updated unit tests to cover toObject, readFieldsAsMap recursion, and the new isInaccessibleObjectException behavior, plus minor import and assertion adjustments. --- .../microsphere/reflect/ReflectionUtils.java | 94 ++++++++++++------- .../reflect/ReflectionUtilsTest.java | 42 ++++++++- 2 files changed, 101 insertions(+), 35 deletions(-) diff --git a/microsphere-java-core/src/main/java/io/microsphere/reflect/ReflectionUtils.java b/microsphere-java-core/src/main/java/io/microsphere/reflect/ReflectionUtils.java index f92cd2481..c675db165 100644 --- a/microsphere-java-core/src/main/java/io/microsphere/reflect/ReflectionUtils.java +++ b/microsphere-java-core/src/main/java/io/microsphere/reflect/ReflectionUtils.java @@ -12,18 +12,21 @@ import java.lang.reflect.Field; import java.lang.reflect.Method; import java.util.ArrayList; -import java.util.LinkedHashMap; import java.util.List; import java.util.Map; -import java.util.Objects; +import static io.microsphere.collection.MapUtils.newLinkedHashMap; import static io.microsphere.logging.LoggerFactory.getLogger; -import static io.microsphere.reflect.AccessibleObjectUtils.trySetAccessible; +import static io.microsphere.reflect.FieldUtils.getFieldValue; +import static io.microsphere.reflect.MemberUtils.isStatic; +import static io.microsphere.reflect.TypeUtils.getTypeName; import static io.microsphere.util.ClassLoaderUtils.resolveClass; +import static io.microsphere.util.ClassUtils.getType; import static io.microsphere.util.ClassUtils.isPrimitive; import static io.microsphere.util.ClassUtils.isSimpleType; import static java.lang.Class.forName; -import static java.lang.reflect.Modifier.isStatic; +import static java.lang.Thread.currentThread; +import static java.util.Collections.emptyMap; import static java.util.Collections.unmodifiableMap; /** @@ -128,7 +131,7 @@ public abstract class ReflectionUtils implements Utils { static { int invocationFrame = 0; // Use java.lang.StackTraceElement to calculate frame - StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace(); + StackTraceElement[] stackTraceElements = currentThread().getStackTrace(); for (StackTraceElement stackTraceElement : stackTraceElements) { String className = stackTraceElement.getClassName(); if (TYPE.getName().equals(className)) { @@ -217,7 +220,7 @@ static String getCallerClassNameInGeneralJVM() { * @return specified invocation frame class */ static String getCallerClassNameInGeneralJVM(int invocationFrame) throws IndexOutOfBoundsException { - StackTraceElement[] elements = Thread.currentThread().getStackTrace(); + StackTraceElement[] elements = currentThread().getStackTrace(); if (invocationFrame < elements.length) { StackTraceElement targetStackTraceElement = elements[invocationFrame]; return targetStackTraceElement.getClassName(); @@ -387,16 +390,14 @@ public static List toList(Object array) throws IllegalArgumentException { return list; } - private static Object toObject(Object object) { - if (object == null) { - return object; - } - Class type = object.getClass(); - if (type.isArray()) { - return toList(object); - } else { - return object; + static Object toObject(Object object) { + if (object != null) { + Class type = object.getClass(); + if (type.isArray()) { + return toList(object); + } } + return object; } @@ -445,31 +446,27 @@ private static Object toObject(Object object) { @Nonnull @Immutable public static Map readFieldsAsMap(Object object) { - Map fieldsAsMap = new LinkedHashMap(); + if (object == null) { + return emptyMap(); + } Class type = object.getClass(); Field[] fields = type.getDeclaredFields(); + Map fieldsAsMap = newLinkedHashMap(fields.length); for (Field field : fields) { - if (isStatic(field.getModifiers())) { // To filter static fields + if (isStatic(field)) { // To filter static fields continue; } - trySetAccessible(field); - - try { - String fieldName = field.getName(); - Object fieldValue = field.get(object); - if (fieldValue != null && fieldValue != object) { - Class fieldValueType = fieldValue.getClass(); - if (!isPrimitive(fieldValueType) - && !isSimpleType(fieldValueType) - && !Objects.equals(object.getClass(), fieldValueType)) { - fieldValue = readFieldsAsMap(fieldValue); - } - fieldsAsMap.put(fieldName, fieldValue); + String fieldName = field.getName(); + Object fieldValue = getFieldValue(object, field); + Class fieldValueType = field.getType(); + if (fieldValue != object) { + if (!isPrimitive(fieldValueType) && !isSimpleType(fieldValueType) + && !object.getClass().equals(fieldValueType)) { + fieldValue = readFieldsAsMap(fieldValue); } - } catch (IllegalAccessException e) { - throw new IllegalStateException(e); + fieldsAsMap.put(fieldName, fieldValue); } } return unmodifiableMap(fieldsAsMap); @@ -502,10 +499,39 @@ public static Map readFieldsAsMap(Object object) { * {@link java.lang.reflect.InaccessibleObjectException}, false otherwise. */ public static boolean isInaccessibleObjectException(Throwable failure) { - return failure != null && INACCESSIBLE_OBJECT_EXCEPTION_CLASS_NAME.equals(failure.getClass().getName()); + return isInaccessibleObjectException(getType(failure)); } - private ReflectionUtils() { + /** + * Checks whether the specified {@link Class} represents + * {@link java.lang.reflect.InaccessibleObjectException}. + * + *

    This method is useful when dealing with reflection operations that may fail due to module system + * restrictions introduced in JDK 9+. It avoids direct dependency on the presence of the class, which + * may not be available in earlier JDK versions.

    + * + *

    Example Usage

    + * 
    {@code
+     * Class exceptionClass = SomeException.class;
+     * if (ReflectionUtils.isInaccessibleObjectException(exceptionClass)) {
+     *     System.err.println("The class represents InaccessibleObjectException");
+     * } else {
+     *     System.out.println("The class does not represent InaccessibleObjectException");
+     * }
+     * }
    + * + * @param throwableClass The {@link Class} to check. + * @return true if the specified {@link Class} represents + * {@link java.lang.reflect.InaccessibleObjectException}, false otherwise. + */ + public static boolean isInaccessibleObjectException(Class throwableClass) { + return isInaccessibleObjectException(getTypeName(throwableClass)); } + static boolean isInaccessibleObjectException(String className) { + return INACCESSIBLE_OBJECT_EXCEPTION_CLASS_NAME.equals(className); + } + + private ReflectionUtils() { + } } \ No newline at end of file diff --git a/microsphere-java-core/src/test/java/io/microsphere/reflect/ReflectionUtilsTest.java b/microsphere-java-core/src/test/java/io/microsphere/reflect/ReflectionUtilsTest.java index 9087a231b..6d8c42b7b 100644 --- a/microsphere-java-core/src/test/java/io/microsphere/reflect/ReflectionUtilsTest.java +++ b/microsphere-java-core/src/test/java/io/microsphere/reflect/ReflectionUtilsTest.java @@ -1,24 +1,33 @@ package io.microsphere.reflect; import io.microsphere.AbstractTestCase; +import io.microsphere.test.Data; import org.junit.jupiter.api.Test; import java.util.HashMap; import java.util.List; import java.util.Map; +import static io.microsphere.collection.Lists.ofList; +import static io.microsphere.reflect.ReflectionUtils.INACCESSIBLE_OBJECT_EXCEPTION_CLASS; +import static io.microsphere.reflect.ReflectionUtils.INACCESSIBLE_OBJECT_EXCEPTION_CLASS_NAME; import static io.microsphere.reflect.ReflectionUtils.getCallerClass; import static io.microsphere.reflect.ReflectionUtils.getCallerClassInGeneralJVM; import static io.microsphere.reflect.ReflectionUtils.getCallerClassInSunJVM; import static io.microsphere.reflect.ReflectionUtils.getCallerClassName; import static io.microsphere.reflect.ReflectionUtils.getCallerClassNameInGeneralJVM; import static io.microsphere.reflect.ReflectionUtils.getCallerClassNameInSunJVM; +import static io.microsphere.reflect.ReflectionUtils.isInaccessibleObjectException; import static io.microsphere.reflect.ReflectionUtils.isSupportedSunReflectReflection; import static io.microsphere.reflect.ReflectionUtils.readFieldsAsMap; import static io.microsphere.reflect.ReflectionUtils.toList; +import static io.microsphere.reflect.ReflectionUtils.toObject; +import static io.microsphere.util.ArrayUtils.ofArray; import static java.util.Arrays.asList; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; /** * {@link ReflectionUtils} Test @@ -30,7 +39,7 @@ class ReflectionUtilsTest extends AbstractTestCase { @Test - void testGetCallerClassX() throws Exception { + void testGetCallerClassX() { Class expectedClass = ReflectionUtilsTest.class; Class callerClass = getCallerClass(); @@ -90,5 +99,36 @@ void testReadFieldsAsMap() { value.put("c", "c"); map = readFieldsAsMap(value); assertFalse(map.isEmpty()); + + T t = new T(); + t.self = t; + t.other = new T(); + + map = readFieldsAsMap(t); + assertFalse(map.isEmpty()); + } + + @Test + void testToObject() { + assertNull(toObject(null)); + assertEquals("test", toObject("test")); + assertEquals(ofList("a", "b", "c"), toObject(ofArray("a", "b", "c"))); + } + + @Test + void testIsInaccessibleObjectException() { + assertFalse(isInaccessibleObjectException(new RuntimeException())); + assertFalse(isInaccessibleObjectException((Throwable) null)); + assertFalse(isInaccessibleObjectException((Class) null)); + assertFalse(isInaccessibleObjectException(Class.class)); + assertEquals(INACCESSIBLE_OBJECT_EXCEPTION_CLASS != null, isInaccessibleObjectException(INACCESSIBLE_OBJECT_EXCEPTION_CLASS)); + assertTrue(isInaccessibleObjectException(INACCESSIBLE_OBJECT_EXCEPTION_CLASS_NAME)); + } + + static class T extends Data { + + private T self; + + private T other; } } From f612511d7ebd66a7d5cd2c66e3a71d982001e60b Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Fri, 6 Feb 2026 20:49:47 +0800 Subject: [PATCH 74/79] Invoke shutdown hook and adjust ExecutorUtilsTest Modify ExecutorUtilsTest to explicitly qualify executorService with this and to simulate JVM shutdown by fetching ShutdownHookUtils.shutdownHookCallbacks (via getStaticFieldValue), polling the registered callback and running it, then asserting the executor is shutdown. Added necessary imports (ShutdownHookUtils, PriorityBlockingQueue, FieldUtils). Minor EOF newline change in ExecutorUtils.java. --- .../microsphere/concurrent/ExecutorUtils.java | 2 +- .../concurrent/ExecutorUtilsTest.java | 21 ++++++++++++------- 2 files changed, 15 insertions(+), 8 deletions(-) diff --git a/microsphere-java-core/src/main/java/io/microsphere/concurrent/ExecutorUtils.java b/microsphere-java-core/src/main/java/io/microsphere/concurrent/ExecutorUtils.java index a4cfc45e8..c3b97c056 100644 --- a/microsphere-java-core/src/main/java/io/microsphere/concurrent/ExecutorUtils.java +++ b/microsphere-java-core/src/main/java/io/microsphere/concurrent/ExecutorUtils.java @@ -136,4 +136,4 @@ public static boolean shutdown(ExecutorService executorService) { private ExecutorUtils() { } -} +} \ No newline at end of file diff --git a/microsphere-java-core/src/test/java/io/microsphere/concurrent/ExecutorUtilsTest.java b/microsphere-java-core/src/test/java/io/microsphere/concurrent/ExecutorUtilsTest.java index ec6866136..255295db8 100644 --- a/microsphere-java-core/src/test/java/io/microsphere/concurrent/ExecutorUtilsTest.java +++ b/microsphere-java-core/src/test/java/io/microsphere/concurrent/ExecutorUtilsTest.java @@ -1,15 +1,18 @@ package io.microsphere.concurrent; import io.microsphere.AbstractTestCase; +import io.microsphere.util.ShutdownHookUtils; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.util.concurrent.Executor; import java.util.concurrent.ExecutorService; +import java.util.concurrent.PriorityBlockingQueue; import static io.microsphere.concurrent.CustomizedThreadFactory.newThreadFactory; import static io.microsphere.concurrent.ExecutorUtils.shutdown; import static io.microsphere.concurrent.ExecutorUtils.shutdownOnExit; +import static io.microsphere.reflect.FieldUtils.getStaticFieldValue; import static java.util.concurrent.Executors.newSingleThreadExecutor; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -27,19 +30,23 @@ class ExecutorUtilsTest extends AbstractTestCase { @BeforeEach void setUp() { - executorService = newSingleThreadExecutor(newThreadFactory("ExecutorUtilsTest-", true)); - executorService.execute(() -> log("Running...")); + this.executorService = newSingleThreadExecutor(newThreadFactory("ExecutorUtilsTest-", true)); + this.executorService.execute(() -> log("Running...")); } @Test void testShutdownOnExit() { - shutdownOnExit(executorService, executorService, executorService); + shutdownOnExit(this.executorService, this.executorService, this.executorService); + PriorityBlockingQueue shutdownHookCallbacks = getStaticFieldValue(ShutdownHookUtils.class, "shutdownHookCallbacks"); + Runnable callback = shutdownHookCallbacks.poll(); + callback.run(); + assertTrue(this.executorService.isShutdown()); } @Test void testShutdownForExecutor() { - assertTrue(shutdown((Executor) executorService)); - assertTrue(shutdown((Executor) executorService)); + assertTrue(shutdown((Executor) this.executorService)); + assertTrue(shutdown((Executor) this.executorService)); } @Test @@ -49,8 +56,8 @@ void testShutdownForExecutorOnNull() { @Test void testShutdownForExecutorService() { - assertTrue(shutdown(executorService)); - assertTrue(shutdown(executorService)); + assertTrue(shutdown(this.executorService)); + assertTrue(shutdown(this.executorService)); } @Test From 1de621c74f8ca49d92754bb29ac8da03913e62fa Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Fri, 6 Feb 2026 21:27:25 +0800 Subject: [PATCH 75/79] Log ExecutorService shutdown and harden tests Add tracing log when an ExecutorService is shut down by introducing a Logger into ExecutorUtils. This helps debugging executor lifecycle events. Update ExecutorUtilsTest to be more robust: add @AfterEach tearDown to shut down the executor, make testShutdownOnExit handle InterruptedException, iterate over ShutdownHookUtils' callbacks to find and run the lambda-based shutdown callbacks (instead of assuming queue order), remove executed callbacks, and wait briefly for termination before asserting shutdown. Also add necessary imports and assertions. --- .../microsphere/concurrent/ExecutorUtils.java | 5 ++++ .../concurrent/ExecutorUtilsTest.java | 30 ++++++++++++++++--- 2 files changed, 31 insertions(+), 4 deletions(-) diff --git a/microsphere-java-core/src/main/java/io/microsphere/concurrent/ExecutorUtils.java b/microsphere-java-core/src/main/java/io/microsphere/concurrent/ExecutorUtils.java index c3b97c056..930ce67d8 100644 --- a/microsphere-java-core/src/main/java/io/microsphere/concurrent/ExecutorUtils.java +++ b/microsphere-java-core/src/main/java/io/microsphere/concurrent/ExecutorUtils.java @@ -16,6 +16,7 @@ */ package io.microsphere.concurrent; +import io.microsphere.logging.Logger; import io.microsphere.util.ShutdownHookUtils; import io.microsphere.util.Utils; @@ -23,6 +24,7 @@ import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; +import static io.microsphere.logging.LoggerFactory.getLogger; import static io.microsphere.util.ArrayUtils.forEach; import static io.microsphere.util.ShutdownHookUtils.addShutdownHookCallback; @@ -37,6 +39,8 @@ */ public abstract class ExecutorUtils implements Utils { + private static final Logger logger = getLogger(ExecutorUtils.class); + /** * Registers a shutdown hook to gracefully shut down the given {@link Executor} instances when the JVM exits. * @@ -131,6 +135,7 @@ public static boolean shutdown(ExecutorService executorService) { if (!executorService.isShutdown()) { executorService.shutdown(); } + logger.trace("The ExecutorService({}) has been shutdown", executorService); return true; } diff --git a/microsphere-java-core/src/test/java/io/microsphere/concurrent/ExecutorUtilsTest.java b/microsphere-java-core/src/test/java/io/microsphere/concurrent/ExecutorUtilsTest.java index 255295db8..26d821203 100644 --- a/microsphere-java-core/src/test/java/io/microsphere/concurrent/ExecutorUtilsTest.java +++ b/microsphere-java-core/src/test/java/io/microsphere/concurrent/ExecutorUtilsTest.java @@ -2,9 +2,11 @@ import io.microsphere.AbstractTestCase; import io.microsphere.util.ShutdownHookUtils; +import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import java.util.Iterator; import java.util.concurrent.Executor; import java.util.concurrent.ExecutorService; import java.util.concurrent.PriorityBlockingQueue; @@ -14,7 +16,9 @@ import static io.microsphere.concurrent.ExecutorUtils.shutdownOnExit; import static io.microsphere.reflect.FieldUtils.getStaticFieldValue; import static java.util.concurrent.Executors.newSingleThreadExecutor; +import static java.util.concurrent.TimeUnit.MILLISECONDS; import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertTrue; /** @@ -34,13 +38,31 @@ void setUp() { this.executorService.execute(() -> log("Running...")); } + @AfterEach + void tearDown() { + this.executorService.shutdown(); + } + @Test - void testShutdownOnExit() { + void testShutdownOnExit() throws InterruptedException { shutdownOnExit(this.executorService, this.executorService, this.executorService); PriorityBlockingQueue shutdownHookCallbacks = getStaticFieldValue(ShutdownHookUtils.class, "shutdownHookCallbacks"); - Runnable callback = shutdownHookCallbacks.poll(); - callback.run(); - assertTrue(this.executorService.isShutdown()); + assertNotNull(shutdownHookCallbacks); + + Iterator iterator = shutdownHookCallbacks.iterator(); + String classNamePrefix = ExecutorUtils.class.getName() + "$$Lambda/"; + while (iterator.hasNext()) { + Runnable callback = iterator.next(); + Class callbackClass = callback.getClass(); + String callbackClassName = callbackClass.getName(); + if (callbackClassName.startsWith(classNamePrefix)) { + callback.run(); + iterator.remove(); + } + } + if (this.executorService.awaitTermination(50, MILLISECONDS)) { + assertTrue(this.executorService.isShutdown()); + } } @Test From 3da036e1442302c6c5d51f1cc68c55208d09a5a6 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Fri, 6 Feb 2026 21:34:21 +0800 Subject: [PATCH 76/79] Call super in priority and add equals test In AbstractConverterTest, the anonymous converter now calls super.resolvePriority() and overrides getPriority() to return super.getPriority(). Also adds testEquals() to assert the converter equals itself. These changes improve test coverage for priority delegation and equality behavior. --- .../io/microsphere/convert/AbstractConverterTest.java | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/microsphere-java-core/src/test/java/io/microsphere/convert/AbstractConverterTest.java b/microsphere-java-core/src/test/java/io/microsphere/convert/AbstractConverterTest.java index b8a2273d3..5148e64ad 100644 --- a/microsphere-java-core/src/test/java/io/microsphere/convert/AbstractConverterTest.java +++ b/microsphere-java-core/src/test/java/io/microsphere/convert/AbstractConverterTest.java @@ -44,8 +44,14 @@ protected Object doConvert(Object source) throws Throwable { @Override protected Integer resolvePriority() { + super.resolvePriority(); return null; } + + @Override + public int getPriority() { + return super.getPriority(); + } }; } @@ -76,4 +82,8 @@ void testGetConverter() { assertNotEquals(this.converter, new Object()); } + @Test + void testEquals() { + assertEquals(this.converter, this.converter); + } } From ab9143f32310fc176b84e6f4b4ed06936b39c4d7 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Fri, 6 Feb 2026 21:37:55 +0800 Subject: [PATCH 77/79] Use Objects.nonNull and simplify trace logging Replace explicit null comparison with java.util.Objects.nonNull for readability in supports(). Remove the manual isTraceEnabled() guard and call logger.trace directly in current(), relying on the logger implementation to check the level. No functional behavior changes; just small cleanup and simplification. --- .../io/microsphere/process/ModernProcessIdResolver.java | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/microsphere-java-core/src/main/java/io/microsphere/process/ModernProcessIdResolver.java b/microsphere-java-core/src/main/java/io/microsphere/process/ModernProcessIdResolver.java index 6a138378d..c1c606418 100644 --- a/microsphere-java-core/src/main/java/io/microsphere/process/ModernProcessIdResolver.java +++ b/microsphere-java-core/src/main/java/io/microsphere/process/ModernProcessIdResolver.java @@ -22,6 +22,7 @@ import static io.microsphere.reflect.MethodUtils.invokeMethod; import static io.microsphere.reflect.MethodUtils.invokeStaticMethod; import static io.microsphere.util.ClassLoaderUtils.resolveClass; +import static java.util.Objects.nonNull; /** * A {@link ProcessIdResolver} implementation for modern JDKs (Java 9+). @@ -56,16 +57,14 @@ public class ModernProcessIdResolver implements ProcessIdResolver { @Override public boolean supports() { - return PROCESS_HANDLE_CLASS != null; + return nonNull(PROCESS_HANDLE_CLASS); } @Override public Long current() { Object processHandle = invokeStaticMethod(PROCESS_HANDLE_CLASS, "current"); Long pid = invokeMethod(processHandle, PROCESS_HANDLE_CLASS, "pid"); - if (logger.isTraceEnabled()) { - logger.trace("The PID was resolved from the method 'java.lang.ProcessHandle#pid()' : {}", pid); - } + logger.trace("The PID was resolved from the method 'java.lang.ProcessHandle#pid()' : {}", pid); return pid; } From a58eae282ecb96a0566ded26de1df2077590516c Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Fri, 6 Feb 2026 21:42:16 +0800 Subject: [PATCH 78/79] Use Objects.nonNull and simplify trace logging Replace explicit null check with java.util.Objects.nonNull for JVM_FIELD and remove the manual logger.isTraceEnabled() guard, calling logger.trace(...) directly. This simplifies the code and improves readability without changing behavior. --- .../process/VirtualMachineProcessIdResolver.java | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/microsphere-java-core/src/main/java/io/microsphere/process/VirtualMachineProcessIdResolver.java b/microsphere-java-core/src/main/java/io/microsphere/process/VirtualMachineProcessIdResolver.java index ddfa97746..a2e48bbba 100644 --- a/microsphere-java-core/src/main/java/io/microsphere/process/VirtualMachineProcessIdResolver.java +++ b/microsphere-java-core/src/main/java/io/microsphere/process/VirtualMachineProcessIdResolver.java @@ -27,6 +27,7 @@ import static io.microsphere.reflect.FieldUtils.getFieldValue; import static io.microsphere.reflect.MethodUtils.invokeMethod; import static java.lang.Long.valueOf; +import static java.util.Objects.nonNull; /** * A {@link ProcessIdResolver} implementation for retrieving the process ID using the SUN JVM internal APIs. @@ -81,7 +82,7 @@ public class VirtualMachineProcessIdResolver implements ProcessIdResolver { @Override public boolean supports() { - return JVM_FIELD != null; + return nonNull(JVM_FIELD); } @Override @@ -89,9 +90,7 @@ public Long current() { RuntimeMXBean runtimeMXBean = getRuntimeMXBean(); Object jvm = getFieldValue(runtimeMXBean, JVM_FIELD); Integer processId = invokeMethod(jvm, GET_PROCESS_ID_METHOD_NAME); - if (logger.isTraceEnabled()) { - logger.trace("The PID was resolved from the native method 'sun.management.VMManagementImpl#getProcessId()' : {}", processId); - } + logger.trace("The PID was resolved from the native method 'sun.management.VMManagementImpl#getProcessId()' : {}", processId); return valueOf(processId.longValue()); } From 2aac5117592c564b66f1e0e92954a4b2141e1c54 Mon Sep 17 00:00:00 2001 From: Mercy Ma Date: Fri, 6 Feb 2026 21:43:02 +0800 Subject: [PATCH 79/79] Remove isTraceEnabled guard in PID resolver Simplify ClassicProcessIdResolver#current() by removing the explicit logger.isTraceEnabled() check and calling logger.trace(...) directly to log the resolved runtimeName and processId. Also remove the trailing newline at EOF in the file. --- .../io/microsphere/process/ClassicProcessIdResolver.java | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/microsphere-java-core/src/main/java/io/microsphere/process/ClassicProcessIdResolver.java b/microsphere-java-core/src/main/java/io/microsphere/process/ClassicProcessIdResolver.java index 7a1ce136c..10ff9f6ac 100644 --- a/microsphere-java-core/src/main/java/io/microsphere/process/ClassicProcessIdResolver.java +++ b/microsphere-java-core/src/main/java/io/microsphere/process/ClassicProcessIdResolver.java @@ -82,9 +82,7 @@ public boolean supports() { @Override public Long current() { Long processId = valueOf(processIdValue); - if (logger.isTraceEnabled()) { - logger.trace("The PID was resolved from the method 'java.lang.management.RuntimeMXBean#getName()' = {} : {}", runtimeName, processId); - } + logger.trace("The PID was resolved from the method 'java.lang.management.RuntimeMXBean#getName()' = {} : {}", runtimeName, processId); return processId; } @@ -92,4 +90,4 @@ public Long current() { public int getPriority() { return NORMAL_PRIORITY + 9; } -} +} \ No newline at end of file