Refactor GenericsResolverTest add Assertions static import to make test simpler.

Signed-off-by: Manoel Campos <[email protected]>

Author: manoelcampos

typescript-generator-core/src/test/java/cz/habarta/typescript/generator/GenericsResolverTest.java

@@ -4,22 +4,23 @@
 import cz.habarta.typescript.generator.type.JTypeVariable;
 import cz.habarta.typescript.generator.util.GenericsResolver;
 import cz.habarta.typescript.generator.util.Utils;
+import org.junit.jupiter.api.Test;
+
 import java.lang.reflect.Type;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
-import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.Test;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
-public class GenericsResolverTest {
 
+public class GenericsResolverTest {
     @Test
     public void testStringField() throws Exception {
         final Class<?> cls = F1String.class;
         final Type type = GenericsResolver.resolveField(cls, cls.getField("field"));
-        Assertions.assertEquals(String.class, type);
+        assertEquals(String.class, type);
     }
 
     static class F1<T> {
@@ -32,7 +33,7 @@ static class F1String extends F1<String> {
     public void testListOfStringField() throws Exception {
         final Class<?> cls = F2String.class;
         final Type type = GenericsResolver.resolveField(cls, cls.getField("list"));
-        Assertions.assertEquals(Utils.createParameterizedType(List.class, String.class), type);
+        assertEquals(Utils.createParameterizedType(List.class, String.class), type);
     }
 
     static class F2<T> {
@@ -45,7 +46,7 @@ static class F2String extends F2<String> {
     public void testMapOfStringAndListOfLongField() throws Exception {
         final Class<?> cls = F3StringLong.class;
         final Type type = GenericsResolver.resolveField(cls, cls.getField("map"));
-        Assertions.assertEquals(Utils.createParameterizedType(Map.class, String.class, Utils.createParameterizedType(List.class, Long.class)), type);
+        assertEquals(Utils.createParameterizedType(Map.class, String.class, Utils.createParameterizedType(List.class, Long.class)), type);
     }
 
     static class F3<K, V> {
@@ -58,21 +59,21 @@ static class F3StringLong extends F3<String, Long> {
     public void testInheritancePath() throws Exception {
         final Class<?> cls = P123Number.class;
         final Type type = GenericsResolver.resolveField(cls, cls.getField("field"));
-        Assertions.assertEquals(Utils.createParameterizedType(List.class, Number.class), type);
+        assertEquals(Utils.createParameterizedType(List.class, Number.class), type);
     }
 
     @Test
     public void testInheritancePathWithUnresolvedVariable1() throws Exception {
         final Class<?> cls = P123.class;
         final Type type = GenericsResolver.resolveField(cls, cls.getField("field"));
-        Assertions.assertEquals(Utils.createParameterizedType(List.class, new JTypeVariable<>(P123.class, "B")), type);
+        assertEquals(Utils.createParameterizedType(List.class, new JTypeVariable<>(P123.class, "B")), type);
     }
 
     @Test
     public void testInheritancePathWithUnresolvedVariable2() throws Exception {
         final Class<?> cls = P12.class;
         final Type type = GenericsResolver.resolveField(cls, cls.getField("field"));
-        Assertions.assertEquals(new JTypeVariable<>(P12.class, "V"), type);
+        assertEquals(new JTypeVariable<>(P12.class, "V"), type);
     }
 
     static class P1<T> {
@@ -88,13 +89,13 @@ static class P123Number extends P123<String, Number, Boolean> {
     @Test
     public void testGenericVariableMappingToBase1() {
         final List<String> mappedTypeParameters = GenericsResolver.mapGenericVariablesToBase(R123.class, R1.class);
-        Assertions.assertEquals(Arrays.asList(null, null, "T"), mappedTypeParameters);
+        assertEquals(Arrays.asList(null, null, "T"), mappedTypeParameters);
     }
 
     @Test
     public void testGenericVariableMappingToBase2() {
         final List<String> mappedTypeParameters = GenericsResolver.mapGenericVariablesToBase(R12.class, R1.class);
-        Assertions.assertEquals(Arrays.asList("T", "S"), mappedTypeParameters);
+        assertEquals(Arrays.asList("T", "S"), mappedTypeParameters);
     }
 
     static class R1<S, T> {
@@ -108,21 +109,21 @@ static class R123<A, B, C> extends R12<C, List<B>> {
     public void testResolvingGenericVariablesInContextType1() throws NoSuchFieldException {
         final Type contextType = MyClass.class.getField("property1").getGenericType();
         final List<Type> resolvedTypeParameters = GenericsResolver.resolveBaseGenericVariables(BaseClass.class, contextType);
-        Assertions.assertEquals(Arrays.asList("java.lang.String", "java.lang.Integer"), getTypeNames(resolvedTypeParameters));
+        assertEquals(Arrays.asList("java.lang.String", "java.lang.Integer"), getTypeNames(resolvedTypeParameters));
     }
 
     @Test
     public void testResolvingGenericVariablesInContextType3() throws NoSuchFieldException {
         final Type contextType = MyClass.class.getField("property3").getGenericType();
         final List<Type> resolvedTypeParameters = GenericsResolver.resolveBaseGenericVariables(BaseClass.class, contextType);
-        Assertions.assertEquals(Arrays.asList("java.lang.Integer", "java.lang.Boolean"), getTypeNames(resolvedTypeParameters));
+        assertEquals(Arrays.asList("java.lang.Integer", "java.lang.Boolean"), getTypeNames(resolvedTypeParameters));
     }
 
     @Test
     public void testResolvingGenericVariablesInContextTypeBase() throws NoSuchFieldException {
         final Type contextType = MyClass.class.getField("propertyBase").getGenericType();
         final List<Type> resolvedTypeParameters = GenericsResolver.resolveBaseGenericVariables(BaseClass.class, contextType);
-        Assertions.assertEquals(Arrays.asList("java.lang.Integer", "java.lang.String"), getTypeNames(resolvedTypeParameters));
+        assertEquals(Arrays.asList("java.lang.Integer", "java.lang.String"), getTypeNames(resolvedTypeParameters));
     }
 
     static class BaseClass<A, B> {}
@@ -141,14 +142,14 @@ static class MyClass {
     public void testResolvingRawUsage1() throws NoSuchFieldException {
         final Type contextType = RawUsage.class.getField("rawMap").getGenericType();
         final List<Type> resolvedTypeParameters = GenericsResolver.resolveBaseGenericVariables(Map.class, contextType);
-        Assertions.assertEquals(Arrays.asList("java.lang.Object", "java.lang.Object"), getTypeNames(resolvedTypeParameters));
+        assertEquals(Arrays.asList("java.lang.Object", "java.lang.Object"), getTypeNames(resolvedTypeParameters));
     }
 
     @Test
     public void testResolvingRawUsage2() throws NoSuchFieldException {
         final Type contextType = RawUsage.class.getField("rawStringKeyMap").getGenericType();
         final List<Type> resolvedTypeParameters = GenericsResolver.resolveBaseGenericVariables(Map.class, contextType);
-        Assertions.assertEquals(Arrays.asList("java.lang.Object", "java.lang.Object"), getTypeNames(resolvedTypeParameters));
+        assertEquals(Arrays.asList("java.lang.Object", "java.lang.Object"), getTypeNames(resolvedTypeParameters));
     }
 
     static class RawUsage {
@@ -163,7 +164,7 @@ static interface StringKeyMap<T> extends Map<String, T> {}
     public void testResolvingFixedDescendant() throws NoSuchFieldException {
         final Type contextType = StringMapDescendantUsage.class.getField("stringMapDescendant").getGenericType();
         final List<Type> resolvedTypeParameters = GenericsResolver.resolveBaseGenericVariables(Map.class, contextType);
-        Assertions.assertEquals(Arrays.asList("java.lang.String", "java.lang.String"), getTypeNames(resolvedTypeParameters));
+        assertEquals(Arrays.asList("java.lang.String", "java.lang.String"), getTypeNames(resolvedTypeParameters));
     }
 
     static class StringMapDescendantUsage {