From a6c375fe0df5cfacdf33d5b5bb0099fa881bee02 Mon Sep 17 00:00:00 2001 From: Christoph Strobl Date: Thu, 11 Sep 2025 23:24:06 +0200 Subject: [PATCH] Add tests for TypeNames. Original Pull Request: #3357 --- .../data/javapoet/JavaPoetUnitTests.java | 34 +++++----- .../data/javapoet/TypeNamesUnitTests.java | 62 +++++++++++++++++++ 2 files changed, 79 insertions(+), 17 deletions(-) create mode 100644 src/test/java/org/springframework/data/javapoet/TypeNamesUnitTests.java diff --git a/src/test/java/org/springframework/data/javapoet/JavaPoetUnitTests.java b/src/test/java/org/springframework/data/javapoet/JavaPoetUnitTests.java index c549b91a5..a39d09fb6 100644 --- a/src/test/java/org/springframework/data/javapoet/JavaPoetUnitTests.java +++ b/src/test/java/org/springframework/data/javapoet/JavaPoetUnitTests.java @@ -125,22 +125,22 @@ class JavaPoetUnitTests { void shouldRenderConditionalLongReturn() { CodeBlock block = LordOfTheStrings.returning(Long.class).whenLong("1L").whenBoxedLong("$T.valueOf(1)", Long.class) - .otherwise("😫").build(); + .otherwise(":-[").build(); assertThat(block).hasToString("return java.lang.Long.valueOf(1)"); block = LordOfTheStrings.returning(Long.class).whenBoxedLong("$T.valueOf(1)", Long.class).whenLong("1L") - .otherwise("😫").build(); + .otherwise(":-[").build(); assertThat(block).hasToString("return java.lang.Long.valueOf(1)"); block = LordOfTheStrings.returning(long.class).whenBoxedLong("$T.valueOf(1)", Long.class).whenLong("1L") - .otherwise("😫").build(); + .otherwise(":-[").build(); assertThat(block).hasToString("return 1L"); - block = LordOfTheStrings.returning(Long.class).whenBoxed(Long.class, "$T.valueOf(1)", Long.class).otherwise("😫") + block = LordOfTheStrings.returning(Long.class).whenBoxed(Long.class, "$T.valueOf(1)", Long.class).otherwise(":-[") .build(); assertThat(block).hasToString("return java.lang.Long.valueOf(1)"); - block = LordOfTheStrings.returning(Long.class).whenBoxed(long.class, "$T.valueOf(1)", Long.class).otherwise("😫") + block = LordOfTheStrings.returning(Long.class).whenBoxed(long.class, "$T.valueOf(1)", Long.class).otherwise(":-[") .build(); assertThat(block).hasToString("return java.lang.Long.valueOf(1)"); } @@ -149,44 +149,44 @@ class JavaPoetUnitTests { void shouldRenderConditionalIntReturn() { CodeBlock block = LordOfTheStrings.returning(Integer.class).whenBoxed(long.class, "$T.valueOf(1)", Long.class) - .otherwise("😫").build(); - assertThat(block).hasToString("return 😫"); + .otherwise(":-[").build(); + assertThat(block).hasToString("return :-["); - block = LordOfTheStrings.returning(Integer.class).whenBoxedInteger("$T.valueOf(1)", Integer.class).otherwise("😫") + block = LordOfTheStrings.returning(Integer.class).whenBoxedInteger("$T.valueOf(1)", Integer.class).otherwise(":-[") .build(); assertThat(block).hasToString("return java.lang.Integer.valueOf(1)"); block = LordOfTheStrings.returning(int.class).whenBoxedInteger("$T.valueOf(1)", Integer.class).whenInt("1") - .otherwise("😫").build(); + .otherwise(":-[").build(); assertThat(block).hasToString("return 1"); } @Test // GH-3357 void shouldRenderConditionalBooleanReturn() { - CodeBlock block = LordOfTheStrings.returning(boolean.class).whenBoolean("$L", true).otherwise("😫").build(); + CodeBlock block = LordOfTheStrings.returning(boolean.class).whenBoolean("$L", true).otherwise(":-[").build(); assertThat(block).hasToString("return true"); - block = LordOfTheStrings.returning(Boolean.class).whenBoolean("$L", true).otherwise("😫").build(); + block = LordOfTheStrings.returning(Boolean.class).whenBoolean("$L", true).otherwise(":-[").build(); assertThat(block).hasToString("return true"); } @Test // GH-3357 void shouldRenderConditionalNumericReturn() { - CodeBlock block = LordOfTheStrings.returning(boolean.class).number("someNumericVariable").otherwise("😫").build(); - assertThat(block).hasToString("return 😫"); + CodeBlock block = LordOfTheStrings.returning(boolean.class).number("someNumericVariable").otherwise(":-[").build(); + assertThat(block).hasToString("return :-["); - block = LordOfTheStrings.returning(long.class).number("someNumericVariable").otherwise("😫").build(); + block = LordOfTheStrings.returning(long.class).number("someNumericVariable").otherwise(":-[").build(); assertThat(block).hasToString("return someNumericVariable != null ? someNumericVariable.longValue() : 0L"); - block = LordOfTheStrings.returning(Long.class).number("someNumericVariable").otherwise("😫").build(); + block = LordOfTheStrings.returning(Long.class).number("someNumericVariable").otherwise(":-[").build(); assertThat(block).hasToString("return someNumericVariable != null ? someNumericVariable.longValue() : null"); - block = LordOfTheStrings.returning(int.class).number("someNumericVariable").otherwise("😫").build(); + block = LordOfTheStrings.returning(int.class).number("someNumericVariable").otherwise(":-[").build(); assertThat(block).hasToString("return someNumericVariable != null ? someNumericVariable.intValue() : 0"); - block = LordOfTheStrings.returning(Integer.class).number("someNumericVariable").otherwise("😫").build(); + block = LordOfTheStrings.returning(Integer.class).number("someNumericVariable").otherwise(":-[").build(); assertThat(block).hasToString("return someNumericVariable != null ? someNumericVariable.intValue() : null"); } diff --git a/src/test/java/org/springframework/data/javapoet/TypeNamesUnitTests.java b/src/test/java/org/springframework/data/javapoet/TypeNamesUnitTests.java new file mode 100644 index 000000000..74a28f90c --- /dev/null +++ b/src/test/java/org/springframework/data/javapoet/TypeNamesUnitTests.java @@ -0,0 +1,62 @@ +/* + * Copyright 2025 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.data.javapoet; + +import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat; + +import java.util.Set; +import java.util.stream.Stream; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.springframework.core.ResolvableType; +import org.springframework.javapoet.ParameterizedTypeName; +import org.springframework.javapoet.TypeName; + +/** + * @author Christoph Strobl + */ +class TypeNamesUnitTests { + + static Stream typeNames() { + return Stream.of(Arguments.of(ResolvableType.forClass(String.class), TypeName.get(String.class)), + Arguments.of(ResolvableType.forClassWithGenerics(Set.class, String.class), + ParameterizedTypeName.get(Set.class, String.class)), + Arguments.of(ResolvableType.forClass(Void.class), TypeName.get(Void.class)), + Arguments.of(ResolvableType.forClass(Iterable.class, Object.class), TypeName.get(Iterable.class))); + } + + static Stream classNames() { + return Stream.of(Arguments.of(ResolvableType.forClass(String.class), TypeName.get(String.class)), + Arguments.of(ResolvableType.forClassWithGenerics(Set.class, String.class), TypeName.get(Set.class)), + Arguments.of(ResolvableType.forClass(Void.class), TypeName.get(Void.class)), + Arguments.of(ResolvableType.forClass(Iterable.class, Object.class), TypeName.get(Iterable.class))); + } + + @ParameterizedTest // GH-3357 + @MethodSource + void typeNames(ResolvableType resolvableType, TypeName expected) { + assertThat(TypeNames.typeName(resolvableType)).isEqualTo(expected); + } + + @ParameterizedTest // GH-3357 + @MethodSource + void classNames(ResolvableType resolvableType, TypeName expected) { + assertThat(TypeNames.className(resolvableType)).isEqualTo(expected); + } + +}