Use Java 17

Author: mpkorstanje

java/src/main/java/io/cucumber/cucumberexpressions/GeneratedExpression.java

@@ -1,6 +1,7 @@
 package io.cucumber.cucumberexpressions;
 
 import org.apiguardian.api.API;
+import org.jspecify.annotations.Nullable;
 
 import java.text.Collator;
 import java.util.ArrayList;
@@ -34,7 +35,7 @@ public class GeneratedExpression {
         this.parameterTypes = parameterTypes;
     }
 
-    private static boolean isJavaKeyword(String keyword) {
+    private static boolean isJavaKeyword(@Nullable String keyword) {
         return (Arrays.binarySearch(JAVA_KEYWORDS, keyword, ENGLISH_COLLATOR) >= 0);
     }
 

java/src/main/java/io/cucumber/cucumberexpressions/ParameterType.java

@@ -40,18 +40,13 @@ static boolean isValidParameterTypeName(String name) {
     }
 
     static ParameterType<Object> createAnonymousParameterType(String regexp) {
-        return new ParameterType<>("", singletonList(regexp), Object.class, new CaptureGroupTransformer<Object>() {
-
-            @Override
-            public Object transform(String[] arg) {
-                throw new UnsupportedOperationException("Anonymous transform must be deanonymized before use");
-            }
+        return new ParameterType<>("", singletonList(regexp), Object.class, arg -> {
+            throw new UnsupportedOperationException("Anonymous transform must be deanonymized before use");
         }, false, true, false, true);
     }
 
-    @SuppressWarnings("unchecked")
-    static <E extends Enum> ParameterType<E> fromEnum(final Class<E> enumClass) {
-        Enum[] enumConstants = enumClass.getEnumConstants();
+    static <E extends Enum<E>> ParameterType<E> fromEnum(final Class<E> enumClass) {
+        var enumConstants = enumClass.getEnumConstants();
         StringBuilder regexpBuilder = new StringBuilder();
         for (int i = 0; i < enumConstants.length; i++) {
             if (i > 0)
@@ -62,7 +57,7 @@ static <E extends Enum> ParameterType<E> fromEnum(final Class<E> enumClass) {
                 enumClass.getSimpleName(),
                 regexpBuilder.toString(),
                 enumClass,
-                (@Nullable String arg) -> arg == null ? null : (E) Enum.valueOf(enumClass, arg)
+                (@Nullable String arg) -> arg == null ? null : Enum.valueOf(enumClass, arg)
         );
     }
 
@@ -210,7 +205,7 @@ public boolean preferForRegexpMatch() {
     }
 
     /**
-     * Indicates whether or not this is a parameter type should be used for generating
+     * Indicates whether this is a parameter type should be used for generating
      * {@link GeneratedExpression}s from text. Typically, parameter types with greedy regexps
      * should return false.
      *
@@ -248,13 +243,13 @@ T transform(List<String> groupValues) {
         if (transformer instanceof TransformerAdaptor) {
             if (groupValues.size() > 1) {
                 if (isAnonymous()) {
-                    throw new CucumberExpressionException(String.format("" +
+                    throw new CucumberExpressionException(String.format(
                             "Anonymous ParameterType has multiple capture groups %s. " +
-                            "You can only use a single capture group in an anonymous ParameterType.", regexps));
+                                    "You can only use a single capture group in an anonymous ParameterType.", regexps));
                 }
-                throw new CucumberExpressionException(String.format("" +
+                throw new CucumberExpressionException(String.format(
                         "ParameterType {%s} was registered with a Transformer but has multiple capture groups %s. " +
-                        "Did you mean to use a CaptureGroupTransformer?", name, regexps));
+                                "Did you mean to use a CaptureGroupTransformer?", name, regexps));
             }
         }
 
@@ -296,7 +291,7 @@ private TransformerAdaptor(Transformer<T> transformer) {
         }
 
         @Override
-        public @Nullable T transform(String[] args) throws Throwable {
+        public @Nullable T transform(@Nullable String[] args) throws Throwable {
             return transformer.transform(args[0]);
         }
 

java/src/test/java/io/cucumber/cucumberexpressions/CustomParameterTypeTest.java

@@ -15,10 +15,8 @@
 import static java.util.regex.Pattern.compile;
 import static org.assertj.core.api.Assertions.assertThat;
 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.assertThrows;
-import static org.junit.jupiter.api.Assertions.fail;
 
 class CustomParameterTypeTest {
 
@@ -226,7 +224,7 @@ void conflicting_parameter_type_is_not_detected_for_regexp() {
     void matches_RegularExpression_arguments_with_custom_parameter_type_without_name() {
         parameterTypeRegistry = new ParameterTypeRegistry(Locale.ENGLISH);
         parameterTypeRegistry.defineParameterType(new ParameterType<>(
-                null,
+                "null",
                 "red|blue|yellow",
                 Color.class,
                 (@Nullable String name) -> new Color(requireNonNull(name)),

java/src/test/java/io/cucumber/cucumberexpressions/EnumParameterTypeTest.java

@@ -2,12 +2,11 @@
 
 import org.junit.jupiter.api.Test;
 
-import java.util.List;
 import java.util.Locale;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
 
-public class EnumParameterTypeTest {
+class EnumParameterTypeTest {
 
     public enum Mood {
         happy,
@@ -16,13 +15,15 @@ public enum Mood {
     }
 
     @Test
-    public void converts_to_enum() {
-        ParameterTypeRegistry registry = new ParameterTypeRegistry(Locale.ENGLISH);
+    void converts_to_enum() {
+        var registry = new ParameterTypeRegistry(Locale.ENGLISH);
         registry.defineParameterType(ParameterType.fromEnum(Mood.class));
 
-        CucumberExpression expression = new CucumberExpression("I am {Mood}", registry);
-        List<Argument<?>> args = expression.match("I am happy");
-        assertEquals(Mood.happy, args.get(0).getValue());
+        var expression = new CucumberExpression("I am {Mood}", registry);
+        var args = expression.match("I am happy");
+        assertThat(args).singleElement()
+                .extracting(Argument::getValue)
+                .isEqualTo(Mood.happy);
     }
 
 }

java/src/test/java/io/cucumber/cucumberexpressions/GenericParameterTypeTest.java

@@ -1,12 +1,18 @@
 package io.cucumber.cucumberexpressions;
 
+import org.assertj.core.api.Assertions;
+import org.jspecify.annotations.Nullable;
 import org.junit.jupiter.api.Test;
 
+import java.lang.reflect.Type;
 import java.util.List;
 import java.util.Locale;
+import java.util.Objects;
 
 import static java.util.Arrays.asList;
 import static java.util.Collections.singletonList;
+import static java.util.Objects.requireNonNull;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class GenericParameterTypeTest {
@@ -17,20 +23,16 @@ public void transforms_to_a_list_of_string() {
         parameterTypeRegistry.defineParameterType(new ParameterType<>(
                 "stringlist",
                 singletonList(".*"),
-                new TypeReference<List<String>>() {
-                }.getType(),
-                new CaptureGroupTransformer<List<String>>() {
-                    @Override
-                    public List<String> transform(String... args) {
-                        return asList(args[0].split(","));
-                    }
-                },
+                new TypeReference<List<String>>() {}.getType(),
+                (@Nullable String arg) -> requireNonNull(arg).split(","),
                 false,
                 false)
         );
-        Expression expression = new CucumberExpression("I have {stringlist} yay", parameterTypeRegistry);
-        List<Argument<?>> args = expression.match("I have three,blind,mice yay");
-        assertEquals(asList("three", "blind", "mice"), args.get(0).getValue());
+        var expression = new CucumberExpression("I have {stringlist} yay", parameterTypeRegistry);
+        var args = expression.match("I have three,blind,mice yay");
+        assertThat(args).singleElement()
+                .extracting(Argument::getValue)
+                .isEqualTo(asList("three", "blind", "mice"));
     }
 
 }

java/src/test/java/io/cucumber/cucumberexpressions/NumberParserTest.java

@@ -29,12 +29,11 @@ void can_parse_float() {
 
     @Test
     void can_parse_double() {
-        assertEquals(1042.000000000000002, english.parseDouble("1,042.000000000000002"), 0);
-        assertEquals(1042.000000000000002, canadian.parseDouble("1,042.000000000000002"), 0);
-
-        assertEquals(1042.000000000000002, german.parseDouble("1.042,000000000000002"), 0);
-        assertEquals(1042.000000000000002, canadianFrench.parseDouble("1.042,000000000000002"), 0);
-        assertEquals(1042.000000000000002, norwegian.parseDouble("1.042,000000000000002"), 0);
+        assertEquals(Double.parseDouble("1042.000000000000002"), english.parseDouble("1,042.000000000000002"), 0);
+        assertEquals(Double.parseDouble("1042.000000000000002"), canadian.parseDouble("1,042.000000000000002"), 0);
+        assertEquals(Double.parseDouble("1042.000000000000002"), german.parseDouble("1.042,000000000000002"), 0);
+        assertEquals(Double.parseDouble("1042.000000000000002"), canadianFrench.parseDouble("1.042,000000000000002"), 0);
+        assertEquals(Double.parseDouble("1042.000000000000002"), norwegian.parseDouble("1.042,000000000000002"), 0);
     }
 
     @Test

java/src/test/java/io/cucumber/cucumberexpressions/ParameterByTypeTransformerTest.java

@@ -3,6 +3,8 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.type.TypeFactory;
 import com.fasterxml.jackson.datatype.jdk8.Jdk8Module;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 
@@ -140,6 +142,7 @@ public void should_convert_to_enum(final ParameterByTypeTransformer defaultTrans
         assertEquals(TestEnum.TEST, defaultTransformer.transform("TEST", TestEnum.class));
     }
 
+    @NullMarked
     private static class TestJacksonDefaultTransformer implements ParameterByTypeTransformer {
         ObjectMapper delegate = initMapper();
 
@@ -150,7 +153,7 @@ private static ObjectMapper initMapper() {
         }
 
         @Override
-        public Object transform(String fromValue, Type toValueType) {
+        public Object transform(@Nullable String fromValue, Type toValueType) {
             TypeFactory typeFactory = delegate.getTypeFactory();
             return delegate.convertValue(fromValue, typeFactory.constructType(toValueType));
         }

java/src/test/java/io/cucumber/cucumberexpressions/ParameterTypeComparatorTest.java

@@ -1,6 +1,7 @@
 package io.cucumber.cucumberexpressions;
 
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.shadow.de.siegmar.fastcsv.util.Nullable;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -14,25 +15,25 @@
 public class ParameterTypeComparatorTest {
 
     public static class A {
-        A(String s) {
+        A(@Nullable String s) {
             assertNotNull(s);
         }
     }
 
     public static class B {
-        B(String s) {
+        B(@Nullable String s) {
             assertNotNull(s);
         }
     }
 
     public static class C {
-        C(String s) {
+        C(@Nullable String s) {
             assertNotNull(s);
         }
     }
 
     public static class D {
-        D(String s) {
+        D(@Nullable String s) {
             assertNotNull(s);
         }
     }
@@ -46,7 +47,7 @@ public void sorts_parameter_types_by_preferential_then_name() {
         set.add(new ParameterType<>("b", "b", B.class, B::new, false, true));
 
         List<String> names = new ArrayList<>();
-        for (ParameterType parameterType : set) {
+        for (ParameterType<?> parameterType : set) {
             names.add(parameterType.getName());
         }
         assertEquals(asList("b", "c", "a", "d"), names);

java/src/test/java/io/cucumber/cucumberexpressions/ParameterTypeRegistryTest.java

@@ -2,6 +2,7 @@
 
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.function.Executable;
+import org.junit.jupiter.params.shadow.de.siegmar.fastcsv.util.Nullable;
 
 import java.math.BigDecimal;
 import java.util.Locale;
@@ -20,19 +21,19 @@ public class ParameterTypeRegistryTest {
     private static final String CAPITALISED_WORD = "[A-Z]+\\w+";
 
     public static class Name {
-        Name(String s) {
+        Name(@Nullable String s) {
             assertNotNull(s);
         }
     }
 
     public static class Person {
-        Person(String s) {
+        Person(@Nullable String s) {
             assertNotNull(s);
         }
     }
 
     public static class Place {
-        Place(String s) {
+        Place(@Nullable String s) {
             assertNotNull(s);
         }
     }