diff --git a/spring-core/src/main/kotlin/org/springframework/aot/hint/JdkProxyHintExtensions.kt b/spring-core/src/main/kotlin/org/springframework/aot/hint/JdkProxyHintExtensions.kt new file mode 100644 index 00000000000..670349d1b5e --- /dev/null +++ b/spring-core/src/main/kotlin/org/springframework/aot/hint/JdkProxyHintExtensions.kt @@ -0,0 +1,28 @@ +/* + * Copyright 2002-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. + */ + +package org.springframework.aot.hint + +import kotlin.reflect.KClass + +/** + * Extension for [JdkProxyHint.Builder.proxiedInterfaces] providing a [KClass] based variant. + * + * @author Sebastien Deleuze + * @since 6.0.5 + */ +fun JdkProxyHint.Builder.proxiedInterfaces(vararg proxiedInterfaces: KClass<*>) = + proxiedInterfaces(*proxiedInterfaces.map { it::class.java }.toTypedArray()) diff --git a/spring-core/src/main/kotlin/org/springframework/aot/hint/ProxyHintsExtensions.kt b/spring-core/src/main/kotlin/org/springframework/aot/hint/ProxyHintsExtensions.kt new file mode 100644 index 00000000000..e74e54f185f --- /dev/null +++ b/spring-core/src/main/kotlin/org/springframework/aot/hint/ProxyHintsExtensions.kt @@ -0,0 +1,28 @@ +/* + * Copyright 2002-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. + */ + +package org.springframework.aot.hint + +import kotlin.reflect.KClass + +/** + * Extension for [ProxyHints.registerJdkProxy] providing a [KClass] based variant. + * + * @author Sebastien Deleuze + * @since 6.0.5 + */ +fun ProxyHints.registerJdkProxy(vararg proxiedInterfaces: KClass<*>) = + registerJdkProxy(*proxiedInterfaces.map { it::class.java }.toTypedArray()) diff --git a/spring-core/src/main/kotlin/org/springframework/aot/hint/ReflectionHintsExtensions.kt b/spring-core/src/main/kotlin/org/springframework/aot/hint/ReflectionHintsExtensions.kt new file mode 100644 index 00000000000..1d91e17ddf4 --- /dev/null +++ b/spring-core/src/main/kotlin/org/springframework/aot/hint/ReflectionHintsExtensions.kt @@ -0,0 +1,47 @@ +/* + * Copyright 2002-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. + */ + +package org.springframework.aot.hint + +/** + * Extension for [ReflectionHints.getTypeHint] providing a `getTypeHint(...)` + * variant. + * + * @author Sebastien Deleuze + * @since 6.0.5 + */ +inline fun ReflectionHints.getTypeHint() = + getTypeHint(T::class.java) + +/** + * Extension for [ReflectionHints.registerType] providing a `registerType { ... }` + * variant. + * + * @author Sebastien Deleuze + * @since 6.0.5 + */ +inline fun ReflectionHints.registerType(noinline typeHint: (TypeHint.Builder) -> Unit) = + registerType(T::class.java, typeHint::invoke) + +/** + * Extension for [ReflectionHints.registerType] providing a `registerType(...)` + * variant. + * + * @author Sebastien Deleuze + * @since 6.0.5 + */ +inline fun ReflectionHints.registerType(vararg memberCategories: MemberCategory) = + registerType(T::class.java, *memberCategories) diff --git a/spring-core/src/main/kotlin/org/springframework/aot/hint/ResourceHintsExtensions.kt b/spring-core/src/main/kotlin/org/springframework/aot/hint/ResourceHintsExtensions.kt new file mode 100644 index 00000000000..536fe02c133 --- /dev/null +++ b/spring-core/src/main/kotlin/org/springframework/aot/hint/ResourceHintsExtensions.kt @@ -0,0 +1,27 @@ +/* + * Copyright 2002-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. + */ + +package org.springframework.aot.hint + +/** + * Extension for [ResourceHints.registerType] providing a `registerType()` + * variant. + * + * @author Sebastien Deleuze + * @since 6.0.5 + */ +inline fun ResourceHints.registerType() = + registerType(T::class.java) diff --git a/spring-core/src/main/kotlin/org/springframework/aot/hint/SerializationHintsExtensions.kt b/spring-core/src/main/kotlin/org/springframework/aot/hint/SerializationHintsExtensions.kt new file mode 100644 index 00000000000..628fd80a7c5 --- /dev/null +++ b/spring-core/src/main/kotlin/org/springframework/aot/hint/SerializationHintsExtensions.kt @@ -0,0 +1,29 @@ +/* + * Copyright 2002-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. + */ + +package org.springframework.aot.hint + +import java.io.Serializable + +/** + * Extension for [SerializationHints.registerType] providing a `registerType()` + * variant. + * + * @author Sebastien Deleuze + * @since 6.0.5 + */ +inline fun SerializationHints.registerType(noinline serializationHint: (JavaSerializationHint.Builder) -> Unit = {}) = + registerType(T::class.java, serializationHint::invoke) diff --git a/spring-core/src/main/kotlin/org/springframework/aot/hint/TypeHintExtensions.kt b/spring-core/src/main/kotlin/org/springframework/aot/hint/TypeHintExtensions.kt new file mode 100644 index 00000000000..e666ae8b724 --- /dev/null +++ b/spring-core/src/main/kotlin/org/springframework/aot/hint/TypeHintExtensions.kt @@ -0,0 +1,27 @@ +/* + * Copyright 2002-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. + */ + +package org.springframework.aot.hint + +/** + * Extension for [TypeHint.Builder.onReachableType] providing a `onReachableType())` + * variant. + * + * @author Sebastien Deleuze + * @since 6.0.5 + */ +inline fun TypeHint.Builder.onReachableType() = + onReachableType(T::class.java) diff --git a/spring-core/src/test/kotlin/org/springframework/aot/hint/JdkProxyHintExtensionsTests.kt b/spring-core/src/test/kotlin/org/springframework/aot/hint/JdkProxyHintExtensionsTests.kt new file mode 100644 index 00000000000..3fc49733be4 --- /dev/null +++ b/spring-core/src/test/kotlin/org/springframework/aot/hint/JdkProxyHintExtensionsTests.kt @@ -0,0 +1,40 @@ +/* + * Copyright 2002-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. + */ + +package org.springframework.aot.hint + +import io.mockk.every +import io.mockk.mockk +import io.mockk.verify +import org.junit.jupiter.api.Test + +/** + * Tests for [JdkProxyHint] Kotlin extensions. + * + * @author Sebastien Deleuze + */ +class JdkProxyHintExtensionsTests { + + private val builder = mockk() + + @Test + fun `proxiedInterfaces builder extension`() { + every { builder.proxiedInterfaces(*anyVararg>()) } returns builder + builder.proxiedInterfaces(String::class, Int::class) + verify { builder.proxiedInterfaces(*anyVararg>()) } + } + +} diff --git a/spring-core/src/test/kotlin/org/springframework/aot/hint/ProxyHintsExtensionsTests.kt b/spring-core/src/test/kotlin/org/springframework/aot/hint/ProxyHintsExtensionsTests.kt new file mode 100644 index 00000000000..e1c7768bfd6 --- /dev/null +++ b/spring-core/src/test/kotlin/org/springframework/aot/hint/ProxyHintsExtensionsTests.kt @@ -0,0 +1,40 @@ +/* + * Copyright 2002-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. + */ + +package org.springframework.aot.hint + +import io.mockk.every +import io.mockk.mockk +import io.mockk.verify +import org.junit.jupiter.api.Test + +/** + * Tests for [ProxyHints] Kotlin extensions. + * + * @author Sebastien Deleuze + */ +class ProxyHintsExtensionsTests { + + private val proxyHints = mockk() + + @Test + fun `registerJdkProxy extension`() { + every { proxyHints.registerJdkProxy(*anyVararg>()) } returns proxyHints + proxyHints.registerJdkProxy(String::class, Int::class) + verify { proxyHints.registerJdkProxy(*anyVararg>()) } + } + +} diff --git a/spring-core/src/test/kotlin/org/springframework/aot/hint/ReflectionHintsExtensionsTests.kt b/spring-core/src/test/kotlin/org/springframework/aot/hint/ReflectionHintsExtensionsTests.kt new file mode 100644 index 00000000000..8e1dd370e8c --- /dev/null +++ b/spring-core/src/test/kotlin/org/springframework/aot/hint/ReflectionHintsExtensionsTests.kt @@ -0,0 +1,58 @@ +/* + * Copyright 2002-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. + */ + +package org.springframework.aot.hint + +import io.mockk.every +import io.mockk.mockk +import io.mockk.verify +import org.junit.jupiter.api.Test +import java.util.function.Consumer + +/** + * Tests for [ReflectionHints] Kotlin extensions. + * + * @author Sebastien Deleuze + */ +class ReflectionHintsExtensionsTests { + + private val reflectionHints = mockk() + + @Test + fun `getTypeHint extension`() { + val typeHint = mockk() + every { reflectionHints.getTypeHint(any>()) } returns typeHint + reflectionHints.getTypeHint() + verify { reflectionHints.getTypeHint(String::class.java) } + } + + @Test + fun `registerType extension with Consumer`() { + every { reflectionHints.registerType(any>(), any>()) } returns reflectionHints + reflectionHints.registerType { } + verify { reflectionHints.registerType(String::class.java, any>()) } + } + + @Test + fun `registerType extension with MemberCategory`() { + val memberCategory1 = mockk() + val memberCategory2 = mockk() + every { reflectionHints.registerType(any>(), any(), any()) } returns reflectionHints + reflectionHints.registerType(memberCategory1, memberCategory2) + verify { reflectionHints.registerType(String::class.java, memberCategory1, memberCategory2) } + } + +} diff --git a/spring-core/src/test/kotlin/org/springframework/aot/hint/ResourceHintsExtensionsTests.kt b/spring-core/src/test/kotlin/org/springframework/aot/hint/ResourceHintsExtensionsTests.kt new file mode 100644 index 00000000000..b530760f73d --- /dev/null +++ b/spring-core/src/test/kotlin/org/springframework/aot/hint/ResourceHintsExtensionsTests.kt @@ -0,0 +1,41 @@ +/* + * Copyright 2002-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. + */ + +package org.springframework.aot.hint + +import io.mockk.every +import io.mockk.mockk +import io.mockk.verify +import org.junit.jupiter.api.Test +import java.util.function.Consumer + +/** + * Tests for [ResourceHints] Kotlin extensions. + * + * @author Sebastien Deleuze + */ +class ResourceHintsExtensionsTests { + + private val resourceHints = mockk() + + @Test + fun `registerType extension with MemberCategory`() { + every { resourceHints.registerType(any>()) } returns resourceHints + resourceHints.registerType() + verify { resourceHints.registerType(String::class.java) } + } + +} diff --git a/spring-core/src/test/kotlin/org/springframework/aot/hint/SerializationHintsExtensionsTests.kt b/spring-core/src/test/kotlin/org/springframework/aot/hint/SerializationHintsExtensionsTests.kt new file mode 100644 index 00000000000..d781ad923b4 --- /dev/null +++ b/spring-core/src/test/kotlin/org/springframework/aot/hint/SerializationHintsExtensionsTests.kt @@ -0,0 +1,48 @@ +/* + * Copyright 2002-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. + */ + +package org.springframework.aot.hint + +import io.mockk.every +import io.mockk.mockk +import io.mockk.verify +import org.junit.jupiter.api.Test +import java.util.function.Consumer + +/** + * Tests for [SerializationHints] Kotlin extensions. + * + * @author Sebastien Deleuze + */ +class SerializationHintsExtensionsTests { + + private val serializationHints = mockk() + + @Test + fun `registerType extension with Consumer`() { + every { serializationHints.registerType(any>(), any>()) } returns serializationHints + serializationHints.registerType { } + verify { serializationHints.registerType(String::class.java, any>()) } + } + + @Test + fun `registerType extension`() { + every { serializationHints.registerType(any>(), any>()) } returns serializationHints + serializationHints.registerType() + verify { serializationHints.registerType(String::class.java, any>()) } + } + +} diff --git a/spring-core/src/test/kotlin/org/springframework/aot/hint/TypeHintExtensionsTests.kt b/spring-core/src/test/kotlin/org/springframework/aot/hint/TypeHintExtensionsTests.kt new file mode 100644 index 00000000000..e637c50487f --- /dev/null +++ b/spring-core/src/test/kotlin/org/springframework/aot/hint/TypeHintExtensionsTests.kt @@ -0,0 +1,40 @@ +/* + * Copyright 2002-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. + */ + +package org.springframework.aot.hint + +import io.mockk.every +import io.mockk.mockk +import io.mockk.verify +import org.junit.jupiter.api.Test + +/** + * Tests for [TypeHint] Kotlin extensions. + * + * @author Sebastien Deleuze + */ +class TypeHintExtensionsTests { + + private val builder = mockk() + + @Test + fun `onReachableType builder extension`() { + every { builder.onReachableType(any>()) } returns builder + builder.onReachableType() + verify { builder.onReachableType(String::class.java) } + } + +}