[GenAI] Test fix for com.graphql-java:graphql-java-extended-scalars:2018-10-05T23-44-12-5312ccd using gpt-5.5

[vjovanov]

What does this PR do?

Fixes: #5202

This PR provides test fixes and new metadata for com.graphql-java:graphql-java-extended-scalars:2018-10-05T23-44-12-5312ccd, addressing compile java failures caused by changes in the updated library version.

Summary:

• Strategy: javac_iterative_with_coverage_sources_pi_gpt-5.5
• Agent: pi
• Model: gpt-5.5
• Input tokens: 64264
• Cached input tokens: 871424
• Output tokens: 10159
• Metadata entries: 0
• Iterations: 1
• Library coverage percentage: 65.64
• Previous library version metadata entries: 0
• Previous library version coverage percentage: 50.25

Metadata Forge

• Forge monitored branch: origin/forge/shared-issue-search-cache
• Forge branch: master
• Forge commit hash: 28845144503d650122a0233d6f4c63d472ef6d0d

Stats from stats/<groupId>/<artifactId>/<metadata-version>/stats.json

Dynamic access coverage

• com.graphql-java:graphql-java-extended-scalars:21.0: 0/0 covered calls (100.00%)
• com.graphql-java:graphql-java-extended-scalars:2018-10-05T23-44-12-5312ccd: 0/0 covered calls (100.00%)

Library coverage

Instruction:

• com.graphql-java:graphql-java-extended-scalars:21.0: 1325/5245 (25.26%)
• com.graphql-java:graphql-java-extended-scalars:2018-10-05T23-44-12-5312ccd: 817/1382 (59.12%)

Line:

• com.graphql-java:graphql-java-extended-scalars:21.0: 398/792 (50.25%)
• com.graphql-java:graphql-java-extended-scalars:2018-10-05T23-44-12-5312ccd: 191/291 (65.64%)

Method:

• com.graphql-java:graphql-java-extended-scalars:21.0: 118/183 (64.48%)
• com.graphql-java:graphql-java-extended-scalars:2018-10-05T23-44-12-5312ccd: 90/100 (90.00%)

Comparison between existing test version and AI-Generated update

diff --git 1/tests/src/com.graphql-java/graphql-java-extended-scalars/21.0/build.gradle 2/tests/src/com.graphql-java/graphql-java-extended-scalars/2018-10-05T23-44-12-5312ccd/build.gradle
index c1a73b9cd1..99f8b32462 100644
--- 1/tests/src/com.graphql-java/graphql-java-extended-scalars/21.0/build.gradle
+++ 2/tests/src/com.graphql-java/graphql-java-extended-scalars/2018-10-05T23-44-12-5312ccd/build.gradle
@@ -12,7 +12,6 @@ String libraryVersion = tck.testedLibraryVersion.get()
 
 dependencies {
     testImplementation "com.graphql-java:graphql-java-extended-scalars:$libraryVersion"
-    testImplementation "com.graphql-java:graphql-java:$libraryVersion"
     testImplementation 'org.assertj:assertj-core:3.22.0'
 }
 
diff --git 1/tests/src/com.graphql-java/graphql-java-extended-scalars/21.0/src/test/java/com_graphql_java/graphql_java_extended_scalars/Graphql_java_extended_scalarsTest.java 2/tests/src/com.graphql-java/graphql-java-extended-scalars/2018-10-05T23-44-12-5312ccd/src/test/java/com_graphql_java/graphql_java_extended_scalars/Graphql_java_extended_scalarsTest.java
index ffdb830e57..40da0c1137 100644
--- 1/tests/src/com.graphql-java/graphql-java-extended-scalars/21.0/src/test/java/com_graphql_java/graphql_java_extended_scalars/Graphql_java_extended_scalarsTest.java
+++ 2/tests/src/com.graphql-java/graphql-java-extended-scalars/2018-10-05T23-44-12-5312ccd/src/test/java/com_graphql_java/graphql_java_extended_scalars/Graphql_java_extended_scalarsTest.java
@@ -13,32 +13,24 @@ import java.net.URI;
 import java.net.URL;
 import java.nio.file.Path;
 import java.time.LocalDate;
-import java.time.LocalTime;
 import java.time.OffsetDateTime;
 import java.time.OffsetTime;
 import java.time.ZonedDateTime;
 import java.util.LinkedHashMap;
 import java.util.List;
-import java.util.Locale;
 import java.util.Map;
-import java.util.UUID;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.regex.Pattern;
 
 import graphql.ExecutionInput;
 import graphql.ExecutionResult;
 import graphql.GraphQL;
-import graphql.GraphQLContext;
-import graphql.execution.CoercedVariables;
 import graphql.language.FloatValue;
 import graphql.language.IntValue;
-import graphql.language.StringValue;
 import graphql.language.Value;
 import graphql.scalars.ExtendedScalars;
 import graphql.schema.DataFetcher;
-import graphql.schema.FieldCoordinates;
 import graphql.schema.GraphQLArgument;
-import graphql.schema.GraphQLCodeRegistry;
 import graphql.schema.GraphQLFieldDefinition;
 import graphql.schema.GraphQLObjectType;
 import graphql.schema.GraphQLScalarType;
@@ -51,19 +43,24 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
 public class Graphql_java_extended_scalarsTest {
 
     @Test
-    void temporalAndIdentifierScalarsRoundTripThroughGraphQl() throws Exception {
+    void temporalScalarsRoundTripThroughGraphQl() {
         EchoResult dateTimeVariable = executeVariableEcho(ExtendedScalars.DateTime, "2024-01-02T03:04:05Z");
         assertSuccessful(dateTimeVariable);
         assertThat(dateTimeVariable.inputValue()).isEqualTo(OffsetDateTime.parse("2024-01-02T03:04:05Z"));
-        assertThat(outputValue(dateTimeVariable.executionResult())).isEqualTo("2024-01-02T03:04:05.000Z");
+        assertThat(OffsetDateTime.parse((String) outputValue(dateTimeVariable.executionResult())))
+            .isEqualTo(OffsetDateTime.parse("2024-01-02T03:04:05Z"));
 
         EchoResult dateTimeLiteral = executeLiteralEcho(ExtendedScalars.DateTime, "\"2024-01-02T03:04:05Z\"");
         assertSuccessful(dateTimeLiteral);
         assertThat(dateTimeLiteral.inputValue()).isEqualTo(OffsetDateTime.parse("2024-01-02T03:04:05Z"));
-        assertThat(outputValue(dateTimeLiteral.executionResult())).isEqualTo("2024-01-02T03:04:05.000Z");
+        assertThat(OffsetDateTime.parse((String) outputValue(dateTimeLiteral.executionResult())))
+            .isEqualTo(OffsetDateTime.parse("2024-01-02T03:04:05Z"));
 
-        assertThat(serialize(ExtendedScalars.DateTime, ZonedDateTime.parse("2024-01-02T03:04:05+02:00")))
-            .isEqualTo("2024-01-02T03:04:05.000+02:00");
+        Object serializedDateTime = serialize(
+            ExtendedScalars.DateTime,
+            ZonedDateTime.parse("2024-01-02T03:04:05+02:00"));
+        assertThat(OffsetDateTime.parse((String) serializedDateTime))
+            .isEqualTo(OffsetDateTime.parse("2024-01-02T03:04:05+02:00"));
 
         EchoResult dateVariable = executeVariableEcho(ExtendedScalars.Date, "2024-01-02");
         assertSuccessful(dateVariable);
@@ -74,22 +71,6 @@ public class Graphql_java_extended_scalarsTest {
         assertSuccessful(timeVariable);
         assertThat(timeVariable.inputValue()).isEqualTo(OffsetTime.parse("03:04:05Z"));
         assertThat(outputValue(timeVariable.executionResult())).isEqualTo("03:04:05Z");
-
-        EchoResult localTimeVariable = executeVariableEcho(ExtendedScalars.LocalTime, "03:04:05");
-        assertSuccessful(localTimeVariable);
-        assertThat(localTimeVariable.inputValue()).isEqualTo(LocalTime.parse("03:04:05"));
-        assertThat(outputValue(localTimeVariable.executionResult())).isEqualTo("03:04:05");
-
-        EchoResult uuidVariable = executeVariableEcho(ExtendedScalars.UUID, "123e4567-e89b-12d3-a456-426614174000");
-        assertSuccessful(uuidVariable);
-        assertThat(uuidVariable.inputValue()).isEqualTo(UUID.fromString("123e4567-e89b-12d3-a456-426614174000"));
-        assertThat(outputValue(uuidVariable.executionResult())).isEqualTo("123e4567-e89b-12d3-a456-426614174000");
-
-        EchoResult localeVariable = executeVariableEcho(ExtendedScalars.Locale, "fr-CA");
-        assertSuccessful(localeVariable);
-        assertThat(localeVariable.inputValue()).isEqualTo(Locale.forLanguageTag("fr-CA"));
-        assertThat(outputValue(localeVariable.executionResult())).isEqualTo("fr-CA");
-
     }
 
     @Test
@@ -105,7 +86,7 @@ public class Graphql_java_extended_scalarsTest {
     }
 
     @Test
-    void numericAndCharacterScalarsValidateBoundaries() {
+    void numericScalarsValidateBoundaries() {
         assertThat(parseValue(ExtendedScalars.PositiveInt, 1)).isEqualTo(1);
         assertThatThrownBy(() -> parseValue(ExtendedScalars.PositiveInt, 0))
             .hasMessageContaining("positive integer");
@@ -114,55 +95,24 @@ public class Graphql_java_extended_scalarsTest {
         assertThatThrownBy(() -> parseValue(ExtendedScalars.NegativeInt, 0))
             .hasMessageContaining("negative integer");
 
-        assertThat(parseLiteral(ExtendedScalars.NonNegativeFloat, new IntValue(BigInteger.ZERO)))
-            .isEqualTo(0.0d);
+        assertThat(parseValue(ExtendedScalars.NonPositiveInt, 0)).isEqualTo(0);
+        assertThat(parseLiteral(ExtendedScalars.NonNegativeInt, new IntValue(BigInteger.ZERO))).isEqualTo(0);
+
+        assertThat(parseValue(ExtendedScalars.PositiveFloat, 1.25d)).isEqualTo(1.25d);
+        assertThat(parseValue(ExtendedScalars.NegativeFloat, -1.25d)).isEqualTo(-1.25d);
+        assertThat(parseLiteral(ExtendedScalars.NonNegativeFloat, new FloatValue(new BigDecimal("12.34"))))
+            .isEqualTo(12.34d);
         assertThatThrownBy(() -> parseValue(ExtendedScalars.NonPositiveFloat, 0.1d))
             .hasMessageContaining("less than or equal to zero");
-
-        assertThat(parseLiteral(ExtendedScalars.GraphQLByte, new IntValue(BigInteger.valueOf(127))))
-            .isEqualTo((byte) 127);
-        assertThatThrownBy(() -> parseLiteral(ExtendedScalars.GraphQLByte, new IntValue(BigInteger.valueOf(128))))
-            .hasMessageContaining("Byte range");
-
-        assertThat(parseLiteral(ExtendedScalars.GraphQLShort, new IntValue(BigInteger.valueOf(32767))))
-            .isEqualTo((short) 32767);
-        assertThatThrownBy(() -> parseValue(ExtendedScalars.GraphQLShort, 32768))
-            .hasMessageContaining("Short");
-
-        assertThat(parseLiteral(ExtendedScalars.GraphQLLong, new StringValue("1234567890123")))
-            .isEqualTo(1_234_567_890_123L);
-        assertThat(parseLiteral(ExtendedScalars.GraphQLBigDecimal, new FloatValue(new BigDecimal("12.34"))))
-            .isEqualTo(new BigDecimal("12.34"));
-        assertThat(parseLiteral(ExtendedScalars.GraphQLBigInteger, new StringValue("1234")))
-            .isEqualTo(new BigInteger("1234"));
-
-        assertThat(parseValue(ExtendedScalars.GraphQLChar, "x")).isEqualTo('x');
-        assertThatThrownBy(() -> parseValue(ExtendedScalars.GraphQLChar, "xy"))
-            .hasMessageContaining("Char");
     }
 
     @Test
-    void urlScalarAcceptsUrlObjectsAndPreservesExternalForm() throws Exception {
-        URL url = URI.create("file:/tmp/graphql/schema.graphql").toURL();
+    void urlScalarAcceptsUrlObjectsUriAndFileInputs() throws Exception {
+        URL fileUrl = URI.create("file:/tmp/graphql/schema.graphql").toURL();
 
-        URL parsedValue = (URL) parseValue(ExtendedScalars.Url, url);
-        assertThat(parsedValue.toExternalForm()).isEqualTo(url.toExternalForm());
+        assertUrlLikeInputRoundTrip(fileUrl, fileUrl.toExternalForm());
 
-        StringValue literal = (StringValue) valueToLiteral(ExtendedScalars.Url, url);
-        assertThat(literal.getValue()).isEqualTo(url.toExternalForm());
-
-        EchoResult variableResult = executeVariableEcho(ExtendedScalars.Url, url);
-        assertSuccessful(variableResult);
-        assertThat(variableResult.inputValue()).isInstanceOf(URL.class);
-        assertThat(((URL) variableResult.inputValue()).toExternalForm()).isEqualTo(url.toExternalForm());
-        assertThat(outputValue(variableResult.executionResult())).isInstanceOf(URL.class);
-        assertThat(((URL) outputValue(variableResult.executionResult())).toExternalForm()).isEqualTo(url.toExternalForm());
-    }
-
-    @Test
-    void urlScalarAcceptsUriAndFileInputs() throws Exception {
         Path schemaPath = Path.of("build", "tmp", "graphql", "schema.graphql");
-
         URI uri = schemaPath.toUri();
         assertUrlLikeInputRoundTrip(uri, uri.toURL().toExternalForm());
 
@@ -187,58 +137,51 @@ public class Graphql_java_extended_scalarsTest {
         assertThat(invalidRegex.executionResult().getErrors().get(0).getMessage()).contains("HexColor");
         assertThat(invalidRegex.inputValue()).isNull();
 
-        GraphQLScalarType aliasedScalar = ExtendedScalars.newAliasedScalar("EpochMillis")
-            .description("Alias for the built-in long scalar")
-            .aliasedScalar(ExtendedScalars.GraphQLLong)
+        GraphQLScalarType aliasedScalar = ExtendedScalars.newAliasedScalar("PositiveScore")
+            .description("Alias for the positive integer scalar")
+            .aliasedScalar(ExtendedScalars.PositiveInt)
             .build();
 
-        assertThat(aliasedScalar.getName()).isEqualTo("EpochMillis");
-        assertThat(aliasedScalar.getDescription()).isEqualTo("Alias for the built-in long scalar");
+        assertThat(aliasedScalar.getName()).isEqualTo("PositiveScore");
+        assertThat(aliasedScalar.getDescription()).isEqualTo("Alias for the positive integer scalar");
 
-        EchoResult aliasedVariable = executeVariableEcho(aliasedScalar, 42L);
+        EchoResult aliasedVariable = executeVariableEcho(aliasedScalar, 42);
         assertSuccessful(aliasedVariable);
-        assertThat(aliasedVariable.inputValue()).isEqualTo(42L);
-        assertThat(outputValue(aliasedVariable.executionResult())).isEqualTo(42L);
+        assertThat(aliasedVariable.inputValue()).isEqualTo(42);
+        assertThat(outputValue(aliasedVariable.executionResult())).isEqualTo(42);
 
         EchoResult aliasedLiteral = executeLiteralEcho(aliasedScalar, "42");
         assertSuccessful(aliasedLiteral);
-        assertThat(aliasedLiteral.inputValue()).isEqualTo(42L);
-        assertThat(outputValue(aliasedLiteral.executionResult())).isEqualTo(42L);
+        assertThat(aliasedLiteral.inputValue()).isEqualTo(42);
+        assertThat(outputValue(aliasedLiteral.executionResult())).isEqualTo(42);
     }
 
     private void assertUrlLikeInputRoundTrip(Object input, String expectedExternalForm) {
         URL parsedValue = (URL) parseValue(ExtendedScalars.Url, input);
         assertThat(parsedValue.toExternalForm()).isEqualTo(expectedExternalForm);
 
-        StringValue literal = (StringValue) valueToLiteral(ExtendedScalars.Url, input);
-        assertThat(literal.getValue()).isEqualTo(expectedExternalForm);
+        URL serialized = (URL) serialize(ExtendedScalars.Url, input);
+        assertThat(serialized.toExternalForm()).isEqualTo(expectedExternalForm);
 
         EchoResult variableResult = executeVariableEcho(ExtendedScalars.Url, input);
         assertSuccessful(variableResult);
         assertThat(variableResult.inputValue()).isInstanceOf(URL.class);
         assertThat(((URL) variableResult.inputValue()).toExternalForm()).isEqualTo(expectedExternalForm);
         assertThat(outputValue(variableResult.executionResult())).isInstanceOf(URL.class);
-        assertThat(((URL) outputValue(variableResult.executionResult())).toExternalForm()).isEqualTo(expectedExternalForm);
+        URL outputUrl = (URL) outputValue(variableResult.executionResult());
+        assertThat(outputUrl.toExternalForm()).isEqualTo(expectedExternalForm);
     }
 
     private Object serialize(GraphQLScalarType scalarType, Object input) {
-        return scalarType.getCoercing()
-            .serialize(input, GraphQLContext.getDefault(), Locale.ENGLISH);
+        return scalarType.getCoercing().serialize(input);
     }
 
     private Object parseValue(GraphQLScalarType scalarType, Object input) {
-        return scalarType.getCoercing()
-            .parseValue(input, GraphQLContext.getDefault(), Locale.ENGLISH);
+        return scalarType.getCoercing().parseValue(input);
     }
 
     private Object parseLiteral(GraphQLScalarType scalarType, Value<?> input) {
-        return scalarType.getCoercing()
-            .parseLiteral(input, CoercedVariables.emptyVariables(), GraphQLContext.getDefault(), Locale.ENGLISH);
-    }
-
-    private Value<?> valueToLiteral(GraphQLScalarType scalarType, Object input) {
-        return scalarType.getCoercing()
-            .valueToLiteral(input, GraphQLContext.getDefault(), Locale.ENGLISH);
+        return scalarType.getCoercing().parseLiteral(input);
     }
 
     private void assertStructuredScalarRoundTrip(GraphQLScalarType scalarType, Map<String, Object> variableInput) {
@@ -247,9 +190,11 @@ public class Graphql_java_extended_scalarsTest {
         assertThat(variableResult.inputValue()).isInstanceOf(Map.class);
         assertCountAndFlags(asMap(variableResult.inputValue()));
         assertCountAndFlags(asMap(outputValue(variableResult.executionResult())));
-        assertThat(asMap(outputValue(variableResult.executionResult())).get("tags")).isEqualTo(List.of("alpha", "beta"));
+        Map<String, Object> outputValue = asMap(outputValue(variableResult.executionResult()));
+        assertThat(outputValue.get("tags")).isEqualTo(List.of("alpha", "beta"));
 
-        EchoResult literalResult = executeLiteralEcho(scalarType, "{count: 1, enabled: true, tags: [\"alpha\", \"beta\"], child: {code: \"A1\"}}");
+        String literalInput = "{count: 1, enabled: true, tags: [\"alpha\", \"beta\"], child: {code: \"A1\"}}";
+        EchoResult literalResult = executeLiteralEcho(scalarType, literalInput);
         assertSuccessful(literalResult);
         assertThat(literalResult.inputValue()).isInstanceOf(Map.class);
         assertCountAndFlags(asMap(literalResult.inputValue()));
@@ -270,7 +215,8 @@ public class Graphql_java_extended_scalarsTest {
               echo(input: $input)
             }
             """.formatted(scalarType.getName());
-        ExecutionResult executionResult = graphQl.execute(ExecutionInput.newExecutionInput(query)
+        ExecutionResult executionResult = graphQl.execute(ExecutionInput.newExecutionInput()
+            .query(query)
             .variables(Map.of("input", variableValue))
             .build());
         return new EchoResult(executionResult, inputValue.get());
@@ -289,37 +235,30 @@ public class Graphql_java_extended_scalarsTest {
     }
 
     private GraphQL createEchoGraphQl(GraphQLScalarType scalarType, AtomicReference<Object> inputValue) {
-        String typeName = "Query";
-        String fieldName = "echo";
+        DataFetcher<Object> echoDataFetcher = environment -> {
+            Object argument = environment.getArgument("input");
+            inputValue.set(argument);
+            return argument;
+        };
 
         GraphQLFieldDefinition field = GraphQLFieldDefinition.newFieldDefinition()
-            .name(fieldName)
+            .name("echo")
             .type(scalarType)
             .argument(GraphQLArgument.newArgument()
                 .name("input")
                 .type(scalarType)
                 .build())
+            .dataFetcher(echoDataFetcher)
             .build();
 
         GraphQLObjectType queryType = GraphQLObjectType.newObject()
-            .name(typeName)
+            .name("Query")
             .field(field)
             .build();
 
-        DataFetcher<Object> echoDataFetcher = environment -> {
-            Object argument = environment.getArgument("input");
-            inputValue.set(argument);
-            return argument;
-        };
-
-        GraphQLCodeRegistry codeRegistry = GraphQLCodeRegistry.newCodeRegistry()
-            .dataFetcher(FieldCoordinates.coordinates(typeName, fieldName), echoDataFetcher)
-            .build();
-
         GraphQLSchema schema = GraphQLSchema.newSchema()
             .query(queryType)
             .additionalType(scalarType)
-            .codeRegistry(codeRegistry)
             .build();
 
         return GraphQL.newGraphQL(schema).build();
diff --git 1/tests/src/com.graphql-java/graphql-java-extended-scalars/21.0/user-code-filter.json 2/tests/src/com.graphql-java/graphql-java-extended-scalars/2018-10-05T23-44-12-5312ccd/user-code-filter.json
index e981b6b2f4..173a494ec8 100644
--- 1/tests/src/com.graphql-java/graphql-java-extended-scalars/21.0/user-code-filter.json
+++ 2/tests/src/com.graphql-java/graphql-java-extended-scalars/2018-10-05T23-44-12-5312ccd/user-code-filter.json
@@ -5,6 +5,9 @@
     },
     {
       "includeClasses" : "graphql.scalars.**"
+    },
+    {
+      "includeClasses" : "com_graphql_java.graphql_java_extended_scalars.**"
     }
   ]
 }

Local CI Verification

• Status: success
• Commands run: 15
• Fixup attempts: 0

[jormundur00]

Checked the authoritative diff from gh, the change stays scoped to com.graphql-java:graphql-java-extended-scalars:2018-10-05T23-44-12-5312ccd, and the test updates adapt the older GraphQL API without any blocking coverage regression. Dynamic-access coverage remains 0/0 vs. the previous tested version, metadata entry counts remain 0 vs. 0, and the relevant compile/test lanes are green. I found no blocking issues.